fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2014-03-11 09:38 UTC+0100 Przemyslaw Czerpak (druzus/at/poczta.onet.pl)

Browse Source 
* include/hbdbsort.h
  * include/hbrddcdx.h
  * include/hbrddnsx.h
  * include/hbrddntx.h
  * include/hbsxfunc.h
  * src/rdd/dbfcdx/dbfcdx1.c
  * src/rdd/dbffpt/dbffpt1.c
  * src/rdd/dbfnsx/dbfnsx1.c
  * src/rdd/dbfntx/dbfntx1.c
  * src/rdd/dbsql.c
  * src/rdd/hbdbsort.c
  * src/rdd/hbsix/sxcompr.c
  * src/rdd/hbsix/sxsem.c
    * changed hb_fs*() API to hb_file*() API
This commit is contained in:
Przemysław Czerpak
2014-03-11 09:38:36 +01:00
parent 74f298f8ec
commit e227af16d0
14 changed files with 306 additions and 288 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
ChangeLog.txt
View File

@@ -10,6 +10,22 @@
* Change, ! Fix, % Optimization, + Addition, - Removal, ; Comment
*/
2014-03-11 09:38 UTC+0100 Przemyslaw Czerpak (druzus/at/poczta.onet.pl)
* include/hbdbsort.h
* include/hbrddcdx.h
* include/hbrddnsx.h
* include/hbrddntx.h
* include/hbsxfunc.h
* src/rdd/dbfcdx/dbfcdx1.c
* src/rdd/dbffpt/dbffpt1.c
* src/rdd/dbfnsx/dbfnsx1.c
* src/rdd/dbfntx/dbfntx1.c
* src/rdd/dbsql.c
* src/rdd/hbdbsort.c
* src/rdd/hbsix/sxcompr.c
* src/rdd/hbsix/sxsem.c
* changed hb_fs*() API to hb_file*() API
2014-03-10 18:59 UTC+0100 Przemyslaw Czerpak (druzus/at/poczta.onet.pl)
* contrib/hbtcpio/tcpio.c
* use default timeout defined in initial hostname string in read/write

2
include/hbdbsort.h
View File

@@ -61,7 +61,7 @@ HB_EXTERN_BEGIN
typedef struct _DBQUICKSORT
{
HB_FHANDLE hFile;
PHB_FILE pFile;
char szTempName[ HB_PATH_MAX ];
HB_BYTE * pBuffer;
HB_BYTE * pSwapBufferA;

38
include/hbrddcdx.h
View File

@@ -419,30 +419,30 @@ typedef CDXSWAPPAGE * LPCDXSWAPPAGE;
typedef struct
{
LPCDXTAG pTag; /* current Tag */
HB_FHANDLE hTempFile; /* handle to temporary file */
char * szTempFileName; /* temporary file name */
int keyLen; /* key length */
HB_BYTE bTrl; /* filler char for shorter keys */
HB_BOOL fUnique; /* HB_TRUE if index is unique */
HB_BOOL fReindex; /* HB_TRUE if reindexing is in process */
HB_ULONG ulMaxRec; /* the highest record number */
HB_ULONG ulTotKeys; /* total number of keys indexed */
HB_ULONG ulKeys; /* keys in curently created page */
HB_ULONG ulPages; /* number of pages */
HB_ULONG ulCurPage; /* current page */
HB_ULONG ulPgKeys; /* maximum number of key in page memory buffer */
HB_ULONG ulMaxKey; /* maximum number of keys in single page */
HB_BYTE * pKeyPool; /* memory buffer for current page then for pages */
LPCDXSWAPPAGE pSwapPage; /* list of pages */
LPCDXPAGE NodeList[ CDX_STACKSIZE ]; /* Stack of pages */
LPCDXTAG pTag; /* current Tag */
PHB_FILE pTempFile; /* handle to temporary file */
char * szTempFileName; /* temporary file name */
int keyLen; /* key length */
HB_BYTE bTrl; /* filler char for shorter keys */
HB_BOOL fUnique; /* HB_TRUE if index is unique */
HB_BOOL fReindex; /* HB_TRUE if reindexing is in process */
HB_ULONG ulMaxRec; /* the highest record number */
HB_ULONG ulTotKeys; /* total number of keys indexed */
HB_ULONG ulKeys; /* keys in curently created page */
HB_ULONG ulPages; /* number of pages */
HB_ULONG ulCurPage; /* current page */
HB_ULONG ulPgKeys; /* maximum number of key in page memory buffer */
HB_ULONG ulMaxKey; /* maximum number of keys in single page */
HB_BYTE * pKeyPool; /* memory buffer for current page then for pages */
LPCDXSWAPPAGE pSwapPage; /* list of pages */
LPCDXPAGE NodeList[ CDX_STACKSIZE ]; /* Stack of pages */
HB_ULONG ulFirst;
HB_ULONG * pSortedPages;
HB_BYTE pLastKey[ CDX_MAXKEY ]; /* last key val */
HB_BYTE pLastKey[ CDX_MAXKEY ]; /* last key val */
HB_ULONG ulLastRec;
HB_BYTE * pRecBuff;
#ifndef HB_CDX_PACKTRAIL
int iLastTrl; /* last key trailing spaces */
int iLastTrl; /* last key trailing spaces */
#endif
} CDXSORTINFO;
typedef CDXSORTINFO * LPCDXSORTINFO;

58
include/hbrddnsx.h
View File

@@ -520,36 +520,36 @@ typedef NSXSWAPPAGE * LPNSXSWAPPAGE;
typedef struct
{
LPTAGINFO pTag; /* current Tag */
HB_FHANDLE hTempFile; /* handle to temporary file */
char * szTempFileName; /* temporary file name */
int keyLen; /* key length */
HB_UCHAR trailChar; /* index key trail character */
HB_UCHAR recSize; /* record size in leaf keys */
HB_BOOL fUnique; /* HB_TRUE if index is unique */
HB_BOOL fReindex; /* HB_TRUE if reindexing is in process */
HB_ULONG ulMaxRec; /* the highest record number */
HB_ULONG ulTotKeys; /* total number of keys indexed */
HB_ULONG ulKeys; /* keys in curently created page */
HB_ULONG ulPages; /* number of pages */
HB_ULONG ulCurPage; /* current page */
HB_ULONG ulPgKeys; /* maximum number of key in page memory buffer */
HB_ULONG ulMaxKey; /* maximum number of keys in single page */
HB_UCHAR * pKeyPool; /* memory buffer for current page then for pages */
HB_UCHAR * pStartKey; /* begining of key pool after sorting */
LPNSXSWAPPAGE pSwapPage; /* list of pages */
LPPAGEINFO NodeList[ NSX_STACKSIZE ]; /* Stack of pages */
HB_ULONG ulFirst;
HB_ULONG * pSortedPages;
HB_UCHAR pLastKey[ NSX_MAXKEYLEN ]; /* last key val */
HB_ULONG ulLastRec;
HB_ULONG ulLastLeaf; /* last non empty leaf page written to tag */
LPTAGINFO pTag; /* current Tag */
PHB_FILE pTempFile; /* handle to temporary file */
char * szTempFileName; /* temporary file name */
int keyLen; /* key length */
HB_UCHAR trailChar; /* index key trail character */
HB_UCHAR recSize; /* record size in leaf keys */
HB_BOOL fUnique; /* HB_TRUE if index is unique */
HB_BOOL fReindex; /* HB_TRUE if reindexing is in process */
HB_ULONG ulMaxRec; /* the highest record number */
HB_ULONG ulTotKeys; /* total number of keys indexed */
HB_ULONG ulKeys; /* keys in curently created page */
HB_ULONG ulPages; /* number of pages */
HB_ULONG ulCurPage; /* current page */
HB_ULONG ulPgKeys; /* maximum number of key in page memory buffer */
HB_ULONG ulMaxKey; /* maximum number of keys in single page */
HB_UCHAR * pKeyPool; /* memory buffer for current page then for pages */
HB_UCHAR * pStartKey; /* begining of key pool after sorting */
LPNSXSWAPPAGE pSwapPage; /* list of pages */
LPPAGEINFO NodeList[ NSX_STACKSIZE ]; /* Stack of pages */
HB_ULONG ulFirst;
HB_ULONG * pSortedPages;
HB_UCHAR pLastKey[ NSX_MAXKEYLEN ]; /* last key val */
HB_ULONG ulLastRec;
HB_ULONG ulLastLeaf; /* last non empty leaf page written to tag */
HB_UCHAR * pBuffIO; /* index IO buffer */
HB_ULONG ulSizeIO; /* size of IO buffer in index pages */
HB_ULONG ulPagesIO; /* number of index pages in buffer */
HB_ULONG ulFirstIO; /* first page in buffer */
HB_ULONG ulLastIO; /* last page in buffer */
HB_UCHAR * pBuffIO; /* index IO buffer */
HB_ULONG ulSizeIO; /* size of IO buffer in index pages */
HB_ULONG ulPagesIO; /* number of index pages in buffer */
HB_ULONG ulFirstIO; /* first page in buffer */
HB_ULONG ulLastIO; /* last page in buffer */
} NSXSORTINFO;
typedef NSXSORTINFO * LPNSXSORTINFO;

2
include/hbrddntx.h
View File

@@ -303,7 +303,7 @@ typedef NTXSWAPPAGE * LPNTXSWAPPAGE;
typedef struct
{
LPTAGINFO pTag; /* current Tag */
HB_FHANDLE hTempFile; /* handle to temporary file */
PHB_FILE pTempFile; /* handle to temporary file */
char * szTempFileName; /* temporary file name */
int keyLen; /* key length */
HB_BOOL fUnique; /* HB_TRUE if index is unique */

4
include/hbsxfunc.h
View File

@@ -66,8 +66,8 @@ void hb_sxDeCrypt( const char * pSrc, char * pDst, const char * pKeyVal, HB_SIZE
HB_BOOL hb_LZSSxDecompressMem( const char * pSrcBuf, HB_SIZE nSrcLen, char * pDstBuf, HB_SIZE nDstLen );
HB_BOOL hb_LZSSxCompressMem( const char * pSrcBuf, HB_SIZE nSrcLen, char * pDstBuf, HB_SIZE nDstLen, HB_SIZE * pnSize );
HB_BOOL hb_LZSSxCompressFile( HB_FHANDLE hInput, HB_FHANDLE hOutput, HB_SIZE * pnSize );
HB_BOOL hb_LZSSxDecompressFile( HB_FHANDLE hInput, HB_FHANDLE hOutput );
HB_BOOL hb_LZSSxCompressFile( PHB_FILE pInput, PHB_FILE pOutput, HB_SIZE * pnSize );
HB_BOOL hb_LZSSxDecompressFile( PHB_FILE pInput, PHB_FILE pOutput );
HB_EXTERN_END

23
src/rdd/dbfcdx/dbfcdx1.c
View File

@@ -8987,19 +8987,20 @@ static void hb_cdxSortWritePage( LPCDXSORTINFO pSort )
hb_cdxSortSortPage( pSort );
if( pSort->hTempFile == FS_ERROR )
if( pSort->pTempFile == NULL )
{
char szName[ HB_PATH_MAX ];
pSort->hTempFile = hb_fsCreateTemp( NULL, NULL, FC_NORMAL, szName );
if( pSort->hTempFile == FS_ERROR )
pSort->pTempFile = hb_fileCreateTemp( NULL, NULL, FC_NORMAL, szName );
if( pSort->pTempFile == NULL )
{
hb_errInternal( 9301, "hb_cdxSortWritePage: Can't create temporary file.", NULL, NULL );
}
pSort->szTempFileName = hb_strdup( szName );
}
pSort->pSwapPage[ pSort->ulCurPage ].ulKeys = pSort->ulKeys;
pSort->pSwapPage[ pSort->ulCurPage ].nOffset = hb_fsSeekLarge( pSort->hTempFile, 0, FS_END );
if( hb_fsWriteLarge( pSort->hTempFile, pSort->pKeyPool, nSize ) != nSize )
pSort->pSwapPage[ pSort->ulCurPage ].nOffset = hb_fileSize( pSort->pTempFile );
if( hb_fileWriteAt( pSort->pTempFile, pSort->pKeyPool,
nSize, pSort->pSwapPage[ pSort->ulCurPage ].nOffset ) != nSize )
{
hb_errInternal( 9302, "hb_cdxSortWritePage: Write error in temporary file.", NULL, NULL );
}
@@ -9017,8 +9018,8 @@ static void hb_cdxSortGetPageKey( LPCDXSORTINFO pSort, HB_ULONG ulPage,
HB_ULONG ulKeys = HB_MIN( pSort->ulPgKeys, pSort->pSwapPage[ ulPage ].ulKeys );
HB_SIZE nSize = ulKeys * ( iLen + 4 );
if( hb_fsSeekLarge( pSort->hTempFile, pSort->pSwapPage[ ulPage ].nOffset, FS_SET ) != pSort->pSwapPage[ ulPage ].nOffset ||
hb_fsReadLarge( pSort->hTempFile, pSort->pSwapPage[ ulPage ].pKeyPool, nSize ) != nSize )
if( hb_fileReadAt( pSort->pTempFile, pSort->pSwapPage[ ulPage ].pKeyPool,
nSize, pSort->pSwapPage[ ulPage ].nOffset ) != nSize )
{
hb_errInternal( 9303, "hb_cdxSortGetPageKey: Read error from temporary file.", NULL, NULL );
}
@@ -9277,7 +9278,7 @@ static LPCDXSORTINFO hb_cdxSortNew( LPCDXTAG pTag, HB_ULONG ulRecCount )
}
pSort->pTag = pTag;
pSort->hTempFile = FS_ERROR;
pSort->pTempFile = NULL;
pSort->keyLen = iLen;
pSort->bTrl = pTag->bTrail;
pSort->fUnique = pTag->UniqueKey;
@@ -9294,13 +9295,13 @@ static LPCDXSORTINFO hb_cdxSortNew( LPCDXTAG pTag, HB_ULONG ulRecCount )
static void hb_cdxSortFree( LPCDXSORTINFO pSort )
{
if( pSort->hTempFile != FS_ERROR )
if( pSort->pTempFile != NULL )
{
hb_fsClose( pSort->hTempFile );
hb_fileClose( pSort->pTempFile );
}
if( pSort->szTempFileName )
{
hb_fsDelete( pSort->szTempFileName );
hb_fileDelete( pSort->szTempFileName );
hb_xfree( pSort->szTempFileName );
}
if( pSort->pKeyPool )

155
src/rdd/dbffpt/dbffpt1.c
View File

@@ -2474,7 +2474,7 @@ static HB_ERRCODE hb_fptReadFlexItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_B
}
static HB_ERRCODE hb_fptCopyToRawFile( PHB_FILE pSrc, HB_FOFFSET from,
HB_FHANDLE hDst,
PHB_FILE pDst,
HB_FOFFSET size )
{
HB_ERRCODE errCode = HB_SUCCESS;
@@ -2495,7 +2495,7 @@ static HB_ERRCODE hb_fptCopyToRawFile( PHB_FILE pSrc, HB_FOFFSET from,
from + written );
if( ulRead == 0 )
errCode = EDBF_READ;
else if( hb_fsWriteLarge( hDst, pBuffer, ulRead ) != ulRead )
else if( hb_fileWrite( pDst, pBuffer, ulRead, -1 ) != ulRead )
errCode = EDBF_WRITE;
else
written += ulRead;
@@ -2544,7 +2544,7 @@ static HB_ERRCODE hb_fptCopyToFile( PHB_FILE pSrc, HB_FOFFSET from,
return errCode;
}
static HB_ERRCODE hb_fptReadRawBlock( FPTAREAP pArea, HB_BYTE * bBuffer, HB_FHANDLE hFile,
static HB_ERRCODE hb_fptReadRawBlock( FPTAREAP pArea, HB_BYTE * bBuffer, PHB_FILE pFile,
HB_ULONG ulBlock, HB_ULONG ulSize )
{
HB_ERRCODE errCode = HB_SUCCESS;
@@ -2552,10 +2552,10 @@ static HB_ERRCODE hb_fptReadRawBlock( FPTAREAP pArea, HB_BYTE * bBuffer, HB_FHAN
if( ulBlock == 0 )
return EDBF_CORRUPT;
if( hFile != FS_ERROR )
if( pFile != NULL )
{
errCode = hb_fptCopyToRawFile( pArea->pMemoFile, FPT_BLOCK_OFFSET( ulBlock ),
hFile, ulSize );
pFile, ulSize );
}
else
{
@@ -2568,7 +2568,7 @@ static HB_ERRCODE hb_fptReadRawBlock( FPTAREAP pArea, HB_BYTE * bBuffer, HB_FHAN
}
static HB_ERRCODE hb_fptReadBlobBlock( FPTAREAP pArea, PHB_ITEM pItem,
HB_FHANDLE hFile, HB_ULONG ulBlock,
PHB_FILE pFile, HB_ULONG ulBlock,
HB_USHORT uiMode )
{
HB_ULONG ulSize;
@@ -2584,9 +2584,9 @@ static HB_ERRCODE hb_fptReadBlobBlock( FPTAREAP pArea, PHB_ITEM pItem,
return EDBF_READ;
ulSize = HB_GET_LE_UINT32( buffer );
if( hFile != FS_ERROR )
if( pFile != NULL )
return hb_fptCopyToRawFile( pArea->pMemoFile, FPT_BLOCK_OFFSET( ulBlock ) + 4,
hFile, ulSize );
pFile, ulSize );
if( ulSize == 0 )
hb_itemPutC( pItem, NULL );
@@ -2651,7 +2651,7 @@ static HB_ERRCODE hb_fptReadSMTBlock( FPTAREAP pArea, PHB_ITEM pItem,
* Read fpt vartype memos.
*/
static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem,
HB_FHANDLE hFile, HB_ULONG ulBlock, HB_ULONG ulStart,
PHB_FILE pFile, HB_ULONG ulBlock, HB_ULONG ulStart,
HB_ULONG ulCount, int iTrans )
{
HB_ERRCODE errCode;
@@ -2660,7 +2660,7 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt
HB_BYTE * bMemoBuf;
FPTBLOCK fptBlock;
HB_TRACE( HB_TR_DEBUG, ( "hb_fptGetMemo(%p, %hu, %p, %p, %lu, %lu, %d)", pArea, uiIndex, pItem, ( void * ) ( HB_PTRDIFF ) hFile, ulStart, ulCount, iTrans ) );
HB_TRACE( HB_TR_DEBUG, ( "hb_fptGetMemo(%p, %hu, %p, %p, %lu, %lu, %d)", pArea, uiIndex, pItem, pFile, ulStart, ulCount, iTrans ) );
if( uiIndex )
{
@@ -2725,9 +2725,9 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt
if( ulStart && ulSize )
fOffset += ulStart;
if( hFile != FS_ERROR )
if( pFile != NULL )
{
return hb_fptCopyToRawFile( pArea->pMemoFile, fOffset, hFile, ulSize );
return hb_fptCopyToRawFile( pArea->pMemoFile, fOffset, pFile, ulSize );
}
if( pArea->bMemoType == DB_MEMO_FPT )
@@ -2920,7 +2920,7 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt
* Write memo data.
*/
static HB_ERRCODE hb_fptWriteMemo( FPTAREAP pArea, HB_ULONG ulBlock, HB_ULONG ulSize,
const HB_BYTE * bBufPtr, HB_FHANDLE hFile,
const HB_BYTE * bBufPtr, PHB_FILE pFile,
HB_ULONG ulType, HB_ULONG ulLen, HB_ULONG * pulStoredBlock )
{
MEMOGCTABLE fptGCtable;
@@ -2928,7 +2928,7 @@ static HB_ERRCODE hb_fptWriteMemo( FPTAREAP pArea, HB_ULONG ulBlock, HB_ULONG ul
HB_BOOL bWrite;
HB_TRACE( HB_TR_DEBUG, ( "hb_fptWriteMemo(%p, %lu, %lu, %p, %p, %lu, %lu, %p)",
pArea, ulBlock, ulSize, bBufPtr, ( void * ) ( HB_PTRDIFF ) hFile, ulType, ulLen, pulStoredBlock ) );
pArea, ulBlock, ulSize, bBufPtr, pFile, ulType, ulLen, pulStoredBlock ) );
bWrite = ( ulLen != 0 || ( pArea->bMemoType == DB_MEMO_FPT &&
ulType != FPTIT_TEXT && ulType != FPTIT_BINARY &&
@@ -2987,15 +2987,15 @@ static HB_ERRCODE hb_fptWriteMemo( FPTAREAP pArea, HB_ULONG ulBlock, HB_ULONG ul
if( errCode == HB_SUCCESS && ulLen > 0 )
{
/* TODO: uiMode => BLOB_IMPORT_COMPRESS, BLOB_IMPORT_ENCRYPT */
if( hFile != FS_ERROR )
if( pFile != NULL )
{
HB_ULONG ulWritten = 0, ulRead, ulBufSize = HB_MIN( ( 1 << 16 ), ulLen );
HB_BYTE * bBuffer = ( HB_BYTE * ) hb_xgrab( ulBufSize );
do
{
ulRead = ( HB_ULONGCAST ) hb_fsReadLarge( hFile, bBuffer,
HB_MIN( ulBufSize, ulLen - ulWritten ) );
ulRead = ( HB_ULONGCAST ) hb_fileRead( pFile, bBuffer,
HB_MIN( ulBufSize, ulLen - ulWritten ), -1 );
if( ulRead == 0 )
errCode = EDBF_READ;
else if( hb_fileWriteAt( pArea->pMemoFile, bBuffer,
@@ -3236,7 +3236,7 @@ static HB_ERRCODE hb_fptPutMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt
}
if( errCode == HB_SUCCESS )
errCode = hb_fptWriteMemo( pArea, ulBlock, ulOldSize, bBufPtr, FS_ERROR,
errCode = hb_fptWriteMemo( pArea, ulBlock, ulOldSize, bBufPtr, NULL,
ulType, ulSize, &ulBlock );
if( bBufAlloc != NULL )
@@ -3365,14 +3365,14 @@ static HB_ERRCODE hb_fptLockForRead( FPTAREAP pArea, HB_USHORT uiIndex, HB_BOOL
return errCode;
}
static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem, HB_FHANDLE hFile )
static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem, PHB_FILE pFile )
{
LPFIELD pField;
HB_ERRCODE errCode;
HB_BYTE * pFieldBuf;
HB_BOOL fUnLock = HB_FALSE;
HB_TRACE( HB_TR_DEBUG, ( "hb_fptGetVarField(%p, %hu, %p, %p)", pArea, uiIndex, pItem, ( void * ) ( HB_PTRDIFF ) hFile ) );
HB_TRACE( HB_TR_DEBUG, ( "hb_fptGetVarField(%p, %hu, %p, %p)", pArea, uiIndex, pItem, pFile ) );
pField = pArea->area.lpFields + uiIndex - 1;
@@ -3435,7 +3435,7 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM
ulSize -= uiVLen;
pPtr += uiVLen;
}
errCode = hb_fptReadRawBlock( pArea, ( HB_BYTE * ) pPtr, FS_ERROR, ulBlock, ulSize );
errCode = hb_fptReadRawBlock( pArea, ( HB_BYTE * ) pPtr, NULL, ulBlock, ulSize );
if( errCode == HB_SUCCESS && ulLen > 0 &&
( pField->uiFlags & HB_FF_BINARY ) == 0 &&
hb_vmCDP() != pArea->area.cdPage )
@@ -3453,9 +3453,9 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM
if( errCode == HB_SUCCESS )
{
if( hFile != FS_ERROR )
if( pFile != NULL )
{
if( hb_fsWriteLarge( hFile, pString, ulLen ) != ulLen )
if( hb_fileWrite( pFile, pString, ulLen, -1 ) != ulLen )
errCode = EDBF_WRITE;
}
else if( pAlloc )
@@ -3471,14 +3471,14 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM
}
else if( uiType == HB_VF_LOG )
{
if( hFile != FS_ERROR )
if( pFile != NULL )
errCode = EDBF_DATATYPE;
else
hb_itemPutL( pItem, pFieldBuf[ 0 ] != 0 );
}
else if( uiType == HB_VF_DNUM ) /* n>12 VFIELD else MEMO (bLen[1],bDec[1],dVal[8]) */
{
if( hFile != FS_ERROR )
if( pFile != NULL )
errCode = EDBF_DATATYPE;
else
{
@@ -3489,7 +3489,7 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM
compatibility */
if( pField->uiLen <= 12 )
{
errCode = hb_fptReadRawBlock( pArea, pBuffer, FS_ERROR, ulBlock, 11 );
errCode = hb_fptReadRawBlock( pArea, pBuffer, NULL, ulBlock, 11 );
if( errCode == HB_SUCCESS )
{
if( pBuffer[ 0 ] == SMT_IT_DOUBLE )
@@ -3510,7 +3510,7 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM
}
else if( uiType == HB_VF_ARRAY ) /* MEMO only as SMT ARRAY */
{
if( hFile != FS_ERROR )
if( pFile != NULL )
errCode = EDBF_DATATYPE;
else
errCode = hb_fptReadSMTBlock( pArea, pItem, ulBlock, 0,
@@ -3519,11 +3519,11 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM
FPT_TRANS_CP : FPT_TRANS_NONE );
}
else if( uiType == HB_VF_BLOB )
errCode = hb_fptReadBlobBlock( pArea, pItem, hFile, ulBlock, 0 );
errCode = hb_fptReadBlobBlock( pArea, pItem, pFile, ulBlock, 0 );
else if( uiType == HB_VF_BLOBCOMPRESS )
errCode = hb_fptReadBlobBlock( pArea, pItem, hFile, ulBlock, BLOB_IMPORT_COMPRESS );
errCode = hb_fptReadBlobBlock( pArea, pItem, pFile, ulBlock, BLOB_IMPORT_COMPRESS );
else if( uiType == HB_VF_BLOBENCRYPT )
errCode = hb_fptReadBlobBlock( pArea, pItem, hFile, ulBlock, BLOB_IMPORT_ENCRYPT );
errCode = hb_fptReadBlobBlock( pArea, pItem, pFile, ulBlock, BLOB_IMPORT_ENCRYPT );
else
errCode = EDBF_DATATYPE;
}
@@ -3537,12 +3537,12 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM
if( errCode != HB_SUCCESS )
return errCode;
errCode = hb_fptGetMemo( pArea, uiIndex, pItem, hFile, 0, 0, 0,
errCode = hb_fptGetMemo( pArea, uiIndex, pItem, pFile, 0, 0, 0,
( pField->uiFlags & HB_FF_UNICODE ) != 0 ? FPT_TRANS_UNICODE :
( ( pField->uiFlags & HB_FF_BINARY ) == 0 &&
hb_vmCDP() != pArea->area.cdPage ? FPT_TRANS_CP : FPT_TRANS_NONE ) );
}
else if( hFile == FS_ERROR )
else if( pFile == NULL )
{
return SUPER_GETVALUE( ( AREAP ) pArea, uiIndex, pItem );
}
@@ -3560,25 +3560,25 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM
static HB_ERRCODE hb_fptGetVarFile( FPTAREAP pArea, HB_ULONG ulBlock, const char * szFile, HB_USHORT uiMode, int iTrans )
{
HB_ERRCODE errCode;
HB_FHANDLE hFile;
PHB_FILE pFile;
HB_TRACE( HB_TR_DEBUG, ( "hb_fptGetVarFile(%p, %lu, %s, %hu, %d)", pArea, ulBlock, szFile, uiMode, iTrans ) );
hFile = hb_fsExtOpen( szFile, NULL, FO_WRITE | FO_EXCLUSIVE |
FXO_DEFAULTS | FXO_SHARELOCK |
( uiMode == FILEGET_APPEND ?
FXO_APPEND : FXO_TRUNCATE ),
NULL, NULL );
pFile = hb_fileExtOpen( szFile, NULL, FO_WRITE | FO_EXCLUSIVE |
FXO_DEFAULTS | FXO_SHARELOCK |
( uiMode == FILEGET_APPEND ?
FXO_APPEND : FXO_TRUNCATE ),
NULL, NULL );
if( hFile == FS_ERROR )
if( pFile == NULL )
{
errCode = uiMode != FILEGET_APPEND ? EDBF_CREATE : EDBF_OPEN_DBF;
}
else
{
hb_fsSeekLarge( hFile, 0, FS_END );
errCode = hb_fptGetMemo( pArea, 0, NULL, hFile, ulBlock, 0, 0, iTrans );
hb_fsClose( hFile );
hb_fileSeek( pFile, 0, FS_END );
errCode = hb_fptGetMemo( pArea, 0, NULL, pFile, ulBlock, 0, 0, iTrans );
hb_fileClose( pFile );
}
/* Exit if any error */
@@ -3599,21 +3599,21 @@ static HB_ERRCODE hb_fptGetVarFile( FPTAREAP pArea, HB_ULONG ulBlock, const char
static HB_ULONG hb_fptPutVarFile( FPTAREAP pArea, HB_ULONG ulBlock, const char * szFile )
{
HB_ERRCODE errCode;
HB_FHANDLE hFile;
PHB_FILE pFile;
HB_TRACE( HB_TR_DEBUG, ( "hb_fptPutVarFile(%p, %lu, %s)", pArea, ulBlock, szFile ) );
hFile = hb_fsExtOpen( szFile, NULL, FO_READ | FO_DENYNONE |
FXO_DEFAULTS | FXO_SHARELOCK, NULL, NULL );
if( hFile == FS_ERROR )
pFile = hb_fileExtOpen( szFile, NULL, FO_READ | FO_DENYNONE |
FXO_DEFAULTS | FXO_SHARELOCK, NULL, NULL );
if( pFile == NULL )
{
errCode = EDBF_OPEN_DBF;
}
else
{
HB_ULONG ulSize;
HB_FOFFSET size = hb_fsSeekLarge( hFile, 0, FS_END );
hb_fsSeek( hFile, 0, FS_SET );
HB_FOFFSET size = hb_fileSize( pFile );
hb_fileSeek( pFile, 0, FS_SET );
if( ( HB_FOFFSET ) ( size & 0xFFFFFFFFUL ) == size )
ulSize = HB_MIN( ( HB_ULONG ) size, 0xFFFFFFFFUL - sizeof( FPTBLOCK ) );
else
@@ -3621,7 +3621,7 @@ static HB_ULONG hb_fptPutVarFile( FPTAREAP pArea, HB_ULONG ulBlock, const char *
if( hb_fptFileLockEx( pArea, HB_TRUE ) )
{
errCode = hb_fptWriteMemo( pArea, ulBlock, 0, NULL, hFile,
errCode = hb_fptWriteMemo( pArea, ulBlock, 0, NULL, pFile,
0, ulSize, &ulBlock );
hb_fptFileUnLockEx( pArea );
}
@@ -3629,7 +3629,7 @@ static HB_ULONG hb_fptPutVarFile( FPTAREAP pArea, HB_ULONG ulBlock, const char *
{
errCode = EDBF_LOCK;
}
hb_fsClose( hFile );
hb_fileClose( pFile );
}
if( errCode != HB_SUCCESS )
@@ -3868,7 +3868,7 @@ static HB_ERRCODE hb_fptPutVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM
else
{
errCode = hb_fptWriteMemo( pArea, ulOldBlock, ulOldSize,
pBlock, FS_ERROR,
pBlock, NULL,
FPTIT_DUMMY, ulNewSize, &ulOldBlock );
if( errCode == HB_SUCCESS )
{
@@ -3958,7 +3958,7 @@ static HB_ERRCODE hb_fptGetValue( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI
if( ! uiIndex || uiIndex > pArea->area.uiFieldCount )
return HB_FAILURE;
errCode = hb_fptGetVarField( pArea, uiIndex, pItem, FS_ERROR );
errCode = hb_fptGetVarField( pArea, uiIndex, pItem, NULL );
if( errCode != HB_SUCCESS )
{
@@ -4203,23 +4203,23 @@ static HB_ERRCODE hb_fptGetValueFile( FPTAREAP pArea, HB_USHORT uiIndex, const c
pArea->area.lpFields[ uiIndex - 1 ].uiType == HB_FT_ANY ) )
{
HB_ERRCODE errCode;
HB_FHANDLE hFile;
PHB_FILE pFile;
hFile = hb_fsExtOpen( szFile, NULL, FO_WRITE | FO_EXCLUSIVE |
FXO_DEFAULTS | FXO_SHARELOCK |
( uiMode == FILEGET_APPEND ?
FXO_APPEND : FXO_TRUNCATE ),
NULL, NULL );
pFile = hb_fileExtOpen( szFile, NULL, FO_WRITE | FO_EXCLUSIVE |
FXO_DEFAULTS | FXO_SHARELOCK |
( uiMode == FILEGET_APPEND ?
FXO_APPEND : FXO_TRUNCATE ),
NULL, NULL );
if( hFile == FS_ERROR )
if( pFile == NULL )
{
errCode = uiMode != FILEGET_APPEND ? EDBF_CREATE : EDBF_OPEN_DBF;
}
else
{
hb_fsSeekLarge( hFile, 0, FS_END );
errCode = hb_fptGetVarField( pArea, uiIndex, NULL, hFile );
hb_fsClose( hFile );
hb_fileSeek( pFile, 0, FS_END );
errCode = hb_fptGetVarField( pArea, uiIndex, NULL, pFile );
hb_fileClose( pFile );
}
/* Exit if any error */
@@ -4405,7 +4405,7 @@ static HB_ERRCODE hb_fptPutValueFile( FPTAREAP pArea, HB_USHORT uiIndex, const c
{
HB_ERRCODE errCode;
HB_BOOL bDeleted;
HB_FHANDLE hFile;
PHB_FILE pFile;
/* update any pending relations and reread record if necessary */
errCode = SELF_DELETED( ( AREAP ) pArea, &bDeleted );
@@ -4419,9 +4419,9 @@ static HB_ERRCODE hb_fptPutValueFile( FPTAREAP pArea, HB_USHORT uiIndex, const c
if( ! pArea->fRecordChanged && SELF_GOHOT( ( AREAP ) pArea ) == HB_FAILURE )
return HB_FAILURE;
hFile = hb_fsExtOpen( szFile, NULL, FO_READ | FO_DENYNONE |
FXO_DEFAULTS | FXO_SHARELOCK, NULL, NULL );
if( hFile == FS_ERROR )
pFile = hb_fileExtOpen( szFile, NULL, FO_READ | FO_DENYNONE |
FXO_DEFAULTS | FXO_SHARELOCK, NULL, NULL );
if( pFile == NULL )
{
errCode = EDBF_OPEN_DBF;
}
@@ -4429,12 +4429,11 @@ static HB_ERRCODE hb_fptPutValueFile( FPTAREAP pArea, HB_USHORT uiIndex, const c
{
HB_BYTE * pAlloc;
HB_ULONG ulSize;
HB_FOFFSET size = hb_fsSeekLarge( hFile, 0, FS_END );
HB_FOFFSET size = hb_fileSize( pFile );
ulSize = ( HB_ULONG ) HB_MIN( size, HB_VF_CHAR );
pAlloc = ( HB_BYTE * ) hb_xgrab( ulSize + 1 );
hb_fsSeek( hFile, 0, FS_SET );
if( hb_fsRead( hFile, pAlloc, ( HB_USHORT ) ulSize ) != ( HB_USHORT ) ulSize )
if( hb_fileReadAt( pFile, pAlloc, ulSize, 0 ) != ulSize )
{
errCode = EDBF_READ;
hb_xfree( pAlloc );
@@ -4443,7 +4442,7 @@ static HB_ERRCODE hb_fptPutValueFile( FPTAREAP pArea, HB_USHORT uiIndex, const c
{
pAlloc[ ulSize ] = '\0';
}
hb_fsClose( hFile );
hb_fileClose( pFile );
if( errCode == HB_SUCCESS )
{
PHB_ITEM pItem = hb_itemPutCLPtr( NULL, ( char * ) pAlloc, ulSize );
@@ -4453,15 +4452,15 @@ static HB_ERRCODE hb_fptPutValueFile( FPTAREAP pArea, HB_USHORT uiIndex, const c
}
else if( ! hb_fptFileLockEx( pArea, HB_TRUE ) )
{
hb_fsClose( hFile );
hb_fileClose( pFile );
errCode = EDBF_LOCK;
}
else
{
HB_ULONG ulSize, ulBlock, ulType, ulOldSize, ulOldType;
HB_FOFFSET size = hb_fsSeekLarge( hFile, 0, FS_END );
HB_FOFFSET size = hb_fileSize( pFile );
hb_fsSeek( hFile, 0, FS_SET );
hb_fileSeek( pFile, 0, FS_SET );
if( ( HB_FOFFSET ) ( size & 0xFFFFFFFFUL ) == size )
{
ulSize = HB_MIN( ( HB_ULONG ) size, 0xFFFFFFFFUL - sizeof( FPTBLOCK ) );
@@ -4480,7 +4479,7 @@ static HB_ERRCODE hb_fptPutValueFile( FPTAREAP pArea, HB_USHORT uiIndex, const c
errCode = hb_dbfGetMemoData( ( DBFAREAP ) pArea, uiIndex - 1,
&ulBlock, &ulOldSize, &ulOldType );
if( errCode == HB_SUCCESS )
errCode = hb_fptWriteMemo( pArea, ulBlock, ulOldSize, NULL, hFile,
errCode = hb_fptWriteMemo( pArea, ulBlock, ulOldSize, NULL, pFile,
ulType, ulSize, &ulBlock );
if( errCode == HB_SUCCESS )
errCode = hb_dbfSetMemoData( ( DBFAREAP ) pArea, uiIndex - 1, ulBlock, ulSize, ulType );
@@ -4492,7 +4491,7 @@ static HB_ERRCODE hb_fptPutValueFile( FPTAREAP pArea, HB_USHORT uiIndex, const c
}
#endif
hb_fptFileUnLockEx( pArea );
hb_fsClose( hFile );
hb_fileClose( pFile );
}
/* Exit if any error */
if( errCode != HB_SUCCESS )
@@ -4967,7 +4966,7 @@ static HB_ERRCODE hb_fptInfo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem
{
ulBlock = ulStart = ulCount = 0;
}
errCode = hb_fptGetMemo( pArea, 0, pItem, FS_ERROR, ulBlock, ulStart, ulCount, FPT_DIRECT_TRANS( pArea ) );
errCode = hb_fptGetMemo( pArea, 0, pItem, NULL, ulBlock, ulStart, ulCount, FPT_DIRECT_TRANS( pArea ) );
if( errCode != HB_SUCCESS )
{
if( errCode != HB_FAILURE )
@@ -5023,7 +5022,7 @@ static HB_ERRCODE hb_fptInfo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem
errCode = hb_fptGetRootBlock( pArea, &ulBlock );
if( errCode == HB_SUCCESS )
{
errCode = hb_fptGetMemo( pArea, 0, pItem, FS_ERROR, ulBlock, 0, 0, FPT_DIRECT_TRANS( pArea ) );
errCode = hb_fptGetMemo( pArea, 0, pItem, NULL, ulBlock, 0, 0, FPT_DIRECT_TRANS( pArea ) );
}
if( errCode != HB_SUCCESS )
{
@@ -5140,7 +5139,7 @@ static HB_ERRCODE hb_fptFieldInfo( FPTAREAP pArea, HB_USHORT uiIndex, HB_USHORT
}
if( ulStart || ulCount )
iTrans = FPT_TRANS_NONE;
errCode = hb_fptGetMemo( pArea, uiIndex, pItem, FS_ERROR, 0, ulStart, ulCount, iTrans );
errCode = hb_fptGetMemo( pArea, uiIndex, pItem, NULL, 0, ulStart, ulCount, iTrans );
if( errCode != HB_SUCCESS )
{
if( errCode != HB_FAILURE )

29
src/rdd/dbfnsx/dbfnsx1.c
View File

@@ -5249,11 +5249,11 @@ static void hb_nsxSortWritePage( LPNSXSORTINFO pSort )
hb_nsxSortSortPage( pSort );
if( pSort->hTempFile == FS_ERROR )
if( pSort->pTempFile == NULL )
{
char szName[ HB_PATH_MAX ];
pSort->hTempFile = hb_fsCreateTemp( NULL, NULL, FC_NORMAL, szName );
if( pSort->hTempFile == FS_ERROR )
pSort->pTempFile = hb_fileCreateTemp( NULL, NULL, FC_NORMAL, szName );
if( pSort->pTempFile == NULL )
hb_nsxErrorRT( pSort->pTag->pIndex->pArea, EG_CREATE, EDBF_CREATE_TEMP,
szName, hb_fsError(), 0, NULL );
else
@@ -5261,10 +5261,11 @@ static void hb_nsxSortWritePage( LPNSXSORTINFO pSort )
}
pSort->pSwapPage[ pSort->ulCurPage ].ulKeys = pSort->ulKeys;
if( pSort->hTempFile != FS_ERROR )
if( pSort->pTempFile != NULL )
{
pSort->pSwapPage[ pSort->ulCurPage ].nOffset = hb_fsSeekLarge( pSort->hTempFile, 0, FS_END );
if( hb_fsWriteLarge( pSort->hTempFile, pSort->pStartKey, nSize ) != nSize )
pSort->pSwapPage[ pSort->ulCurPage ].nOffset = hb_fileSize( pSort->pTempFile );
if( hb_fileWriteAt( pSort->pTempFile, pSort->pStartKey,
nSize, pSort->pSwapPage[ pSort->ulCurPage ].nOffset ) != nSize )
hb_nsxErrorRT( pSort->pTag->pIndex->pArea, EG_WRITE, EDBF_WRITE_TEMP,
pSort->szTempFileName, hb_fsError(), 0, NULL );
}
@@ -5284,9 +5285,9 @@ static void hb_nsxSortGetPageKey( LPNSXSORTINFO pSort, HB_ULONG ulPage,
HB_ULONG ulKeys = HB_MIN( pSort->ulPgKeys, pSort->pSwapPage[ ulPage ].ulKeys );
HB_SIZE nSize = ulKeys * ( iLen + 4 );
if( pSort->hTempFile != FS_ERROR &&
( hb_fsSeekLarge( pSort->hTempFile, pSort->pSwapPage[ ulPage ].nOffset, FS_SET ) != pSort->pSwapPage[ ulPage ].nOffset ||
hb_fsReadLarge( pSort->hTempFile, pSort->pSwapPage[ ulPage ].pKeyPool, nSize ) != nSize ) )
if( pSort->pTempFile != NULL &&
hb_fileReadAt( pSort->pTempFile, pSort->pSwapPage[ ulPage ].pKeyPool,
nSize, pSort->pSwapPage[ ulPage ].nOffset ) != nSize )
{
hb_nsxErrorRT( pSort->pTag->pIndex->pArea, EG_READ, EDBF_READ_TEMP,
pSort->szTempFileName, hb_fsError(), 0, NULL );
@@ -5498,7 +5499,7 @@ static LPNSXSORTINFO hb_nsxSortNew( LPTAGINFO pTag, HB_ULONG ulRecCount )
}
pSort->pTag = pTag;
pSort->hTempFile = FS_ERROR;
pSort->pTempFile = NULL;
pSort->keyLen = iLen;
pSort->trailChar = pTag->TrailChar;
pSort->recSize = hb_nsxGetRecSize( ulRecCount );
@@ -5518,14 +5519,14 @@ static LPNSXSORTINFO hb_nsxSortNew( LPTAGINFO pTag, HB_ULONG ulRecCount )
static void hb_nsxSortFree( LPNSXSORTINFO pSort, HB_BOOL fFull )
{
if( pSort->hTempFile != FS_ERROR )
if( pSort->pTempFile != NULL )
{
hb_fsClose( pSort->hTempFile );
pSort->hTempFile = FS_ERROR;
hb_fileClose( pSort->pTempFile );
pSort->pTempFile = NULL;
}
if( pSort->szTempFileName )
{
hb_fsDelete( pSort->szTempFileName );
hb_fileDelete( pSort->szTempFileName );
hb_xfree( pSort->szTempFileName );
pSort->szTempFileName = NULL;
}

29
src/rdd/dbfntx/dbfntx1.c
View File

@@ -4817,11 +4817,11 @@ static void hb_ntxSortWritePage( LPNTXSORTINFO pSort )
hb_ntxSortSortPage( pSort );
if( pSort->hTempFile == FS_ERROR )
if( pSort->pTempFile == NULL )
{
char szName[ HB_PATH_MAX ];
pSort->hTempFile = hb_fsCreateTemp( NULL, NULL, FC_NORMAL, szName );
if( pSort->hTempFile == FS_ERROR )
pSort->pTempFile = hb_fileCreateTemp( NULL, NULL, FC_NORMAL, szName );
if( pSort->pTempFile == NULL )
hb_ntxErrorRT( pSort->pTag->Owner->Owner, EG_CREATE, EDBF_CREATE_TEMP,
szName, hb_fsError(), 0, NULL );
else
@@ -4829,10 +4829,11 @@ static void hb_ntxSortWritePage( LPNTXSORTINFO pSort )
}
pSort->pSwapPage[ pSort->ulCurPage ].ulKeys = pSort->ulKeys;
if( pSort->hTempFile != FS_ERROR )
if( pSort->pTempFile != NULL )
{
pSort->pSwapPage[ pSort->ulCurPage ].nOffset = hb_fsSeekLarge( pSort->hTempFile, 0, FS_END );
if( hb_fsWriteLarge( pSort->hTempFile, pSort->pStartKey, nSize ) != nSize )
pSort->pSwapPage[ pSort->ulCurPage ].nOffset = hb_fileSize( pSort->pTempFile );
if( hb_fileWriteAt( pSort->pTempFile, pSort->pStartKey, nSize,
pSort->pSwapPage[ pSort->ulCurPage ].nOffset ) != nSize )
hb_ntxErrorRT( pSort->pTag->Owner->Owner, EG_WRITE, EDBF_WRITE_TEMP,
pSort->szTempFileName, hb_fsError(), 0, NULL );
}
@@ -4852,9 +4853,9 @@ static void hb_ntxSortGetPageKey( LPNTXSORTINFO pSort, HB_ULONG ulPage,
HB_ULONG ulKeys = HB_MIN( pSort->ulPgKeys, pSort->pSwapPage[ ulPage ].ulKeys );
HB_SIZE nSize = ulKeys * ( iLen + 4 );
if( pSort->hTempFile != FS_ERROR &&
( hb_fsSeekLarge( pSort->hTempFile, pSort->pSwapPage[ ulPage ].nOffset, FS_SET ) != pSort->pSwapPage[ ulPage ].nOffset ||
hb_fsReadLarge( pSort->hTempFile, pSort->pSwapPage[ ulPage ].pKeyPool, nSize ) != nSize ) )
if( pSort->pTempFile != NULL &&
hb_fileReadAt( pSort->pTempFile, pSort->pSwapPage[ ulPage ].pKeyPool,
nSize, pSort->pSwapPage[ ulPage ].nOffset ) != nSize )
{
hb_ntxErrorRT( pSort->pTag->Owner->Owner, EG_READ, EDBF_READ_TEMP,
pSort->szTempFileName, hb_fsError(), 0, NULL );
@@ -5078,7 +5079,7 @@ static LPNTXSORTINFO hb_ntxSortNew( LPTAGINFO pTag, HB_ULONG ulRecCount )
}
pSort->pTag = pTag;
pSort->hTempFile = FS_ERROR;
pSort->pTempFile = NULL;
pSort->keyLen = iLen;
pSort->fUnique = pTag->UniqueKey;
pSort->ulMaxKey = ulMax << 1;
@@ -5096,14 +5097,14 @@ static LPNTXSORTINFO hb_ntxSortNew( LPTAGINFO pTag, HB_ULONG ulRecCount )
static void hb_ntxSortFree( LPNTXSORTINFO pSort, HB_BOOL fFull )
{
if( pSort->hTempFile != FS_ERROR )
if( pSort->pTempFile != NULL )
{
hb_fsClose( pSort->hTempFile );
pSort->hTempFile = FS_ERROR;
hb_fileClose( pSort->pTempFile );
pSort->pTempFile = NULL;
}
if( pSort->szTempFileName )
{
hb_fsDelete( pSort->szTempFileName );
hb_fileDelete( pSort->szTempFileName );
hb_xfree( pSort->szTempFileName );
pSort->szTempFileName = NULL;
}

36
src/rdd/dbsql.c
View File

@@ -62,7 +62,7 @@
#define HB_FILE_BUF_SIZE 0x10000
typedef struct _HB_FILEBUF
{
HB_FHANDLE hFile;
PHB_FILE pFile;
HB_BYTE * pBuf;
HB_SIZE nSize;
HB_SIZE nPos;
@@ -73,7 +73,7 @@ static void hb_flushFBuffer( PHB_FILEBUF pFileBuf )
{
if( pFileBuf->nPos > 0 )
{
hb_fsWriteLarge( pFileBuf->hFile, pFileBuf->pBuf, pFileBuf->nPos );
hb_fileWrite( pFileBuf->pFile, pFileBuf->pBuf, pFileBuf->nPos, -1 );
pFileBuf->nPos = 0;
}
}
@@ -115,11 +115,11 @@ static void hb_destroyFBuffer( PHB_FILEBUF pFileBuf )
hb_xfree( pFileBuf );
}
static PHB_FILEBUF hb_createFBuffer( HB_FHANDLE hFile, HB_SIZE nSize )
static PHB_FILEBUF hb_createFBuffer( PHB_FILE pFile, HB_SIZE nSize )
{
PHB_FILEBUF pFileBuf = ( PHB_FILEBUF ) hb_xgrab( sizeof( HB_FILEBUF ) );
pFileBuf->hFile = hFile;
pFileBuf->pFile = pFile;
pFileBuf->pBuf = ( HB_BYTE * ) hb_xgrab( nSize );
pFileBuf->nSize = nSize;
pFileBuf->nPos = 0;
@@ -236,7 +236,7 @@ static HB_ULONG hb_db2Sql( AREAP pArea, PHB_ITEM pFields, HB_MAXINT llNext,
PHB_ITEM pWhile, PHB_ITEM pFor,
const char * szDelim, const char * szSep,
const char * szEsc, const char * szTable,
HB_FHANDLE hFile, HB_BOOL fInsert, HB_BOOL fRecno )
PHB_FILE pFile, HB_BOOL fInsert, HB_BOOL fRecno )
{
PHB_FILEBUF pFileBuf;
HB_ULONG ulRecords = 0;
@@ -254,7 +254,7 @@ static HB_ULONG hb_db2Sql( AREAP pArea, PHB_ITEM pFields, HB_MAXINT llNext,
if( fInsert && szTable )
szInsert = hb_xstrcpy( NULL, "INSERT INTO ", szTable, " VALUES ( ", NULL );
pFileBuf = hb_createFBuffer( hFile, HB_FILE_BUF_SIZE );
pFileBuf = hb_createFBuffer( pFile, HB_FILE_BUF_SIZE );
pTmp = hb_itemNew( NULL );
while( llNext-- > 0 )
@@ -335,7 +335,7 @@ static HB_ULONG hb_db2Sql( AREAP pArea, PHB_ITEM pFields, HB_MAXINT llNext,
hb_itemRelease( pTmp );
/* Writing EOF */
/* hb_fsWrite( hFile, "\x1A", 1 ); */
/* hb_fileWrite( pFile, "\x1A", 1, -1 ); */
return ulRecords;
}
@@ -362,8 +362,8 @@ HB_FUNC( __DBSQL )
const char * szDelim = hb_parcx( 14 );
const char * szEsc = hb_parcx( 15 );
HB_MAXINT llNext = HB_VMLONG_MAX;
HB_FHANDLE hFile;
HB_ERRCODE errCode;
PHB_FILE pFile;
if( ! szFileName )
hb_errRT_DBCMD( EG_ARG, EDBCMD_DBCMDBADPARAMETER, NULL, HB_ERR_FUNCNAME );
@@ -375,12 +375,12 @@ HB_FUNC( __DBSQL )
/* Try to create Dat file */
do
{
hFile = hb_fsExtOpen( szFileName, NULL,
( fAppend ? 0 : FXO_TRUNCATE ) |
FO_READWRITE | FO_EXCLUSIVE |
FXO_DEFAULTS | FXO_SHARELOCK,
NULL, pError );
if( hFile == FS_ERROR )
pFile = hb_fileExtOpen( szFileName, NULL,
( fAppend ? 0 : FXO_TRUNCATE ) |
FO_READWRITE | FO_EXCLUSIVE |
FXO_DEFAULTS | FXO_SHARELOCK,
NULL, pError );
if( pFile == NULL )
{
if( ! pError )
{
@@ -413,10 +413,10 @@ HB_FUNC( __DBSQL )
if( pError )
hb_itemRelease( pError );
if( hFile != FS_ERROR )
if( pFile != NULL )
{
if( fAppend )
hb_fsSeekLarge( hFile, 0, FS_END );
hb_fileSeek( pFile, 0, FS_END );
errCode = HB_SUCCESS;
if( pRecord )
@@ -436,9 +436,9 @@ HB_FUNC( __DBSQL )
{
hb_retnint( hb_db2Sql( pArea, pFields, llNext, pWhile, pFor,
szDelim, szSep, szEsc,
szTable, hFile, fInsert, fRecno ) );
szTable, pFile, fInsert, fRecno ) );
}
hb_fsClose( hFile );
hb_fileClose( pFile );
}
}
else

40
src/rdd/hbdbsort.c
View File

@@ -51,8 +51,8 @@
HB_BOOL hb_dbQSortInit( LPDBQUICKSORT pQuickSort, LPDBSORTINFO pSortInfo, HB_USHORT uiRecordLen )
{
/* Create temp file */
pQuickSort->hFile = hb_fsCreateTemp( NULL, NULL, FC_NORMAL, pQuickSort->szTempName );
if( pQuickSort->hFile == FS_ERROR )
pQuickSort->pFile = hb_fileCreateTemp( NULL, NULL, FC_NORMAL, pQuickSort->szTempName );
if( pQuickSort->pFile == NULL )
return HB_FALSE;
/* Alloc buffers */
@@ -72,8 +72,8 @@ HB_BOOL hb_dbQSortInit( LPDBQUICKSORT pQuickSort, LPDBSORTINFO pSortInfo, HB_USH
void hb_dbQSortExit( LPDBQUICKSORT pQuickSort )
{
/* Close and delete temp file */
hb_fsClose( pQuickSort->hFile );
hb_fsDelete( pQuickSort->szTempName );
hb_fileClose( pQuickSort->pFile );
hb_fileDelete( pQuickSort->szTempName );
/* Free buffers */
hb_xfree( pQuickSort->pBuffer );
@@ -89,7 +89,7 @@ HB_BOOL hb_dbQSortAdvance( LPDBQUICKSORT pQuickSort, HB_USHORT uiCount )
/* Write chunk */
uiSize = uiCount * pQuickSort->uiRecordLen;
return hb_fsWrite( pQuickSort->hFile, pQuickSort->pBuffer, uiSize ) == uiSize;
return hb_fileWrite( pQuickSort->pFile, pQuickSort->pBuffer, uiSize, -1 ) == uiSize;
}
static HB_BOOL hb_dbQSortIsLess( LPDBQUICKSORT pQuickSort, HB_ULONG ulRecNo1, HB_ULONG ulRecNo2 )
@@ -103,10 +103,10 @@ static HB_BOOL hb_dbQSortIsLess( LPDBQUICKSORT pQuickSort, HB_ULONG ulRecNo1, HB
pArea = ( DBFAREAP ) pQuickSort->pSortInfo->dbtri.lpaSource;
/* Read records */
hb_fsSeek( pQuickSort->hFile, ( ulRecNo1 - 1 ) * pQuickSort->uiRecordLen, FS_SET );
hb_fsRead( pQuickSort->hFile, pQuickSort->pSwapBufferA, pQuickSort->uiRecordLen );
hb_fsSeek( pQuickSort->hFile, ( ulRecNo2 - 1 ) * pQuickSort->uiRecordLen, FS_SET );
hb_fsRead( pQuickSort->hFile, pQuickSort->pSwapBufferB, pQuickSort->uiRecordLen );
hb_fileReadAt( pQuickSort->pFile, pQuickSort->pSwapBufferA,
pQuickSort->uiRecordLen, ( ulRecNo1 - 1 ) * pQuickSort->uiRecordLen );
hb_fileReadAt( pQuickSort->pFile, pQuickSort->pSwapBufferB,
pQuickSort->uiRecordLen, ( ulRecNo2 - 1 ) * pQuickSort->uiRecordLen );
/* Compare fields */
for( uiCount = 0; uiCount < pQuickSort->pSortInfo->uiItemCount; uiCount++ )
@@ -167,14 +167,14 @@ static HB_BOOL hb_dbQSortIsLess( LPDBQUICKSORT pQuickSort, HB_ULONG ulRecNo1, HB
static void hb_dbQSortSwap( LPDBQUICKSORT pQuickSort, HB_ULONG ulRecNo1, HB_ULONG ulRecNo2 )
{
/* Swap records */
hb_fsSeek( pQuickSort->hFile, ( ulRecNo1 - 1 ) * pQuickSort->uiRecordLen, FS_SET );
hb_fsRead( pQuickSort->hFile, pQuickSort->pSwapBufferA, pQuickSort->uiRecordLen );
hb_fsSeek( pQuickSort->hFile, ( ulRecNo2 - 1 ) * pQuickSort->uiRecordLen, FS_SET );
hb_fsRead( pQuickSort->hFile, pQuickSort->pSwapBufferB, pQuickSort->uiRecordLen );
hb_fsSeek( pQuickSort->hFile, ( ulRecNo1 - 1 ) * pQuickSort->uiRecordLen, FS_SET );
hb_fsWrite( pQuickSort->hFile, pQuickSort->pSwapBufferB, pQuickSort->uiRecordLen );
hb_fsSeek( pQuickSort->hFile, ( ulRecNo2 - 1 ) * pQuickSort->uiRecordLen, FS_SET );
hb_fsWrite( pQuickSort->hFile, pQuickSort->pSwapBufferA, pQuickSort->uiRecordLen );
hb_fileReadAt( pQuickSort->pFile, pQuickSort->pSwapBufferA,
pQuickSort->uiRecordLen, ( ulRecNo1 - 1 ) * pQuickSort->uiRecordLen );
hb_fileReadAt( pQuickSort->pFile, pQuickSort->pSwapBufferB,
pQuickSort->uiRecordLen, ( ulRecNo2 - 1 ) * pQuickSort->uiRecordLen );
hb_fileWriteAt( pQuickSort->pFile, pQuickSort->pSwapBufferB,
pQuickSort->uiRecordLen, ( ulRecNo1 - 1 ) * pQuickSort->uiRecordLen );
hb_fileWriteAt( pQuickSort->pFile, pQuickSort->pSwapBufferA,
pQuickSort->uiRecordLen, ( ulRecNo2 - 1 ) * pQuickSort->uiRecordLen );
}
static void hb_dbQSortDo( LPDBQUICKSORT pQuickSort, HB_ULONG ulFirst, HB_ULONG ulLast )
@@ -223,16 +223,16 @@ void hb_dbQSortComplete( LPDBQUICKSORT pQuickSort )
HB_ULONG ulRecCount;
AREAP pArea;
ulRecCount = hb_fsSeek( pQuickSort->hFile, 0, FS_END ) / pQuickSort->uiRecordLen;
ulRecCount = hb_fileSize( pQuickSort->pFile ) / pQuickSort->uiRecordLen;
if( ulRecCount >= 1 )
{
hb_dbQSortDo( pQuickSort, 1, ulRecCount );
pArea = pQuickSort->pSortInfo->dbtri.lpaDest;
hb_fsSeek( pQuickSort->hFile, 0, FS_SET );
hb_fileSeek( pQuickSort->pFile, 0, FS_SET );
while( ulRecCount-- > 0 )
{
/* Read sorted record */
hb_fsRead( pQuickSort->hFile, pQuickSort->pSwapBufferA, pQuickSort->uiRecordLen );
hb_fileRead( pQuickSort->pFile, pQuickSort->pSwapBufferA, pQuickSort->uiRecordLen, -1 );
/* Remove deleted flag */
pQuickSort->pSwapBufferA[ 0 ] = ' ';

102
src/rdd/hbsix/sxcompr.c
View File

@@ -168,14 +168,14 @@
typedef struct _HB_LZSSX_COMPR
{
HB_FHANDLE hInput;
PHB_FILE pInput;
HB_BYTE * inBuffer;
HB_SIZE inBuffSize;
HB_SIZE inBuffPos;
HB_SIZE inBuffRead;
HB_BOOL fInFree;
HB_FHANDLE hOutput;
PHB_FILE pOutput;
HB_BYTE * outBuffer;
HB_SIZE outBuffSize;
HB_SIZE outBuffPos;
@@ -207,27 +207,27 @@ static void hb_LZSSxExit( PHB_LZSSX_COMPR pCompr )
}
static PHB_LZSSX_COMPR hb_LZSSxInit(
HB_FHANDLE hInput, HB_BYTE * pSrcBuf, HB_SIZE nSrcBuf,
HB_FHANDLE hOutput, HB_BYTE * pDstBuf, HB_SIZE nDstBuf )
PHB_FILE pInput, HB_BYTE * pSrcBuf, HB_SIZE nSrcBuf,
PHB_FILE pOutput, HB_BYTE * pDstBuf, HB_SIZE nDstBuf )
{
PHB_LZSSX_COMPR pCompr = ( PHB_LZSSX_COMPR ) hb_xgrab( sizeof( HB_LZSSX_COMPR ) );
if( hInput != FS_ERROR && nSrcBuf == 0 )
if( pInput != NULL && nSrcBuf == 0 )
nSrcBuf = LZSS_IOBUFLEN;
if( hOutput != FS_ERROR && nDstBuf == 0 )
if( pOutput != NULL && nDstBuf == 0 )
nDstBuf = LZSS_IOBUFLEN;
pCompr->hInput = hInput;
pCompr->pInput = pInput;
pCompr->inBuffer = pSrcBuf;
pCompr->inBuffSize = nSrcBuf;
pCompr->inBuffPos = 0;
pCompr->inBuffRead = ( hInput == FS_ERROR ) ? nSrcBuf : 0;
pCompr->fInFree = ( hInput != FS_ERROR && pSrcBuf == NULL );
pCompr->hOutput = hOutput;
pCompr->inBuffRead = ( pInput == NULL ) ? nSrcBuf : 0;
pCompr->fInFree = ( pInput != NULL && pSrcBuf == NULL );
pCompr->pOutput = pOutput;
pCompr->outBuffer = pDstBuf;
pCompr->outBuffSize = nDstBuf;
pCompr->outBuffPos = 0;
pCompr->fOutFree = ( hOutput != FS_ERROR && pDstBuf == NULL );
pCompr->fOutFree = ( pOutput != NULL && pDstBuf == NULL );
pCompr->ulMaxSize = 0;
pCompr->ulOutSize = 0;
@@ -249,10 +249,10 @@ static PHB_LZSSX_COMPR hb_LZSSxInit(
static HB_BOOL hb_LZSSxFlush( PHB_LZSSX_COMPR pCompr )
{
if( pCompr->fResult && pCompr->hOutput != FS_ERROR )
if( pCompr->fResult && pCompr->pOutput != NULL )
{
if( hb_fsWriteLarge( pCompr->hOutput, pCompr->outBuffer,
pCompr->outBuffPos ) != pCompr->outBuffPos )
if( hb_fileWrite( pCompr->pOutput, pCompr->outBuffer,
pCompr->outBuffPos, -1 ) != pCompr->outBuffPos )
{
pCompr->fResult = HB_FALSE;
}
@@ -285,10 +285,10 @@ static int hb_LZSSxRead( PHB_LZSSX_COMPR pCompr )
if( pCompr->inBuffPos < pCompr->inBuffRead )
return ( HB_UCHAR ) pCompr->inBuffer[ pCompr->inBuffPos++ ];
if( pCompr->hInput != FS_ERROR )
if( pCompr->pInput != NULL )
{
pCompr->inBuffRead = hb_fsReadLarge( pCompr->hInput, pCompr->inBuffer,
pCompr->inBuffSize );
pCompr->inBuffRead = hb_fileRead( pCompr->pInput, pCompr->inBuffer,
pCompr->inBuffSize, -1 );
pCompr->inBuffPos = 0;
if( pCompr->inBuffPos < pCompr->inBuffRead )
return ( HB_UCHAR ) pCompr->inBuffer[ pCompr->inBuffPos++ ];
@@ -563,8 +563,8 @@ HB_BOOL hb_LZSSxCompressMem( const char * pSrcBuf, HB_SIZE nSrcLen,
PHB_LZSSX_COMPR pCompr;
HB_SIZE nSize;
pCompr = hb_LZSSxInit( FS_ERROR, ( HB_BYTE * ) pSrcBuf, nSrcLen,
FS_ERROR, ( HB_BYTE * ) pDstBuf, nDstLen );
pCompr = hb_LZSSxInit( NULL, ( HB_BYTE * ) pSrcBuf, nSrcLen,
NULL, ( HB_BYTE * ) pDstBuf, nDstLen );
nSize = hb_LZSSxEncode( pCompr );
hb_LZSSxExit( pCompr );
if( pnSize )
@@ -578,19 +578,19 @@ HB_BOOL hb_LZSSxDecompressMem( const char * pSrcBuf, HB_SIZE nSrcLen,
PHB_LZSSX_COMPR pCompr;
HB_BOOL fResult;
pCompr = hb_LZSSxInit( FS_ERROR, ( HB_BYTE * ) pSrcBuf, nSrcLen,
FS_ERROR, ( HB_BYTE * ) pDstBuf, nDstLen );
pCompr = hb_LZSSxInit( NULL, ( HB_BYTE * ) pSrcBuf, nSrcLen,
NULL, ( HB_BYTE * ) pDstBuf, nDstLen );
fResult = hb_LZSSxDecode( pCompr );
hb_LZSSxExit( pCompr );
return fResult;
}
HB_BOOL hb_LZSSxCompressFile( HB_FHANDLE hInput, HB_FHANDLE hOutput, HB_SIZE * pnSize )
HB_BOOL hb_LZSSxCompressFile( PHB_FILE pInput, PHB_FILE pOutput, HB_SIZE * pnSize )
{
PHB_LZSSX_COMPR pCompr;
HB_SIZE nSize;
pCompr = hb_LZSSxInit( hInput, NULL, 0, hOutput, NULL, 0 );
pCompr = hb_LZSSxInit( pInput, NULL, 0, pOutput, NULL, 0 );
nSize = hb_LZSSxEncode( pCompr );
hb_LZSSxExit( pCompr );
if( pnSize )
@@ -598,12 +598,12 @@ HB_BOOL hb_LZSSxCompressFile( HB_FHANDLE hInput, HB_FHANDLE hOutput, HB_SIZE * p
return nSize != ( HB_SIZE ) -1;
}
HB_BOOL hb_LZSSxDecompressFile( HB_FHANDLE hInput, HB_FHANDLE hOutput )
HB_BOOL hb_LZSSxDecompressFile( PHB_FILE pInput, PHB_FILE pOutput )
{
PHB_LZSSX_COMPR pCompr;
HB_BOOL fResult;
pCompr = hb_LZSSxInit( hInput, NULL, 0, hOutput, NULL, 0 );
pCompr = hb_LZSSxInit( pInput, NULL, 0, pOutput, NULL, 0 );
fResult = hb_LZSSxDecode( pCompr );
hb_LZSSxExit( pCompr );
return fResult;
@@ -612,35 +612,35 @@ HB_BOOL hb_LZSSxDecompressFile( HB_FHANDLE hInput, HB_FHANDLE hOutput )
HB_FUNC( SX_FCOMPRESS )
{
HB_BOOL fRet = HB_FALSE;
HB_FHANDLE hInput, hOutput;
PHB_FILE pInput, pOutput;
const char * szSource = hb_parc( 1 ), * szDestin = hb_parc( 2 );
HB_BYTE buf[ 4 ];
HB_SIZE nSize;
if( szSource && *szSource && szDestin && *szDestin )
{
hInput = hb_fsExtOpen( szSource, NULL, FO_READ | FO_DENYNONE |
FXO_DEFAULTS | FXO_SHARELOCK, NULL, NULL );
if( hInput != FS_ERROR )
pInput = hb_fileExtOpen( szSource, NULL, FO_READ | FO_DENYNONE |
FXO_DEFAULTS | FXO_SHARELOCK, NULL, NULL );
if( pInput != NULL )
{
hOutput = hb_fsExtOpen( szDestin, NULL, FO_READWRITE |
FO_EXCLUSIVE | FXO_TRUNCATE |
FXO_DEFAULTS | FXO_SHARELOCK, NULL, NULL );
if( hOutput != FS_ERROR )
pOutput = hb_fileExtOpen( szDestin, NULL, FO_READWRITE |
FO_EXCLUSIVE | FXO_TRUNCATE |
FXO_DEFAULTS | FXO_SHARELOCK, NULL, NULL );
if( pOutput != NULL )
{
/* store uncompressed file size in first 4 bytes of destination
* file in little endian order - for SIX3 compatibility
*/
nSize = hb_fsSeek( hInput, 0, FS_END );
if( hb_fsSeek( hInput, 0, FS_SET ) == 0 )
nSize = hb_fileSize( pInput );
if( hb_fileSeek( pInput, 0, FS_SET ) == 0 )
{
HB_PUT_LE_UINT32( buf, nSize );
if( hb_fsWrite( hOutput, buf, 4 ) == 4 )
fRet = hb_LZSSxCompressFile( hInput, hOutput, NULL );
if( hb_fileWrite( pOutput, buf, 4, -1 ) == 4 )
fRet = hb_LZSSxCompressFile( pInput, pOutput, NULL );
}
hb_fsClose( hOutput );
hb_fileClose( pOutput );
}
hb_fsClose( hInput );
hb_fileClose( pInput );
}
}
hb_retl( fRet );
@@ -649,26 +649,26 @@ HB_FUNC( SX_FCOMPRESS )
HB_FUNC( SX_FDECOMPRESS )
{
HB_BOOL fRet = HB_FALSE;
HB_FHANDLE hInput, hOutput;
PHB_FILE pInput, pOutput;
const char * szSource = hb_parc( 1 ), * szDestin = hb_parc( 2 );
if( szSource && *szSource && szDestin && *szDestin )
{
hInput = hb_fsExtOpen( szSource, NULL, FO_READ | FO_DENYNONE |
FXO_DEFAULTS | FXO_SHARELOCK, NULL, NULL );
if( hInput != FS_ERROR )
pInput = hb_fileExtOpen( szSource, NULL, FO_READ | FO_DENYNONE |
FXO_DEFAULTS | FXO_SHARELOCK, NULL, NULL );
if( pInput != NULL )
{
hOutput = hb_fsExtOpen( szDestin, NULL, FO_READWRITE |
FO_EXCLUSIVE | FXO_TRUNCATE |
FXO_DEFAULTS | FXO_SHARELOCK, NULL, NULL );
if( hOutput != FS_ERROR )
pOutput = hb_fileExtOpen( szDestin, NULL, FO_READWRITE |
FO_EXCLUSIVE | FXO_TRUNCATE |
FXO_DEFAULTS | FXO_SHARELOCK, NULL, NULL );
if( pOutput != NULL )
{
/* skip the four bytes with original file length */
if( hb_fsSeek( hInput, 4, FS_SET ) == 4 )
fRet = hb_LZSSxDecompressFile( hInput, hOutput );
hb_fsClose( hOutput );
if( hb_fileSeek( pInput, 4, FS_SET ) == 4 )
fRet = hb_LZSSxDecompressFile( pInput, pOutput );
hb_fileClose( pOutput );
}
hb_fsClose( hInput );
hb_fileClose( pInput );
}
}
hb_retl( fRet );

60
src/rdd/hbsix/sxsem.c
View File

@@ -71,6 +71,7 @@ static HB_BOOL hb_sxSemName( char * szFileName )
else
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
if( pArea )
{
DBORDERINFO pOrderInfo;
@@ -96,25 +97,25 @@ static HB_BOOL hb_sxSemName( char * szFileName )
return fResult;
}
static HB_FHANDLE hb_sxSemOpen( char * szFileName, HB_BOOL * pfNewFile )
static PHB_FILE hb_sxSemOpen( char * szFileName, HB_BOOL * pfNewFile )
{
HB_FHANDLE hFile;
PHB_FILE pFile;
int i = 0;
do
{
hFile = hb_fsExtOpen( szFileName, ".sem",
FO_READWRITE | FO_EXCLUSIVE | FXO_DEFAULTS |
FXO_SHARELOCK | FXO_COPYNAME, NULL, NULL );
if( hFile != FS_ERROR )
pFile = hb_fileExtOpen( szFileName, ".sem",
FO_READWRITE | FO_EXCLUSIVE | FXO_DEFAULTS |
FXO_SHARELOCK | FXO_COPYNAME, NULL, NULL );
if( pFile != NULL )
break;
if( pfNewFile )
{
hFile = hb_fsExtOpen( szFileName, ".sem", FXO_UNIQUE |
FO_READWRITE | FO_EXCLUSIVE | FXO_DEFAULTS |
FXO_SHARELOCK | FXO_COPYNAME, NULL, NULL );
if( hFile != FS_ERROR )
pFile = hb_fileExtOpen( szFileName, ".sem", FXO_UNIQUE |
FO_READWRITE | FO_EXCLUSIVE | FXO_DEFAULTS |
FXO_SHARELOCK | FXO_COPYNAME, NULL, NULL );
if( pFile != NULL )
{
*pfNewFile = HB_TRUE;
break;
@@ -131,7 +132,7 @@ static HB_FHANDLE hb_sxSemOpen( char * szFileName, HB_BOOL * pfNewFile )
}
while( ++i < 25 );
return hFile;
return pFile;
}
@@ -144,15 +145,15 @@ HB_FUNC( SX_MAKESEM )
if( hb_sxSemName( szFileName ) )
{
HB_FHANDLE hFile = hb_sxSemOpen( szFileName, &fNewFile );
if( hFile != FS_ERROR )
PHB_FILE pFile = hb_sxSemOpen( szFileName, &fNewFile );
if( pFile != NULL )
{
if( fNewFile )
iUsers = 1;
else
{
hb_fsSeek( hFile, 0, FS_SET );
if( hb_fsRead( hFile, buffer, 2 ) != 2 )
if( hb_fileReadAt( pFile, buffer, 2, 0 ) != 2 )
fError = HB_TRUE;
else
iUsers = HB_GET_LE_INT16( buffer ) + 1;
@@ -160,11 +161,10 @@ HB_FUNC( SX_MAKESEM )
if( ! fError )
{
HB_PUT_LE_UINT16( buffer, iUsers );
hb_fsSeek( hFile, 0, FS_SET );
if( hb_fsWrite( hFile, buffer, 2 ) != 2 )
if( hb_fileWriteAt( pFile, buffer, 2, 0 ) != 2 )
fError = HB_TRUE;
}
hb_fsClose( hFile );
hb_fileClose( pFile );
}
}
if( fError )
@@ -181,19 +181,19 @@ HB_FUNC( SX_KILLSEM )
if( hb_sxSemName( szFileName ) )
{
HB_FHANDLE hFile = hb_sxSemOpen( szFileName, NULL );
if( hFile != FS_ERROR )
PHB_FILE pFile = hb_sxSemOpen( szFileName, NULL );
if( pFile != NULL )
{
if( hb_fsRead( hFile, buffer, 2 ) == 2 )
if( hb_fileReadAt( pFile, buffer, 2, 0 ) == 2 )
{
iUsers = HB_GET_LE_INT16( buffer ) - 1;
hb_fsSeek( hFile, 0, FS_SET );
HB_PUT_LE_UINT16( buffer, iUsers );
hb_fsWrite( hFile, buffer, 2 );
hb_fileWriteAt( pFile, buffer, 2, 0 );
}
hb_fsClose( hFile );
hb_fileClose( pFile );
if( iUsers == 0 )
hb_fsDelete( szFileName );
hb_fileDelete( szFileName );
}
}
hb_retni( iUsers );
@@ -203,14 +203,14 @@ HB_FUNC( SX_KILLSEM )
HB_FUNC( SX_ISSEM )
{
char szFileName[ HB_PATH_MAX ];
HB_FHANDLE hFile = FS_ERROR;
PHB_FILE pFile = NULL;
if( hb_sxSemName( szFileName ) )
{
hFile = hb_sxSemOpen( szFileName, NULL );
if( hFile != FS_ERROR )
hb_fsClose( hFile );
pFile = hb_sxSemOpen( szFileName, NULL );
if( pFile != NULL )
hb_fileClose( pFile );
}
hb_retl( hFile != FS_ERROR );
hb_retl( pFile != NULL );
}