Subversion Repositories Kolibri OS

Rev

Rev 4874 | Blame | Compare with Previous | Last modification | View Log | 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. <<ftell>>, <<ftello>>---return position in a stream or file
  21.  
  22. INDEX
  23.         ftell
  24. INDEX
  25.         ftello
  26. INDEX
  27.         _ftell_r
  28. INDEX
  29.         _ftello_r
  30.  
  31. ANSI_SYNOPSIS
  32.         #include <stdio.h>
  33.         long ftell(FILE *<[fp]>);
  34.         off_t ftello(FILE *<[fp]>);
  35.         long _ftell_r(struct _reent *<[ptr]>, FILE *<[fp]>);
  36.         off_t _ftello_r(struct _reent *<[ptr]>, FILE *<[fp]>);
  37.  
  38. TRAD_SYNOPSIS
  39.         #include <stdio.h>
  40.         long ftell(<[fp]>)
  41.         FILE *<[fp]>;
  42.  
  43.         off_t ftello(<[fp]>)
  44.         FILE *<[fp]>;
  45.  
  46.         long _ftell_r(<[ptr]>, <[fp]>)
  47.         struct _reent *<[ptr]>;
  48.         FILE *<[fp]>;
  49.  
  50.         off_t _ftello_r(<[ptr]>, <[fp]>)
  51.         struct _reent *<[ptr]>;
  52.         FILE *<[fp]>;
  53.  
  54. DESCRIPTION
  55. Objects of type <<FILE>> can have a ``position'' that records how much
  56. of the file your program has already read.  Many of the <<stdio>> functions
  57. depend on this position, and many change it as a side effect.
  58.  
  59. The result of <<ftell>>/<<ftello>> is the current position for a file
  60. identified by <[fp]>.  If you record this result, you can later
  61. use it with <<fseek>>/<<fseeko>> to return the file to this
  62. position.  The difference between <<ftell>> and <<ftello>> is that
  63. <<ftell>> returns <<long>> and <<ftello>> returns <<off_t>>.
  64.  
  65. In the current implementation, <<ftell>>/<<ftello>> simply uses a character
  66. count to represent the file position; this is the same number that
  67. would be recorded by <<fgetpos>>.
  68.  
  69. RETURNS
  70. <<ftell>>/<<ftello>> return the file position, if possible.  If they cannot do
  71. this, they return <<-1L>>.  Failure occurs on streams that do not support
  72. positioning; the global <<errno>> indicates this condition with the
  73. value <<ESPIPE>>.
  74.  
  75. PORTABILITY
  76. <<ftell>> is required by the ANSI C standard, but the meaning of its
  77. result (when successful) is not specified beyond requiring that it be
  78. acceptable as an argument to <<fseek>>.  In particular, other
  79. conforming C implementations may return a different result from
  80. <<ftell>> than what <<fgetpos>> records.
  81.  
  82. <<ftello>> is defined by the Single Unix specification.
  83.  
  84. No supporting OS subroutines are required.
  85. */
  86.  
  87. #if defined(LIBC_SCCS) && !defined(lint)
  88. static char sccsid[] = "%W% (Berkeley) %G%";
  89. #endif /* LIBC_SCCS and not lint */
  90.  
  91. /*
  92.  * ftello: return current offset.
  93.  */
  94.  
  95. #include <_ansi.h>
  96. #include <reent.h>
  97. #include <stdio.h>
  98. #include <errno.h>
  99. #include "local.h"
  100.  
  101. _off_t
  102. _DEFUN(_ftello_r, (ptr, fp),
  103.        struct _reent * ptr _AND
  104.        register FILE * fp)
  105. {
  106.   _fpos_t pos;
  107.  
  108.   /* Ensure stdio is set up.  */
  109.  
  110.   CHECK_INIT (ptr, fp);
  111.  
  112.   _newlib_flockfile_start (fp);
  113.  
  114.   if (fp->_seek == NULL)
  115.     {
  116.       ptr->_errno = ESPIPE;
  117.       _newlib_flockfile_exit (fp);
  118.       return -1L;
  119.     }
  120.  
  121.   /* Find offset of underlying I/O object, then adjust for buffered
  122.      bytes.  Flush a write stream, since the offset may be altered if
  123.      the stream is appending.  Do not flush a read stream, since we
  124.      must not lose the ungetc buffer.  */
  125.   if (fp->_flags & __SWR)
  126.     _fflush_r (ptr, fp);
  127.   if (fp->_flags & __SOFF)
  128.     pos = fp->_offset;
  129.   else
  130.     {
  131.       pos = fp->_seek (ptr, fp->_cookie, (_fpos_t) 0, SEEK_CUR);
  132.       if (pos == -1L)
  133.         {
  134.           _newlib_flockfile_exit (fp);
  135.           return pos;
  136.         }
  137.     }
  138.   if (fp->_flags & __SRD)
  139.     {
  140.       /*
  141.        * Reading.  Any unread characters (including
  142.        * those from ungetc) cause the position to be
  143.        * smaller than that in the underlying object.
  144.        */
  145.       pos -= fp->_r;
  146.       if (HASUB (fp))
  147.         pos -= fp->_ur;
  148.     }
  149.   else if ((fp->_flags & __SWR) && fp->_p != NULL)
  150.     {
  151.       /*
  152.        * Writing.  Any buffered characters cause the
  153.        * position to be greater than that in the
  154.        * underlying object.
  155.        */
  156.       pos += fp->_p - fp->_bf._base;
  157.     }
  158.  
  159.   _newlib_flockfile_end (fp);
  160.   return pos;
  161. }
  162.  
  163. #ifndef _REENT_ONLY
  164.  
  165. _off_t
  166. _DEFUN(ftello, (fp),
  167.        register FILE * fp)
  168. {
  169.   return _ftello_r (_REENT, fp);
  170. }
  171.  
  172. #endif /* !_REENT_ONLY */
  173.