summaryrefslogtreecommitdiff
path: root/xbase64/xbmemo.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'xbase64/xbmemo.cpp')
-rwxr-xr-xxbase64/xbmemo.cpp1173
1 files changed, 0 insertions, 1173 deletions
diff --git a/xbase64/xbmemo.cpp b/xbase64/xbmemo.cpp
deleted file mode 100755
index 75956dd..0000000
--- a/xbase64/xbmemo.cpp
+++ /dev/null
@@ -1,1173 +0,0 @@
-/* xbmemo.cpp
-
- Xbase64 project source code
-
- This file contains the basic Xbase64 routines for handling
- dBASE III+ and dBASE IV style memo .dbt files
-
-
- Copyright (C) 1997,2003 Gary A Kunkel
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU Lesser General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-
- Contact:
-
- Email:
-
- xdb-devel@lists.sourceforge.net
- xdb-users@lists.sourceforge.net
-
-
- Regular Mail:
-
- XBase Support
- 149C South Main St
- Keller Texas, 76248
- USA
-*/
-
-#ifdef __WIN32__
-#include <xbase64/xbwincfg.h>
-#else
-#include <xbase64/xbconfig.h>
-#endif
-
-#include <xbase64/xbase64.h>
-#ifdef XB_MEMO_FIELDS
-
-#include <stdio.h>
-//#include <xbase64/xbexcept.h>
-
-#ifdef HAVE_IO_H
-#include <io.h>
-#endif
-
-
-/*! \file xbmemo.cpp
-*/
-
-/************************************************************************/
-//! Short description
-/*!
-*/
-xbLong xbDbf::CalcLastDataBlock()
-{
- if( _fseek( mfp, 0, SEEK_END ) != 0 )
- return XB_SEEK_ERROR;
- return ( _ftell( mfp ) / MemoHeader.BlockSize );
-}
-/************************************************************************/
-//! Short description
-/*!
- \param BlocksNeeded
- \param Location
- \param PrevNode
-*/
-xbShort xbDbf::GetBlockSetFromChain( xbLong BlocksNeeded,
- xbLong Location, xbLong PrevNode )
-
-/* this routine grabs a set of blocks out of the free block chain */
-{
- xbShort rc;
- xbLong NextFreeBlock2, NewFreeBlocks, SaveNextFreeBlock;
-
- if(( rc = ReadMemoBlock( Location, 2 )) != XB_NO_ERROR )
- return rc;
-
- if( BlocksNeeded == FreeBlockCnt ){ /* grab this whole set of blocks */
- if( PrevNode == 0 ){ /* first in the chain */
- MemoHeader.NextBlock = NextFreeBlock;
- if(( rc = UpdateHeadNextNode()) != XB_NO_ERROR )
- return rc;
- }
- else /* remove out of the middle or end */
- {
- NextFreeBlock2 = NextFreeBlock;
- if(( rc = ReadMemoBlock( PrevNode, 2 )) != XB_NO_ERROR )
- return rc;
- NextFreeBlock = NextFreeBlock2;
- if(( rc = WriteMemoBlock( PrevNode, 2 )) != XB_NO_ERROR )
- return rc;
- }
- }
-
- else /* only take a portion of this set */
- {
- if( PrevNode == 0 ){ /* first in the set */
- MemoHeader.NextBlock = Location + BlocksNeeded;
- if(( rc = UpdateHeadNextNode()) != XB_NO_ERROR )
- return rc;
- FreeBlockCnt -= BlocksNeeded;
- if(( rc = WriteMemoBlock( MemoHeader.NextBlock, 2 )) != XB_NO_ERROR )
- return rc;
- }
- else /* remove out of the middle or end */
- {
- NewFreeBlocks = FreeBlockCnt - BlocksNeeded;
- SaveNextFreeBlock = NextFreeBlock;
- NextFreeBlock2= Location + BlocksNeeded;
- if(( rc = ReadMemoBlock( PrevNode, 2 )) != XB_NO_ERROR )
- return rc;
- NextFreeBlock = NextFreeBlock2;
- if(( rc = WriteMemoBlock( PrevNode, 2 )) != XB_NO_ERROR )
- return rc;
- FreeBlockCnt = NewFreeBlocks;
- NextFreeBlock = SaveNextFreeBlock;
- if(( rc = WriteMemoBlock( NextFreeBlock2, 2 )) != XB_NO_ERROR )
- return rc;
- }
- }
- return 0;
-}
-/************************************************************************/
-//! Short description
-/*!
- \param BlocksNeeded
- \param LastDataBlock
- \param Location
- \param PreviousNode
-*/
-xbShort xbDbf::FindBlockSetInChain( xbLong BlocksNeeded,
- xbLong LastDataBlock, xbLong &Location, xbLong &PreviousNode )
-
-/* this routine searches thru the free node chain in a dbase IV type
- memo file searching for a place to grab some free blocks for reuse
-
- LastDataBlock- is the last data block in the file, enter 0
- for the routine to calculate it.
- BlocksNeeded - is the size to look in the chain for
- Location - is the location it finds
- PreviousNode - is the block number of the node imediately previous
- to this node in the chain - 0 if header node
- returns - 0 if no spot in chain found
- 1 if spot in chain is found
-*/
-{
- xbShort rc;
- xbLong LDB, PrevNode, CurNode;
-
- if( LastDataBlock == 0 )
- LDB = CalcLastDataBlock();
- else
- LDB = LastDataBlock;
-
- if( MemoHeader.NextBlock < LDB ){
- PrevNode = 0L;
- CurNode = MemoHeader.NextBlock;
- if(( rc = ReadMemoBlock( MemoHeader.NextBlock, 2 )) != XB_NO_ERROR )
- return rc;
- while( BlocksNeeded > FreeBlockCnt && NextFreeBlock < LDB ){
- PrevNode = CurNode;
- CurNode = NextFreeBlock;
- if(( rc = ReadMemoBlock( NextFreeBlock, 2 )) != XB_NO_ERROR )
- return rc;
- }
- if( BlocksNeeded <= FreeBlockCnt ){
- Location = CurNode;
- PreviousNode = PrevNode;
- return 1;
- }
- else{ /* no data found and at end of chain */
- PreviousNode = CurNode;
- return 0;
- }
- }
- else{
- PreviousNode = 0;
- return 0;
- }
-}
-/************************************************************************/
-//! Short description
-/*!
- \param BlockSize
-*/
-xbShort xbDbf::SetMemoBlockSize( xbShort BlockSize )
-{
- if(IsType3Dbt())
- return XB_NO_ERROR; // not applicable for type 3
- if( BlockSize % 512 != 0 )
- return XB_INVALID_BLOCK_SIZE;
-
- MemoHeader.BlockSize = BlockSize;
- return XB_NO_ERROR;
-}
-/***********************************************************************/
-//! Short description
-/*!
- \param Option
-*/
-xbShort xbDbf::GetDbtHeader( xbShort Option )
-{
- char *p;
- xbShort i;
- char MemoBlock[24];
-
- /* Option = 0 --> read only first four bytes
- 1 --> read the entire thing */
-
- if( !mfp )
- return XB_NOT_OPEN;
-
- if( _fseek( mfp, 0, SEEK_SET ))
- return XB_SEEK_ERROR;
-
- if(( fread( MemoBlock, 24, 1, mfp )) != 1 )
- return XB_READ_ERROR;
-
- p = MemoBlock;
- MemoHeader.NextBlock = xbase->GetLong( p );
- if(IsType3Dbt() || Option == 0)
- return XB_NO_ERROR;
-
- /* version IV stuff follows */
- p+=8;
- for( i = 0; i < 8; i++, p++ )
- MemoHeader.FileName[i] = *p;
- MemoHeader.Version = *p;
- p+=4;
- MemoHeader.BlockSize = xbase->GetShort( p );
- return XB_NO_ERROR;
-}
-
-/***********************************************************************/
-xbShort xbDbf::OpenFPTFile()
-{
- if (GetFileName().len() < 3)
- return XB_INVALID_NAME;
-
- xbShort len = GetFileName().len() - 1;
- xbString ext = GetFileName().mid(len-2, 3);
- MemofileName = GetFileName().mid(0, len-2);
- if (ext == "DBF")
- MemofileName += "FPT";
- else
- if (ext = "dbf")
- MemofileName += "fpt";
- else
- return XB_INVALID_NAME;
- if ((mfp = fopen(MemofileName, "r+b" )) == NULL){
- //
- // Try to open read only if can't open read/write
- //
- if ((mfp = fopen(MemofileName, "rb" )) == NULL)
- return XB_OPEN_ERROR;
- }
- char header[8];
- if ((fread(header, 8, 1, mfp)) != 1)
- return XB_READ_ERROR;
-
- char *p = header;
- MemoHeader.NextBlock = xbase->GetHBFULong(p);
- p += 6;
- MemoHeader.BlockSize = xbase->GetHBFShort(p);
- return XB_NO_ERROR;
-}
-/***********************************************************************/
-//! Short description
-/*!
-*/
-xbShort xbDbf::OpenMemoFile()
-{
- if (Version == (char)0xf5 || Version == (char)0x30)
- return OpenFPTFile();
-
- xbShort len, rc;
- xbOffT Size, NewSize, l;
- MemofileName = GetFileName();
- len = GetFileName().len() - 1;
- if( MemofileName[len] == 'F' )
- MemofileName.putAt(len, 'T');
- else if( MemofileName[len] == 'f' )
- MemofileName.putAt(len, 't');
- else
- return XB_INVALID_NAME;
-
- if(( mfp = fopen( MemofileName, "r+b" )) == NULL ){
- //
- // Try to open read only if can't open read/write
- //
- if(( mfp = fopen( MemofileName, "rb" )) == NULL )
- return XB_OPEN_ERROR;
- }
-#ifdef XB_LOCKING_ON
- setbuf( mfp, NULL );
-#endif
- if(( rc = GetDbtHeader(1)) != 0 ){
- fclose( mfp );
- return rc;
- }
-
- len = GetMemoBlockSize();
- if( len == 0 || ((len % 512) != 0 )){
- fclose( mfp );
- return XB_INVALID_BLOCK_SIZE;
- }
-
- /* logic to verify file size is a multiple of block size */
- if(( rc = _fseek( mfp, 0, SEEK_END )) != 0 ){
- fclose( mfp );
- return XB_SEEK_ERROR;
- }
-
- /* if the file is not a multiple of block size, fix it, append nulls */
- Size = _ftell( mfp );
- if(( Size % MemoHeader.BlockSize ) != 0 ){
- NewSize = ( Size / MemoHeader.BlockSize + 1) * MemoHeader.BlockSize;
- for( l = Size; l < NewSize; l++ )
- fputc( 0x00, mfp );
- }
-
- if(( mbb = (void *) malloc(len)) == NULL ){
- fclose( mfp );
- return XB_NO_MEMORY;
- }
- return XB_NO_ERROR;
-}
-/***********************************************************************/
-//! Short description
-/*!
-*/
-xbShort xbDbf::CreateMemoFile( void )
-{
- xbShort len,i;
- char *sp;
- char buf[4];
-
- len = GetMemoBlockSize();
- if( len == 0 || len % 512 != 0 )
- return XB_INVALID_BLOCK_SIZE;
-
- if(( sp = (char*)strrchr(GetFileName(), PATH_SEPARATOR)) != NULL )
- sp++;
- else
- sp = MemoHeader.FileName;
-
- memset( MemoHeader.FileName, 0x00, 8 );
-
- for( i = 0; i < 8 && *sp != '.'; i++ )
- MemoHeader.FileName[i] = *sp++;
-
- MemofileName = GetFileName();
-
- len = GetFileName().len() - 1;
- if( MemofileName[len] == 'F' )
- MemofileName.putAt(len, 'T');
- else if( MemofileName[len] == 'f' )
- MemofileName.putAt(len, 't');
- else
- return XB_INVALID_NAME;
-
- /* Initialize the variables */
- MemoHeader.NextBlock = 1L;
-
- if(( mfp = fopen( MemofileName, "w+b" )) == NULL )
- return XB_OPEN_ERROR;
-#ifdef XB_LOCKING_ON
- setbuf( mfp, NULL );
-#endif
-
- if(( _fseek( mfp, 0, SEEK_SET )) != 0 ){
- fclose( mfp );
- return XB_SEEK_ERROR;
- }
-
- memset( buf, 0x00, 4 );
- xbase->PutLong( buf, MemoHeader.NextBlock );
- if(( fwrite( &buf, 4, 1, mfp )) != 1 ){
- fclose( mfp );
- return XB_WRITE_ERROR;
- }
-
- if( IsType3Dbt() ){ /* dBASE III+ */
- for( i = 0; i < 12; i++ ) fputc( 0x00, mfp );
- fputc( 0x03, mfp );
- for( i = 0; i < 495; i++ ) fputc( 0x00, mfp );
- }
- else
- {
- for( i = 0; i < 4; i++ ) fputc( 0x00, mfp );
- fwrite( &MemoHeader.FileName, 8, 1, mfp );
- for( i = 0; i < 4; i++ ) fputc( 0x00, mfp );
- memset( buf, 0x00, 2 );
- xbase->PutShort( buf, MemoHeader.BlockSize );
- if(( fwrite( &buf, 2, 1, mfp )) != 1 ){
- fclose( mfp );
- return XB_WRITE_ERROR;
- }
- for( i = 22; i < MemoHeader.BlockSize; i++ ) fputc( 0x00, mfp );
- }
-
- if(( mbb = (void *) malloc( MemoHeader.BlockSize )) == NULL ){
- fclose( mfp );
- return XB_NO_MEMORY;
- }
- return XB_NO_ERROR;
-}
-/***********************************************************************/
-//! Short description
-/*!
- \param BlockNo
- \param Option
-*/
-
-/* Option = 0 - 1st Block of a set of valid data blocks, load buckets */
-/* Option = 1 - subsequant block of data in a multi block set or db III*/
-/* Option = 2 - 1st block of a set of free blocks, load buckets */
-/* Option = 3 - read 8 bytes of a block, don't load any buckets */
-/* Option = 4 - read 8 bytes of a block, load data buckets */
-
-xbShort xbDbf::ReadMemoBlock( xbLong BlockNo, xbShort Option )
-{
- size_t ReadSize;
- CurMemoBlockNo = -1;
-
- if( BlockNo < 1L )
- return XB_INVALID_BLOCK_NO;
-
- if( _fseek( mfp,((xbOffT)BlockNo*MemoHeader.BlockSize), SEEK_SET ))
- return XB_SEEK_ERROR;
-
-
- if( Option == 0 || Option == 1 )
- ReadSize = MemoHeader.BlockSize;
- else
- ReadSize = 8L;
-
- if(fread( mbb, ReadSize, 1, mfp ) != 1 )
- return XB_READ_ERROR;
-
- if( Option == 0 || Option == 4){ // 1st block of a set of valid data blocks
- mfield1 = xbase->GetShort( (char *) mbb );
- MStartPos = xbase->GetShort( (char *) mbb+2 );
- MFieldLen = xbase->GetLong ( (char *) mbb+4 );
- }
- else if( Option == 2 ){ // 1st block of a set of free blocks
- NextFreeBlock = xbase->GetLong( (char *) mbb );
- FreeBlockCnt = xbase->GetLong( (char *) mbb+4 );
- }
-
- if( Option == 0 || Option == 1 )
- CurMemoBlockNo = BlockNo;
-
- return XB_NO_ERROR;
-}
-/************************************************************************/
-//! Short description
-/*!
- \param BlockNo
- \param Option
-*/
-xbShort xbDbf::WriteMemoBlock( xbLong BlockNo, xbShort Option )
-{
-/* Option = 0 - 1st Block of a set of valid data blocks, set buckets */
-/* Option = 1 - subsequant block of data in a multi block set or db III */
-/* Option = 2 - 1st block of a set offree blocks, set buckets */
-
- xbLong WriteSize;
-
- if( BlockNo < 1L )
- return XB_INVALID_BLOCK_NO;
-
- CurMemoBlockNo = -1;
-
- if( Option == 0 ){
- xbase->PutShort( (char *) mbb, mfield1 );
- xbase->PutShort( (char *) mbb+2, MStartPos );
- xbase->PutLong ( (char *) mbb+4, MFieldLen );
- WriteSize = MemoHeader.BlockSize;
- }
- else if( Option == 2 ){
- xbase->PutLong((char *) mbb, NextFreeBlock );
- xbase->PutLong((char *) mbb+4, FreeBlockCnt );
- WriteSize = 8L;
- }
- else
- WriteSize = MemoHeader.BlockSize;
-
- if( _fseek( mfp,((xbOffT)BlockNo*MemoHeader.BlockSize), SEEK_SET ))
- return XB_SEEK_ERROR;
-
- if(( fwrite( mbb, WriteSize, 1, mfp )) != 1 )
- return XB_WRITE_ERROR;
-
- if( Option == 0 || Option == 1 )
- CurMemoBlockNo = BlockNo;
-
- return XB_NO_ERROR;
-}
-/***********************************************************************/
-//! Short description
-/*!
- \param FieldNo
- \param len
- \param Buf
- \param LockOpt
-*/
-xbShort xbDbf::GetFPTField(xbShort FieldNo, xbLong len,
- char * Buf, xbShort LockOpt) {
-
- if (FieldNo < 0 || FieldNo > (NoOfFields - 1))
- return XB_INVALID_FIELDNO;
-
- if (GetFieldType(FieldNo) != 'M')
- return XB_NOT_MEMO_FIELD;
-
-#ifdef XB_LOCKING_ON
-// if( LockOpt != -1 )
-// if( LockMemoFile( XB_LOCK ) != XB_NO_ERROR )
-// return XB_LOCK_FAILED;
-#endif
-
- xbLong BlockNo;
- char buf[18];
-
- if( Version == (char)0x30 ) {
- memset( buf, 0x00, 18 ) ;
- GetField( FieldNo, buf );
- BlockNo = xbase->GetLong((char*) buf);
- } else {
- BlockNo = GetLongField(FieldNo);
- }
-
- if ( BlockNo == 0L )
- return 0L;
-
- // Seek to start_of_block + 4
-
-
-// FIXME LOCK
-
-#ifdef XB_LOCKING_ON
-// try {
-#endif
- if (_fseek(mfp, ((xbOffT)BlockNo * MemoHeader.BlockSize + 4), SEEK_SET) != 0)
- return XB_SEEK_ERROR;
- char h[4];
- if ((fread(h, 4, 1, mfp)) != 1)
- return XB_READ_ERROR;
-
- xbULong fLen = xbase->GetHBFULong(h);
-
- xbULong l = (fLen < (xbULong)len) ? fLen : len;
- if ((fread(Buf, l, 1, mfp)) != 1)
- return XB_READ_ERROR;
- Buf[l]=0;
-#ifdef XB_LOCKING_ON
-// }
-// catch (...) {
-// if (LockOpt != -1)
-// LockMemoFile( XB_UNLOCK );
-// throw;
-// }
-#endif
-
-#ifdef XB_LOCKING_ON
-// if (LockOpt != -1)
-// LockMemoFile( XB_UNLOCK );
-#endif
-
- return XB_NO_ERROR;
-}
-/***********************************************************************/
-//! Short description
-/*!
- \param FieldNo
- \param len
- \param Buf
- \param LockOpt
-*/
-xbShort xbDbf::GetMemoField( xbShort FieldNo, xbLong len,
- char * Buf, xbShort LockOpt )
-{
- if( Version == (char)0xf5 || Version == (char)0x30 )
- return GetFPTField(FieldNo, len, Buf, LockOpt);
-
- xbLong BlockNo, Tcnt, Scnt;
- char *tp, *sp; /* target and source pointers */
- xbShort rc;
- xbShort Vswitch;
- xbLong MemoLen;
-
- if( FieldNo < 0 || FieldNo > ( NoOfFields - 1 ))
- return XB_INVALID_FIELDNO;
-
- if( GetFieldType( FieldNo ) != 'M' )
- return XB_NOT_MEMO_FIELD;
-
-#ifdef XB_LOCKING_ON
-// if( LockOpt != -1 )
-// if(( rc = LockMemoFile( LockOpt, XB_LOCK )) != XB_NO_ERROR )
-// return XB_LOCK_FAILED;
-#endif
-
- if(( BlockNo = GetLongField( FieldNo )) == 0 ){
-#ifdef XB_LOCKING_ON
-// if( LockOpt != -1 )
-// LockMemoFile( XB_UNLOCK );
-#endif
- return XB_NO_MEMO_DATA;
- }
-
- if( IsType3Dbt() )
- Vswitch = 1;
- else
- Vswitch = 0;
-
- if(( rc = ReadMemoBlock( BlockNo, Vswitch )) != 0 ){
-#ifdef XB_LOCKING_ON
-// if( LockOpt != -1 )
-// LockMemoFile( XB_UNLOCK );
-#endif
- return rc;
- }
-
- tp = Buf;
- sp = (char *) mbb;
-
- if( IsType4Dbt() ){
- sp+=8;
- Scnt = 8L;
- }
- else
- Scnt = 0L;
-
- Tcnt = 0L;
- MemoLen = GetMemoFieldLen( FieldNo );
- while( Tcnt < len && Tcnt < MemoLen ){
- *tp++ = *sp++;
- Scnt++;
- Tcnt++;
- if( Scnt >= MemoHeader.BlockSize ){
- BlockNo++;
- if(( rc = ReadMemoBlock( BlockNo, 1 )) != 0 )
- return rc;
- Scnt = 0;
- sp = (char *) mbb;
- }
- }
-#ifdef XB_LOCKING_ON
- //if( LockOpt != -1 )
-// LockMemoFile( XB_LOCK );
-#endif
-
- return XB_NO_ERROR;
-}
-/***********************************************************************/
-//! Short description
-/*!
- \param FieldNo
-*/
-xbLong xbDbf::GetFPTFieldLen( xbShort FieldNo )
-{
- xbLong BlockNo;
- if(( BlockNo = GetLongField(FieldNo)) == 0L )
- return 0L;
- // Seek to start_of_block + 4
- if(_fseek(mfp, ((xbOffT)BlockNo * MemoHeader.BlockSize + 4), SEEK_SET) != 0)
- return XB_SEEK_ERROR;
- char h[4];
- if((fread(h, 4, 1, mfp)) != 1)
- return XB_READ_ERROR;
-
- return xbase->GetHBFULong(h);
-}
-/***********************************************************************/
-//! Short description
-/*!
- \param FieldNo
-*/
-xbLong xbDbf::GetMemoFieldLen( xbShort FieldNo ) {
- if (Version == (char)0xf5 || Version == (char)0x30 )
- return GetFPTFieldLen(FieldNo);
-
- xbLong BlockNo, ByteCnt;
- xbShort scnt, NotDone;
- char *sp, *spp;
-
- if(( BlockNo = GetLongField( FieldNo )) == 0L )
- return 0L;
-
- if( IsType4Dbt()){ /* dBASE IV */
- if( BlockNo == CurMemoBlockNo && CurMemoBlockNo != -1 )
- return MFieldLen - MStartPos;
- if( ReadMemoBlock( BlockNo, 0 ) != XB_NO_ERROR )
- return 0L;
- return MFieldLen - MStartPos;
- } else { /* version 0x03 dBASE III+ */
- ByteCnt = 0L;
- spp = NULL;
- NotDone = 1;
- while( NotDone ){
- if( ReadMemoBlock( BlockNo++, 1 ) != XB_NO_ERROR )
- return 0L;
- scnt = 0;
- sp = (char *) mbb;
- while( scnt < 512 && NotDone ){
- if( *sp == 0x1a && *spp == 0x1a )
- NotDone = 0;
- else{
- ByteCnt++; scnt++; spp = sp; sp++;
- }
- }
- }
- if( ByteCnt > 0 ) ByteCnt--;
- return ByteCnt;
- }
-}
-/***********************************************************************/
-//! Short description
-/*!
-*/
-xbShort xbDbf::MemoFieldsPresent() const
-{
- xbShort i;
- for( i = 0; i < NoOfFields; i++ )
- if( GetFieldType( i ) == 'M' )
- return 1;
-
- return 0;
-}
-/***********************************************************************/
-//! Short description
-/*!
- \param FieldNo
-*/
-xbShort xbDbf::DeleteMemoField( xbShort FieldNo )
-{
- xbLong SBlockNo, SNoOfBlocks, SNextBlock;
- xbLong LastFreeBlock, LastFreeBlockCnt, LastDataBlock;
- xbShort rc;
-
- NextFreeBlock = 0L;
- LastFreeBlockCnt = 0L;
- LastFreeBlock = 0L;
-
- if( IsType3Dbt() ){ /* type III */
- PutField( FieldNo, " " );
- return XB_NO_ERROR;
- }
-
- /* Get Block Number */
- if(( SBlockNo = GetLongField( FieldNo )) == 0 )
- return XB_INVALID_BLOCK_NO;
-
- /* Load the first block */
-
- if(( rc = ReadMemoBlock( SBlockNo, 4 )) != XB_NO_ERROR )
- return rc;
-
- if( (MFieldLen+2) % MemoHeader.BlockSize )
- SNoOfBlocks = (MFieldLen+2)/MemoHeader.BlockSize+1L;
- else
- SNoOfBlocks = (MFieldLen+2)/MemoHeader.BlockSize;
-
- /* Determine last good data block */
- LastDataBlock = CalcLastDataBlock();
-
- /* position to correct location in chain */
- NextFreeBlock = MemoHeader.NextBlock;
- while( SBlockNo > NextFreeBlock && SBlockNo < LastDataBlock ){
- LastFreeBlock = NextFreeBlock;
- if(( rc = ReadMemoBlock( NextFreeBlock, 2 )) != XB_NO_ERROR )
- return rc;
- LastFreeBlockCnt = FreeBlockCnt;
- }
-
-
- /* if next block should be concatonated onto the end of this set */
-
- if((SBlockNo+SNoOfBlocks) == NextFreeBlock && NextFreeBlock < LastDataBlock )
- {
- if(( rc = ReadMemoBlock( NextFreeBlock, 2 )) != XB_NO_ERROR )
- return XB_NO_ERROR;
- SNoOfBlocks += FreeBlockCnt;
- SNextBlock = NextFreeBlock;
- } else if( LastFreeBlock == 0L )
- SNextBlock = MemoHeader.NextBlock;
- else
- SNextBlock = NextFreeBlock;
-
- /* if this is the first set of free blocks */
- if( LastFreeBlock == 0L ){
- /* 1 - write out the current block */
- /* 2 - update header block */
- /* 3 - write header block */
- /* 4 - update data field */
-
- NextFreeBlock = SNextBlock;
- FreeBlockCnt = SNoOfBlocks;
- if(( rc = WriteMemoBlock( SBlockNo, 2 )) != XB_NO_ERROR )
- return rc;
-
- MemoHeader.NextBlock = SBlockNo;
- if(( rc = UpdateHeadNextNode()) != XB_NO_ERROR )
- return rc;
- PutField( FieldNo, " " );
- return XB_NO_ERROR;
- }
-
-/* determine if this block set should be added to the previous set */
-
- if(( LastFreeBlockCnt + LastFreeBlock ) == SBlockNo ){
- if(( rc = ReadMemoBlock( LastFreeBlock, 2 )) != XB_NO_ERROR )
- return rc;
- NextFreeBlock = SNextBlock;
- FreeBlockCnt += SNoOfBlocks;
- if(( rc = WriteMemoBlock( LastFreeBlock, 2 )) != XB_NO_ERROR )
- return rc;
- PutField( FieldNo, " " );
- return XB_NO_ERROR;
- }
-
- /* insert into the chain */
- /* 1 - set the next bucket on the current node */
- /* 2 - write this node */
- /* 3 - go to the previous node */
- /* 4 - insert this nodes id into the previous node set */
- /* 5 - write previous node */
-
- FreeBlockCnt = SNoOfBlocks;
- if(( rc = WriteMemoBlock( SBlockNo, 2 )) != XB_NO_ERROR )
- return rc;
- if(( rc = ReadMemoBlock( LastFreeBlock, 2 )) != XB_NO_ERROR )
- return rc;
- NextFreeBlock = SBlockNo;
- if(( rc = WriteMemoBlock( LastFreeBlock, 2 )) != XB_NO_ERROR )
- return rc;
- PutField( FieldNo, " " );
-
- return XB_NO_ERROR;
-}
-/***********************************************************************/
-//! Short description
-/*!
- \param FieldNo
- \param DataLen
- \param Buf
-*/
-
-xbShort xbDbf::AddMemoData( xbShort FieldNo, xbLong DataLen,
- const char * Buf )
-{
- xbShort rc;
- xbLong BlocksNeeded, LastDataBlock;
- xbLong PrevNode, HeadBlock;
- xbLong TotalLen; /* total length of needed area for memo field */
-
- TotalLen = DataLen+2;
- LastDataBlock = CalcLastDataBlock();
-
- if( IsType3Dbt() || /* always append to end */
- ( LastDataBlock == MemoHeader.NextBlock )){ /* no free space */
- if( TotalLen % MemoHeader.BlockSize )
- BlocksNeeded = TotalLen / MemoHeader.BlockSize + 1;
- else
- BlocksNeeded = TotalLen / MemoHeader.BlockSize;
-
- MemoHeader.NextBlock = LastDataBlock + BlocksNeeded; /* reset to eof */
- if(( rc = PutMemoData( LastDataBlock, BlocksNeeded, DataLen, Buf ))
- != XB_NO_ERROR )
- return rc;
- HeadBlock = LastDataBlock;
- if(( rc = UpdateHeadNextNode()) != XB_NO_ERROR )
- return rc;
- }else{
- TotalLen += 8;
- if( TotalLen % MemoHeader.BlockSize )
- BlocksNeeded = TotalLen / MemoHeader.BlockSize + 1;
- else
- BlocksNeeded = TotalLen / MemoHeader.BlockSize;
-
- if(( rc = FindBlockSetInChain( BlocksNeeded, LastDataBlock,
- HeadBlock, PrevNode )) == 1 ){
- if(( rc = GetBlockSetFromChain( BlocksNeeded, HeadBlock, PrevNode ))
- != XB_NO_ERROR )
- return rc;
- if(( rc = PutMemoData( HeadBlock, BlocksNeeded, DataLen, Buf ))
- != XB_NO_ERROR )
- return rc;
- } else { /* append to the end */
- /* if header block needed updated, already done by here */
- if(( rc = PutMemoData( LastDataBlock, BlocksNeeded, DataLen, Buf ))
- != XB_NO_ERROR )
- return rc;
- HeadBlock = LastDataBlock;
- if(( rc = ReadMemoBlock( PrevNode, 2 )) != XB_NO_ERROR )
- return rc;
- NextFreeBlock += BlocksNeeded;
- if(( rc = WriteMemoBlock( PrevNode, 2 )) != XB_NO_ERROR )
- return rc;
- }
- }
- PutLongField( FieldNo, HeadBlock );
- return XB_NO_ERROR;
-}
-/***********************************************************************/
-//! Short description
-/*!
-*/
-xbShort xbDbf::UpdateHeadNextNode() const
-{
- char buf[4];
- memset( buf, 0x00, 4 );
- xbase->PutLong( buf, MemoHeader.NextBlock );
- if(( _fseek( mfp, 0, SEEK_SET )) != 0 )
- return XB_SEEK_ERROR;
-
- if(( fwrite( &buf, 4, 1, mfp )) != 1 )
- return XB_WRITE_ERROR;
-
- return XB_NO_ERROR;
-}
-/***********************************************************************/
-//! Short description
-/*!
- \param StartBlock First block to write
- \param BlocksNeeded Total number of blocks needed
- \param DataLen Length of data to write
- \param Buf Actual data
-*/
-xbShort xbDbf::PutMemoData( xbLong StartBlock, xbLong BlocksNeeded,
- xbLong DataLen, const char *Buf )
-{
- xbShort i, rc, Tctr;
- xbShort BytesProcessed; // bytes processed so far
- xbShort TotalLen; // total length of data
- xbLong CurBlock;
- char *tp;
- const char *sp;
-
- TotalLen = DataLen + 2;
- CurBlock = StartBlock;
- memset( (char *) mbb, 0x00, MemoHeader.BlockSize );
- tp = (char *) mbb;
- sp = Buf;
- BytesProcessed = 0; /* total length processed */
-
-
- if( IsType3Dbt() )
- Tctr = 0;
- else{ /* dBASE IV */
- tp += 8;
- Tctr = 8;
- }
-
- for( i = 0; i < BlocksNeeded; i++ ){
- while( Tctr < MemoHeader.BlockSize && BytesProcessed < TotalLen ){
- if( BytesProcessed >= DataLen )
- *tp++ = 0x1a; /* end of data marker */
- else
- *tp++ = *sp++; /* copy data to memo block buffer */
- Tctr++;
- BytesProcessed++;
- }
-
- /* if incomplete block, finish it out with 0x00 */
- while( Tctr++ < MemoHeader.BlockSize )
- *tp++ = 0x00;
-
- if( i == 0 && IsType4Dbt() ){
- mfield1 = -1;
- MStartPos = 8;
- MFieldLen = DataLen + MStartPos;
- if(( rc = WriteMemoBlock( CurBlock++, 0 )) != XB_NO_ERROR )
- return rc;
- } else {
- if(( rc = WriteMemoBlock( CurBlock++, 1 )) != XB_NO_ERROR )
- return rc;
- }
- Tctr = 0;
- tp = (char *) mbb;
- }
- return XB_NO_ERROR;
-}
-/***********************************************************************/
-//! Short description
-/*!
- \param FieldNo
- \param DataLen
- \param Buf
- \param LockOpt
-*/
-xbShort xbDbf::UpdateMemoData( xbShort FieldNo, xbLong DataLen,
- const char * Buf, xbShort LockOpt )
-{
- xbShort rc;
- xbLong TotalLen;
- xbLong BlocksNeeded, BlocksAvailable;
-
- #ifdef XB_LOCKING_ON
- if( LockOpt != -1 )
-// if(( rc = LockMemoFile( XB_LOCK )) != XB_NO_ERROR )
-// return XB_LOCK_FAILED;
- #endif
-
- if( DataLen ){
- TotalLen = DataLen + 2; // add 2 eod 0x1a chars
- if( IsType4Dbt()) TotalLen += 8; // leading fields for dbase iv
- }
- else
- TotalLen = 0;
-
- if( DataLen == 0L ){ /* handle delete */
- if( MemoFieldExists( FieldNo )){
- if(( rc = DeleteMemoField( FieldNo )) != XB_NO_ERROR ){
- #ifdef XB_LOCKING_ON
-// LockMemoFile( XB_UNLOCK );
- #endif
- return rc;
- }
- }
- } else if((IsType3Dbt() || GetMemoFieldLen(FieldNo)==0L)){
- if(( rc = AddMemoData( FieldNo, DataLen, Buf )) != XB_NO_ERROR ){
- #ifdef XB_LOCKING_ON
-// LockMemoFile( XB_UNLOCK );
- #endif
- return rc;
- }
- } else { /* version IV type files, reuse unused space */
- if( TotalLen % MemoHeader.BlockSize )
- BlocksNeeded = TotalLen / MemoHeader.BlockSize + 1;
- else
- BlocksNeeded = TotalLen / MemoHeader.BlockSize;
-
- if(( rc = ReadMemoBlock( GetLongField( FieldNo ), 4 )) != XB_NO_ERROR ){
- #ifdef XB_LOCKING_ON
-// LockMemoFile( XB_UNLOCK );
- #endif
- return rc;
- }
-
- if( (MFieldLen+2) % MemoHeader.BlockSize )
- BlocksAvailable = (MFieldLen+2) / MemoHeader.BlockSize + 1;
- else
- BlocksAvailable = (MFieldLen+2) / MemoHeader.BlockSize;
-
- if( BlocksNeeded == BlocksAvailable ){
- if(( rc = PutMemoData( GetLongField( FieldNo ), BlocksNeeded,
- DataLen, Buf )) != XB_NO_ERROR ){
- #ifdef XB_LOCKING_ON
-// LockMemoFile( XB_UNLOCK );
- #endif
- return rc;
- }
- } else {
- if(( rc = DeleteMemoField( FieldNo )) != XB_NO_ERROR ){
- #ifdef XB_LOCKING_ON
-// LockMemoFile( XB_UNLOCK );
- #endif
- return rc;
- }
- if(( rc = AddMemoData( FieldNo, DataLen, Buf )) != XB_NO_ERROR ){
- #ifdef XB_LOCKING_ON
-// LockMemoFile( XB_UNLOCK );
- #endif
- return rc;
- }
- }
- }
-
-
- #ifdef XB_LOCKING_ON
-// if( LockOpt != -1 )
-// if(( rc = LockMemoFile( XB_UNLOCK )) != XB_NO_ERROR )
-// return XB_LOCK_FAILED;
- #endif
- return XB_NO_ERROR;
-}
-/***********************************************************************/
-//! Short description
-/*!
- \param FieldNo
-*/
-xbShort xbDbf::MemoFieldExists( xbShort FieldNo ) const
-{
- if( GetLongField( FieldNo ) == 0L )
- return 0;
- else
- return 1;
-}
-/***********************************************************************/
-//! Short description
-/*!
-*/
-#ifdef XBASE_DEBUG
-void xbDbf::DumpMemoHeader() const
-{
- xbShort i;
- std::cout << "\n*********************************";
- std::cout << "\nMemo header data...";
- std::cout << "\nNext Block " << MemoHeader.NextBlock;
- if( IsType4Dbt() ){
- std::cout << "\nFilename ";
- for( i = 0; i < 8; i++ )
- std::cout << MemoHeader.FileName[i];
- }
- std::cout << "\nBlocksize " << MemoHeader.BlockSize;
- return;
-}
-/***********************************************************************/
-//! Short description
-/*!
-*/
-xbShort xbDbf::DumpMemoFreeChain()
-{
- xbShort rc;
- xbLong CurBlock, LastDataBlock;
-
- if(( rc = GetDbtHeader(1)) != XB_NO_ERROR )
- return rc;
- LastDataBlock = CalcLastDataBlock();
- CurBlock = MemoHeader.NextBlock;
- std::cout << "Total blocks in file = " << LastDataBlock << std::endl;
- std::cout << "Head Next Block = " << CurBlock << std::endl;;
- while( CurBlock < LastDataBlock ){
- if(( rc = ReadMemoBlock( CurBlock, 2 )) != XB_NO_ERROR )
- return rc;
- std::cout << "**********************************" << std::endl;
- std::cout << "This Block = " << CurBlock << std::endl;
- std::cout << "Next Block = " << NextFreeBlock << std::endl;
- std::cout << "No Of Blocks = " << FreeBlockCnt << std::endl;
- CurBlock = NextFreeBlock;
- }
- return XB_NO_ERROR;
-}
-/***********************************************************************/
-//! Short description
-/*!
-*/
-void xbDbf::DumpMemoBlock() const
-{
- xbShort i;
- char *p;
- p = (char *) mbb;
- if( IsType3Dbt() ){
- for( i = 0; i < 512; i++ )
- std::cout << *p++;
- } else {
- std::cout << "\nField1 => " << mfield1;
- std::cout << "\nStart Pos => " << MStartPos;
- std::cout << "\nField Len => " << MFieldLen;
- std::cout << "\nBlock data => ";
- p += 8;
- for( i = 8; i < MemoHeader.BlockSize; i++ )
- std::cout << *p++;
- }
- return;
-}
-#endif /* XBASE_DEBUG */
-#endif /* MEMO_FIELD */
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-13 10:20:56 +0000