Пример #1
0
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 );
}
Пример #2
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 );
}
Пример #3
0
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 );
}
Пример #4
0
static  void    ChkDisk( ftnfile *fcb ) {
//=======================================

// Make sure that the file is a disk file.

    if( IsDevice( fcb ) ) {
        FSetErr( IO_BAD_OPERATION, fcb->fileptr );
    }
}
Пример #5
0
b_file  *_AllocFile( int h, f_attrs attrs, long int fpos ) {
// Allocate file structure.
    b_file      *io;
    struct stat info;
    int         buff_size;

    if( fstat( h, &info ) == -1 ) {
        FSetSysErr( NULL );
        return( NULL );
    }
    attrs &= ~CREATION_MASK;
    if( S_ISCHR( info.st_mode ) ) {
        io = MEM_ALLOC( sizeof( a_file ) );
        // Turn off truncate just in case we turned it on by accident due to
        // a buggy NT dos box.  We NEVER want to truncate a device.
        attrs &= ~TRUNC_ON_WRITE;
        attrs |= CHAR_DEVICE;
    } else {
        attrs |= BUFFERED;
        buff_size = IOBufferSize;
        io = MEM_ALLOC( sizeof( b_file ) + IOBufferSize - MIN_BUFFER );
        if( ( io == NULL ) && ( IOBufferSize > MIN_BUFFER ) ) {
            // buffer is too big (low on memory) so use small buffer
            buff_size = MIN_BUFFER;
            io = MEM_ALLOC( sizeof( b_file ) );
        }
    }
    if( io == NULL ) {
        close( h );
        FSetErr( IO_NO_MEM, NULL );
    } else {
        if( attrs & CARRIAGE_CONTROL ) {
            attrs |= CC_NOLF;
        }
        io->attrs = attrs;
        io->handle = h;
        if( attrs & BUFFERED ) {
            io->b_curs = 0;
            io->read_len = 0;
            io->buff_size = buff_size;
            io->high_water = 0;
        }
        io->phys_offset = fpos;
        IOOk( io );
    }
    return( io );
}
Пример #6
0
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 );
    }
}
Пример #7
0
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 );
    }
}