You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
229 lines
8.2 KiB
229 lines
8.2 KiB
/***
|
|
*ftelli64.c - get current file position
|
|
*
|
|
* Copyright (c) 1994-2001, Microsoft Corporation. All rights reserved.
|
|
*
|
|
*Purpose:
|
|
* defines _ftelli64() - find current current position of file pointer
|
|
*
|
|
*Revision History:
|
|
* 12-22-94 GJF Module created. Derived from ftell.c
|
|
* 02-06-94 CFW assert -> _ASSERTE.
|
|
* 03-07-95 GJF _[un]lock_str macros now take FILE * arg.
|
|
* 06-23-95 GJF Replaced _osfile[] with _osfile() (macro referencing
|
|
* field in ioinfo struct).
|
|
* 03-02-98 GJF Exception-safe locking.
|
|
* 03-04-98 RKP Added 64 bit support.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
#include <cruntime.h>
|
|
#include <stdio.h>
|
|
#include <file2.h>
|
|
#include <dbgint.h>
|
|
#include <errno.h>
|
|
#include <msdos.h>
|
|
#include <stddef.h>
|
|
#include <io.h>
|
|
#include <internal.h>
|
|
#include <mtdll.h>
|
|
|
|
/***
|
|
*__int64 _ftelli64(stream) - query stream file pointer
|
|
*
|
|
*Purpose:
|
|
* Find out what stream's position is. coordinate with buffering; adjust
|
|
* backward for read-ahead and forward for write-behind. This is NOT
|
|
* equivalent to fseek(stream,0L,1), because fseek will remove an ungetc,
|
|
* may flush buffers, etc.
|
|
*
|
|
*Entry:
|
|
* FILE *stream - stream to query for position
|
|
*
|
|
*Exit:
|
|
* return present file position if succeeds
|
|
* returns -1i64 and sets errno if fails
|
|
*
|
|
*Exceptions:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
#ifdef _MT
|
|
|
|
__int64 __cdecl _ftelli64 (
|
|
FILE *stream
|
|
)
|
|
{
|
|
__int64 retval;
|
|
|
|
_ASSERTE(stream != NULL);
|
|
|
|
_lock_str(stream);
|
|
|
|
__try {
|
|
retval = _ftelli64_lk (stream);
|
|
}
|
|
__finally {
|
|
_unlock_str(stream);
|
|
}
|
|
|
|
return(retval);
|
|
}
|
|
|
|
|
|
/***
|
|
*_ftelli64_lk() - _ftelli64() core routine (assumes stream is locked).
|
|
*
|
|
*Purpose:
|
|
* Core _ftelli64() routine (assumes caller has aquired stream lock).
|
|
*
|
|
*Entry:
|
|
*
|
|
*Exit:
|
|
*
|
|
*Exceptions:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
__int64 __cdecl _ftelli64_lk (
|
|
|
|
#else /* mdef _MT */
|
|
|
|
__int64 __cdecl _ftelli64 (
|
|
|
|
#endif /* _MT */
|
|
|
|
FILE *str
|
|
)
|
|
{
|
|
REG1 FILE *stream;
|
|
size_t offset;
|
|
__int64 filepos;
|
|
REG2 char *p;
|
|
char *max;
|
|
int fd;
|
|
size_t rdcnt;
|
|
|
|
_ASSERTE(str != NULL);
|
|
|
|
/* Init stream pointer and file descriptor */
|
|
stream = str;
|
|
fd = _fileno(stream);
|
|
|
|
if (stream->_cnt < 0)
|
|
stream->_cnt = 0;
|
|
|
|
if ((filepos = _lseeki64(fd, 0i64, SEEK_CUR)) < 0L)
|
|
return(-1i64);
|
|
|
|
if (!bigbuf(stream)) /* _IONBF or no buffering designated */
|
|
return(filepos - stream->_cnt);
|
|
|
|
offset = (size_t)(stream->_ptr - stream->_base);
|
|
|
|
if (stream->_flag & (_IOWRT|_IOREAD)) {
|
|
if (_osfile(fd) & FTEXT)
|
|
for (p = stream->_base; p < stream->_ptr; p++)
|
|
if (*p == '\n') /* adjust for '\r' */
|
|
offset++;
|
|
}
|
|
else if (!(stream->_flag & _IORW)) {
|
|
errno=EINVAL;
|
|
return(-1i64);
|
|
}
|
|
|
|
if (filepos == 0i64)
|
|
return((__int64)offset);
|
|
|
|
if (stream->_flag & _IOREAD) /* go to preceding sector */
|
|
|
|
if (stream->_cnt == 0) /* filepos holds correct location */
|
|
offset = 0;
|
|
|
|
else {
|
|
|
|
/* Subtract out the number of unread bytes left in the
|
|
buffer. [We can't simply use _iob[]._bufsiz because
|
|
the last read may have hit EOF and, thus, the buffer
|
|
was not completely filled.] */
|
|
|
|
rdcnt = stream->_cnt + (size_t)(stream->_ptr - stream->_base);
|
|
|
|
/* If text mode, adjust for the cr/lf substitution. If
|
|
binary mode, we're outta here. */
|
|
if (_osfile(fd) & FTEXT) {
|
|
/* (1) If we're not at eof, simply copy _bufsiz
|
|
onto rdcnt to get the # of untranslated
|
|
chars read. (2) If we're at eof, we must
|
|
look through the buffer expanding the '\n'
|
|
chars one at a time. */
|
|
|
|
/* [NOTE: Performance issue -- it is faster to
|
|
do the two _lseek() calls than to blindly go
|
|
through and expand the '\n' chars regardless
|
|
of whether we're at eof or not.] */
|
|
|
|
if (_lseeki64(fd, 0i64, SEEK_END) == filepos) {
|
|
|
|
max = stream->_base + rdcnt;
|
|
for (p = stream->_base; p < max; p++)
|
|
if (*p == '\n')
|
|
/* adjust for '\r' */
|
|
rdcnt++;
|
|
|
|
/* If last byte was ^Z, the lowio read
|
|
didn't tell us about it. Check flag
|
|
and bump count, if necessary. */
|
|
|
|
if (stream->_flag & _IOCTRLZ)
|
|
++rdcnt;
|
|
}
|
|
|
|
else {
|
|
|
|
if (_lseeki64(fd, filepos, SEEK_SET) < 0)
|
|
return (-1);
|
|
|
|
/* We want to set rdcnt to the number
|
|
of bytes originally read into the
|
|
stream buffer (before crlf->lf
|
|
translation). In most cases, this
|
|
will just be _bufsiz. However, the
|
|
buffer size may have been changed,
|
|
due to fseek optimization, at the
|
|
END of the last _filbuf call. */
|
|
|
|
if ( (rdcnt <= _SMALL_BUFSIZ) &&
|
|
(stream->_flag & _IOMYBUF) &&
|
|
!(stream->_flag & _IOSETVBUF) )
|
|
{
|
|
/* The translated contents of
|
|
the buffer is small and we
|
|
are not at eof. The buffer
|
|
size must have been set to
|
|
_SMALL_BUFSIZ during the
|
|
last _filbuf call. */
|
|
|
|
rdcnt = _SMALL_BUFSIZ;
|
|
}
|
|
else
|
|
rdcnt = stream->_bufsiz;
|
|
|
|
|
|
/* If first byte in untranslated buffer
|
|
was a '\n', assume it was preceeded
|
|
by a '\r' which was discarded by the
|
|
previous read operation and count
|
|
the '\n'. */
|
|
if (_osfile(fd) & FCRLF)
|
|
++rdcnt;
|
|
}
|
|
|
|
} /* end if FTEXT */
|
|
|
|
filepos -= (__int64)rdcnt;
|
|
|
|
} /* end else stream->_cnt != 0 */
|
|
|
|
return(filepos + (__int64)offset);
|
|
}
|