Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (c) 1990 The Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms are permitted
  6.  * provided that the above copyright notice and this paragraph are
  7.  * duplicated in all such forms and that any documentation,
  8.  * advertising materials, and other materials related to such
  9.  * distribution and use acknowledge that the software was developed
  10.  * by the University of California, Berkeley.  The name of the
  11.  * University may not be used to endorse or promote products derived
  12.  * from this software without specific prior written permission.
  13.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  14.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  15.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  16.  */
  17.  
  18. /*
  19. FUNCTION
  20. <<fgets>>---get character string from a file or stream
  21.  
  22. INDEX
  23.         fgets
  24. INDEX
  25.         _fgets_r
  26.  
  27. ANSI_SYNOPSIS
  28.         #include <stdio.h>
  29.         char *fgets(char *<[buf]>, int <[n]>, FILE *<[fp]>);
  30.  
  31.         #include <stdio.h>
  32.         char *_fgets_r(struct _reent *<[ptr]>, char *<[buf]>, int <[n]>, FILE *<[fp]>);
  33.  
  34. TRAD_SYNOPSIS
  35.         #include <stdio.h>
  36.         char *fgets(<[buf]>,<[n]>,<[fp]>)
  37.         char *<[buf]>;
  38.         int <[n]>;
  39.         FILE *<[fp]>;
  40.  
  41.         #include <stdio.h>
  42.         char *_fgets_r(<[ptr]>, <[buf]>,<[n]>,<[fp]>)
  43.         struct _reent *<[ptr]>;
  44.         char *<[buf]>;
  45.         int <[n]>;
  46.         FILE *<[fp]>;
  47.  
  48. DESCRIPTION
  49.         Reads at most <[n-1]> characters from <[fp]> until a newline
  50.         is found. The characters including to the newline are stored
  51.         in <[buf]>. The buffer is terminated with a 0.
  52.  
  53.         The <<_fgets_r>> function is simply the reentrant version of
  54.         <<fgets>> and is passed an additional reentrancy structure
  55.         pointer: <[ptr]>.
  56.  
  57. RETURNS
  58.         <<fgets>> returns the buffer passed to it, with the data
  59.         filled in. If end of file occurs with some data already
  60.         accumulated, the data is returned with no other indication. If
  61.         no data are read, NULL is returned instead.
  62.  
  63. PORTABILITY
  64.         <<fgets>> should replace all uses of <<gets>>. Note however
  65.         that <<fgets>> returns all of the data, while <<gets>> removes
  66.         the trailing newline (with no indication that it has done so.)
  67.  
  68. Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
  69. <<lseek>>, <<read>>, <<sbrk>>, <<write>>.
  70. */
  71.  
  72. #include <_ansi.h>
  73. #include <stdio.h>
  74. #include <string.h>
  75. #include "local.h"
  76.  
  77. /*
  78.  * Read at most n-1 characters from the given file.
  79.  * Stop when a newline has been read, or the count runs out.
  80.  * Return first argument, or NULL if no characters were read.
  81.  */
  82.  
  83. char *
  84. _DEFUN(_fgets_r, (ptr, buf, n, fp),
  85.        struct _reent * ptr _AND
  86.        char *buf _AND
  87.        int n     _AND
  88.        FILE * fp)
  89. {
  90.   size_t len;
  91.   char *s;
  92.   unsigned char *p, *t;
  93.  
  94.   if (n < 2)                    /* sanity check */
  95.     return 0;
  96.  
  97.   s = buf;
  98.  
  99.   CHECK_INIT(ptr, fp);
  100.  
  101.   __sfp_lock_acquire ();
  102.   _flockfile (fp);
  103. #ifdef __SCLE
  104.   if (fp->_flags & __SCLE)
  105.     {
  106.       int c;
  107.       /* Sorry, have to do it the slow way */
  108.       while (--n > 0 && (c = __sgetc_r (ptr, fp)) != EOF)
  109.         {
  110.           *s++ = c;
  111.           if (c == '\n')
  112.             break;
  113.         }
  114.       if (c == EOF && s == buf)
  115.         {
  116.           _funlockfile (fp);
  117.           __sfp_lock_release ();
  118.           return NULL;
  119.         }
  120.       *s = 0;
  121.       _funlockfile (fp);
  122.       __sfp_lock_release ();
  123.       return buf;
  124.     }
  125. #endif
  126.  
  127.   n--;                          /* leave space for NUL */
  128.   do
  129.     {
  130.       /*
  131.        * If the buffer is empty, refill it.
  132.        */
  133.       if ((len = fp->_r) <= 0)
  134.         {
  135.           if (__srefill_r (ptr, fp))
  136.             {
  137.               /* EOF: stop with partial or no line */
  138.               if (s == buf)
  139.                 {
  140.                   _funlockfile (fp);
  141.                   __sfp_lock_release ();
  142.                   return 0;
  143.                 }
  144.               break;
  145.             }
  146.           len = fp->_r;
  147.         }
  148.       p = fp->_p;
  149.  
  150.       /*
  151.        * Scan through at most n bytes of the current buffer,
  152.        * looking for '\n'.  If found, copy up to and including
  153.        * newline, and stop.  Otherwise, copy entire chunk
  154.        * and loop.
  155.        */
  156.       if (len > n)
  157.         len = n;
  158.       t = (unsigned char *) memchr ((_PTR) p, '\n', len);
  159.       if (t != 0)
  160.         {
  161.           len = ++t - p;
  162.           fp->_r -= len;
  163.           fp->_p = t;
  164.           _CAST_VOID memcpy ((_PTR) s, (_PTR) p, len);
  165.           s[len] = 0;
  166.           _funlockfile (fp);
  167.           __sfp_lock_release ();
  168.           return (buf);
  169.         }
  170.       fp->_r -= len;
  171.       fp->_p += len;
  172.       _CAST_VOID memcpy ((_PTR) s, (_PTR) p, len);
  173.       s += len;
  174.     }
  175.   while ((n -= len) != 0);
  176.   *s = 0;
  177.   _funlockfile (fp);
  178.   __sfp_lock_release ();
  179.   return buf;
  180. }
  181.  
  182. #ifndef _REENT_ONLY
  183.  
  184. char *
  185. _DEFUN(fgets, (buf, n, fp),
  186.        char *buf _AND
  187.        int n     _AND
  188.        FILE * fp)
  189. {
  190.   return _fgets_r (_REENT, buf, n, fp);
  191. }
  192.  
  193. #endif /* !_REENT_ONLY */
  194.