Subversion Repositories Kolibri OS

/*

 * Copyright (c) 1990, 2007 The Regents of the University of California.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms are permitted

 * provided that the above copyright notice and this paragraph are

 * duplicated in all such forms and that any documentation,

 * advertising materials, and other materials related to such

 * distribution and use acknowledge that the software was developed

 * by the University of California, Berkeley.  The name of the

 * University may not be used to endorse or promote products derived

 * from this software without specific prior written permission.

 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

 */

/*

FUNCTION

<>---read array elements from a file

INDEX

	fread

INDEX

	_fread_r

ANSI_SYNOPSIS

	#include 

	size_t fread(void *<[buf]>, size_t <[size]>, size_t <[count]>,

		     FILE *<[fp]>);

	#include 

	size_t _fread_r(struct _reent *<[ptr]>, void *<[buf]>,

	                size_t <[size]>, size_t <[count]>, FILE *<[fp]>);

TRAD_SYNOPSIS

	#include 

	size_t fread(<[buf]>, <[size]>, <[count]>, <[fp]>)

	char *<[buf]>;

	size_t <[size]>;

	size_t <[count]>;

	FILE *<[fp]>;

	#include 

	size_t _fread_r(<[ptr]>, <[buf]>, <[size]>, <[count]>, <[fp]>)

	struct _reent *<[ptr]>;

	char *<[buf]>;

	size_t <[size]>;

	size_t <[count]>;

	FILE *<[fp]>;

DESCRIPTION

<> attempts to copy, from the file or stream identified by

<[fp]>, <[count]> elements (each of size <[size]>) into memory,

starting at <[buf]>.   <> may copy fewer elements than

<[count]> if an error, or end of file, intervenes.

<> also advances the file position indicator (if any) for

<[fp]> by the number of @emph{characters} actually read.

<<_fread_r>> is simply the reentrant version of <> that

takes an additional reentrant structure pointer argument: <[ptr]>.

RETURNS

The result of <> is the number of elements it succeeded in

reading.

PORTABILITY

ANSI C requires <>.

Supporting OS subroutines required: <>, <>, <>,

<>, <>, <>, <>.

*/

#include <_ansi.h>

#include 

#include 

#include 

#include "local.h"

#ifdef __SCLE

static size_t

_DEFUN(crlf_r, (ptr, fp, buf, count, eof),

       struct _reent * ptr _AND

       FILE * fp _AND

       char * buf _AND

       size_t count _AND

       int eof)

{

  int r;

  char *s, *d, *e;

  if (count == 0)

    return 0;

  e = buf + count;

  for (s=d=buf; s

    {

      if (*s == '\r' && s[1] == '\n')

        s++;

      *d++ = *s;

    }

  if (s < e)

    {

      if (*s == '\r')

        {

          int c = __sgetc_raw_r (ptr, fp);

          if (c == '\n')

            *s = '\n';

          else

            ungetc (c, fp);

        }

      *d++ = *s++;

    }

  while (d < e)

    {

      r = _getc_r (ptr, fp);

      if (r == EOF)

        return count - (e-d);

      *d++ = r;

    }

  return count;

}

#endif

size_t

_DEFUN(_fread_r, (ptr, buf, size, count, fp),

       struct _reent * ptr _AND

       _PTR buf _AND

       size_t size _AND

       size_t count _AND

       FILE * fp)

{

  register size_t resid;

  register char *p;

  register int r;

  size_t total;

  if ((resid = count * size) == 0)

    return 0;

  CHECK_INIT(ptr, fp);

  _flockfile (fp);

  ORIENT (fp, -1);

  if (fp->_r < 0)

    fp->_r = 0;

  total = resid;

  p = buf;

#if !defined(PREFER_SIZE_OVER_SPEED) && !defined(__OPTIMIZE_SIZE__)

  /* Optimize unbuffered I/O.  */

  if (fp->_flags & __SNBF)

    {

      /* First copy any available characters from ungetc buffer.  */

      int copy_size = resid > fp->_r ? fp->_r : resid;

      _CAST_VOID memcpy ((_PTR) p, (_PTR) fp->_p, (size_t) copy_size);

      fp->_p += copy_size;

      fp->_r -= copy_size;

      p += copy_size;

      resid -= copy_size;

      /* If still more data needed, free any allocated ungetc buffer.  */

      if (HASUB (fp) && resid > 0)

	FREEUB (ptr, fp);

      /* Finally read directly into user's buffer if needed.  */

      while (resid > 0)

	{

	  int rc = 0;

	  /* save fp buffering state */

	  void *old_base = fp->_bf._base;

	  void * old_p = fp->_p;

	  int old_size = fp->_bf._size;

	  /* allow __refill to use user's buffer */

	  fp->_bf._base = (unsigned char *) p;

	  fp->_bf._size = resid;

	  fp->_p = (unsigned char *) p;

	  rc = __srefill_r (ptr, fp);

	  /* restore fp buffering back to original state */

	  fp->_bf._base = old_base;

	  fp->_bf._size = old_size;

	  fp->_p = old_p;

	  resid -= fp->_r;

	  p += fp->_r;

	  fp->_r = 0;

	  if (rc)

	    {

#ifdef __SCLE

              if (fp->_flags & __SCLE)

	        {

	          _funlockfile (fp);

	          return crlf_r (ptr, fp, buf, total-resid, 1) / size;

	        }

#endif

	      _funlockfile (fp);

	      return (total - resid) / size;

	    }

	}

    }

  else

#endif /* !PREFER_SIZE_OVER_SPEED && !__OPTIMIZE_SIZE__ */

    {

      while (resid > (r = fp->_r))

	{

	  _CAST_VOID memcpy ((_PTR) p, (_PTR) fp->_p, (size_t) r);

	  fp->_p += r;

	  /* fp->_r = 0 ... done in __srefill */

	  p += r;

	  resid -= r;

	  if (__srefill_r (ptr, fp))

	    {

	      /* no more input: return partial result */

#ifdef __SCLE

	      if (fp->_flags & __SCLE)

		{

		  _funlockfile (fp);

		  return crlf_r (ptr, fp, buf, total-resid, 1) / size;

		}

#endif

	      _funlockfile (fp);

	      return (total - resid) / size;

	    }

	}

      _CAST_VOID memcpy ((_PTR) p, (_PTR) fp->_p, resid);

      fp->_r -= resid;

      fp->_p += resid;

    }

  /* Perform any CR/LF clean-up if necessary.  */

#ifdef __SCLE

  if (fp->_flags & __SCLE)

    {

      _funlockfile (fp);

      return crlf_r(ptr, fp, buf, total, 0) / size;

    }

#endif

  _funlockfile (fp);

  return count;

}

#ifndef _REENT_ONLY

size_t

_DEFUN(fread, (buf, size, count, fp),

       _PTR buf _AND

       size_t size _AND

       size_t count _AND

       FILE * fp)

{

   return _fread_r (_REENT, buf, size, count, fp);

}

#endif