/***
*fseek.c - reposition file pointer on a stream
*
*	Copyright (c) 1985-1992, Microsoft Corporation. All rights reserved.
*
*Purpose:
*	defines fseek() - move the file pointer to new place in file
*
*Revision History:
*	10-13-83  RN	initial version
*	06-26-85  TC	added code to allow variable buffer lengths
*	02-10-87  BCM	fixed '%' mistakenly used for '/'
*	03-04-87  JCR	added errno settings
*	04-16-87  JCR	added _IOUNGETC support for bug fix and changes whence
*			from unsigned int to int (ANSI conformance)
*	04-17-87  JCR	fseek() now clears end-of-file indicator flag _IOEOF
*			(for ANSI conformance)
*	04-21-87  JCR	be smart about lseek'ing to the end of the file and
*			back
*	09-17-87  SKS	handle case of '\n' at beginning of buffer (FCRLF flag)
*	09-24-87  JCR	fixed an incorrect access to flag _IOEOF
*	09-28-87  JCR	Corrected _iob2 indexing (now uses _iob_index() macro).
*	09-30-87  JCR	Fixed buffer allocation bug, now use _getbuf()
*	11-04-87  JCR	Multi-thread support
*	12-11-87  JCR	Added "_LOAD_DS" to declaration
*	01-13-88  JCR	Removed unnecessary calls to mthread fileno/feof/ferror
*	03-04-88  JCR	Return value from read() must be treated as unsigned
*			value
*	05-27-88  PHG	Merged DLL and normal versions
*	06-06-88  JCR	Optimized _iob2[] references
*	06-15-88  JCR	Near reference to _iob[] entries; improve REG variables
*	08-25-88  GJF	Don't use FP_OFF() macro for the 386
*	12-02-88  JCR	Added _IOCTRLZ support (fixes bug pertaining to ^Z at
*			eof)
*	04-12-89  JCR	Ripped out all of the special read-only code.  See the
*			comments in the routine header for more information.
*	08-17-89  GJF	Clean up, now specific to OS/2 2.0 (i.e., 386 flat
*			model). Also fixed copyright and indents.
*	02-15-90  GJF	Fixed copyright
*	03-19-90  GJF	Made calling type _CALLTYPE1, added #include
*			<cruntime.h> and removed #include <register.h>.
*	05-29-90  SBM   Use _flush, not [_]fflush[_lk]
*	07-23-90  SBM	Replaced <assertm.h> by <assert.h>
*	10-02-90  GJF	New-style function declarators.
*	01-21-91  GJF	ANSI naming.
*	03-27-92  DJM	POSIX support.
*	08-08-92  GJF	Use seek method constants!
*	08-26-92  GJF	Include unistd.h for POSIX build.
*
*******************************************************************************/

#include <cruntime.h>
#include <stdio.h>
#include <file2.h>
#include <assert.h>
#ifdef	_POSIX_
#include <unistd.h>
#else
#include <msdos.h>
#endif
#include <errno.h>
#include <malloc.h>
#include <io.h>
#include <stddef.h>
#include <internal.h>
#ifndef _POSIX_
#include <os2dll.h>
#endif

/***
*int fseek(stream, offset, whence) - reposition file pointer
*
*Purpose:
*
*	Reposition file pointer to the desired location.  The new location
*	is calculated as follows:
*				 { whence=0, beginning of file }
*		<offset> bytes + { whence=1, current position  }
*				 { whence=2, end of file       }
*
*	Be careful to coordinate with buffering.
*
*			- - - - - - - - - - - - -
*
*	[NOTE: We used to bend over backwards to try and preserve the current
*	buffer and maintain disk block alignment.  This ended up making our
*	code big and slow and complicated, and slowed us down quite a bit.
*	Some of the things pertinent to the old implimentation:
*
*	(1) Read-only: We only did the special code path if the file was
*	opened read-only (_IOREAD).  If the file was writable, we didn't
*	try to optimize.
*
*	(2) Buffering:	We'd assign a buffer, if necessary, since the
*	later code might need it (i.e., call _getbuf).
*
*	(3) Ungetc: Fseek had to be careful NOT to save the buffer if
*	an ungetc had ever been done on the buffer (flag _IOUNGETC).
*
*	(4) Control ^Z: Fseek had to deal with ^Z after reading a
*	new buffer's worth of data (flag _IOCTRLZ).
*
*	(5) Seek-to-end-and-back: To determine if the new seek was within
*	the current buffer, we had to 'normalize' the desired location.
*	This means that we sometimes had to seek to the end of the file
*	and back to determine what the 0-relative offset was.  Two extra
*	lseek() calls hurt performance.
*
*	(6) CR/LF accounting - When trying to seek within a buffer that
*	is in text mode, we had to go account for CR/LF expansion.  This
*	required us to look at every character up to the new offset and
*	see if it was '\n' or not.  In addition, we had to check the
*	FCRLF flag to see if the new buffer started with '\n'.
*
*	Again, all of these notes are for the OLD implimentation just to
*	remind folks of some of the issues involving seeking within a buffer
*	and maintaining buffer alignment.  As an aside, I think this may have
*	been a big win in the 'old days' on floppy-based systems but on newer
*	fast hard disks, the extra code/complexity overwhelmed any gain.
*
*			- - - - - - - - - - - - -
*
*Entry:
*	FILE *stream - file to reposition file pointer on
*	long offset - offset to seek to
*	int whence - origin offset is measured from (0=beg, 1=current pos,
*		     2=end)
*
*Exit:
*	returns 0 if succeeds
*	returns -1 and sets errno if fails
*	fields of FILE struct will be changed
*
*Exceptions:
*
*******************************************************************************/

#ifdef MTHREAD	/* multi-thread; define both fseek() and _lk_fseek() */

int _CALLTYPE1 fseek (
	FILE *stream,
	long offset,
	int whence
	)
{
	int retval;
#ifdef MTHREAD
	int index;
#endif

	assert(stream != NULL);

#ifdef MTHREAD
	index = _iob_index(stream);
#endif

	_lock_str(index);

	retval = _fseek_lk (stream, offset, whence);

	_unlock_str(index);

	return(retval);
}


/***
*_fseek_lk() - Core fseek() routine (stream is locked)
*
*Purpose:
*	Core fseek() routine; assumes that caller has the stream locked.
*
*	[See fseek() for more info.]
*
*Entry: [See fseek()]
*
*Exit:	[See fseek()]
*
*Exceptions:
*
*******************************************************************************/

int _CALLTYPE1 _fseek_lk (

#else	/* non multi-thread; just define fseek() */

int _CALLTYPE1 fseek (

#endif	/* rejoin common code */

	FILE *str,
	long offset,
	int whence
	)
{


	REG1 FILE *stream;

	assert(str != NULL);

	/* Init stream pointer */
	stream = str;

	if ( !inuse(stream) || ((whence != SEEK_SET) && (whence != SEEK_CUR) &&
	    (whence != SEEK_END)) ) {
		errno=EINVAL;
		return(-1);
	}

	/* Clear EOF flag */

	stream->_flag &= ~_IOEOF;

	/* If seeking relative to current location, then convert to
	   a seek relative to beginning of file.  This accounts for
	   buffering, etc. by letting fseek() tell us where we are. */

	if (whence == SEEK_CUR) {
		offset += _ftell_lk(stream);
		whence = SEEK_SET;
	}

	/* Flush buffer as necessary */

#ifdef _POSIX_
	/*
	 * If the stream was last read, we throw away the buffer so
	 * that a possible subsequent write will encounter a clean
	 * buffer.  (The Win32 version of fflush() throws away the
	 * buffer if it's read.)  Write buffers must be flushed.
	 */
	
	if ((stream->_flag & (_IOREAD | _IOWRT)) == _IOREAD) {
		stream->_ptr = stream->_base;
		stream->_cnt = 0;
	} else {
		_flush(stream);
	}
#else
	_flush(stream);
#endif


	/* If file opened for read/write, clear flags since we don't know
	what the user is going to do next. */

	if (stream->_flag & _IORW)
		stream->_flag &= ~(_IOWRT|_IOREAD);

	/* Seek to the desired locale and return. */

#ifdef _POSIX_
	return(lseek(fileno(stream), offset, whence) == -1L ? -1 : 0);
#else
	return(_lseek(_fileno(stream), offset, whence) == -1L ? -1 : 0);
#endif
}