mars_nwe/mars-flaim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5f74191893a6cf50554e2ccc97e650f4ac7d5b79
mars-flaim/xflaim/src/frecread.cpp

5719 lines
117 KiB
C++
Raw Blame History

//------------------------------------------------------------------------------
// Desc: Routines for reading records from FLXIM 4.x databases
//
// Tabs: 3
//
// Copyright (c) 2003-2006 Novell, Inc. All Rights Reserved.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of version 2 of the GNU General Public
// License as published by the Free Software Foundation.
//
// 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, contact Novell, Inc.
//
// To contact Novell about this file by physical or electronic mail,
// you may find current contact information at www.novell.com
//
// $Id: frecread.cpp 3114 2006-01-19 13:22:45 -0700 (Thu, 19 Jan 2006) dsanders $
//------------------------------------------------------------------------------
#include "flaimsys.h"
static FLMBYTE gv_ucMaxBcdINT32[] = {0x21, 0x47, 0x48, 0x36, 0x47};
static FLMBYTE gv_ucMinBcdINT32[] = {0xB2, 0x14, 0x74, 0x83, 0x64, 0x8F};
static FLMBYTE gv_ucMaxBcdUINT32[] = {0x42, 0x94, 0x96, 0x72, 0x95};
typedef struct
{
const char * pszTagName;
FLMUINT uiTagNum;
FLMUINT uiFieldType;
} FLM_4x_DICT_TAG_INFO;
FLM_4x_DICT_TAG_INFO Flm4xDictTagInfo[] =
{
{FLM_4x_FIELD_TAG_NAME, FLM_4x_FIELD_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_INDEX_TAG_NAME, FLM_4x_INDEX_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_TYPE_TAG_NAME, FLM_4x_TYPE_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_CONTAINER_TAG_NAME, FLM_4x_CONTAINER_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_LANGUAGE_TAG_NAME, FLM_4x_LANGUAGE_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_OPTIONAL_TAG_NAME, FLM_4x_OPTIONAL_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_UNIQUE_TAG_NAME, FLM_4x_UNIQUE_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_KEY_TAG_NAME, FLM_4x_KEY_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_REFS_TAG_NAME, FLM_4x_REFS_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_AREA_TAG_NAME, FLM_4x_AREA_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_STATE_TAG_NAME, FLM_4x_STATE_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_BLOB_TAG_NAME, FLM_4x_BLOB_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_THRESHOLD_TAG_NAME, FLM_4x_THRESHOLD_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_SUFFIX_TAG_NAME, FLM_4x_SUFFIX_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_SUBDIRECTORY_TAG_NAME, FLM_4x_SUBDIRECTORY_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_RESERVED_TAG_NAME, FLM_4x_RESERVED_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_SUBNAME_TAG_NAME, FLM_4x_SUBNAME_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_NAME_TAG_NAME, FLM_4x_NAME_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_BASE_TAG_NAME, FLM_4x_BASE_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_CASE_TAG_NAME, FLM_4x_CASE_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_COMBINATIONS_TAG_NAME, FLM_4x_COMBINATIONS_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_COUNT_TAG_NAME, FLM_4x_COUNT_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_POSITIONING_TAG_NAME, FLM_4x_POSITIONING_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_PAIRED_TAG_NAME, FLM_4x_PAIRED_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_PARENT_TAG_NAME, FLM_4x_PARENT_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_POST_TAG_NAME, FLM_4x_POST_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_REQUIRED_TAG_NAME, FLM_4x_REQUIRED_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_USE_TAG_NAME, FLM_4x_USE_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_FILTER_TAG_NAME, FLM_4x_FILTER_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_LIMIT_TAG_NAME, FLM_4x_LIMIT_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_DICT_TAG_NAME, FLM_4x_DICT_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_RECINFO_TAG_NAME, FLM_4x_RECINFO_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_DRN_TAG_NAME, FLM_4x_DRN_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_DICT_SEQ_TAG_NAME, FLM_4x_DICT_SEQ_TAG, FLM_4x_TEXT_TYPE},
{FLM_4x_LAST_CONTAINER_INDEXED_TAG_NAME, FLM_4x_LAST_CONTAINER_INDEXED_TAG, FLM_4x_NUMBER_TYPE},
{FLM_4x_LAST_DRN_INDEXED_TAG_NAME, FLM_4x_LAST_DRN_INDEXED_TAG, FLM_4x_NUMBER_TYPE},
{FLM_4x_ONLINE_TRANS_ID_TAG_NAME, FLM_4x_ONLINE_TRANS_ID_TAG, FLM_4x_NUMBER_TYPE},
{NULL, 0}
};
/***************************************************************************
Desc:
****************************************************************************/
F_4xReader::F_4xReader()
{
m_tmpPool.poolInit( 32 * 1024);
m_pSuperHdl = NULL;
m_pLckFile = NULL;
m_uiMaxFileSize = 0;
m_pLFileTbl = NULL;
m_uiLFileCnt = 0;
m_uiFieldTblSize = 0;
m_puiFieldTbl = NULL;
m_ppBlockTbl = NULL;
m_uiBlockTblSize = 0;
m_uiDefaultContainer = 0;
m_pNameTable = NULL;
f_memset( &m_fileHdr, 0, sizeof( F_4x_FILE_HDR));
f_memset( &m_logHdr, 0, sizeof( F_4x_LOG_HDR));
}
/***************************************************************************
Desc:
****************************************************************************/
F_4xReader::~F_4xReader()
{
closeDatabase();
m_tmpPool.poolFree();
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::openDatabase(
char * pszPath)
{
RCODE rc = NE_XFLM_OK;
FLMBYTE * pucReadBuf = NULL;
FLMBYTE * pucPrefix;
FLMBYTE * pucFileHdr;
FLMBYTE * pucLogHdr;
FLMUINT uiBytesRead;
FLMUINT uiTmp;
F_FileHdl * pFileHdl = NULL;
flmAssert( !m_pSuperHdl);
if( (m_pSuperHdl = f_new F_SuperFileHdl) == NULL)
{
rc = RC_SET( NE_XFLM_MEM);
goto Exit;
}
if( RC_BAD( rc = m_pSuperHdl->Setup( NULL, pszPath, NULL)))
{
goto Exit;
}
// We must have exclusive access.
if( RC_BAD( rc = createLckFile( pszPath)))
{
goto Exit;
}
// Read and verify the file and log headers.
if( RC_BAD( rc = m_pSuperHdl->GetFileHdl( 0, FALSE,
(IF_FileHdl **)&pFileHdl)))
{
goto Exit;
}
if( RC_BAD( rc = f_alloc( 2048, &pucReadBuf)))
{
goto Exit;
}
// Read the fixed information area
if( RC_BAD( rc = pFileHdl->Read( 0, 2048, pucReadBuf, &uiBytesRead)))
{
goto Exit;
}
*pucReadBuf = 0xFF;
pucPrefix = pucReadBuf;
pucFileHdr = &pucReadBuf[ FLM_4x_FLAIM_HEADER_START];
// Make sure we have a valid prefix
if( pucPrefix[ 1] != f_toascii('W') ||
pucPrefix[ 2] != f_toascii('P') ||
pucPrefix[ 3] != f_toascii('C'))
{
rc = RC_SET( NE_XFLM_NOT_FLAIM);
goto Exit;
}
// Extract the file header info
m_fileHdr.uiBlockSize = (FLMUINT)FB2UW( &pucFileHdr[ FLM_4x_DB_BLOCK_SIZE]);
m_fileHdr.uiAppMajorVer = pucPrefix[ 10];
m_fileHdr.uiAppMinorVer = pucPrefix[ 11];
m_fileHdr.uiDefaultLanguage = pucFileHdr[ FLM_4x_DB_DEFAULT_LANGUAGE];
m_fileHdr.uiVersionNum =
((FLMUINT16)(pucFileHdr[ FLM_4x_VER_POS] - ASCII_ZERO) * 100 +
(FLMUINT16)(pucFileHdr[ FLM_4x_MINOR_VER_POS] - ASCII_ZERO) * 10 +
(FLMUINT16)(pucFileHdr[ FLM_4x_SMINOR_VER_POS] - ASCII_ZERO));
// Is the block size valid?
if( m_fileHdr.uiBlockSize != 4096 &&
m_fileHdr.uiBlockSize != 8192)
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
// Supported version?
switch( m_fileHdr.uiVersionNum)
{
case FLM_VER_4_0:
case FLM_VER_4_3:
case FLM_VER_4_31:
case FLM_VER_4_50:
case FLM_VER_4_51:
break;
default:
rc = RC_SET( NE_XFLM_UNSUPPORTED_VERSION);
goto Exit;
}
// Get other log header elements.
m_fileHdr.uiFirstLFHBlkAddr =
(FLMUINT)FB2UD( &pucFileHdr[ FLM_4x_DB_1ST_LFH_ADDR]);
if( pucFileHdr[ FLM_4x_FLAIM_NAME_POS ] != f_toascii( 'F') ||
pucFileHdr[ FLM_4x_FLAIM_NAME_POS + 1 ] != f_toascii( 'L') ||
pucFileHdr[ FLM_4x_FLAIM_NAME_POS + 2 ] != f_toascii( 'A') ||
pucFileHdr[ FLM_4x_FLAIM_NAME_POS + 3 ] != f_toascii( 'I') ||
pucFileHdr[ FLM_4x_FLAIM_NAME_POS + 4 ] != f_toascii( 'M'))
{
rc = RC_SET( NE_XFLM_NOT_FLAIM);
goto Exit;
}
// Set up the uiSigBitsInBlkSize member of the file
// header
m_fileHdr.uiSigBitsInBlkSize = 0;
uiTmp = m_fileHdr.uiBlockSize;
while( !(uiTmp & 0x0001))
{
m_fileHdr.uiSigBitsInBlkSize++;
uiTmp >>= 1;
}
// Get the log file header information
pucLogHdr = &pucReadBuf[ FLM_4x_DB_LOG_HEADER_START];
// Verify the checksums in the log header
if( lgHdrCheckSum( pucLogHdr, TRUE) != 0)
{
rc = RC_SET( NE_XFLM_BLOCK_CRC);
goto Exit;
}
m_logHdr.uiCurrTransID =
(FLMUINT)FB2UD( &pucLogHdr[ FLM_4x_LOG_CURR_TRANS_ID]);
m_logHdr.uiLogicalEOF =
(FLMUINT)FB2UD( &pucLogHdr[ FLM_4x_LOG_LOGICAL_EOF]);
m_logHdr.uiFirstAvailBlkAddr =
(FLMUINT)FB2UD( &pucLogHdr[ FLM_4x_LOG_PF_AVAIL_BLKS]);
m_logHdr.uiAvailBlkCount =
(FLMUINT)FB2UD( &pucLogHdr[ FLM_4x_LOG_PF_NUM_AVAIL_BLKS]);
// Get the maximum file size
if( m_fileHdr.uiVersionNum >= FLM_VER_4_3)
{
m_uiMaxFileSize = (FLMUINT)(FB2UW(&((pucLogHdr)[
FLM_4x_LOG_MAX_FILE_SIZE]))) << 16;
}
else
{
m_uiMaxFileSize = 0x7FF00000;
}
// Make sure that no recovery needs to be done.
if( (FLMUINT)FB2UD( &pucLogHdr[ FLM_4x_LOG_ROLLBACK_EOF]) !=
m_fileHdr.uiBlockSize ||
(FLMUINT)FB2UD( &pucLogHdr[ FLM_4x_LOG_PL_FIRST_CP_BLOCK_ADDR]))
{
rc = RC_SET( NE_XFLM_ILLEGAL_OP);
goto Exit;
}
// Set the block size
m_pSuperHdl->ReleaseFile( (FLMUINT)0, TRUE);
m_pSuperHdl->SetBlockSize( m_fileHdr.uiBlockSize);
// Set up the block table
m_uiBlockTblSize = 1024;
if( RC_BAD( rc = f_calloc(
sizeof( F_Block *) * m_uiBlockTblSize, &m_ppBlockTbl)))
{
m_uiBlockTblSize = 0;
goto Exit;
}
// Set the default container
m_uiDefaultContainer = FLM_4x_DATA_CONTAINER;;
// Read the LFile table
if( RC_BAD( rc = readLFiles()))
{
goto Exit;
}
// Read the dictionary
if( RC_BAD( rc = readDictionary()))
{
goto Exit;
}
Exit:
if( pFileHdl)
{
m_pSuperHdl->ReleaseFile( (FLMUINT)0, TRUE);
}
if( pucReadBuf)
{
f_free( &pucReadBuf);
}
if( RC_BAD( rc))
{
closeDatabase();
}
return( rc);
}
/********************************************************************
Desc:
*********************************************************************/
FLMUINT F_4xReader::lgHdrCheckSum(
FLMBYTE * pucLogHdr,
FLMBOOL bCompare)
{
FLMUINT uiCnt;
FLMUINT uiTempSum;
FLMUINT uiCurrCheckSum;
FLMUINT uiTempSum2;
FLMUINT uiBytesToChecksum;
uiBytesToChecksum = (FB2UW( &pucLogHdr[
FLM_4x_LOG_FLAIM_VERSION]) < FLM_VER_4_3)
? 88
: 156;
if( (uiCurrCheckSum = (FLMUINT)FB2UW(
&pucLogHdr[ FLM_4x_LOG_HDR_CHECKSUM])) == 0xFFFF)
{
uiCurrCheckSum = 0;
}
if( bCompare && !uiCurrCheckSum)
{
return( 0);
}
for( uiTempSum = 0 - (FLMUINT)FB2UW( &pucLogHdr[ FLM_4x_LOG_HDR_CHECKSUM]),
uiCnt = 1 + uiBytesToChecksum / sizeof( FLMUINT16); --uiCnt != 0;)
{
uiTempSum += (FLMUINT)FB2UW( pucLogHdr);
pucLogHdr += sizeof( FLMUINT16);
}
if( (0 == (uiTempSum2 = (uiTempSum & 0xFFFF))) || (uiTempSum2 == 0xFFFF))
{
uiTempSum2 = 1;
}
return( (FLMUINT)(((bCompare) && (uiTempSum2 == uiCurrCheckSum))
? (FLMUINT)0
: uiTempSum2) );
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::createLckFile(
char * pszFilePath)
{
RCODE rc = NE_XFLM_OK;
char szLockPath[ F_PATH_MAX_SIZE];
char szDbBaseName[ F_FILENAME_SIZE];
char * pszFileExt;
F_FileHdl * pLockFileHdl = NULL;
// Extract the 8.3 name and put a .lck extension on it to create
// the full path for the .lck file.
if( RC_BAD( rc = gv_pFileSystem->pathReduce(
pszFilePath, szLockPath, szDbBaseName)))
{
goto Exit;
}
pszFileExt = &szDbBaseName[ 0];
while( (*pszFileExt) && (*pszFileExt != '.'))
{
pszFileExt++;
}
f_strcpy( pszFileExt, ".lck");
if (RC_BAD( rc = gv_pFileSystem->pathAppend( szLockPath, szDbBaseName)))
{
goto Exit;
}
if( (pLockFileHdl = f_new F_FileHdl) == NULL)
{
rc = RC_SET( NE_XFLM_MEM);
goto Exit;
}
#ifndef FLM_UNIX
pLockFileHdl->setupFileHdl( 0, TRUE);
#else
// On Unix, we do not want to delete the file because it
// will succeed even if someone else has the file open.
pLockFileHdl->setupFileHdl( 0, FALSE);
#endif
if( RC_BAD( pLockFileHdl->Create( szLockPath,
XFLM_IO_RDWR | XFLM_IO_EXCL | XFLM_IO_SH_DENYRW)))
{
#ifndef FLM_UNIX
if (RC_BAD( gv_pFileSystem->Delete( szLockPath)))
{
rc = RC_SET( NE_XFLM_IO_ACCESS_DENIED);
goto Exit;
}
else if (RC_BAD( pLockFileHdl->Create( szLockPath,
XFLM_IO_RDWR | XFLM_IO_EXCL | XFLM_IO_SH_DENYRW)))
{
rc = RC_SET( NE_XFLM_IO_ACCESS_DENIED);
goto Exit;
}
#else
if( RC_BAD( pLockFileHdl->Open( szLockPath,
XFLM_IO_RDWR | XFLM_IO_SH_DENYRW)))
{
rc = RC_SET( NE_XFLM_IO_ACCESS_DENIED);
goto Exit;
}
#endif
}
#ifdef FLM_UNIX
if( RC_BAD( pLockFileHdl->Lock()))
{
rc = RC_SET( NE_XFLM_IO_ACCESS_DENIED);
goto Exit;
}
#endif
m_pLckFile = pLockFileHdl;
pLockFileHdl = NULL;
Exit:
if (pLockFileHdl)
{
pLockFileHdl->Close();
pLockFileHdl->Release();
}
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
void F_4xReader::closeDatabase( void)
{
FLMUINT uiLoop;
m_tmpPool.poolReset( NULL);
if( m_pLckFile)
{
m_pLckFile->Release();
m_pLckFile = NULL;
}
if( m_pSuperHdl)
{
m_pSuperHdl->Release();
}
if( m_pLFileTbl)
{
f_free( &m_pLFileTbl);
m_pLFileTbl = NULL;
}
m_uiLFileCnt = 0;
if( m_puiFieldTbl)
{
f_free( &m_puiFieldTbl);
m_puiFieldTbl = NULL;
}
m_uiFieldTblSize = 0;
if( m_ppBlockTbl)
{
for( uiLoop = 0; uiLoop < m_uiBlockTblSize; uiLoop++)
{
if( m_ppBlockTbl[ uiLoop])
{
m_ppBlockTbl[ uiLoop]->Release();
}
}
f_free( &m_ppBlockTbl);
}
m_uiBlockTblSize = 0;
if( m_pNameTable)
{
m_pNameTable->Release();
m_pNameTable = NULL;
}
m_uiMaxFileSize = 0;
f_memset( &m_fileHdr, 0, sizeof( F_4x_FILE_HDR));
f_memset( &m_logHdr, 0, sizeof( F_4x_LOG_HDR));
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::readLFiles( void)
{
RCODE rc = NE_XFLM_OK;
F_Block * pBlock = NULL;
FLMBYTE * pucBlk;
FLMUINT uiBlkAddress;
FLMUINT uiPos;
FLMUINT uiEndPos;
FLMUINT uiEstCount;
FLMUINT uiLFileCnt;
FLMUINT uiLFHCnt;
FLMUINT uiBlkSize = m_fileHdr.uiBlockSize;
F_4x_LFILE TmpLFile;
F_4x_LFILE * pLFile;
F_4x_LFILE * pLFiles = NULL;
f_memset( &TmpLFile, 0, sizeof( F_4x_LFILE));
for( uiEstCount = 0, uiLFileCnt = 4,
uiBlkAddress = m_fileHdr.uiFirstLFHBlkAddr;
uiBlkAddress != FLM_4x_BT_END;)
{
if( RC_BAD( rc = readBlock( uiBlkAddress, &pBlock)))
{
goto Exit;
}
pucBlk = pBlock->m_pucBlk;
uiPos = FLM_4x_BH_OVHD;
if( (uiEndPos = (FLMUINT)FB2UW(
&pucBlk[ FLM_4x_BH_ELM_END])) <= FLM_4x_BH_OVHD)
{
uiEndPos = FLM_4x_BH_OVHD;
uiLFHCnt = 0;
}
else
{
if( uiEndPos > uiBlkSize)
{
uiEndPos = uiBlkSize;
}
uiLFHCnt = (FLMUINT)((uiEndPos - FLM_4x_BH_OVHD) / FLM_4x_LFH_SIZE);
uiEndPos = (FLMUINT)(FLM_4x_BH_OVHD + uiLFHCnt * FLM_4x_LFH_SIZE);
}
// May allocate too many like the inactive ones but OK for now.
// Allocate an additional 2 for the default data and dict containers.
if( !uiEstCount)
{
uiEstCount = uiLFHCnt + uiLFileCnt;
if( uiEstCount)
{
if( RC_BAD( rc = f_calloc(
uiEstCount * sizeof( F_4x_LFILE), &pLFiles)))
{
goto Exit;
}
}
}
else if( uiLFHCnt)
{
uiEstCount += uiLFHCnt;
if( RC_BAD(rc = f_recalloc( uiEstCount * sizeof( F_4x_LFILE),
&pLFiles)))
{
goto Exit;
}
}
// Read through all of the logical file definitions in the block
for( ; uiPos < uiEndPos; uiPos += FLM_4x_LFH_SIZE)
{
FLMUINT uiLfNum;
// Have to fix up the offsets later when they are read in
TmpLFile.uiBlkAddress = uiBlkAddress;
TmpLFile.uiOffsetInBlk = uiPos;
if( (TmpLFile.uiLfType =
(FLMUINT)pucBlk[ uiPos + FLM_4x_LFH_TYPE_OFFSET]) == FLM_4x_LF_INVALID)
{
TmpLFile.uiLfType = FLM_4x_LF_INVALID;
continue;
}
TmpLFile.uiLfNum =
(FLMUINT)FB2UW( &pucBlk[ uiPos + FLM_4x_LFH_LF_NUMBER_OFFSET]);
TmpLFile.uiRootBlk =
(FLMUINT)FB2UD( &pucBlk[ uiPos + FLM_4x_LFH_ROOT_BLK_OFFSET]);
TmpLFile.uiNextDrn =
(FLMUINT) FB2UD( &pucBlk[ uiPos + FLM_4x_LFH_NEXT_DRN_OFFSET]);
uiLfNum = TmpLFile.uiLfNum;
if( uiLfNum == FLM_4x_DATA_CONTAINER)
{
pLFile = pLFiles + FLM_4x_LFILE_DATA_CONTAINER_OFFSET;
}
else if( uiLfNum == FLM_4x_DICT_CONTAINER)
{
pLFile = pLFiles + FLM_4x_LFILE_DICT_CONTAINER_OFFSET;
}
else if( uiLfNum == FLM_4x_DICT_INDEX)
{
pLFile = pLFiles + FLM_4x_LFILE_DICT_INDEX_OFFSET;
}
else if( uiLfNum == FLM_4x_TRACKER_CONTAINER)
{
pLFile = pLFiles + FLM_4x_LFILE_TRACKER_CONTAINER_OFFSET;
}
else
{
pLFile = pLFiles + uiLFileCnt++;
}
f_memcpy( pLFile, &TmpLFile, sizeof( F_4x_LFILE));
}
// Get the next block in the chain
uiBlkAddress = (FLMUINT)FB2UD( &pucBlk[ FLM_4x_BH_NEXT_BLK]);
}
m_pLFileTbl = pLFiles;
m_uiLFileCnt = uiLFileCnt;
pLFiles = NULL;
Exit:
if( pBlock)
{
pBlock->Release();
}
if( pLFiles)
{
f_free( &pLFiles);
}
return( rc );
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::getLFile(
FLMUINT uiLFile,
F_4x_LFILE ** ppLFile)
{
RCODE rc = NE_XFLM_OK;
F_4x_LFILE * pLFile = NULL;
FLMUINT uiLoop;
if( uiLFile == FLM_4x_DATA_CONTAINER)
{
pLFile = &m_pLFileTbl[ FLM_4x_LFILE_DATA_CONTAINER_OFFSET];
}
else if( uiLFile == FLM_4x_DICT_CONTAINER)
{
pLFile = &m_pLFileTbl[ FLM_4x_LFILE_DICT_CONTAINER_OFFSET];
}
else if( uiLFile == FLM_4x_TRACKER_CONTAINER)
{
pLFile = &m_pLFileTbl[ FLM_4x_LFILE_TRACKER_CONTAINER_OFFSET];
}
else
{
for( uiLoop = 0; uiLoop < m_uiLFileCnt; uiLoop++)
{
if( m_pLFileTbl[ uiLoop].uiLfNum == uiLFile)
{
pLFile = &m_pLFileTbl[ uiLoop];
break;
}
}
}
if( !pLFile)
{
rc = RC_SET( NE_XFLM_BAD_COLLECTION);
goto Exit;
}
*ppLFile = pLFile;
Exit:
return( rc);
}
/****************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::getNextDrn(
FLMUINT uiContainer,
FLMUINT * puiDrn)
{
RCODE rc = NE_XFLM_OK;
BTSK stackBuf[ FLM_4x_BH_MAX_LEVELS ];
BTSK * pStack = stackBuf;
FLMBYTE * pucElm;
FLMBOOL bUsedStack = FALSE;
F_4x_LFILE * pLFile;
if( RC_BAD( rc = getLFile( uiContainer, &pLFile)))
{
goto Exit;
}
bUsedStack = TRUE;
initStack( &stackBuf[ 0]);
if( RC_BAD( rc = btSearchEnd( pLFile,
FLM_4x_DRN_LAST_MARKER, &pStack)))
{
goto Exit;
}
if( pLFile->uiRootBlk == FLM_4x_BT_END)
{
*puiDrn = pLFile->uiNextDrn;
}
else
{
if( pLFile->uiLfNum !=
FB2UW( &pStack->pBlk->m_pucBlk[ FLM_4x_BH_LOG_FILE_NUM]))
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
pucElm = FLM_4x_CURRENT_ELM( pStack);
pucElm += FLM_4x_BBE_GETR_KL( pucElm) + FLM_4x_BBE_KEY;
*puiDrn = FB2UD( pucElm);
}
Exit:
if( bUsedStack)
{
releaseStack( stackBuf);
}
return( rc);
}
/***************************************************************************
Desc: Search the right-most end of the b-tree.
****************************************************************************/
RCODE F_4xReader::btSearchEnd(
F_4x_LFILE * pLFile,
FLMUINT uiDrn,
BTSK ** ppStack)
{
RCODE rc = NE_XFLM_OK;
BTSK * pStack = *ppStack;
FLMBYTE ucKey[ FLM_4x_DIN_KEY_SIZ];
FLMUINT uiBlkAddr;
if( RC_BAD( rc = getRootBlock( pLFile, pStack)))
{
goto Exit;
}
longToByte( uiDrn, ucKey);
for(;;)
{
if( pStack->uiLevel)
{
pStack->uiCurElm = pStack->uiBlkEnd;
btPrevElm( pStack, pLFile);
}
else
{
if( pStack->uiBlkType != FLM_4x_BHT_NON_LEAF_DATA)
{
if( RC_BAD( rc = btScan( pStack, ucKey)))
{
goto Exit;
}
}
else
{
if( RC_BAD( rc = btScanNonLeafData( pStack, uiDrn)))
{
goto Exit;
}
}
}
if( !pStack->uiLevel)
{
break;
}
uiBlkAddr = childBlkAddr( pStack);
pStack++;
if( RC_BAD( rc = getBlock( pLFile, uiBlkAddr, pStack)))
{
goto Exit;
}
}
*ppStack = pStack;
Exit:
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::readBlock(
FLMUINT uiBlkAddr,
F_Block ** ppBlock)
{
RCODE rc = NE_XFLM_OK;
F_Block * pBlock = NULL;
F_Block * pReuseBlock = NULL;
F_Block ** ppTblSlot = NULL;
if( *ppBlock)
{
(*ppBlock)->Release();
*ppBlock = NULL;
}
if( m_ppBlockTbl)
{
ppTblSlot = getHashBucket( uiBlkAddr);
pBlock = *ppTblSlot;
if( pBlock)
{
if( FLM_4x_GET_BH_ADDR( pBlock->m_pucBlk) != uiBlkAddr)
{
if( pBlock->getRefCount() == 1)
{
pReuseBlock = *ppTblSlot;
}
else
{
(*ppTblSlot)->Release();
}
pBlock = NULL;
*ppTblSlot = NULL;
}
else
{
pBlock->AddRef();
}
}
}
if( !pBlock)
{
if( pReuseBlock)
{
pBlock = pReuseBlock;
pReuseBlock = NULL;
}
else
{
if( (pBlock = f_new F_Block) == NULL)
{
rc = RC_SET( NE_XFLM_MEM);
goto Exit;
}
}
if( RC_BAD( rc = pBlock->allocBlockBuf( m_fileHdr.uiBlockSize)))
{
goto Exit;
}
if( RC_BAD( rc = m_pSuperHdl->ReadBlock( uiBlkAddr,
m_fileHdr.uiBlockSize, pBlock->m_pucBlk, NULL)))
{
if( rc == NE_XFLM_IO_END_OF_FILE)
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
}
goto Exit;
}
// Verify the block checksum
if( RC_BAD( rc = blkCheckSum(
pBlock->m_pucBlk, uiBlkAddr, m_fileHdr.uiBlockSize)))
{
goto Exit;
}
// See if we even got the block we thought we wanted
if( FLM_4x_GET_BH_ADDR( pBlock->m_pucBlk) != uiBlkAddr)
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
flmAssert( *ppTblSlot == NULL);
*ppTblSlot = pBlock;
pBlock->AddRef();
}
flmAssert( *ppTblSlot == pBlock);
*ppBlock = pBlock;
pBlock = NULL;
Exit:
if( pBlock)
{
pBlock->Release();
}
if( pReuseBlock)
{
pReuseBlock->Release();
}
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::blkCheckSum(
FLMBYTE * pucBlkPtr,
FLMUINT uiBlkAddress,
FLMUINT uiBlkSize)
{
RCODE rc = NE_XFLM_OK;
FLMUINT uiCnt;
FLMUINT uiAdds;
FLMUINT uiXORs;
FLMUINT uiCurrCheckSum;
FLMUINT uiNewCheckSum;
FLMUINT uiEncryptSize;
FLMBYTE * pucSaveBlkPtr = pucBlkPtr;
// Check the block length against the max. block size
uiEncryptSize = (FLMUINT)getEncryptSize( pucBlkPtr);
if( uiEncryptSize > uiBlkSize || uiEncryptSize < FLM_4x_BH_OVHD)
{
rc = RC_SET( NE_XFLM_BLOCK_CRC);
goto Exit;
}
uiCurrCheckSum = (FLMUINT)(((FLMUINT)pucBlkPtr[
FLM_4x_BH_CHECKSUM_HIGH] << 8) +
(FLMUINT)pucBlkPtr[ FLM_4x_BH_CHECKSUM_LOW]);
uiAdds = 0 - (pucBlkPtr[ FLM_4x_BH_CHECKSUM_LOW] +
pucBlkPtr[ FLM_4x_BH_CHECKSUM_HIGH]);
uiXORs = pucBlkPtr[ FLM_4x_BH_CHECKSUM_LOW] ^
pucBlkPtr[ FLM_4x_BH_CHECKSUM_HIGH];
if( uiBlkAddress != FLM_4x_BT_END)
{
uiAdds += (FLMBYTE)uiBlkAddress;
uiXORs ^= (FLMBYTE)uiBlkAddress;
}
for( uiCnt = uiEncryptSize; uiCnt--;)
{
uiAdds += *pucBlkPtr;
uiXORs ^= *(pucBlkPtr++);
}
uiNewCheckSum = (((uiAdds << 8) + uiXORs) & 0xFFFF);
if( uiBlkAddress == FLM_4x_BT_END )
{
FLMBYTE byXor;
FLMBYTE byAdd;
FLMBYTE byDelta;
// If there is a one byte value that will satisfy both
// sides of the checksum, the checksum is OK and that value
// is the first byte value.
byXor = (FLMBYTE) uiNewCheckSum;
byAdd = (FLMBYTE) (uiNewCheckSum >> 8);
byDelta = byXor ^ pucSaveBlkPtr[ FLM_4x_BH_CHECKSUM_LOW];
// This is the big check, if byDelta is also what is
// off with the add portion of the checksum, we have
// a good value.
if( ((FLMBYTE) (byAdd + byDelta)) ==
pucSaveBlkPtr[ FLM_4x_BH_CHECKSUM_HIGH])
{
// Set the low checksum value with the computed value.
pucSaveBlkPtr[ FLM_4x_BH_CHECKSUM_LOW] = byDelta;
goto Exit;
}
}
else
{
// This has the side effect of setting the low block address byte
// in the block thus getting rid of the low checksum byte.
//
// NOTE: We are allowing the case where the calculated checksum is
// zero and the stored checksum is one because we used to change
// a calculated zero to a one in old databases and store the one.
// This is probably a somewhat rare case (1 out of 65536 checksums
// will be zero), so forgiving it will be OK most of the time.
// So that those don't cause us to report block checksum errors,
// we just allow it - checksumming isn't a perfect check anyway.
if( uiNewCheckSum == uiCurrCheckSum ||
((!uiNewCheckSum) && (uiCurrCheckSum == 1)))
{
pucSaveBlkPtr[ FLM_4x_BH_CHECKSUM_LOW] = (FLMBYTE)uiBlkAddress;
goto Exit;
}
}
// Otherwise, we have a checksum error.
rc = RC_SET( NE_XFLM_BLOCK_CRC);
Exit:
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::retrieveRec(
FLMUINT uiContainer,
FLMUINT uiDrn,
FLMUINT uiFlags,
F_Record ** ppRecord)
{
RCODE rc = NE_XFLM_OK;
BTSK stackBuf[ FLM_4x_BH_MAX_LEVELS];
BTSK * pStack = NULL;
F_4x_LFILE * pLFile;
initStack( &stackBuf[ 0]);
pStack = stackBuf;
if( uiDrn >= (FLM_4x_DRN_LAST_MARKER - 1))
{
rc = RC_SET_AND_ASSERT( NE_XFLM_ILLEGAL_OP);
goto Exit;
}
if( RC_BAD( rc = getLFile( uiContainer, &pLFile)))
{
goto Exit;
}
if( uiFlags & XFLM_INCL)
{
// Search the for the record
if( RC_BAD( rc = btSearch( pLFile, uiDrn, &pStack)))
{
goto Exit;
}
if( byteToLong( pStack->ucKeyBuf) == FLM_4x_DRN_LAST_MARKER)
{
rc = RC_SET( NE_XFLM_EOF_HIT);
goto Exit;
}
flmAssert( byteToLong( pStack->ucKeyBuf) >= uiDrn);
}
else if( uiFlags & XFLM_EXCL)
{
// Search the for the record
if( RC_BAD( rc = btSearch( pLFile, uiDrn + 1, &pStack)))
{
goto Exit;
}
if( byteToLong( pStack->ucKeyBuf) == FLM_4x_DRN_LAST_MARKER)
{
rc = RC_SET( NE_XFLM_EOF_HIT);
goto Exit;
}
flmAssert( byteToLong( pStack->ucKeyBuf) > uiDrn);
}
else
{
// Search the for the record
if( RC_BAD( rc = btSearch( pLFile, uiDrn, &pStack)))
{
if( rc == NE_XFLM_EOF_HIT)
{
rc = RC_SET( NE_XFLM_NOT_FOUND);
}
goto Exit;
}
if( !pStack->uiKeyLen ||
byteToLong( pStack->ucKeyBuf) != uiDrn)
{
rc = RC_SET( NE_XFLM_NOT_FOUND);
goto Exit;
}
}
// Read the record
if( RC_BAD( rc = readRecElements( pStack, pLFile, ppRecord)))
{
goto Exit;
}
Exit:
releaseStack( stackBuf);
return( rc);
}
/***************************************************************************
Desc:
*****************************************************************************/
RCODE F_4xReader::retrieveNextRec(
F_Record ** ppRecord)
{
RCODE rc = NE_XFLM_OK;
FLMUINT uiDrn = 0;
FLMUINT uiContainer = m_uiDefaultContainer;
if( *ppRecord)
{
uiDrn = (*ppRecord)->getID();
uiContainer = (*ppRecord)->getContainerID();
}
if( RC_BAD( rc = retrieveRec( uiContainer, uiDrn, XFLM_EXCL, ppRecord)))
{
goto Exit;
}
Exit:
return( rc);
}
/**************************************************************************
Desc:
**************************************************************************/
void F_4xReader::releaseStack(
BTSK * pStack)
{
FLMUINT uiNumLevels = FLM_4x_BH_MAX_LEVELS;
while( uiNumLevels)
{
if( pStack->pBlk)
{
pStack->pBlk->Release();
pStack->pBlk = NULL;
}
uiNumLevels--;
pStack++;
}
}
/**************************************************************************
Desc:
**************************************************************************/
RCODE F_4xReader::readRecElements(
BTSK * pStack,
F_4x_LFILE * pLFile,
F_Record ** ppRecord)
{
RCODE rc = NE_XFLM_OK;
F_Record * pRecord = NULL;
FLMBYTE * pucCurElm;
void * pvMark = m_tmpPool.poolMark();
FLMUINT uiElmRecLen;
FLMUINT uiFieldLen;
FLMUINT uiFieldCount;
FLMUINT uiTrueDataSpace;
FLMUINT uiFieldPos;
TFIELD * pField;
FLDGROUP * pFldGroup = NULL;
FLDGROUP * pFirstFldGroup = NULL;
DATAPIECE * pDataPiece;
LOCKED_BLOCK * pLockedBlock = NULL;
FSTATE state;
// Initialize variables
state.uiLevel = 0;
uiFieldCount = 0;
uiTrueDataSpace = 0;
uiFieldPos = NUM_FIELDS_IN_ARRAY;
// Check to make sure we are positioned at the first element.
pucCurElm = FLM_4x_CURRENT_ELM( pStack);
if( !FLM_4x_BBE_IS_FIRST( pucCurElm))
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
// Loop on each element in the record
for( ;;)
{
// Setup all variables to process the current element
uiElmRecLen = FLM_4x_BBE_GET_RL( pucCurElm);
if( !uiElmRecLen)
{
rc = RC_SET( NE_XFLM_EOF_HIT);
break;
}
pucCurElm += FLM_4x_BBE_REC_OFS( pucCurElm);
state.uiPosInElm = 0;
// Loop on each field within this element.
while( state.uiPosInElm < uiElmRecLen)
{
state.pElement = pucCurElm;
if( RC_BAD( rc = getFldOverhead( &state)))
{
goto Exit;
}
uiFieldLen = state.uiFieldLen;
// Old record info data - skip past for now
if( !state.uiTagNum)
{
state.uiPosInElm += uiFieldLen;
continue;
}
if( !pRecord)
{
// Create a new data record or use the existing data record.
if( *ppRecord)
{
// Reuse the existing F_Record object.
pRecord = *ppRecord;
*ppRecord = NULL;
pRecord->clear();
}
else
{
if( (pRecord = f_new F_Record) == NULL)
{
rc = RC_SET( NE_XFLM_MEM);
goto Exit;
}
}
pRecord->setContainerID(
FB2UW( &pStack->pBlk->m_pucBlk[ FLM_4x_BH_LOG_FILE_NUM]));
pRecord->setID( byteToLong( pStack->ucKeyBuf));
}
// Check if out of fields in the tempoary field group
if( uiFieldPos >= NUM_FIELDS_IN_ARRAY)
{
FLDGROUP * pTempFldGroup;
uiFieldPos = 0;
// Allocate the first field group from the pool.
if( RC_BAD( rc = m_tmpPool.poolAlloc(
sizeof( FLDGROUP), (void **)&pTempFldGroup)))
{
goto Exit;
}
pTempFldGroup->pNext = NULL;
if( pFldGroup)
{
pFldGroup->pNext = pTempFldGroup;
}
else
{
pFirstFldGroup = pTempFldGroup;
}
pFldGroup = pTempFldGroup;
}
flmAssert( state.uiFieldType != FLM_4x_UNKNOWN_TYPE);
uiFieldCount++;
pField = &pFldGroup->pFields[ uiFieldPos++];
pField->uiLevel = state.uiLevel;
pField->uiFieldID = state.uiTagNum;
pField->uiFieldType = state.uiFieldType;
pField->uiFieldLen = state.uiFieldLen;
pDataPiece = &pField->DataPiece;
if( uiFieldLen)
{
FLMUINT uiDataPos = 0;
if( state.uiFieldLen > 4)
{
// Binary data needs to account for alignment issues.
if( state.uiFieldType == FLM_4x_BINARY_TYPE)
{
if( state.uiFieldLen >= 255)
{
// Align so that the data is aligned - not the length
uiTrueDataSpace += 2;
uiTrueDataSpace = ((uiTrueDataSpace + FLM_ALLOC_ALIGN) &
(~(FLM_ALLOC_ALIGN) & 0x7FFFFFFF));
uiTrueDataSpace -= 2;
}
else
{
uiTrueDataSpace = ((uiTrueDataSpace + FLM_ALLOC_ALIGN) &
(~(FLM_ALLOC_ALIGN) & 0x7FFFFFFF));
}
}
uiTrueDataSpace += state.uiFieldLen;
// For read only records, greater than 255 bytes are
// stored length preceded.
if( state.uiFieldLen >= 255)
{
uiTrueDataSpace += 2;
}
}
// Value may start in the next element.
while( uiDataPos < uiFieldLen)
{
// Need to read next element for the value portion?
if( state.uiPosInElm >= uiElmRecLen)
{
if( FLM_4x_BBE_IS_LAST( FLM_4x_CURRENT_ELM( pStack)))
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
// If we are going to the next block, lock down this block
// beacause data pointers are pointing to it.
if( RC_BAD( blkNextElm( pStack)))
{
LOCKED_BLOCK * pLastLockedBlock = pLockedBlock;
if( RC_BAD( rc = m_tmpPool.poolAlloc(
sizeof( LOCKED_BLOCK), (void **)&pLockedBlock)))
{
goto Exit;
}
pLockedBlock->pBlock = pStack->pBlk;
pLockedBlock->pBlock->AddRef();
pLockedBlock->pNext = pLastLockedBlock;
if( RC_BAD( rc = btNextElm( pStack, pLFile)))
{
goto Exit;
}
}
pucCurElm = FLM_4x_CURRENT_ELM( pStack);
uiElmRecLen = FLM_4x_BBE_GET_RL( pucCurElm);
pucCurElm += FLM_4x_BBE_REC_OFS( pucCurElm);
state.uiPosInElm = 0;
}
// Compare number of bytes left if value <= # bytes left in element
if( (uiFieldLen - uiDataPos) <=
(uiElmRecLen - state.uiPosInElm))
{
FLMUINT uiDelta = uiFieldLen - uiDataPos;
pDataPiece->pData = &pucCurElm[ state.uiPosInElm];
pDataPiece->uiLength = uiDelta;
state.uiPosInElm += uiDelta;
pDataPiece->pNext = NULL;
break;
}
else
{
// Take what is there and get next element to grab some more.
FLMUINT uiBytesToMove = uiElmRecLen - state.uiPosInElm;
DATAPIECE * pNextDataPiece;
pDataPiece->pData = &pucCurElm[ state.uiPosInElm];
pDataPiece->uiLength = uiBytesToMove;
state.uiPosInElm += uiBytesToMove;
uiDataPos += uiBytesToMove;
if( RC_BAD( rc = m_tmpPool.poolAlloc(
sizeof( DATAPIECE), (void **)&pNextDataPiece)))
{
goto Exit;
}
pDataPiece->pNext = pNextDataPiece;
pDataPiece = pNextDataPiece;
}
}
}
}
// Done?
if( FLM_4x_BBE_IS_LAST( FLM_4x_CURRENT_ELM( pStack)))
{
break;
}
// Position to next element
if( RC_BAD( blkNextElm( pStack)))
{
LOCKED_BLOCK * pLastLockedBlock = pLockedBlock;
if( RC_BAD( rc = m_tmpPool.poolAlloc(
sizeof( LOCKED_BLOCK), (void **)&pLockedBlock)))
{
goto Exit;
}
pLockedBlock->pBlock = pStack->pBlk;
pLockedBlock->pBlock->AddRef();
pLockedBlock->pNext = pLastLockedBlock;
if( RC_BAD( rc = btNextElm( pStack, pLFile)))
{
goto Exit;
}
}
// Corruption Check.
pucCurElm = FLM_4x_CURRENT_ELM( pStack);
if( FLM_4x_BBE_IS_FIRST( pucCurElm))
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
}
if( pRecord)
{
void * pvField;
if( RC_BAD( rc = pRecord->preallocSpace( uiTrueDataSpace)))
{
goto Exit;
}
pFldGroup = pFirstFldGroup;
for( uiFieldPos = 0; uiFieldCount--; uiFieldPos++)
{
if( uiFieldPos >= NUM_FIELDS_IN_ARRAY)
{
uiFieldPos = 0;
if( (pFldGroup = pFldGroup->pNext) == NULL)
{
break;
}
}
pField = &pFldGroup->pFields[ uiFieldPos];
if( RC_BAD( rc = pRecord->insertLast( pField->uiLevel, pField->uiFieldID,
pField->uiFieldType, &pvField)))
{
goto Exit;
}
if( pField->uiFieldLen)
{
FLMBYTE * pDataPtr; // Points to where the data will go.
pDataPiece = &pField->DataPiece;
pDataPtr = pRecord->getImportDataPtr( pvField,
pField->uiFieldType, pField->uiFieldLen);
if( !pDataPtr)
{
rc = RC_SET( NE_XFLM_MEM);
goto Exit;
}
do
{
f_memcpy( pDataPtr, pDataPiece->pData, pDataPiece->uiLength);
pDataPtr += pDataPiece->uiLength;
pDataPiece = pDataPiece->pNext;
}
while( pDataPiece);
}
}
}
if( *ppRecord)
{
flmAssert( 0);
(*ppRecord)->Release();
}
*ppRecord = pRecord;
pRecord = NULL;
Exit:
// Release all locked down blocks except the current block.
while( pLockedBlock)
{
pLockedBlock->pBlock->Release();
pLockedBlock = pLockedBlock->pNext;
}
m_tmpPool.poolReset( pvMark);
if( pRecord)
{
pRecord->Release();
}
return( rc);
}
/**************************************************************************
Desc:
**************************************************************************/
RCODE F_4xReader::getFldOverhead(
FSTATE * pState)
{
RCODE rc = NE_XFLM_OK;
FLMBYTE * pFieldOvhd = &pState->pElement[ pState->uiPosInElm];
FLMBYTE * pElement = pState->pElement;
FLMBOOL bDoesntHaveFieldDef = TRUE;
FLMUINT uiFieldLen;
FLMUINT uiFieldType = 0;
FLMUINT uiTagNum;
FLMBYTE ucTemp;
if( FLM_4x_FOP_IS_STANDARD( pFieldOvhd))
{
if( FLM_4x_FSTA_LEVEL( pFieldOvhd))
{
pState->uiLevel++;
}
uiFieldLen = FLM_4x_FSTA_FLD_LEN( pFieldOvhd);
uiTagNum = FLM_4x_FSTA_FLD_NUM( pFieldOvhd);
pFieldOvhd += FLM_4x_FSTA_OVHD;
}
else if( FLM_4x_FOP_IS_OPEN( pFieldOvhd))
{
if( FLM_4x_FOPE_LEVEL( pFieldOvhd))
{
pState->uiLevel++;
}
ucTemp = (FLMBYTE)(FLM_4x_FOP_GET_FLD_FLAGS( pFieldOvhd++));
uiTagNum = (FLMUINT)*pFieldOvhd++;
if( FLM_4x_FOP_2BYTE_FLDNUM( ucTemp))
{
uiTagNum += ((FLMUINT) *pFieldOvhd++) << 8;
}
uiFieldLen = (FLMUINT) *pFieldOvhd++;
if( FLM_4x_FOP_2BYTE_FLDLEN( ucTemp))
{
uiFieldLen += ((FLMUINT) *pFieldOvhd++) << 8;
}
}
else if( FLM_4x_FOP_IS_NO_VALUE( pFieldOvhd))
{
if( FLM_4x_FNOV_LEVEL( pFieldOvhd))
{
pState->uiLevel++;
}
ucTemp = (FLMBYTE)(FLM_4x_FOP_GET_FLD_FLAGS( pFieldOvhd++));
uiTagNum = (FLMUINT)*pFieldOvhd++;
if( FLM_4x_FOP_2BYTE_FLDNUM( ucTemp))
{
uiTagNum += ((FLMUINT) *pFieldOvhd++) << 8;
}
uiFieldLen = uiFieldType = 0;
}
else if( FLM_4x_FOP_IS_SET_LEVEL( pFieldOvhd))
{
pState->uiLevel -= FLM_4x_FSLEV_GET( pFieldOvhd++);
pState->uiPosInElm = (FLMUINT)( pFieldOvhd - pElement);
rc = getFldOverhead( pState);
goto Exit;
}
else if( FLM_4x_FOP_IS_TAGGED( pFieldOvhd))
{
bDoesntHaveFieldDef = FALSE;
if( FLM_4x_FTAG_LEVEL( pFieldOvhd))
{
pState->uiLevel++;
}
ucTemp = (FLMBYTE)(FLM_4x_FOP_GET_FLD_FLAGS( pFieldOvhd));
uiFieldType = (FLMUINT)(FLM_4x_FTAG_FLD_TYPE( pFieldOvhd));
pFieldOvhd += FLM_4x_FTAG_OVHD;
uiTagNum = (FLMUINT) *pFieldOvhd++;
if( FLM_4x_FOP_2BYTE_FLDNUM( ucTemp))
{
uiTagNum += ((FLMUINT) *pFieldOvhd++) << 8;
}
uiTagNum ^= 0x8000;
uiFieldLen = (FLMUINT)*pFieldOvhd++;
if( FLM_4x_FOP_2BYTE_FLDLEN( ucTemp))
{
uiFieldLen += ((FLMUINT) *pFieldOvhd++) << 8;
}
}
else if( FLM_4x_FOP_IS_RECORD_INFO( pFieldOvhd))
{
bDoesntHaveFieldDef = FALSE;
ucTemp = *pFieldOvhd++;
uiFieldLen = *pFieldOvhd++;
if( FLM_4x_FOP_2BYTE_FLDLEN( ucTemp))
{
uiFieldLen += ((FLMUINT) *pFieldOvhd++) << 8;
}
uiTagNum = 0;
}
else
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
if( bDoesntHaveFieldDef)
{
if( RC_BAD( rc = getFieldType( uiTagNum, &uiFieldType)))
{
goto Exit;
}
}
pState->uiFieldType = uiFieldType;
pState->uiFieldLen = uiFieldLen;
pState->uiPosInElm = (FLMUINT)(pFieldOvhd - pElement);
pState->uiTagNum = uiTagNum;
Exit:
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
FLMUINT F_4xReader::childBlkAddr(
BTSK * pStack)
{
FLMBYTE * pucChildBlkPtr;
FLMUINT uiElmOvhd = pStack->uiElmOvhd;
if( uiElmOvhd == FLM_4x_BNE_DATA_OVHD)
{
pucChildBlkPtr = FLM_4x_BLK_ELM_ADDR(
pStack, pStack->uiCurElm + FLM_4x_BNE_DATA_CHILD_BLOCK);
return( FB2UD( pucChildBlkPtr));
}
else
{
// Corruption
flmAssert( 0);
return( 0);
}
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::btSearch(
F_4x_LFILE * pLFile,
FLMUINT uiDrn,
BTSK ** ppStack)
{
RCODE rc = NE_XFLM_OK;
BTSK * pStack = *ppStack;
FLMBYTE ucKey[ FLM_4x_DIN_KEY_SIZ];
FLMUINT uiBlkAddr;
// Get the root block
if( RC_BAD( rc = getRootBlock( pLFile, pStack)))
{
goto Exit;
}
longToByte( uiDrn, ucKey);
// Read each block going down the b-tree.
// Save state information in the stack.
for(;;)
{
if( pStack->uiBlkType != FLM_4x_BHT_NON_LEAF_DATA)
{
if( RC_BAD( rc = btScan( pStack, ucKey)))
{
goto Exit;
}
}
else
{
if( RC_BAD( rc = btScanNonLeafData( pStack, uiDrn)))
{
goto Exit;
}
}
if( !pStack->uiLevel)
{
break;
}
uiBlkAddr = childBlkAddr( pStack);
pStack++;
if( RC_BAD( rc = getBlock( pLFile, uiBlkAddr, pStack)))
{
goto Exit;
}
}
*ppStack = pStack;
Exit:
return( rc);
}
/***************************************************************************
Desc: Scan a b-tree block for a matching key at any b-tree block level.
****************************************************************************/
RCODE F_4xReader::btScan(
BTSK * pStack,
FLMBYTE * pucSearchKey)
{
RCODE rc = NE_XFLM_OK;
FLMBYTE * pucCurElm;
FLMBYTE * pBlk;
FLMBYTE * pucKeyBuf;
FLMBYTE * pElmKey;
FLMUINT uiRecLen = 0;
FLMUINT uiPrevKeyCnt;
FLMUINT uiElmKeyLen;
FLMUINT uiBlkType;
FLMUINT uiElmOvhd;
FLMUINT uiBytesMatched;
uiBlkType = pStack->uiBlkType;
flmAssert( uiBlkType != FLM_4x_BHT_NON_LEAF_DATA);
pucKeyBuf = pStack->ucKeyBuf;
pBlk = pStack->pBlk->m_pucBlk;
uiElmOvhd = pStack->uiElmOvhd;
pStack->uiCurElm = FLM_4x_BH_OVHD;
pStack->uiKeyLen = 0;
pStack->uiPKC = 0;
pStack->uiPrevElmPKC = 0;
uiBytesMatched = 0;
for( ;;)
{
pucCurElm = &pBlk[ pStack->uiCurElm];
uiElmKeyLen = FLM_4x_BBE_GETR_KL( pucCurElm);
// Read in RAW mode - doesn't do all bit checking
if( (uiPrevKeyCnt = (FLM_4x_BBE_GETR_PKC( pucCurElm))) >
FLM_4x_BBE_PKC_MAX)
{
uiElmKeyLen += (uiPrevKeyCnt & FLM_4x_BBE_KL_HBITS) <<
FLM_4x_BBE_KL_SHIFT_BITS;
uiPrevKeyCnt &= FLM_4x_BBE_PKC_MAX;
}
// Should not have a non-zero PKC if we are on the first element
// of a block
if( uiPrevKeyCnt && pStack->uiCurElm == FLM_4x_BH_OVHD)
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
// Get the record portion length when on the leaf blocks.
if( uiBlkType == FLM_4x_BHT_LEAF)
{
uiRecLen = FLM_4x_BBE_GET_RL( pucCurElm);
}
pStack->uiPrevElmPKC = pStack->uiPKC;
// The zero length key is the terminating
// element in a right-most block.
if( (pStack->uiKeyLen = uiPrevKeyCnt + uiElmKeyLen) == 0)
{
pStack->uiPrevElmPKC = f_min( uiBytesMatched, FLM_4x_BBE_PKC_MAX);
pStack->uiPKC = 0;
rc = RC_SET( NE_XFLM_EOF_HIT);
goto Exit;
}
// Handle special case of left-end compression maxing out.
if( uiPrevKeyCnt == FLM_4x_BBE_PKC_MAX &&
FLM_4x_BBE_PKC_MAX < uiBytesMatched)
{
uiBytesMatched = FLM_4x_BBE_PKC_MAX;
}
// Check out this element to see if the key matches.
if( uiPrevKeyCnt == uiBytesMatched)
{
pElmKey = &pucCurElm[ uiElmOvhd];
for(;;)
{
// All bytes of the search key are matched?
if( uiBytesMatched == FLM_4x_DIN_KEY_SIZ)
{
pStack->uiPKC = f_min( uiBytesMatched, FLM_4x_BBE_PKC_MAX);
if( pStack->uiKeyLen != FLM_4x_DIN_KEY_SIZ)
{
rc = RC_SET_AND_ASSERT( NE_XFLM_DATA_ERROR);
goto Exit;
}
// Current key is equal to the search key.
f_memcpy( pucKeyBuf, pucSearchKey, FLM_4x_DIN_KEY_SIZ);
goto Exit;
}
if( uiBytesMatched == pStack->uiKeyLen)
{
pStack->uiPKC = f_min( uiBytesMatched, FLM_4x_BBE_PKC_MAX);
goto Next_Element;
}
// Compare the next byte in the search key and element
if( pucSearchKey[ uiBytesMatched] != *pElmKey)
{
break;
}
uiBytesMatched++;
pElmKey++;
}
pStack->uiPKC = f_min( uiBytesMatched, FLM_4x_BBE_PKC_MAX);
// Check if we are done comparing
if( pucSearchKey[ uiBytesMatched] < *pElmKey)
{
if( uiBytesMatched)
{
flmAssert( uiBytesMatched <= FLM_4x_DIN_KEY_SIZ);
f_memcpy( pucKeyBuf, pucSearchKey, uiBytesMatched);
}
flmAssert( pStack->uiKeyLen <= FLM_4x_DIN_KEY_SIZ);
f_memcpy( &pucKeyBuf[ uiBytesMatched], pElmKey,
pStack->uiKeyLen - uiBytesMatched);
goto Exit;
}
}
else if( uiPrevKeyCnt < uiBytesMatched)
{
// Current key > search key. Set pucKeyBuf and break out.
pStack->uiPKC = uiPrevKeyCnt;
if( uiPrevKeyCnt)
{
flmAssert( uiPrevKeyCnt <= FLM_4x_DIN_KEY_SIZ);
f_memcpy( pucKeyBuf, pucSearchKey, uiPrevKeyCnt);
}
flmAssert( uiPrevKeyCnt + uiElmKeyLen <= FLM_4x_DIN_KEY_SIZ);
f_memcpy( &pucKeyBuf[ uiPrevKeyCnt],
&pucCurElm[ uiElmOvhd], uiElmKeyLen);
if( byteToLong( pucKeyBuf) == FLM_4x_BT_END)
{
rc = RC_SET( NE_XFLM_EOF_HIT);
}
goto Exit;
}
Next_Element:
// Position to the next element
pStack->uiCurElm += uiElmKeyLen + ((uiBlkType == FLM_4x_BHT_LEAF )
? (FLM_4x_BBE_KEY + uiRecLen)
: (FLM_4x_BNE_IS_DOMAIN( pucCurElm)
? (FLM_4x_BNE_DOMAIN_LEN + uiElmOvhd)
: uiElmOvhd));
// Most common check first.
if( pStack->uiCurElm < pStack->uiBlkEnd)
{
continue;
}
if( pStack->uiCurElm == pStack->uiBlkEnd)
{
rc = RC_SET( NE_XFLM_EOF_HIT);
goto Exit;
}
// Marched off the end of the block
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
Exit:
return( rc);
}
/***************************************************************************
Desc: Binary search into a non-leaf data record block.
****************************************************************************/
RCODE F_4xReader::btScanNonLeafData(
BTSK * pStack,
FLMUINT uiDrn)
{
RCODE rc = NE_XFLM_OK;
FLMBYTE * pucBlk = pStack->pBlk->m_pucBlk;
FLMUINT uiLow = 0;
FLMUINT uiMid;
FLMUINT uiHigh = ((pStack->uiBlkEnd - FLM_4x_BH_OVHD) >> 3) - 1;
FLMUINT uiTblSize = uiHigh;
FLMUINT uiCurDrn;
for(;;)
{
uiMid = (uiLow + uiHigh) >> 1;
uiCurDrn = byteToLong( &pucBlk[ FLM_4x_BH_OVHD + (uiMid << 3)]);
if( !uiCurDrn)
{
// Special case - at the end of a rightmost block.
break;
}
if( uiDrn == uiCurDrn)
{
// Remember a data record can span multiple blocks (same DRN).
while( uiMid)
{
uiCurDrn = byteToLong(
&pucBlk[ FLM_4x_BH_OVHD + ((uiMid - 1) << 3)]);
if( uiDrn != uiCurDrn)
{
break;
}
uiMid--;
}
break;
}
// Down to one item if too high then position to next item.
if( uiLow >= uiHigh)
{
if( (uiDrn > uiCurDrn) && uiMid < uiTblSize)
{
uiMid++;
}
break;
}
// If too high then try lower section
if( uiDrn < uiCurDrn)
{
// First item too high?
if( !uiMid)
{
break;
}
uiHigh = uiMid - 1;
}
else
{
if( uiMid == uiTblSize)
{
uiMid++;
rc = RC_SET( NE_XFLM_EOF_HIT);
goto Exit;
}
uiLow = uiMid + 1;
}
}
// Set curElm and the key buffer.
pStack->uiCurElm = FLM_4x_BH_OVHD + (uiMid << 3);
longToByte( uiCurDrn, pStack->ucKeyBuf);
Exit:
return( rc);
}
/****************************************************************************
Desc: Goto the next element within the block
****************************************************************************/
RCODE F_4xReader::blkNextElm(
BTSK * pStack)
{
RCODE rc = NE_XFLM_OK;
FLMBYTE * pucElm;
FLMUINT uiElmSize;
pucElm = &pStack->pBlk->m_pucBlk[ pStack->uiCurElm];
if( pStack->uiBlkType == FLM_4x_BHT_LEAF)
{
uiElmSize = FLM_4x_BBE_LEN( pucElm);
if( pStack->uiCurElm + FLM_4x_BBE_LEM_LEN < pStack->uiBlkEnd)
{
if( ((pStack->uiCurElm += uiElmSize) +
FLM_4x_BBE_LEM_LEN < pStack->uiBlkEnd) == 0)
{
rc = RC_SET( NE_XFLM_EOF_HIT);
goto Exit;
}
}
else
{
rc = RC_SET( NE_XFLM_EOF_HIT);
goto Exit;
}
}
else
{
if( pStack->uiBlkType != FLM_4x_BHT_NON_LEAF_DATA)
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
uiElmSize = FLM_4x_BNE_DATA_OVHD;
if( pStack->uiCurElm < pStack->uiBlkEnd)
{
// Check if this is not the last element within the block
if( (pStack->uiCurElm += uiElmSize) >= pStack->uiBlkEnd)
{
rc = RC_SET( NE_XFLM_EOF_HIT);
goto Exit;
}
}
else
{
rc = RC_SET( NE_XFLM_EOF_HIT);
goto Exit;
}
}
Exit:
return( rc);
}
/***************************************************************************
Desc: Go to the next element in the logical b-tree
****************************************************************************/
RCODE F_4xReader::btNextElm(
BTSK * pStack,
F_4x_LFILE * pLFile)
{
RCODE rc = NE_XFLM_OK;
FLMBYTE * pucCurElm;
FLMUINT uiLFile;
uiLFile = FB2UW( &pStack->pBlk->m_pucBlk[ FLM_4x_BH_LOG_FILE_NUM]);
if( pStack->uiCurElm < FLM_4x_BH_OVHD)
{
pStack->uiCurElm = FLM_4x_BH_OVHD;
}
else
{
if( RC_BAD( rc = blkNextElm( pStack)))
{
if( rc == NE_XFLM_EOF_HIT)
{
FLMBYTE * pucBlk = FLM_4x_BLK_ELM_ADDR( pStack, FLM_4x_BH_NEXT_BLK);
FLMUINT uiBlkNum = FB2UD( pucBlk);
if( uiBlkNum != FLM_4x_BT_END)
{
// Current element was last element in the block - goto next block */
if( RC_BAD( rc = getBlock( pLFile, uiBlkNum, pStack)))
{
goto Exit;
}
pucBlk = pStack->pBlk->m_pucBlk;
pStack->uiBlkEnd = (FLMUINT)FB2UW( &pucBlk[ FLM_4x_BH_ELM_END ]);
pStack->uiCurElm = FLM_4x_BH_OVHD;
btAdjustStack( pStack, pLFile, TRUE);
}
}
}
}
pucCurElm = FLM_4x_CURRENT_ELM( pStack);
// Copy the key
f_memcpy( pStack->ucKeyBuf, pucCurElm, FLM_4x_DIN_KEY_SIZ);
Exit:
return(rc );
}
/***************************************************************************
Desc: Go to the previous element in the logical b-tree
****************************************************************************/
RCODE F_4xReader::btPrevElm(
BTSK * pStack,
F_4x_LFILE * pLFile)
{
RCODE rc = NE_XFLM_OK;
FLMUINT uiBlkAddr;
FLMUINT uiTargetElm;
FLMUINT uiPrevElm = 0;
FLMUINT uiPrevKeyCnt = 0;
FLMUINT uiElmKeyLen = 0;
FLMUINT uiElmOvhd = pStack->uiElmOvhd;
FLMBYTE * pucCurElm;
FLMBYTE * pucBlk;
// Check if we are at or before the first element in the block
if( pStack->uiCurElm <= FLM_4x_BH_OVHD)
{
pucBlk = pStack->pBlk->m_pucBlk;
// We're at or before the first element, so read in the previous
// block and go to the last element
if( (uiBlkAddr = (FLMUINT)FB2UD( &pucBlk[
FLM_4x_BH_PREV_BLK])) == FLM_4x_BT_END)
{
// We are at the end
rc = RC_SET( NE_XFLM_EOF_HIT);
goto Exit;
}
else
{
if( RC_BAD( rc = getBlock( pLFile, uiBlkAddr, pStack)))
{
// Set uiBlkEnd and uiCurElm.
// Adjust the parent block to the previous element
pucBlk = pStack->pBlk->m_pucBlk;
pStack->uiCurElm = pStack->uiBlkEnd;
btAdjustStack( pStack, pLFile, FALSE);
goto Exit;
}
}
}
// Move down 1 before the current element
if( pStack->uiBlkType == FLM_4x_BHT_NON_LEAF_DATA)
{
pStack->uiCurElm -= FLM_4x_BNE_DATA_OVHD;
pucBlk = pStack->pBlk->m_pucBlk;
pucCurElm = &pucBlk[ pStack->uiCurElm];
f_memcpy( pStack->ucKeyBuf, pucCurElm, FLM_4x_DIN_KEY_SIZ);
goto Exit;
}
// Set up to point to first element in the block
uiTargetElm = pStack->uiCurElm;
pStack->uiCurElm = FLM_4x_BH_OVHD;
pucBlk = pStack->pBlk->m_pucBlk;
while( pStack->uiCurElm < uiTargetElm)
{
pucCurElm = &pucBlk[ pStack->uiCurElm];
uiPrevKeyCnt = (FLMUINT)(FLM_4x_BBE_GET_PKC( pucCurElm));
uiElmKeyLen = (FLMUINT)(FLM_4x_BBE_GET_KL( pucCurElm));
if( uiElmKeyLen + uiPrevKeyCnt > FLM_4x_DIN_KEY_SIZ)
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
if( uiElmKeyLen)
{
flmAssert( uiPrevKeyCnt + uiElmKeyLen <= FLM_4x_DIN_KEY_SIZ);
f_memcpy( &pStack->ucKeyBuf[ uiPrevKeyCnt],
&pucCurElm[ uiElmOvhd], uiElmKeyLen);
}
uiPrevElm = pStack->uiCurElm;
if( RC_BAD( rc = blkNextElm( pStack)))
{
if( rc != NE_XFLM_EOF_HIT)
{
goto Exit;
}
rc = NE_XFLM_OK;
break;
}
}
pStack->uiKeyLen = uiPrevKeyCnt + uiElmKeyLen;
pStack->uiCurElm = uiPrevElm;
flmAssert( pStack->uiKeyLen == FLM_4x_DIN_KEY_SIZ);
Exit:
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::btAdjustStack(
BTSK * pStack,
F_4x_LFILE * pLFile,
FLMBOOL bMovedNext)
{
RCODE rc = NE_XFLM_OK;
pStack--;
if( RC_BAD( rc = getBlock( pLFile, pStack->uiBlkAddr, pStack)))
{
goto Exit;
}
if( bMovedNext)
{
if( RC_BAD( rc = btNextElm( pStack, pLFile)))
{
goto Exit;
}
}
else
{
if( RC_BAD( rc = btPrevElm( pStack, pLFile)))
{
goto Exit;
}
}
Exit:
pStack++;
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::getNameTable(
F_4xNameTable ** ppNameTable)
{
RCODE rc = NE_XFLM_OK;
FLMBOOL bAllocated = FALSE;
if( !m_pNameTable)
{
if( (m_pNameTable = f_new F_4xNameTable) == NULL)
{
rc = RC_SET( NE_XFLM_MEM);
goto Exit;
}
bAllocated = TRUE;
if( RC_BAD( rc = m_pNameTable->setupNameTable( this)))
{
goto Exit;
}
}
flmAssert( *ppNameTable == NULL);
m_pNameTable->AddRef();
*ppNameTable = m_pNameTable;
Exit:
if( RC_BAD( rc) && bAllocated)
{
m_pNameTable->Release();
m_pNameTable = NULL;
}
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
F_Record::F_Record()
{
m_uiContainerID = 0;
m_uiRecordID = 0;
m_pool.poolInit( sizeof( m_fieldList));
m_pFirstFld = m_pLastFld = NULL;
resetFieldList();
m_pDataBuf = NULL;
m_uiDataBufOffset = 0;
m_uiDataBufLength = 0;
}
/***************************************************************************
Desc:
****************************************************************************/
F_Record::~F_Record()
{
m_pool.poolFree();
if( m_pDataBuf)
{
f_free( &m_pDataBuf);
}
}
/***************************************************************************
Desc:
****************************************************************************/
void F_Record::resetFieldList( void)
{
FLMUINT uiLoop;
FIELD * pCurField;
FIELD * pPrevField = NULL;
for( uiLoop = 0; uiLoop < FLM_4x_FIELD_LIST_SIZE; uiLoop++)
{
pCurField = &m_fieldList[ uiLoop];
pCurField->ui16FieldID = 0xFFFF;
pCurField->pPrev = pPrevField;
pCurField->pNext = &m_fieldList[ uiLoop + 1];
pPrevField = pCurField;
}
pCurField->pNext = NULL;
m_pAvailFld = &m_fieldList[ 0];
}
/***************************************************************************
Desc:
****************************************************************************/
void F_Record::clear()
{
m_uiDataBufOffset = 0;
resetFieldList();
m_pool.poolReset( NULL);
m_pFirstFld = NULL;
m_pLastFld = NULL;
m_uiContainerID = 0;
m_uiRecordID = 0;
}
/***************************************************************************
Desc:
****************************************************************************/
FIELD * F_Record::lastSubTreeField(
FIELD * pField)
{
FIELD * pTempField = (FIELD *)lastChild( pField);
FIELD * pLastChild = NULL;
FLMUINT uiStartLevel = pField->ui8Level;
// Step down through the tree
for( ; pTempField && pTempField->ui8Level > uiStartLevel;
pTempField = nextField( pTempField))
{
pLastChild = pTempField;
}
return( pLastChild);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::insertLast(
FLMUINT uiLevel,
FLMUINT uiFieldID,
FLMUINT uiDataType,
void ** ppvField)
{
RCODE rc = NE_XFLM_OK;
FIELD * pField = NULL;
// Insert new field following current last field
if( RC_BAD( rc = createField( m_pLastFld, &pField)))
{
goto Exit;
}
// Set up the new field and set as the current field
pField->ui16FieldID = (FLMUINT16) uiFieldID;
pField->ui8Level = (FLMUINT8) uiLevel;
pField->ui8Type = (FLMUINT8) uiDataType;
if( ppvField)
{
*ppvField = pField;
}
Exit:
#ifdef FLM_DEBUG
if ( pField)
{
flmAssert( pField->pNext != pField);
flmAssert( pField->pPrev != pField);
flmAssert( pField->ui16FieldID != 0xFFFF);
}
#endif
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
FIELD * F_Record::nextSiblingField(
FIELD * pField)
{
FLMUINT8 ui8Level = pField->ui8Level;
while( (pField = nextField( pField)) != NULL &&
pField->ui8Level > ui8Level)
{
;
}
return( (pField && pField->ui8Level == ui8Level)
? pField
: NULL);
}
/***************************************************************************
Desc:
****************************************************************************/
void * F_Record::prevSibling(
void * pvField)
{
if( !pvField)
{
return( NULL);
}
FIELD * pField = (FIELD *)pvField;
FLMUINT8 ui8Level = pField->ui8Level;
while( (pField = prevField( pField)) != NULL &&
pField->ui8Level > ui8Level)
{
;
}
return( (pField && pField->ui8Level == ui8Level)
? pField
: NULL);
}
/***************************************************************************
Desc:
****************************************************************************/
void * F_Record::lastChild(
void * pvField)
{
FIELD * pField = (FIELD *)pvField;
FIELD * pLastField = NULL;
if( !pField)
{
return( NULL);
}
for( pField = firstChildField( pField);
pField;
pField = nextSiblingField( pField))
{
pLastField = pField;
}
return( pLastField);
}
/***************************************************************************
Desc:
****************************************************************************/
void * F_Record::parent(
void * pvField)
{
FIELD * pField = (FIELD *) pvField;
FLMUINT8 ui8Level;
if( !pField)
{
return( NULL);
}
ui8Level = pField->ui8Level;
while( (pField = prevField( pField)) != NULL &&
pField->ui8Level >= ui8Level)
{
;
}
return( pField);
}
/***************************************************************************
Desc:
****************************************************************************/
FLMBYTE * F_Record::getImportDataPtr(
void * pvField,
FLMUINT uiDataType,
FLMUINT uiLength)
{
FLMBYTE * pucData = NULL;
getNewDataPtr( (FIELD *)pvField, uiDataType, uiLength, &pucData);
((FIELD *)pvField)->ui8Type = (FLMUINT8) uiDataType;
return( pucData);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::preallocSpace(
FLMUINT uiDataSize)
{
RCODE rc = NE_XFLM_OK;
m_uiDataBufOffset = 0;
if( m_uiDataBufLength >= uiDataSize)
{
goto Exit;
}
if( !m_pDataBuf)
{
m_uiDataBufLength = 0;
if( RC_BAD( rc = f_alloc( uiDataSize, &m_pDataBuf)))
{
goto Exit;
}
m_uiDataBufLength = uiDataSize;
}
else
{
if( RC_BAD( rc = f_realloc( uiDataSize, &m_pDataBuf)))
{
goto Exit;
}
m_uiDataBufLength = uiDataSize;
}
Exit:
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
void * F_Record::find(
void * pvField,
FLMUINT uiFieldID,
FLMUINT uiOccur,
FLMBOOL bSearchForest)
{
if( uiOccur == 0)
{
uiOccur = 1;
}
if( pvField)
{
FLMUINT uiStartLevel = ((FIELD *)pvField)->ui8Level;
do
{
if( (uiFieldID ==
((FIELD *)pvField)->ui16FieldID) && (--uiOccur < 1))
{
return( pvField);
}
}
while( (pvField = (FIELD *)(pvField
? ((FIELD *)pvField)->pNext
: NULL)) != NULL &&
((((FIELD *)pvField)->ui8Level > uiStartLevel) ||
(bSearchForest && ((FIELD *)pvField)->ui8Level ==
uiStartLevel)));
}
return( NULL);
}
/***************************************************************************
Desc:
****************************************************************************/
void * F_Record::find(
void * pvField,
FLMUINT * puiPathArray,
FLMUINT uiOccur,
FLMBOOL bSearchForest)
{
void * pvSaveField;
FLMUINT * puiPath;
FLMUINT uiLevel;
// Handle empty record
if( !pvField)
{
return( NULL);
}
if( !uiOccur)
{
uiOccur = 1;
}
uiLevel = ((FIELD *)pvField)->ui8Level;
for(;;)
{
puiPath = puiPathArray + ( ((FIELD *)pvField)->ui8Level - uiLevel);
pvSaveField = pvField;
if( *puiPath == ((FIELD *)pvField)->ui16FieldID)
{
if( *(puiPath + 1) == 0 && (--uiOccur < 1))
{
return( pvField);
}
// Go down level for rest of path
if( ( pvField = firstChild( pvField)) != NULL)
{
continue;
}
pvField = pvSaveField;
}
// Find next sibling/uncle/end
do
{
pvField = (FIELD *)(pvField ? ((FIELD *)pvField)->pNext : NULL);
}
while( pvField != NULL
&& ((FIELD *)pvField)->ui8Level > ((FIELD *)pvSaveField)->ui8Level);
// Are we at the end?
if( !pvField ||
((FIELD *)pvField)->ui8Level < uiLevel ||
(bSearchForest && ((FIELD *)pvField)->ui8Level == uiLevel))
{
break;
}
}
return( NULL);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::createField(
FIELD * pCurField,
FIELD ** ppNewField)
{
RCODE rc = NE_XFLM_OK;
FIELD * pNewField;
if( m_pAvailFld)
{
pNewField = m_pAvailFld;
m_pAvailFld = m_pAvailFld->pNext;
if( m_pAvailFld)
m_pAvailFld->pPrev = NULL;
pNewField->pPrev = NULL;
pNewField->pNext = NULL;
}
else
{
if( RC_BAD( rc = m_pool.poolAlloc( sizeof( FIELD), (void **)&pNewField)))
{
goto Exit;
}
}
if( !pCurField && m_pLastFld)
{
pCurField = m_pLastFld;
}
if( pCurField)
{
pNewField->pNext = pCurField->pNext;
pNewField->pPrev = pCurField;
if( pCurField->pNext)
{
pCurField->pNext->pPrev = pNewField;
}
pCurField->pNext = pNewField;
}
if( !m_pFirstFld)
{
m_pFirstFld = pNewField;
}
if( !m_pLastFld || pCurField == m_pLastFld)
{
m_pLastFld = pNewField;
}
pNewField->uiDataLength = 0;
pNewField->uiDataOffset = 0;
*ppNewField = pNewField;
Exit:
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::getNewDataPtr(
FIELD * pField,
FLMUINT uiDataType,
FLMUINT uiNewLength,
FLMBYTE ** ppDataPtr)
{
RCODE rc = NE_XFLM_OK;
FLMBYTE * pDataPtr;
FLMUINT uiTemp;
if( pField->uiDataLength)
{
rc = RC_SET_AND_ASSERT( NE_XFLM_NOT_IMPLEMENTED);
goto Exit;
}
if( uiNewLength <= sizeof( FLMUINT))
{
pDataPtr = (FLMBYTE *) &(pField->uiDataOffset);
}
else
{
// If this is a binary field it must start on an aligned byte.
if( uiDataType == FLM_4x_BINARY_TYPE &&
(m_uiDataBufOffset & FLM_ALLOC_ALIGN) != 0)
{
uiTemp = (FLM_ALLOC_ALIGN + 1) - (m_uiDataBufOffset & FLM_ALLOC_ALIGN);
m_uiDataBufOffset += uiTemp;
}
if( uiNewLength + m_uiDataBufOffset > m_uiDataBufLength)
{
rc = RC_SET_AND_ASSERT( NE_XFLM_FAILURE);
goto Exit;
}
pDataPtr = m_pDataBuf + m_uiDataBufOffset;
pField->uiDataOffset = m_uiDataBufOffset;
m_uiDataBufOffset += uiNewLength;
}
pField->uiDataLength = uiNewLength;
*ppDataPtr = pDataPtr;
Exit:
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::getINT(
void * pvField,
FLMINT * piNumber)
{
return( pvField
? storage2INT( getDataType( pvField), getDataLength( pvField),
getDataPtr( (FIELD *)pvField), piNumber)
: RC_SET( NE_XFLM_NOT_FOUND));
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::getUINT(
void * pvField,
FLMUINT * puiNumber)
{
return( pvField
? storage2UINT( getDataType( pvField), getDataLength( pvField),
getDataPtr( (FIELD *)pvField), puiNumber)
: RC_SET( NE_XFLM_NOT_FOUND));
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::getUINT32(
void * pvField,
FLMUINT32 * pui32Number)
{
return( pvField
? storage2UINT32( getDataType( pvField), getDataLength( pvField),
getDataPtr( (FIELD *)pvField), pui32Number)
: RC_SET( NE_XFLM_NOT_FOUND));
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::getUnicode(
void * pvField,
FLMUNICODE * pUnicode,
FLMUINT * puiBufLen)
{
return( pvField
? getUnicode( getDataType( pvField), getDataLength( pvField),
getDataPtr( (FIELD *) pvField), puiBufLen, pUnicode)
: RC_SET( NE_XFLM_NOT_FOUND));
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::getNative(
void * pvField,
char * pszString,
FLMUINT * puiBufLen)
{
return( pvField
? storage2Native( getDataType( pvField), getDataLength( pvField),
getDataPtr( (FIELD *) pvField), puiBufLen, pszString)
: RC_SET( NE_XFLM_NOT_FOUND));
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::getBinary(
void * pvField,
void * pvBuf,
FLMUINT * puiBufLen)
{
if( pvField)
{
*puiBufLen = f_min( *puiBufLen, getDataLength( pvField));
f_memcpy( pvBuf, getDataPtr( (FIELD *)pvField), *puiBufLen);
return( NE_XFLM_OK);
}
return( RC_SET( NE_XFLM_NOT_FOUND));
}
/***************************************************************************
Desc:
****************************************************************************/
FLMBYTE * F_Record::getDataPtr(
FIELD * pField)
{
if( !pField->uiDataLength)
{
return( NULL);
}
else if( pField->uiDataLength <= sizeof( FLMUINT))
{
return (FLMBYTE *) &(pField->uiDataOffset);
}
return( m_pDataBuf + pField->uiDataOffset);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::storage2INT(
FLMUINT uiType,
FLMUINT uiBufLength,
FLMBYTE * pBuf,
FLMINT * piNum)
{
RCODE rc = NE_XFLM_OK;
BCD_TYPE bcd = {0};
if( RC_BAD( rc = bcd2Num( uiType, uiBufLength, pBuf, &bcd)))
{
goto Exit;
}
if( bcd.bNegFlag)
{
*piNum = -((FLMINT)bcd.uiNum);
if( !((bcd.uiNibCnt < 11) ||
(bcd.uiNibCnt == 11 &&
(!bcd.pucPtr || (f_memcmp( bcd.pucPtr,
gv_ucMinBcdINT32, 6) <= 0)))))
{
rc = RC_SET( NE_XFLM_CONV_NUM_UNDERFLOW);
goto Exit;
}
}
else
{
*piNum = (FLMINT)bcd.uiNum;
if( !((bcd.uiNibCnt < 10) ||
(bcd.uiNibCnt == 10 &&
(!bcd.pucPtr || (f_memcmp( bcd.pucPtr,
gv_ucMaxBcdINT32, 5) <= 0)))))
{
rc = RC_SET( NE_XFLM_CONV_NUM_OVERFLOW);
goto Exit;
}
}
Exit:
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::storage2UINT(
FLMUINT uiType,
FLMUINT uiBufLength,
FLMBYTE * pBuf,
FLMUINT * puiNum)
{
RCODE rc = NE_XFLM_OK;
BCD_TYPE bcd = {0};
if( RC_BAD( rc = bcd2Num( uiType, uiBufLength, pBuf, &bcd)))
{
goto Exit;
}
*puiNum = bcd.uiNum;
if( bcd.bNegFlag)
{
rc = RC_SET( NE_XFLM_CONV_NUM_UNDERFLOW);
goto Exit;
}
else if( bcd.uiNibCnt == 10)
{
if( !(!bcd.pucPtr ||
(f_memcmp( bcd.pucPtr, gv_ucMaxBcdUINT32, 5) <= 0)))
{
rc = RC_SET( NE_XFLM_CONV_NUM_OVERFLOW);
goto Exit;
}
}
else if( bcd.uiNibCnt > 10)
{
rc = RC_SET( NE_XFLM_CONV_NUM_OVERFLOW);
goto Exit;
}
Exit:
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::storage2UINT32(
FLMUINT uiType,
FLMUINT uiBufLength,
FLMBYTE * pBuf,
FLMUINT32 * pui32Num)
{
RCODE rc = NE_XFLM_OK;
BCD_TYPE bcd = {0};
if( RC_BAD( rc = bcd2Num( uiType, uiBufLength, pBuf, &bcd)))
{
goto Exit;
}
*pui32Num = (FLMUINT32)bcd.uiNum;
if( bcd.bNegFlag)
{
rc = RC_SET( NE_XFLM_CONV_NUM_UNDERFLOW);
goto Exit;
}
else if( bcd.uiNibCnt == 10)
{
if( !(!bcd.pucPtr ||
(f_memcmp( bcd.pucPtr, gv_ucMaxBcdUINT32, 5) <= 0)))
{
rc = RC_SET( NE_XFLM_CONV_NUM_OVERFLOW);
goto Exit;
}
}
else if( bcd.uiNibCnt > 10)
{
rc = RC_SET( NE_XFLM_CONV_NUM_OVERFLOW);
goto Exit;
}
Exit:
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::bcd2Num(
FLMUINT uiType,
FLMUINT uiBufLength,
FLMBYTE * pBuf,
BCD_TYPE * bcd)
{
RCODE rc = NE_XFLM_OK;
if( !pBuf)
{
rc = RC_SET( NE_XFLM_CONV_NULL_SRC);
goto Exit;
}
switch( uiType)
{
case FLM_4x_NUMBER_TYPE:
{
FLMUINT uiTotalNum = 0;
FLMUINT uiByte;
FLMUINT uiNibCnt;
bcd->pucPtr = pBuf;
// Get each nibble and use to create the number
#define FLM_MAX_NIB_CNT 11
for( bcd->bNegFlag =
(FLMBOOL)(uiNibCnt = ((*pBuf & 0xF0) == 0xB0) ? 1 : 0);
uiNibCnt <= FLM_MAX_NIB_CNT;
uiNibCnt++ )
{
uiByte = (uiNibCnt & 0x01)
? (FLMUINT)(0x0F & *pBuf++)
: (FLMUINT)(*pBuf >> 4);
if( uiByte == 0x0F)
{
break;
}
// Multiply by 10 and add n
// NOTE: 10y = 8y + 2y = (y << 3) + (y << 1)
// faster than using the long multiply (10 * y)
uiTotalNum = (uiTotalNum << 3) + (uiTotalNum << 1) + uiByte;
}
bcd->uiNibCnt = uiNibCnt;
bcd->uiNum = uiTotalNum;
break;
}
case FLM_4x_TEXT_TYPE:
{
FLMUINT uiNumber = 0;
// If it is a TEXT Value, convert to a numeric value
// WARNING: The text is not null terminated
while( uiBufLength--)
{
if( *pBuf < ASCII_ZERO || *pBuf > ASCII_NINE)
{
break;
}
uiNumber = (uiNumber * 10) + (*pBuf - ASCII_ZERO);
pBuf++;
}
bcd->uiNum = uiNumber;
bcd->uiNibCnt = 0;
bcd->bNegFlag = FALSE;
break;
}
case FLM_4x_CONTEXT_TYPE :
{
if( uiBufLength == sizeof( FLMUINT32))
{
bcd->uiNum = (FLMUINT)( FB2UD( pBuf));
bcd->bNegFlag = 0;
// Now set the uiNibCnt, the uiNibCnt will not be totally
// accurate, but it's close enough to get the value out...
if( bcd->uiNum < FLM_MAX_UINT8)
{
bcd->uiNibCnt = 3;
}
else if( bcd->uiNum < FLM_MAX_UINT16)
{
bcd->uiNibCnt = 5;
}
else
{
bcd->uiNibCnt = 9;
}
}
break;
}
default :
{
rc = RC_SET_AND_ASSERT( NE_XFLM_CONV_ILLEGAL);
goto Exit;
}
}
Exit:
return( rc);
}
/***************************************************************************
Desc:
****************************************************************************/
RCODE F_Record::getUnicode(
FLMUINT uiType,
FLMUINT uiBufLength,
FLMBYTE * pBuffer,
FLMUINT * puiStrBufLen,
FLMUNICODE * puzStrBuf)
{
RCODE rc = NE_XFLM_OK;
FLMBYTE ucChar;
FLMUINT uiBytesProcessed = 0;
FLMUINT uiBytesOutput = 0;
FLMBOOL bOutputData = FALSE;
FLMUINT uiMaxOutLen;
FLMBYTE ucObjType;
FLMUINT uiObjLength = 0;
FLMBYTE tempBuf[ 80];
FLMBYTE chrSet, chrVal;
FLMUNICODE newChrVal;
// If the value is a number, convert to text first
if( uiType != FLM_4x_TEXT_TYPE)
{
if( !pBuffer)
{
uiBufLength = 0;
}
else
{
if( uiType == FLM_4x_NUMBER_TYPE)
{
uiBufLength = sizeof( tempBuf);
if( RC_BAD( rc = numToText( pBuffer, tempBuf, &uiBufLength)))
{
goto Exit;
}
}
else if( uiType == FLM_4x_TEXT_TYPE)
{
uiBufLength = sizeof( tempBuf);
if( RC_BAD( rc = contextToText( pBuffer, tempBuf, &uiBufLength)))
{
goto Exit;
}
}
else
{
rc = RC_SET( NE_XFLM_CONV_ILLEGAL);
goto Exit;
}
pBuffer = &tempBuf[ 0];
}
}
uiMaxOutLen = *puiStrBufLen;
if( puzStrBuf != NULL && uiMaxOutLen > 1)
{
bOutputData = TRUE;
uiMaxOutLen -= 2;
}
// Parse through the string outputting data to the buffer as we go
while( uiBytesProcessed < uiBufLength)
{
// Determine what we are pointing at
ucChar = *pBuffer;
ucObjType = (FLMBYTE)textObjType( ucChar);
switch( ucObjType)
{
case FLM_4x_ASCII_CHAR_CODE:
{
uiObjLength = 1;
if( bOutputData)
{
if( (uiMaxOutLen < 2) || (uiBytesOutput > uiMaxOutLen - 2))
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto GetUNICODE_Output;
}
*puzStrBuf++ = ucChar;
}
uiBytesOutput += 2;
break;
}
case FLM_4x_CHAR_SET_CODE:
{
uiObjLength = 2;
if( bOutputData)
{
if( (uiMaxOutLen < 2) || (uiBytesOutput > uiMaxOutLen - 2))
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto GetUNICODE_Output;
}
// Convert WP to UNICODE
chrSet = ucChar & 0x3F;
chrVal = *(pBuffer + 1);
if( RC_BAD( rc = flmWPToUnicode(
(((FLMUINT16)chrSet) << 8) | chrVal, &newChrVal)))
{
RC_UNEXPECTED_ASSERT( rc);
goto Exit;
}
if( bOutputData)
{
if( (uiMaxOutLen < 2) || (uiBytesOutput > uiMaxOutLen - 2))
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto GetUNICODE_Output;
}
*puzStrBuf++ = newChrVal;
}
}
uiBytesOutput += 2;
break;
}
case FLM_4x_WHITE_SPACE_CODE:
{
uiObjLength = 1;
if( bOutputData)
{
if( (uiMaxOutLen < 2) || (uiBytesOutput > uiMaxOutLen - 2))
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto GetUNICODE_Output;
}
if( ucChar == (FLM_4x_WHITE_SPACE_CODE | 0x0C))
{
*puzStrBuf = 9;
}
else if( ucChar == (FLM_4x_WHITE_SPACE_CODE | 0x0D))
{
*puzStrBuf = 10;
}
else if( ucChar == (FLM_4x_WHITE_SPACE_CODE | 0x07))
{
*puzStrBuf = 13;
}
else
{
*puzStrBuf = 0x20;
}
puzStrBuf++;
}
uiBytesOutput += 2;
break;
}
case FLM_4x_EXT_CHAR_CODE:
{
uiObjLength = 3;
if( bOutputData)
{
if( (uiMaxOutLen < 2) || (uiBytesOutput > uiMaxOutLen - 2))
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto GetUNICODE_Output;
}
// Convert back from WP to UNICODE
chrSet = *(pBuffer + 1);
chrVal = *(pBuffer + 2);
if( RC_BAD( rc = flmWPToUnicode(
(((FLMUINT16)chrSet) << 8) | chrVal, &newChrVal)))
{
RC_UNEXPECTED_ASSERT( rc);
goto Exit;
}
if( bOutputData)
{
if( (uiMaxOutLen < 2) || (uiBytesOutput > uiMaxOutLen - 2))
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto GetUNICODE_Output;
}
*puzStrBuf++ = newChrVal;
}
}
uiBytesOutput += 2;
break;
}
case FLM_4x_OEM_CODE:
{
uiObjLength = 2;
break;
}
case FLM_4x_UNICODE_CODE:
{
uiObjLength = 3;
if( bOutputData)
{
if( (uiMaxOutLen < 2) || (uiBytesOutput > uiMaxOutLen - 2))
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto GetUNICODE_Output;
}
*puzStrBuf++ = (*(pBuffer + 1) << 8) + *(pBuffer + 2);
}
uiBytesOutput += 2;
break;
}
case FLM_4x_UNK_EQ_1_CODE:
{
uiObjLength = 2;
if( bOutputData)
{
if( (uiMaxOutLen < 2) || (uiBytesOutput > uiMaxOutLen - 2))
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto GetUNICODE_Output;
}
*puzStrBuf++ = *(pBuffer+1);
}
uiBytesOutput += 2;
break;
}
default:
{
flmAssert( 0);
uiBytesProcessed = uiBufLength;
break;
}
}
pBuffer += uiObjLength;
uiBytesProcessed += uiObjLength;
}
GetUNICODE_Output:
if( bOutputData)
{
*puzStrBuf = 0;
}
*puiStrBufLen = uiBytesOutput;
Exit:
return( rc);
}
/***************************************************************************
Desc: Convert a storage text string into a native string
***************************************************************************/
RCODE F_Record::storage2Native(
FLMUINT uiType,
FLMUINT uiBufLength,
FLMBYTE * pBuffer,
FLMUINT * puiOutBufLenRV,
char * pOutBuffer)
{
RCODE rc = NE_XFLM_OK;
FLMBYTE * ptr = pBuffer;
FLMBYTE * pucOut;
FLMBYTE ucChar;
FLMUINT uiBytesProcessed;
FLMUINT uiBytesOutput;
FLMUINT uiValLength = uiBufLength;
FLMBOOL bOutputData = FALSE;
FLMUINT uiMaxOutLen = 0;
FLMBYTE ucObjType;
FLMUINT uiObjLength = 0;
FLMBYTE TempBuf[ 80];
// If needed, try and convert the data to text
if( uiType != FLM_4x_TEXT_TYPE)
{
if( !ptr)
{
uiValLength = 0;
}
else if( uiType == FLM_4x_NUMBER_TYPE)
{
uiValLength = sizeof( TempBuf);
if( RC_BAD( rc = numToText( ptr, TempBuf, &uiValLength)))
{
goto Exit;
}
ptr = &TempBuf[ 0];
}
else if( uiType == FLM_4x_CONTEXT_TYPE)
{
uiValLength = sizeof( TempBuf);
if( RC_BAD( rc = contextToText( ptr, TempBuf, &uiValLength)))
{
goto Exit;
}
ptr = &TempBuf[ 0];
}
else
{
rc = RC_SET( NE_XFLM_CONV_ILLEGAL);
goto Exit;
}
}
if( pOutBuffer != NULL && *puiOutBufLenRV)
{
bOutputData = TRUE;
uiMaxOutLen = *puiOutBufLenRV - 1;
}
uiBytesProcessed = 0;
uiBytesOutput = 0;
pucOut = (FLMBYTE *)pOutBuffer;
// Parse through the string outputting data to the buffer
// as we go
while( uiBytesProcessed < uiValLength)
{
// Determine what we are pointing at
ucChar = *ptr;
ucObjType = (FLMBYTE)textObjType( ucChar);
switch( ucObjType)
{
case FLM_4x_ASCII_CHAR_CODE:
{
uiObjLength = 1;
if( bOutputData)
{
if( uiBytesOutput < uiMaxOutLen)
*pucOut++ = f_tonative( ucChar);
else
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Native_Output;
}
}
uiBytesOutput++;
break;
}
case FLM_4x_CHAR_SET_CODE:
{
uiObjLength = 2;
if( bOutputData)
{
if( uiBytesOutput < uiMaxOutLen)
{
if( (ucChar & (~ucObjType)) == 0)
{
*pucOut++ = f_tonative( *(ptr + 1));
}
else
{
*pucOut++ = 0xFF;
}
}
else
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Native_Output;
}
}
uiBytesOutput++;
break;
}
case FLM_4x_WHITE_SPACE_CODE:
{
uiObjLength = 1;
if( bOutputData)
{
if( uiBytesOutput < uiMaxOutLen)
{
ucChar &= (~FLM_4x_WHITE_SPACE_MASK);
if( (ucChar == 0x03) ||
(ucChar == 0x04) ||
(ucChar == 0x05))
{
ucChar = ASCII_DASH;
}
else if( ucChar == 0x0C)
{
ucChar = ASCII_TAB;
}
else if( ucChar == 0x0D)
{
ucChar = 0x0A;
}
else if( ucChar == 0x07)
{
ucChar = 0x0D;
}
else
{
ucChar = 0x20;
}
*pucOut++ = f_tonative( ucChar);
}
else
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Native_Output;
}
}
uiBytesOutput++;
break;
}
case FLM_4x_UNK_EQ_1_CODE:
{
uiObjLength = 2;
// Skip it if it is not a NATIVE code
if( (ucChar & (~ucObjType)) == 0x02)
{
if( bOutputData)
{
if( uiBytesOutput < uiMaxOutLen)
{
*pucOut++ = f_tonative( *(ptr + 1));
}
else
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Native_Output;
}
}
uiBytesOutput++;
}
break;
}
case FLM_4x_EXT_CHAR_CODE:
{
uiObjLength = 3;
if( bOutputData)
{
if( uiBytesOutput < uiMaxOutLen)
{
*pucOut += 0xFF;
}
else
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Native_Output;
}
}
uiBytesOutput++;
break;
}
case FLM_4x_OEM_CODE:
{
uiObjLength = 2;
if( bOutputData)
{
if( uiBytesOutput < uiMaxOutLen)
{
*pucOut++ = f_tonative( *(ptr + 1));
}
else
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Native_Output;
}
}
uiBytesOutput++;
break;
}
case FLM_4x_UNICODE_CODE:
{
uiObjLength = 3;
if( bOutputData)
{
if( uiBytesOutput < uiMaxOutLen )
{
*pucOut++ = 0xFF;
}
else
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Native_Output;
}
}
uiBytesOutput++;
break;
}
default:
{
flmAssert( 0);
break;
}
}
ptr += uiObjLength;
uiBytesProcessed += uiObjLength;
}
// Add a terminating NULL character, but DO NOT increment the
// uiBytesOutput counter
Native_Output:
if( bOutputData)
{
*pucOut = 0;
}
*puiOutBufLenRV = uiBytesOutput;
Exit:
return( rc);
}
/***************************************************************************
Desc: Convert a storage number into a storage text string
***************************************************************************/
RCODE F_Record::numToText(
FLMBYTE * pucNum,
FLMBYTE * pucOutBuffer,
FLMUINT * puiBufLen)
{
RCODE rc = NE_XFLM_OK;
FLMBYTE * pucOutput;
FLMBYTE ucChar;
FLMBYTE ucOutChar;
FLMUINT uiBytesOutput;
FLMBOOL bOutputData;
FLMUINT uiMaxOutLen;
FLMBOOL bFirstNibble;
uiMaxOutLen = *puiBufLen;
bOutputData = ((pucOutBuffer != NULL) && uiMaxOutLen) ? TRUE : FALSE;
uiBytesOutput = 0;
pucOutput = pucOutBuffer;
// Parse through the string outputting data to the buffer
// as we go
if( !pucNum)
{
goto Exit;
}
bFirstNibble = TRUE;
for( ;;)
{
if( bFirstNibble)
{
ucChar = (FLMBYTE)(*pucNum >> 4);
}
else
{
ucChar = (FLMBYTE)(*pucNum++ & 0x0F);
}
bFirstNibble = !bFirstNibble;
if( ucChar <= 9)
{
ucOutChar = (FLMBYTE)( ASCII_ZERO + ucChar);
}
else if( ucChar == 0x0F)
{
break;
}
else
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
if( bOutputData)
{
if( uiBytesOutput < uiMaxOutLen)
{
*pucOutput++ = ucOutChar;
}
else
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Exit;
}
}
uiBytesOutput++;
}
Exit:
*puiBufLen = uiBytesOutput;
return( rc);
}
/***************************************************************************
Desc: Convert a context value into a storage text string
***************************************************************************/
RCODE F_Record::contextToText(
FLMBYTE * pucValue,
FLMBYTE * pucOutBuffer,
FLMUINT * puiBufLen)
{
RCODE rc = NE_XFLM_OK;
FLMUINT uiMaxOutLen;
FLMUINT uiStrLen;
FLMUINT uiBytesOutput = 0;
FLMBOOL bOutputData;
FLMBYTE ucTmpBuf[ 32];
uiMaxOutLen = *puiBufLen;
bOutputData = ((pucOutBuffer != NULL) && uiMaxOutLen) ? TRUE : FALSE;
if( !pucValue)
{
goto Exit;
}
f_sprintf( (char *)ucTmpBuf, "%u", FB2UD( pucValue));
uiStrLen = f_strlen( ucTmpBuf) + 1;
uiBytesOutput = f_min( uiStrLen, uiMaxOutLen);
if( bOutputData)
{
f_memcpy( pucOutBuffer, ucTmpBuf, uiBytesOutput);
pucOutBuffer[ uiBytesOutput - 1] = 0;
}
if( uiMaxOutLen < uiBytesOutput)
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Exit;
}
Exit:
*puiBufLen = uiBytesOutput;
return( rc);
}
/****************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::getRootBlock(
F_4x_LFILE * pLFile,
BTSK * pStack)
{
RCODE rc = NE_XFLM_OK;
F_Block * pBlock = NULL;
if( RC_BAD( rc = readBlock( pLFile->uiRootBlk, &pBlock)))
{
goto Exit;
}
if( !(FLM_4x_BH_IS_ROOT_BLK( pBlock->m_pucBlk)) ||
(pLFile->uiLfNum != FB2UW( &pBlock->m_pucBlk[
FLM_4x_BH_LOG_FILE_NUM])))
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
// Set up the stack
blkToStack( &pBlock, pStack);
Exit:
if( pBlock)
{
pBlock->Release();
}
return( rc);
}
/****************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::getBlock(
F_4x_LFILE * pLFile,
FLMUINT uiBlkAddr,
BTSK * pStack)
{
RCODE rc = NE_XFLM_OK;
F_Block * pBlock = NULL;
if( RC_BAD( rc = readBlock( uiBlkAddr, &pBlock)))
{
goto Exit;
}
if( pLFile->uiLfNum != FB2UW( &pBlock->m_pucBlk[
FLM_4x_BH_LOG_FILE_NUM]))
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
// Set up the stack
blkToStack( &pBlock, pStack);
Exit:
if( pBlock)
{
pBlock->Release();
}
return( rc);
}
/****************************************************************************
Desc:
****************************************************************************/
void F_4xReader::blkToStack(
F_Block ** ppBlock,
BTSK * pStack)
{
FLMBYTE * pucBlk = (*ppBlock)->m_pucBlk;
FLMUINT uiBlkType;
uiBlkType = (FLMUINT)(FLM_4x_BH_GET_TYPE( pucBlk));
pStack->uiBlkType = uiBlkType;
if( uiBlkType == FLM_4x_BHT_LEAF)
{
pStack->uiElmOvhd = FLM_4x_BBE_KEY;
}
else if( uiBlkType == FLM_4x_BHT_NON_LEAF_DATA)
{
pStack->uiElmOvhd = FLM_4x_BNE_DATA_OVHD;
}
else if( uiBlkType == FLM_4x_BHT_NON_LEAF)
{
pStack->uiElmOvhd = FLM_4x_BNE_KEY_START;
}
else if( uiBlkType == FLM_4x_BHT_NON_LEAF_COUNTS)
{
pStack->uiElmOvhd = FLM_4x_BNE_KEY_COUNTS_START;
}
else
{
flmAssert( 0);
pStack->uiElmOvhd = FLM_4x_BNE_KEY_START;
}
pStack->uiKeyLen = 0;
pStack->uiPKC = 0;
pStack->uiPrevElmPKC = 0;
pStack->uiCurElm = FLM_4x_BH_OVHD;
pStack->uiBlkEnd = (FLMUINT)FB2UW( &pucBlk[ FLM_4x_BH_ELM_END]);
pStack->uiLevel = (FLMUINT)pucBlk[ FLM_4x_BH_LEVEL ];
if( pStack->pBlk)
{
pStack->pBlk->Release();
}
pStack->pBlk = *ppBlock;
*ppBlock = NULL;
}
/****************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::getFieldType(
FLMUINT uiFieldNum,
FLMUINT * puiType)
{
RCODE rc = NE_XFLM_OK;
if( uiFieldNum < m_uiFieldTblSize)
{
if( (*puiType = m_puiFieldTbl[ uiFieldNum - 1]) ==
FLM_4x_UNKNOWN_TYPE)
{
rc = RC_SET( NE_XFLM_BAD_ELEMENT_NUM);
goto Exit;
}
}
else
{
// Check if the field is a FLAIM dictionary field.
// Most of these fields are TEXT fields.
if( (uiFieldNum >= FLM_4x_DICT_FIELD_NUMS) &&
(uiFieldNum <= FLM_4x_LAST_DICT_FIELD_NUM))
{
*puiType = FLM_4x_TEXT_TYPE;
}
else if( uiFieldNum >= FLM_4x_UNREGISTERED_TAGS)
{
*puiType = FLM_4x_TEXT_TYPE;
}
else
{
rc = RC_SET( NE_XFLM_BAD_ELEMENT_NUM);
goto Exit;
}
}
Exit:
return( rc);
}
/****************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::readDictionary( void)
{
RCODE rc = NE_XFLM_OK;
FLMUINT uiType;
FLMUINT uiFieldNum;
F_Record * pRec = NULL;
void * pvField;
if( m_puiFieldTbl)
{
f_free( &m_puiFieldTbl);
}
m_uiFieldTblSize = 0;
if( RC_BAD( rc = f_alloc( FLM_4x_RESERVED_TAG_NUMS,
&m_puiFieldTbl)))
{
goto Exit;
}
m_uiFieldTblSize = FLM_4x_RESERVED_TAG_NUMS;
f_memset( m_puiFieldTbl, FLM_4x_UNKNOWN_TYPE, m_uiFieldTblSize);
setDefaultContainer( FLM_4x_DICT_CONTAINER);
for( ;;)
{
if( RC_BAD( rc = retrieveNextRec( &pRec)))
{
if( rc != NE_XFLM_EOF_HIT)
{
goto Exit;
}
rc = NE_XFLM_OK;
break;
}
if( pRec->getFieldID( pRec->root()) == FLM_4x_FIELD_TAG)
{
pvField = pRec->firstChild( pRec->root());
if( RC_BAD( rc = getTypeTag( pRec, pvField, &uiType)))
{
goto Exit;
}
uiFieldNum = pRec->getID();
flmAssert( uiFieldNum < FLM_4x_RESERVED_TAG_NUMS);
m_puiFieldTbl[ uiFieldNum - 1] = uiType;
}
}
Exit:
if( pRec)
{
pRec->Release();
}
return( rc);
}
/****************************************************************************
Desc:
****************************************************************************/
RCODE F_4xReader::getTypeTag(
F_Record * pRec,
void * pvField,
FLMUINT * puiType)
{
RCODE rc = NE_XFLM_OK;
FLMUINT uiType;
FLMUINT uiBufLen;
char szTmpBuf[ 64];
uiBufLen = sizeof( szTmpBuf);
if( RC_BAD( rc = pRec->getNative( pvField, szTmpBuf, &uiBufLen)))
{
goto Exit;
}
if( f_strnicmp( szTmpBuf, "text", 4) == 0)
{
uiType = FLM_4x_TEXT_TYPE;
}
else if( f_strnicmp( szTmpBuf, "numb", 4) == 0)
{
uiType = FLM_4x_NUMBER_TYPE;
}
else if( f_strnicmp( szTmpBuf, "bina", 4) == 0)
{
uiType = FLM_4x_BINARY_TYPE;
}
else if( f_strnicmp( szTmpBuf, "cont", 4) == 0)
{
uiType = FLM_4x_CONTEXT_TYPE;
}
else if( f_strnicmp( szTmpBuf, "blob", 4) == 0)
{
uiType = FLM_4x_BLOB_TYPE;
}
else
{
rc = RC_SET( NE_XFLM_SYNTAX);
goto Exit;
}
*puiType = uiType;
Exit:
return( rc);
}
/****************************************************************************
Desc: Constructor
****************************************************************************/
F_4xNameTable::F_4xNameTable()
{
m_pool.poolInit( 1024);
m_ppSortedByTagName = NULL;
m_ppSortedByTagNum = NULL;
m_ppSortedByTagTypeAndName = NULL;
m_uiTblSize = 0;
m_uiNumTags = 0;
m_bTablesSorted = FALSE;
}
/****************************************************************************
Desc: Destructor
****************************************************************************/
F_4xNameTable::~F_4xNameTable()
{
clearTable();
m_pool.poolFree();
}
/****************************************************************************
Desc: Free everything in the table
****************************************************************************/
void F_4xNameTable::clearTable( void)
{
m_pool.poolFree();
m_pool.poolInit( 1024);
// NOTE: Only one allocation is used for m_ppSortedByTagName,
// m_ppSortedByTagNum, and m_ppSortedByTagTypeAndName - there is no
// need to free m_ppSortedByTagNum and m_ppSortedByTagTypeAndName.
if (m_ppSortedByTagName)
{
f_free( &m_ppSortedByTagName);
m_ppSortedByTagNum = NULL;
m_ppSortedByTagTypeAndName = NULL;
m_uiTblSize = 0;
m_uiNumTags = 0;
}
}
/****************************************************************************
Desc: Compare two tag names. Name1 can be NATIVE or UNICODE. If a
non-NULL UNICODE string is passed, it will be used. Otherwise,
the NATIVE string will be used.
Note: Comparison is case insensitive for the ASCII characters A-Z.
****************************************************************************/
FLMINT F_4xNameTable::tagNameCompare(
const FLMUNICODE * puzName1, // If NULL, use pszName1 for comparison
const char * pszName1,
const FLMUNICODE * puzName2)
{
FLMUNICODE uzChar1;
FLMUNICODE uzChar2;
if (puzName1)
{
for (;;)
{
uzChar1 = *puzName1;
uzChar2 = *puzName2;
// Convert to lower case for comparison.
if (uzChar1 >= 'A' && uzChar1 <= 'Z')
{
uzChar1 = uzChar1 - 'A' + 'a';
}
if (uzChar2 >= 'A' && uzChar2 <= 'Z')
{
uzChar2 = uzChar2 - 'A' + 'a';
}
if (!uzChar1 || !uzChar2 || uzChar1 != uzChar2)
{
break;
}
puzName1++;
puzName2++;
}
}
else
{
for (;;)
{
uzChar1 = (FLMUNICODE)*pszName1;
uzChar2 = *puzName2;
// Convert to lower case for comparison.
if (uzChar1 >= 'A' && uzChar1 <= 'Z')
{
uzChar1 = uzChar1 - 'A' + 'a';
}
if (uzChar2 >= 'A' && uzChar2 <= 'Z')
{
uzChar2 = uzChar2 - 'A' + 'a';
}
if (!uzChar1 || !uzChar2 || uzChar1 != uzChar2)
{
break;
}
pszName1++;
puzName2++;
}
}
if (uzChar1)
{
return( (FLMINT)((uzChar2 && uzChar1 < uzChar2)
? (FLMINT)-1
: (FLMINT)1));
}
else if (uzChar2)
{
return( -1);
}
else
{
return( 0);
}
}
/****************************************************************************
Desc: Lookup a tag by tag name. Tag name is passed in as a UNICODE
string or a NATIVE string. If a non-NULL UNICODE string is
passed in, it will be used. Otherwise, the NATIVE string will
be used.
****************************************************************************/
FLM_4x_TAG_INFO * F_4xNameTable::findTagByName(
const FLMUNICODE * puzTagName,
const char * pszTagName,
FLMUINT * puiInsertPos)
{
FLM_4x_TAG_INFO * pTagInfo = NULL;
FLMUINT uiTblSize;
FLMUINT uiLow;
FLMUINT uiMid;
FLMUINT uiHigh;
FLMINT iCmp;
// Do binary search in the table
if ((uiTblSize = m_uiNumTags) == 0)
{
if (puiInsertPos)
{
*puiInsertPos = 0;
}
goto Exit;
}
uiHigh = --uiTblSize;
uiLow = 0;
for (;;)
{
uiMid = (uiLow + uiHigh) / 2;
iCmp = tagNameCompare( puzTagName, pszTagName,
m_ppSortedByTagName [uiMid]->puzTagName);
if (iCmp == 0)
{
// Found Match
pTagInfo = m_ppSortedByTagName [uiMid];
if (puiInsertPos)
{
*puiInsertPos = uiMid;
}
goto Exit;
}
// Check if we are done
if (uiLow >= uiHigh)
{
// Done, item not found
if (puiInsertPos)
{
*puiInsertPos = (iCmp < 0)
? uiMid
: uiMid + 1;
}
goto Exit;
}
if (iCmp < 0)
{
if (uiMid == 0)
{
if (puiInsertPos)
{
*puiInsertPos = 0;
}
goto Exit;
}
uiHigh = uiMid - 1;
}
else
{
if (uiMid == uiTblSize)
{
if (puiInsertPos)
{
*puiInsertPos = uiMid + 1;
}
goto Exit;
}
uiLow = uiMid + 1;
}
}
Exit:
return( pTagInfo);
}
/****************************************************************************
Desc: Lookup a tag by tag number.
****************************************************************************/
FLM_4x_TAG_INFO * F_4xNameTable::findTagByNum(
FLMUINT uiTagNum,
FLMUINT * puiInsertPos)
{
FLM_4x_TAG_INFO * pTagInfo = NULL;
FLMUINT uiTblSize;
FLMUINT uiLow;
FLMUINT uiMid;
FLMUINT uiHigh;
FLMUINT uiTblTagNum;
// Do binary search in the table
if ((uiTblSize = m_uiNumTags) == 0)
{
if (puiInsertPos)
{
*puiInsertPos = 0;
}
goto Exit;
}
uiHigh = --uiTblSize;
uiLow = 0;
for (;;)
{
uiMid = (uiLow + uiHigh) / 2;
uiTblTagNum = m_ppSortedByTagNum [uiMid]->uiTagNum;
if (uiTagNum == uiTblTagNum)
{
// Found Match
pTagInfo = m_ppSortedByTagNum [uiMid];
if (puiInsertPos)
{
*puiInsertPos = uiMid;
}
goto Exit;
}
// Check if we are done
if (uiLow >= uiHigh)
{
// Done, item not found
if (puiInsertPos)
{
*puiInsertPos = (uiTagNum < uiTblTagNum)
? uiMid
: uiMid + 1;
}
goto Exit;
}
if (uiTagNum < uiTblTagNum)
{
if (uiMid == 0)
{
if (puiInsertPos)
{
*puiInsertPos = 0;
}
goto Exit;
}
uiHigh = uiMid - 1;
}
else
{
if (uiMid == uiTblSize)
{
if (puiInsertPos)
{
*puiInsertPos = uiMid + 1;
}
goto Exit;
}
uiLow = uiMid + 1;
}
}
Exit:
return( pTagInfo);
}
/****************************************************************************
Desc: Lookup a tag by tag type and tag name. Tag name is passed
in as a UNICODE string or a NATIVE string. If a non-NULL
UNICODE string is passed in, it will be used. Otherwise, the
NATIVE string will be used.
****************************************************************************/
FLM_4x_TAG_INFO * F_4xNameTable::findTagByTypeAndName(
const FLMUNICODE * puzTagName,
const char * pszTagName,
FLMUINT uiType,
FLMUINT * puiInsertPos)
{
FLM_4x_TAG_INFO * pTagInfo = NULL;
FLMUINT uiTblType;
FLMUINT uiTblSize;
FLMUINT uiLow;
FLMUINT uiMid;
FLMUINT uiHigh;
FLMINT iCmp;
// Do binary search in the table
if ((uiTblSize = m_uiNumTags) == 0)
{
if (puiInsertPos)
{
*puiInsertPos = 0;
}
goto Exit;
}
uiHigh = --uiTblSize;
uiLow = 0;
for (;;)
{
uiMid = (uiLow + uiHigh) / 2;
uiTblType = m_ppSortedByTagTypeAndName [uiMid]->uiType;
if (uiType < uiTblType)
{
iCmp = -1;
}
else if (uiType > uiTblType)
{
iCmp = 1;
}
else if ((iCmp = tagNameCompare( puzTagName, pszTagName,
m_ppSortedByTagTypeAndName [uiMid]->puzTagName)) == 0)
{
// Found Match
pTagInfo = m_ppSortedByTagTypeAndName [uiMid];
if (puiInsertPos)
{
*puiInsertPos = uiMid;
}
goto Exit;
}
// Check if we are done
if (uiLow >= uiHigh)
{
// Done, item not found
if (puiInsertPos)
{
*puiInsertPos = (iCmp < 0)
? uiMid
: uiMid + 1;
}
goto Exit;
}
if (iCmp < 0)
{
if (uiMid == 0)
{
if (puiInsertPos)
{
*puiInsertPos = 0;
}
goto Exit;
}
uiHigh = uiMid - 1;
}
else
{
if (uiMid == uiTblSize)
{
if (puiInsertPos)
{
*puiInsertPos = uiMid + 1;
}
goto Exit;
}
uiLow = uiMid + 1;
}
}
Exit:
return( pTagInfo);
}
/****************************************************************************
Desc: Copy a tag name to a UNICODE or NATIVE buffer. Truncate if
necessary. If a non-NULL UNICODE string is passed in, it will
be populated. Otherwise, the NATIVE string will be populated.
****************************************************************************/
void F_4xNameTable::copyTagName(
FLMUNICODE * puzDestTagName,
char * pszDestTagName,
FLMUINT uiDestBufSize, // Bytes, must be enough for null terminator
FLMUNICODE * puzSrcTagName)
{
if (puzDestTagName)
{
// Decrement name buffer size by sizeof( FLMUNICODE) to allow for a
// terminating NULL character. uiDestBufSize better be at list big
// enough for a null terminating character.
flmAssert( uiDestBufSize >= sizeof( FLMUNICODE));
uiDestBufSize -= sizeof( FLMUNICODE);
// Copy the name to the NATIVE buffer. Non-Ascii UNICODE characters
// will be returned as question marks (?).
while (uiDestBufSize >= sizeof( FLMUNICODE) && *puzSrcTagName)
{
*puzDestTagName++ = *puzSrcTagName;
uiDestBufSize -= sizeof( FLMUNICODE);
puzSrcTagName++;
}
*puzDestTagName = 0;
}
else
{
// Decrement name buffer size by one to allow for a terminating
// NULL character. uiDestBufSize better be at list big
// enough for a null terminating character.
flmAssert( uiDestBufSize);
uiDestBufSize--;
// Copy the name to the NATIVE buffer. Non-Ascii UNICODE characters
// will be returned as question marks (?).
while (uiDestBufSize && *puzSrcTagName)
{
if (*puzSrcTagName <= 127)
{
*pszDestTagName++ = (char)*puzSrcTagName;
}
else
{
*pszDestTagName++ = '?';
}
uiDestBufSize--;
puzSrcTagName++;
}
*pszDestTagName = 0;
}
}
/***************************************************************************
Desc: Sort an array of SCACHE pointers by their block address.
****************************************************************************/
void F_4xNameTable::sortTagTbl(
FLM_4x_TAG_INFO ** ppTagInfoTbl,
FLMUINT uiLowerBounds,
FLMUINT uiUpperBounds,
FLM_4x_TAG_COMPARE_FUNC fnTagCompare)
{
FLMUINT uiLBPos;
FLMUINT uiUBPos;
FLMUINT uiMIDPos;
FLMUINT uiLeftItems;
FLMUINT uiRightItems;
FLM_4x_TAG_INFO * pCurTagInfo;
FLMINT iCompare;
Iterate_Larger_Half:
uiUBPos = uiUpperBounds;
uiLBPos = uiLowerBounds;
uiMIDPos = (uiUpperBounds + uiLowerBounds + 1) / 2;
pCurTagInfo = ppTagInfoTbl [uiMIDPos ];
for (;;)
{
while (uiLBPos == uiMIDPos || // Don't compare with target
((iCompare =
fnTagCompare( ppTagInfoTbl [uiLBPos], pCurTagInfo)) < 0))
{
if (uiLBPos >= uiUpperBounds)
{
break;
}
uiLBPos++;
}
while (uiUBPos == uiMIDPos || // Don't compare with target
(((iCompare =
fnTagCompare( pCurTagInfo, ppTagInfoTbl [uiUBPos])) < 0)))
{
if (!uiUBPos)
{
break;
}
uiUBPos--;
}
if (uiLBPos < uiUBPos ) // Interchange and continue loop.
{
// Exchange [uiLBPos] with [uiUBPos].
tagInfoSwap( ppTagInfoTbl, uiLBPos, uiUBPos);
uiLBPos++; // Scan from left to right.
uiUBPos--; // Scan from right to left.
}
else // Past each other - done
{
break;
}
}
// Check for swap( LB, MID ) - cases 3 and 4
if( uiLBPos < uiMIDPos )
{
// Exchange [uiLBPos] with [uiMIDPos]
tagInfoSwap( ppTagInfoTbl, uiMIDPos, uiLBPos);
uiMIDPos = uiLBPos;
}
else if( uiMIDPos < uiUBPos )
{
// Exchange [uUBPos] with [uiMIDPos]
tagInfoSwap( ppTagInfoTbl, uiMIDPos, uiUBPos);
uiMIDPos = uiUBPos;
}
// Check the left piece.
uiLeftItems = (uiLowerBounds + 1 < uiMIDPos )
? uiMIDPos - uiLowerBounds // 2 or more
: 0;
uiRightItems = (uiMIDPos + 1 < uiUpperBounds )
? uiUpperBounds - uiMIDPos // 2 or more
: 0;
if( uiLeftItems < uiRightItems )
{
// Recurse on the LEFT side and goto the top on the RIGHT side.
if (uiLeftItems )
{
sortTagTbl( ppTagInfoTbl, uiLowerBounds, uiMIDPos - 1, fnTagCompare);
}
uiLowerBounds = uiMIDPos + 1;
goto Iterate_Larger_Half;
}
else if (uiLeftItems ) // Compute a truth table to figure out this check.
{
// Recurse on the RIGHT side and goto the top for the LEFT side.
if (uiRightItems )
{
sortTagTbl( ppTagInfoTbl, uiMIDPos + 1, uiUpperBounds, fnTagCompare);
}
uiUpperBounds = uiMIDPos - 1;
goto Iterate_Larger_Half;
}
}
/****************************************************************************
Desc: Allocate a new tag info structure and set it up.
****************************************************************************/
RCODE F_4xNameTable::allocTag(
const FLMUNICODE * puzTagName,
const char * pszTagName,
FLMUINT uiTagNum,
FLMUINT uiType,
FLMUINT uiSubType,
FLM_4x_TAG_INFO ** ppTagInfo)
{
RCODE rc = NE_XFLM_OK;
void * pvMark;
FLM_4x_TAG_INFO * pTagInfo;
FLMUINT uiNameSize;
FLMUNICODE * puzTmp;
// Create a new tag info structure.
pvMark = m_pool.poolMark();
if( RC_BAD( rc = m_pool.poolAlloc( sizeof( FLM_4x_TAG_INFO),
(void **)&pTagInfo)))
{
goto Exit;
}
// Allocate the space for the tag name.
if (puzTagName)
{
uiNameSize = (f_unilen( puzTagName) + 1) * sizeof( FLMUNICODE);
if( RC_BAD( rc = m_pool.poolAlloc( uiNameSize,
(void **)&pTagInfo->puzTagName)))
{
goto Exit;
}
f_memcpy( pTagInfo->puzTagName, puzTagName, uiNameSize);
}
else
{
uiNameSize = (f_strlen( pszTagName) + 1) * sizeof( FLMUNICODE);
if( RC_BAD( rc = m_pool.poolAlloc( uiNameSize,
(void **)&pTagInfo->puzTagName)))
{
goto Exit;
}
puzTmp = pTagInfo->puzTagName;
while (*pszTagName)
{
*puzTmp++ = (FLMUNICODE)*pszTagName;
pszTagName++;
}
*puzTmp = 0;
}
pTagInfo->uiTagNum = uiTagNum;
pTagInfo->uiType = uiType;
pTagInfo->uiSubType = uiSubType;
Exit:
if (RC_BAD( rc))
{
m_pool.poolReset( pvMark);
pTagInfo = NULL;
}
*ppTagInfo = pTagInfo;
return( rc);
}
/****************************************************************************
Desc: Allocate the sort tables.
****************************************************************************/
RCODE F_4xNameTable::reallocSortTables(
FLMUINT uiNewTblSize)
{
RCODE rc = NE_XFLM_OK;
FLM_4x_TAG_INFO ** ppNewTbl;
if( RC_BAD( rc = f_alloc(
sizeof( FLM_4x_TAG_INFO *) * uiNewTblSize * 3, &ppNewTbl)))
{
goto Exit;
}
// Copy the old tables into the new.
if (m_uiNumTags)
{
f_memcpy( ppNewTbl, m_ppSortedByTagName,
sizeof( FLM_4x_TAG_INFO *) * m_uiNumTags);
f_memcpy( &ppNewTbl [uiNewTblSize], m_ppSortedByTagNum,
sizeof( FLM_4x_TAG_INFO *) * m_uiNumTags);
f_memcpy( &ppNewTbl [uiNewTblSize + uiNewTblSize],
m_ppSortedByTagTypeAndName,
sizeof( FLM_4x_TAG_INFO *) * m_uiNumTags);
f_free( &m_ppSortedByTagName);
}
m_ppSortedByTagName = ppNewTbl;
m_ppSortedByTagNum = &ppNewTbl [uiNewTblSize];
m_ppSortedByTagTypeAndName = &ppNewTbl [uiNewTblSize + uiNewTblSize];
m_uiTblSize = uiNewTblSize;
Exit:
return( rc);
}
/****************************************************************************
Desc: Get a tag name, number, etc. using tag number ordering.
Tag name is returned as a UNICODE string or NATIVE string. If a
non-NULL UNICODE string is passed in, it will be used.
Otherwise, the NATIVE string will be used.
****************************************************************************/
FLMBOOL F_4xNameTable::getNextTagNumOrder(
FLMUINT * puiNextPos,
FLMUNICODE * puzTagName,
char * pszTagName,
FLMUINT uiNameBufSize,
FLMUINT * puiTagNum, // May be NULL
FLMUINT * puiType, // May be NULL
FLMUINT * puiSubType) // May be NULL
{
FLM_4x_TAG_INFO * pTagInfo = NULL;
if (!m_bTablesSorted)
{
sortTags();
}
if (*puiNextPos < m_uiNumTags)
{
pTagInfo = m_ppSortedByTagNum [*puiNextPos];
if (puiTagNum)
{
*puiTagNum = pTagInfo->uiTagNum;
}
if (puiType)
{
*puiType = pTagInfo->uiType;
}
if (puiSubType)
{
*puiSubType = pTagInfo->uiSubType;
}
if( puzTagName || pszTagName)
{
copyTagName( puzTagName, pszTagName, uiNameBufSize,
pTagInfo->puzTagName);
}
// Returned *puiNextPos should be the next one to retrieve.
(*puiNextPos)++;
}
else
{
// Nothing more in list, but initialize return variables anyway.
if (puzTagName)
{
*puzTagName = 0;
}
if (pszTagName)
{
*pszTagName = 0;
}
if (puiTagNum)
{
*puiTagNum = 0;
}
if (puiType)
{
*puiType = 0;
}
if (puiSubType)
{
*puiSubType = 0;
}
}
return( (FLMBOOL)(pTagInfo ? (FLMBOOL)TRUE : (FLMBOOL)FALSE));
}
/****************************************************************************
Desc: Get a tag name, number, etc. using tag name ordering.
Tag name is returned as a UNICODE string or NATIVE string. If a
non-NULL UNICODE string is passed in, it will be used.
Otherwise, the NATIVE string will be used.
****************************************************************************/
FLMBOOL F_4xNameTable::getNextTagNameOrder(
FLMUINT * puiNextPos,
FLMUNICODE * puzTagName,
char * pszTagName,
FLMUINT uiNameBufSize,
FLMUINT * puiTagNum, // May be NULL
FLMUINT * puiType, // May be NULL
FLMUINT * puiSubType) // May be NULL
{
FLM_4x_TAG_INFO * pTagInfo = NULL;
if (!m_bTablesSorted)
{
sortTags();
}
if (*puiNextPos < m_uiNumTags)
{
pTagInfo = m_ppSortedByTagName [*puiNextPos];
if (puiTagNum)
{
*puiTagNum = pTagInfo->uiTagNum;
}
if (puiType)
{
*puiType = pTagInfo->uiType;
}
if (puiSubType)
{
*puiSubType = pTagInfo->uiSubType;
}
if( puzTagName || pszTagName)
{
copyTagName( puzTagName, pszTagName, uiNameBufSize,
pTagInfo->puzTagName);
}
// Returned *puiNextPos should be the next one to retrieve.
(*puiNextPos)++;
}
else
{
// Nothing more in list, but initialize return variables anyway.
if (puzTagName)
{
*puzTagName = 0;
}
if (pszTagName)
{
*pszTagName = 0;
}
if (puiTagNum)
{
*puiTagNum = 0;
}
if (puiType)
{
*puiType = 0;
}
if (puiSubType)
{
*puiSubType = 0;
}
}
return( (FLMBOOL)(pTagInfo ? (FLMBOOL)TRUE : (FLMBOOL)FALSE));
}
/****************************************************************************
Desc: Get a tag name and number from type. Tag name is returned as a
UNICODE string or NATIVE string. If a non-NULL UNICODE string is
passed in, it will be used. Otherwise, the NATIVE string
will be used.
****************************************************************************/
FLMBOOL F_4xNameTable::getFromTagType(
FLMUINT uiType,
FLMUINT * puiNextPos, // To get first, initialize to zero.
FLMUNICODE * puzTagName,
char * pszTagName,
FLMUINT uiNameBufSize, // In bytes - must be at least sizeof( FLMUNICODE)
FLMUINT * puiTagNum, // May be NULL
FLMUINT * puiSubType) // May be NULL
{
FLM_4x_TAG_INFO * pTagInfo = NULL;
if (!m_bTablesSorted)
{
sortTags();
}
if (*puiNextPos == 0)
{
// A value of zero indicates we should try to find the first
// one.
(void)findTagByTypeAndName( NULL, "", uiType, puiNextPos);
if (*puiNextPos < m_uiNumTags &&
m_ppSortedByTagTypeAndName [*puiNextPos]->uiType != uiType)
{
(*puiNextPos)++;
}
}
if (*puiNextPos < m_uiNumTags &&
m_ppSortedByTagTypeAndName [*puiNextPos]->uiType == uiType)
{
pTagInfo = m_ppSortedByTagTypeAndName [*puiNextPos];
if (puiTagNum)
{
*puiTagNum = pTagInfo->uiTagNum;
}
if (puiSubType)
{
*puiSubType = pTagInfo->uiSubType;
}
if( puzTagName || pszTagName)
{
copyTagName( puzTagName, pszTagName, uiNameBufSize,
pTagInfo->puzTagName);
}
// Returned *puiNextPos should be the next one to retrieve, so that
// it is not zero.
(*puiNextPos)++;
}
else
{
// Type was not found, but initialize return variables anyway.
if (puzTagName)
{
*puzTagName = 0;
}
if (pszTagName)
{
*pszTagName = 0;
}
if (puiTagNum)
{
*puiTagNum = 0;
}
if (puiSubType)
{
*puiSubType = 0;
}
}
return( (FLMBOOL)(pTagInfo ? (FLMBOOL)TRUE : (FLMBOOL)FALSE));
}
/****************************************************************************
Desc: Get a tag name from its tag number. Tag name is returned as a
UNICODE string or NATIVE string. If a non-NULL UNICODE string
is passed in, it will be used. Otherwise, the NATIVE string
will be used.
****************************************************************************/
FLMBOOL F_4xNameTable::getFromTagNum(
FLMUINT uiTagNum,
FLMUNICODE * puzTagName,
char * pszTagName,
FLMUINT uiNameBufSize, // In bytes, at least enough for null char.
FLMUINT * puiType, // May be NULL
FLMUINT * puiSubType) // May be NULL
{
FLM_4x_TAG_INFO * pTagInfo;
if (!m_bTablesSorted)
{
sortTags();
}
if ((pTagInfo = findTagByNum( uiTagNum)) != NULL)
{
if (puiType)
{
*puiType = pTagInfo->uiType;
}
if (puiSubType)
{
*puiSubType = pTagInfo->uiSubType;
}
if( puzTagName || pszTagName)
{
copyTagName( puzTagName, pszTagName, uiNameBufSize,
pTagInfo->puzTagName);
}
}
else
{
// Tag number was not found, but initialize return variables anyway.
if (puzTagName)
{
*puzTagName = 0;
}
if (pszTagName)
{
*pszTagName = 0;
}
if (puiType)
{
*puiType = 0;
}
if (puiSubType)
{
*puiSubType = 0;
}
}
return( (FLMBOOL)(pTagInfo ? (FLMBOOL)TRUE : (FLMBOOL)FALSE));
}
/****************************************************************************
Desc: Get a tag number and type from its tag name. Tag name is passed
in as a UNICODE string or NATIVE string. If a non-NULL UNICODE
string is passed in, it will be used. Otherwise, the NATIVE
string will be used.
****************************************************************************/
FLMBOOL F_4xNameTable::getFromTagName(
const FLMUNICODE * puzTagName,
const char * pszTagName,
FLMUINT * puiTagNum, // Cannot be NULL
FLMUINT * puiType, // May be NULL
FLMUINT * puiSubType) // May be NULL
{
FLM_4x_TAG_INFO * pTagInfo;
if (!m_bTablesSorted)
{
sortTags();
}
if ((pTagInfo = findTagByName( puzTagName, pszTagName)) != NULL)
{
flmAssert( puiTagNum);
*puiTagNum = pTagInfo->uiTagNum;
if (puiType)
{
*puiType = pTagInfo->uiType;
}
if (puiSubType)
{
*puiSubType = pTagInfo->uiSubType;
}
}
else
{
// Tag name was not found, but initialize return variables anyway.
*puiTagNum = 0;
if (puiType)
{
*puiType = 0;
}
if (puiSubType)
{
*puiSubType = 0;
}
}
return( (FLMBOOL)(pTagInfo ? (FLMBOOL)TRUE : (FLMBOOL)FALSE));
}
/****************************************************************************
Desc: Get a tag number from its tag name and type. Tag name is passed
in as a UNICODE or NATIVE string. If a non-NULL UNICODE string is
passed in, it will be used. Otherwise, the NATIVE string will
be used.
****************************************************************************/
FLMBOOL F_4xNameTable::getFromTagTypeAndName(
const FLMUNICODE * puzTagName,
const char * pszTagName,
FLMUINT uiType,
FLMUINT * puiTagNum, // Cannot be NULL
FLMUINT * puiSubType) // May be NULL
{
FLM_4x_TAG_INFO * pTagInfo;
if (!m_bTablesSorted)
{
sortTags();
}
if ((pTagInfo = findTagByTypeAndName( puzTagName, pszTagName,
uiType)) != NULL)
{
flmAssert( puiTagNum);
*puiTagNum = pTagInfo->uiTagNum;
if (puiSubType)
{
*puiSubType = pTagInfo->uiSubType;
}
}
else
{
// Tag name was not found, but initialize return variables anyway.
*puiTagNum = 0;
if (puiSubType)
{
*puiSubType = 0;
}
}
return( (FLMBOOL)(pTagInfo ? (FLMBOOL)TRUE : (FLMBOOL)FALSE));
}
/****************************************************************************
Desc: Insert a tag info structure into the sorted tables at the
specified positions.
****************************************************************************/
RCODE F_4xNameTable::insertTagInTables(
FLM_4x_TAG_INFO * pTagInfo,
FLMUINT uiTagNameTblInsertPos,
FLMUINT uiTagTypeAndNameTblInsertPos,
FLMUINT uiTagNumTblInsertPos)
{
RCODE rc = NE_XFLM_OK;
FLMUINT uiLoop;
// See if we need to resize the tables. Start at 256. Double each
// time up to 2048. Then just add 2048 at a time.
if (m_uiNumTags == m_uiTblSize)
{
FLMUINT uiNewSize;
if (!m_uiTblSize)
{
uiNewSize = 256;
}
else if (m_uiTblSize < 2048)
{
uiNewSize = m_uiTblSize * 2;
}
else
{
uiNewSize = m_uiTblSize + 2048;
}
if (RC_BAD( rc = reallocSortTables( uiNewSize)))
{
goto Exit;
}
}
// Insert into the sorted-by-name table
uiLoop = m_uiNumTags;
while (uiLoop > uiTagNameTblInsertPos)
{
m_ppSortedByTagName [uiLoop] = m_ppSortedByTagName [uiLoop - 1];
uiLoop--;
}
m_ppSortedByTagName [uiTagNameTblInsertPos] = pTagInfo;
// Insert into the sorted-by-number table
uiLoop = m_uiNumTags;
while (uiLoop > uiTagNumTblInsertPos)
{
m_ppSortedByTagNum [uiLoop] = m_ppSortedByTagNum [uiLoop - 1];
uiLoop--;
}
m_ppSortedByTagNum [uiTagNumTblInsertPos] = pTagInfo;
// Insert into the sorted-by-tag-name-and-type table
uiLoop = m_uiNumTags;
while (uiLoop > uiTagTypeAndNameTblInsertPos)
{
m_ppSortedByTagTypeAndName [uiLoop] =
m_ppSortedByTagTypeAndName [uiLoop - 1];
uiLoop--;
}
m_ppSortedByTagTypeAndName [uiTagTypeAndNameTblInsertPos] = pTagInfo;
// Increment the total number of tags
m_uiNumTags++;
Exit:
return( rc);
}
/****************************************************************************
Desc: Add a tag to the table. Tag name is passed in as a UNICODE
string or NATIVE string. If a non-NULL UNICODE string is passed
in, it will be used. Otherwise, the NATIVE string will be used.
****************************************************************************/
RCODE F_4xNameTable::addTag(
const FLMUNICODE * puzTagName,
const char * pszTagName,
FLMUINT uiTagNum,
FLMUINT uiType,
FLMUINT uiSubType,
FLMBOOL bCheckDuplicates)
{
RCODE rc = NE_XFLM_OK;
FLMUINT uiTagNameTblInsertPos;
FLMUINT uiTagTypeAndNameTblInsertPos;
FLMUINT uiTagNumTblInsertPos;
FLM_4x_TAG_INFO * pTagInfo;
// Must have a non-NULL tag name. Use UNICODE string if it is
// non-NULL. Otherwise, use NATIVE string.
if (puzTagName && *puzTagName)
{
pszTagName = NULL;
}
else if (pszTagName && *pszTagName)
{
puzTagName = NULL;
}
else
{
rc = RC_SET_AND_ASSERT( NE_XFLM_INVALID_PARM);
goto Exit;
}
// Tag number of zero not allowed.
if (!uiTagNum)
{
rc = RC_SET_AND_ASSERT( NE_XFLM_INVALID_PARM);
goto Exit;
}
// Tables must be sorted in order for this to work
if (bCheckDuplicates)
{
if (!m_bTablesSorted)
{
sortTags();
}
// Make sure that the tag name is not already used.
if (findTagByName( puzTagName, pszTagName, &uiTagNameTblInsertPos))
{
rc = RC_SET( NE_XFLM_EXISTS);
goto Exit;
}
// Make sure that the tag name + type is not already used.
if (findTagByTypeAndName( puzTagName, pszTagName,
uiType, &uiTagTypeAndNameTblInsertPos))
{
rc = RC_SET( NE_XFLM_EXISTS);
goto Exit;
}
// Make sure that the tag number is not already used.
if (findTagByNum( uiTagNum, &uiTagNumTblInsertPos))
{
rc = RC_SET( NE_XFLM_EXISTS);
goto Exit;
}
}
else
{
uiTagNameTblInsertPos =
uiTagTypeAndNameTblInsertPos =
uiTagNumTblInsertPos = m_uiNumTags;
m_bTablesSorted = FALSE;
}
// Create a new tag info structure.
if (RC_BAD( rc = allocTag( puzTagName, pszTagName, uiTagNum, uiType,
uiSubType, &pTagInfo)))
{
goto Exit;
}
// Insert the tag structure into the appropriate places in the
// sorted tables.
if (RC_BAD( rc = insertTagInTables( pTagInfo, uiTagNameTblInsertPos,
uiTagTypeAndNameTblInsertPos,
uiTagNumTblInsertPos)))
{
goto Exit;
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Sort the tag tables according to their respective criteria.
****************************************************************************/
void F_4xNameTable::sortTags( void)
{
if (!m_bTablesSorted && m_uiNumTags > 1)
{
sortTagTbl( m_ppSortedByTagName, 0, m_uiNumTags - 1,
compareTagNameOnly);
sortTagTbl( m_ppSortedByTagNum, 0, m_uiNumTags - 1,
compareTagNumOnly);
sortTagTbl( m_ppSortedByTagTypeAndName, 0, m_uiNumTags - 1,
compareTagTypeAndName);
}
m_bTablesSorted = TRUE;
}
/****************************************************************************
Desc: Initialize a name table from a database.
****************************************************************************/
RCODE F_4xNameTable::setupNameTable(
F_4xReader * pDb)
{
RCODE rc = NE_XFLM_OK;
F_Record * pRec = NULL;
FLMUINT uiDrn;
FLMUINT uiLoop;
void * pvField;
FLMUNICODE uzName[ 60];
FLMUNICODE * puzName = &uzName[ 0];
FLMUINT uiNameLen = sizeof( uzName);
FLMUINT uiLen;
FLMUINT uiSubType;
// Clean out all existing tags, if any.
clearTable();
// Find the next DRN in the dictionary container
if( RC_BAD( rc = pDb->getNextDrn( FLM_4x_DICT_CONTAINER, &uiDrn)))
{
goto Exit;
}
// Count the reserved tags
for (uiLoop = 0; Flm4xDictTagInfo[ uiLoop].pszTagName; uiLoop++)
{
;
}
// Preallocate space so we don't have to do it over and over.
if( RC_BAD( rc = reallocSortTables( uiLoop + uiDrn)))
{
goto Exit;
}
// Add in all of the reserved dictionary tags.
for( uiLoop = 0; Flm4xDictTagInfo[ uiLoop].pszTagName; uiLoop++)
{
if( RC_BAD( rc = addTag( NULL,
Flm4xDictTagInfo[ uiLoop].pszTagName,
Flm4xDictTagInfo[ uiLoop].uiTagNum,
FLM_4x_FIELD_TAG,
Flm4xDictTagInfo[ uiLoop].uiFieldType, FALSE)))
{
goto Exit;
}
}
// Read through all of the dictionary records
pDb->setDefaultContainer( FLM_4x_DICT_CONTAINER);
for( ;;)
{
if( RC_BAD( rc = pDb->retrieveNextRec( &pRec)))
{
if( rc != NE_XFLM_EOF_HIT)
{
goto Exit;
}
rc = NE_XFLM_OK;
break;
}
pvField = pRec->root();
uiDrn = pRec->getID();
// Get the unicode name length (does not include NULL terminator)
if( RC_BAD( rc = pRec->getUnicode( pvField, NULL, &uiLen)))
{
goto Exit;
}
// Account for NULL character.
uiLen += sizeof( FLMUNICODE);
// See if we need a larger buffer to get the name.
if (uiLen > uiNameLen)
{
FLMUNICODE * puzTmp;
// Add enough for 60 more unicode characters.
uiLen += (60 * sizeof( FLMUNICODE));
if( RC_BAD( rc = f_alloc( uiLen, &puzTmp)))
{
goto Exit;
}
if (puzName != &uzName [0])
{
f_free( &puzName);
}
puzName = puzTmp;
uiNameLen = uiLen;
}
// Get the tag name.
uiLen = uiNameLen;
if (RC_BAD( rc = pRec->getUnicode( pvField, puzName, &uiLen)))
{
goto Exit;
}
// Get the sub-type.
if (pRec->getFieldID( pvField) == FLM_4x_FIELD_TAG)
{
void * pvFld = pRec->find( pvField, FLM_4x_TYPE_TAG, 1, FALSE);
if (!pvFld ||
RC_BAD( pDb->getTypeTag( pRec, pvFld, &uiSubType)))
{
uiSubType = FLM_4x_TEXT_TYPE;
}
}
else
{
uiSubType = 0;
}
// Add tag to table, without sorting yet.
if (RC_BAD( rc = addTag( puzName, NULL, uiDrn,
pRec->getFieldID( pvField), uiSubType, FALSE)))
{
goto Exit;
}
}
sortTags();
Exit:
if( RC_BAD( rc))
{
clearTable();
}
if( pRec)
{
pRec->Release();
}
if( puzName != &uzName [0])
{
f_free( &puzName);
}
return( rc);
}
Reference in New Issue View Git Blame Copy Permalink