workbench/libs/asyncio/src/FGetsLenAsync.c

   1 #include "async.h"
   2
   3
   4 _LIBCALL APTR
   5 FGetsLenAsync( _REG( a0 ) AsyncFile *file, _REG( a1 ) APTR buf,
   6         _REG( d0 ) LONG numBytes, _REG( a2 ) LONG *len )
   7 {
   8         UBYTE   *p;
   9         LONG    length = 0;
  10
  11         p = ( UBYTE * ) buf;
  12
  13         /* Make room for \n and \0 */
  14         if( --numBytes <= 0 )
  15         {
  16                 /* Handle senseless cases */
  17                 return( NULL );
  18         }
  19
  20         while( TRUE )
  21         {
  22                 UBYTE   *ptr;
  23                 LONG    i, count;
  24
  25                 ptr = ( UBYTE * ) file->af_Offset;
  26
  27                 if( count = file->af_BytesLeft )
  28                 {
  29                         count = MIN( count, numBytes );
  30
  31                         for( i = 0; ( i < count ) && ( *ptr != '\n' ); ++i )
  32                         {
  33                                 *p++ = *ptr++;
  34                         }
  35
  36                         length += i;
  37
  38                         /* Check for valid EOL char */
  39                         if( i < count )
  40                         {
  41                                 /* MH: Since i < count, and count <= numBytes,
  42                                  * there _is_ room for \n\0.
  43                                  */
  44                                 *p++ = '\n';    /* "Read" EOL char */
  45                                 ++i;
  46                                 length += 1;
  47                         }
  48
  49                         file->af_BytesLeft -= i;
  50                         file->af_Offset    += i;
  51
  52                         if( ( i >= numBytes ) || ( *( p - 1 ) == '\n' ) )
  53                         {
  54                                 /* MH: It is enough to break out of the loop.
  55                                  * no need to "waste" code by making a special
  56                                  * exit here. ;)
  57                                  */
  58                                 break;
  59                         }
  60
  61                         numBytes -= i;
  62                 }
  63
  64                 /* MH: numBytes must be at least 1 here, so there is still room
  65                  * for \n\0, in case we read \n.
  66                  */
  67
  68                 if( ReadAsync( file, p, 1 ) < 1 )
  69                 {
  70                         break;
  71                 }
  72
  73                 --numBytes;
  74                 ++length;
  75
  76                 if( *p++ == '\n' )
  77                 {
  78                         break;
  79                 }
  80         }
  81
  82         *p = '\0';
  83         *len = length;
  84
  85         if( p == ( UBYTE * ) buf )
  86         {
  87                 return( NULL );
  88         }
  89
  90         return( buf );
  91 }
  92
  93
  94 _CALL APTR
  95 FGetsAsync( _REG( a0 ) AsyncFile *file, _REG( a1 ) APTR buf, _REG( d0 ) LONG numBytes )
  96 {
  97         LONG    len;
  98
  99         return( FGetsLenAsync( file, buf, numBytes, &len ) );
 100 }