int FSkipLogical( b_file *io )
//================================
{
unsigned_32 tag;
unsigned_32 save_tag;
size_t rc;
for(;;) {
rc = SysRead( io, (char *)(&tag), sizeof( unsigned_32 ) );
if( rc == READ_ERROR ) {
if( io->stat != IO_EOF )
return( -1 );
// if an EOF occurs we've skipped the record
IOOk( io );
return( 0 );
}
if( (tag & 0x80000000) == 0 )
break;
save_tag = tag;
tag &= 0x7fffffff;
if( SysSeek( io, tag, SEEK_CUR ) < 0 )
return( -1 );
rc = SysRead( io, (char *)(&tag), sizeof( unsigned_32 ) );
if( rc == READ_ERROR )
return( -1 );
if( tag != save_tag ) {
FSetErr( IO_BAD_RECORD, io );
return( -1 );
}
}
if( SysSeek( io, -(long)sizeof( unsigned_32 ), SEEK_CUR ) < 0 )
return( -1 );
return( 0 );
}
int SampWrite( void FAR_PTR *buff, unsigned len )
{
unsigned written;
int handle;
int rc;
_fstrcpy( SampName, SharedMemory->SampName );
if( SharedMemory->SampleHandle == 0 ) {
handle = SysCreate( SampName );
SharedMemory->SampleHandle = 1;
} else {
handle = SysOpen( SampName );
if( handle >= 0 ) SysSeek( handle, SharedMemory->SampOffset );
}
if( handle == -1 ) {
SharedMemory->FarWriteProblem = 1;
return( -1 );
}
written = SysWrite( handle, buff, len );
if( written == len ) {
SharedMemory->SampOffset += len;
rc = 0;
} else {
SysSeek( handle, SharedMemory->SampOffset );
SysWrite( handle, "", 0 );
SharedMemory->FarWriteProblem = 1;
rc = -1;
}
SysClose( handle );
return( rc );
} /* SampWrite */
static size_t GetVariableRec( b_file *io, char *b, size_t len )
//=============================================================
// Get a record from a file with "variable" records.
{
size_t tag_len;
unsigned_32 tag;
unsigned_32 save_tag;
if( SysRead( io, (char *)(&tag), sizeof( unsigned_32 ) ) == READ_ERROR ) {
return( 0 );
}
save_tag = tag;
tag_len = tag & 0x7fffffff;
if( tag_len > len ) {
FSetTrunc( io );
if( SysRead( io, b, len ) == READ_ERROR )
return( 0 );
if( SysSeek( io, (long)tag_len - (long)len, SEEK_CUR ) < 0 ) {
FSetSysErr( io );
return( 0 );
}
} else {
if( SysRead( io, b, tag_len ) == READ_ERROR )
return( 0 );
len = tag_len;
}
if( SysRead( io, (char *)(&tag), sizeof( unsigned_32 ) ) == READ_ERROR )
return( 0 );
if( tag != save_tag ) {
FSetErr( IO_BAD_RECORD, io );
return( 0 );
}
return( len );
}
signed_32 FGetVarRecLen( b_file *io )
//=========================================
{
unsigned_32 tag;
unsigned_32 save_tag;
int rc;
long pos;
unsigned_32 size = 0;
pos = FGetFilePos( io );
for( ;; ) {
rc = SysRead( io, (char *)(&tag), sizeof( unsigned_32 ) );
if( rc == READ_ERROR ) {
if( io->stat != IO_EOF )
return( -1 );
// if an EOF occurs we've skipped the record
IOOk( io );
break;
}
save_tag = tag;
if( !size ) {
if( tag & 0x80000000 ) {
FSetErr( IO_BAD_RECORD, io );
return( -1 );
}
} else {
if( tag & 0x80000000 ) {
tag &= 0x7fffffff;
} else {
break;
}
}
size += tag;
if( SysSeek( io, tag, SEEK_CUR ) < 0 )
return( -1 );
rc = SysRead( io, (char *)(&tag), sizeof( unsigned_32 ) );
if( rc == READ_ERROR )
return( -1 );
if( tag != save_tag ) {
FSetErr( IO_BAD_RECORD, io );
return( -1 );
}
}
if( SysSeek( io, pos, SEEK_SET ) < 0 )
return( -1 );
return( size );
}
int SampSeek( unsigned long loc )
{
if( !SampIsDOS ) {
if( SysSeek( SampleHandle, loc ) != loc ) return( -1 );
}
SampOffset = loc;
return( 0 );
}
void FBackspace( b_file *io, int rec_size ) {
//==============================================
// Backspace a file.
uint ch;
unsigned_32 offset;
bool start_of_logical_record;
IOOk( io );
if( io->attrs & REC_VARIABLE ) {
for(;;) {
offset = sizeof( unsigned_32 );
if( SysSeek( io, -offset, SEEK_CUR ) < 0 ) return;
if( SysRead( io, (char *)(&offset), sizeof( unsigned_32 ) ) ==
READ_ERROR ) return;
if( offset & 0x80000000 ) {
offset &= 0x7fffffff;
start_of_logical_record = FALSE;
} else {
start_of_logical_record = TRUE;
}
SysSeek( io, -( offset + 2 * sizeof( unsigned_32 ) ), SEEK_CUR );
if( start_of_logical_record ) break;
}
} else if( io->attrs & REC_TEXT ) {
// skip first record separator
if( GetPrevChar( io ) == NO_CHAR ) return;
for(;;) {
ch = GetPrevChar( io );
if( ch == NO_CHAR ) return;
if( ch == LF ) break;
}
// give back record separator
SysSeek( io, +1, SEEK_CUR );
} else {
SysSeek( io, -rec_size, SEEK_CUR );
}
}
off_t lseek(int fd,off_t offset,int whence)
{
int ret;
ret = SysSeek(fd, offset, whence);
if (ret < 0)
{
errno = -ret;
ret = -1;
}
return (off_t)ret;
}
static uint GetPrevChar( b_file *io ) {
//=========================================
// Get previous character in file.
if( CurrFileOffset( io ) == 0 ) return( NO_CHAR );
if( SysSeek( io, -1L, SEEK_CUR ) < 0 ) {
return( NO_CHAR );
}
if( ( io->attrs & READ_AHEAD ) && io->b_curs < io->read_len ) {
return( io->buffer[ io->b_curs ] );
} else if( io->b_curs < io->high_water ) {
return( io->buffer[ io->b_curs ] );
}
return( NO_CHAR );
}
void FSeekRec( b_file *io, unsigned_32 rec, uint recsize )
// Seek to specified record in file.
{
IOOk( io );
if( io->attrs & SEEK ) {
if( io->attrs & REC_TEXT ) {
#if defined( __UNIX__ )
recsize += sizeof( char ); // compensate for LF
#else
recsize += 2 * sizeof( char ); // compensate for CR/LF
#endif
} else if( io->attrs & REC_VARIABLE ) {
recsize += 2 * sizeof( unsigned_32 ); // compensate for length tags
}
SysSeek( io, rec * recsize, SEEK_SET );
} else {
FSetErr( IO_BAD_OPERATION, io );
}
}
int FCheckLogical( b_file *io )
//=================================
{
unsigned_32 tag;
size_t rc;
rc = SysRead( io, (char *)(&tag), sizeof( unsigned_32 ) );
if( rc == READ_ERROR ) {
if( io->stat != IO_EOF )
return( -1 );
// if an EOF occurs we've skipped the record
IOOk( io );
return( 0 );
}
rc = 0;
if( tag & 0x80000000 ) {
rc = 1;
}
if( SysSeek( io, -(long)sizeof( unsigned_32 ), SEEK_CUR ) < 0 )
return( -1 );
return( rc );
}
int SampWrite( void FAR_PTR *buff, unsigned len )
{
LONG written;
if( SampIsDOS ) {
DOSWrite( SampleHandle, SampOffset, buff, len, &written );
} else {
written = SysWrite( SampleHandle, buff, len );
}
if( written == len ) {
SampOffset += len;
return( 0 );
} else {
if( SampIsDOS ) {
DOSWrite( SampleHandle, SampOffset, buff, 0, &written );
} else {
SysSeek( SampleHandle, SampOffset );
SysWrite( SampleHandle, "", 0 ); /* truncate the file */
}
FarWriteProblem = 1;
return( -1 );
}
}
void FSeekAbs( b_file *io, unsigned_32 offset )
{
SysSeek( io, offset, SEEK_SET );
}
