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 );
}
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 );
}
static size_t GetFixedRec( b_file *io, char *b, size_t len )
//==========================================================
// Get a record from a file with "fixed" records.
{
len = SysRead( io, b, len );
if( len == READ_ERROR )
return( 0 );
return( len );
}
ssize_t read(int fd,void* buf,size_t count)
{
ssize_t ret = SysRead(fd, buf, count);
if (ret < 0)
{
errno=-ret;
return -1;
}
return ret;
}
int s_video_null_mouse_update (s_video_input_data_t *mouse)
{
struct Ps2Packet pack;
int dX, dY;
readAgain:
if (SysRead(mouseFd, &pack, sizeof(struct Ps2Packet)) < 0)
return -EIO;
if (pack.flags.xOverflow || pack.flags.yOverflow)
goto readAgain;
// printf("pack.flags = %u, pack.dX = %d, dY = %d\n", *(unsigned char*)&pack.flags, pack.dX, pack.dY);
// printf("xSign = %u, ySign = %u\n", pack.flags.xSign, pack.flags.ySign);
dX=pack.dX;
dY=pack.dY;
if (pack.flags.xSign)
dX=dX-255;
if (pack.flags.ySign)
dY=dY-255;
mouseX+=dX;
mouseY-=dY;
mouseX=MAX(mouseX, 0);
mouseY=MAX(mouseY, 0);
mouseX=MIN(mouseX, 320);
mouseY=MIN(mouseY, 200);
mouse->mouse.x = mouseX;
mouse->mouse.y = mouseY;
mouse->mouse.buttons = 0;
// printf("x = %u, y = %u\n", mouse->mouse.x, mouse->mouse.y);
if (pack.flags.leftB)
mouse->mouse.buttons |= MOUSE_LEFTBUTTON;
if (pack.flags.middleB)
mouse->mouse.buttons |= MOUSE_MIDDLEBUTTON;
if (pack.flags.rightB)
mouse->mouse.buttons |= MOUSE_RIGHTBUTTON;
return 0;
}
int FileGetChar(struct File* file)
{
if (!file)
return -1;
unsigned char c;
int bytesRead=SysRead(file->fd, &c, 1);
if (!bytesRead)
return -1;
else if (bytesRead != 1)
return -1;
return (int)c;
}
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 );
}
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 );
}
}
static size_t GetTextRec( b_file *io, char *b, size_t len )
//=========================================================
// Get a record from a TEXT file.
{
char ch;
size_t read;
char rs[2];
if( io->attrs & SEEK ) { // direct access
if( SysRead( io, b, len ) == READ_ERROR )
return( 0 );
if( SysRead( io, rs, sizeof( char ) ) == READ_ERROR )
return( 0 );
if( rs[0] == LF )
return( len );
#if ! defined( __UNIX__ )
if( rs[0] == CR ) {
if( SysRead( io, &rs[1], sizeof( char ) ) == READ_ERROR ) {
return( 0 );
}
if( rs[1] == LF )
return( len );
if( ( io->attrs & CARRIAGE_CONTROL ) && ( rs[1] == FF ) ) {
return( len );
}
}
#endif
FSetErr( IO_BAD_RECORD, io );
return( 0 );
} else if( io->attrs & BUFFERED ) {
char *ptr;
char *stop;
bool seen_cr;
bool trunc;
size_t max_valid;
// determine maximum valid position in the buffer
max_valid = io->read_len;
if( max_valid < io->high_water ) {
max_valid = io->high_water;
}
stop = io->buffer + max_valid;
ptr = io->buffer + io->b_curs;
read = 0;
seen_cr = false;
trunc = false;
for( ;; ) {
if( ptr >= stop ) {
io->b_curs = ptr - io->buffer;
if( FillBuffer( io ) < 0 ) {
// we have to do this so that io->b_curs is set properly
// on end of file
ptr = io->buffer + io->b_curs;
if( read > 0 && io->stat == IO_EOF ) {
IOOk( io );
}
break;
}
stop = io->buffer + io->read_len;
ptr = io->buffer + io->b_curs;
}
ch = *ptr;
++ptr;
if( ch == LF )
break;
if( !seen_cr ) {
if( ch == CTRL_Z ) {
--ptr; // give back char so we don't read past EOF
if( read == 0 )
FSetEof( io );
break;
}
if( ch == CR ) {
seen_cr = true;
} else if( read < len ) {
b[read] = ch;
++read;
} else {
trunc = true;
}
} else {
if( ch == FF && (io->attrs & CARRIAGE_CONTROL) )
break;
--ptr; // give back the char
seen_cr = false;
if( read < len ) {
b[read] = CR;
++read;
} else {
trunc = true;
}
}
}
io->b_curs = ptr - io->buffer;
if( trunc ) {
FSetTrunc( io );
}
return( read );
} else { // device (CON)
read = 0;
len = readbytes( io, b, len );
if( len == READ_ERROR )
return( 0 );
for( ;; ) {
if( read == len )
break;
#if defined( __UNIX__ ) || defined( __NETWARE__ )
if( *b == LF )
return( read );
#else
if( *b == CR ) {
++b;
if( read == len - 1 )
break;
if( *b == LF )
return( read );
--b;
} else if( *b == CTRL_Z ) {
FSetEof( io );
return( read );
}
#endif
++b;
++read;
}
FSetTrunc( io );
return( read );
}
}
