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

2010-02-08 22:49 UTC+0100 Viktor Szakats (harbour.01 syenar.hu)

Browse Source 
* src/pp/ppcore.c
  * src/pp/hbpp.c
  * src/vm/macro.c
  * src/vm/runner.c
  * src/vm/estack.c
  * src/vm/itemapi.c
  * src/vm/hvm.c
  * src/vm/cmdarg.c
  * src/vm/maindllp.c
  * src/vm/fm.c
  * src/vm/thread.c
  * src/vm/memvars.c
  * src/vm/eval.c
  * src/vm/extend.c
  * src/vm/classes.c
  * src/debug/dbgentry.c
  * src/common/expropt1.c
  * src/common/expropt2.c
  * src/common/hbhash.c
  * src/nortl/nortl.c
  * src/macro/macrolex.c
  * src/rtl/gtxwc/gtxwc.c
  * src/rtl/gtstd/gtstd.c
  * src/rtl/gtcgi/gtcgi.c
  * src/rtl/errapi.c
  * src/rtl/hbprocfn.c
  * src/rtl/hbsocket.c
  * src/rtl/gtpca/gtpca.c
  * src/rtl/filebuf.c
  * src/rtl/hbproces.c
  * src/rdd/dbfntx/dbfntx1.c
  * src/rdd/dbsql.c
  * src/rdd/hbdbsort.c
  * src/rdd/workarea.c
  * src/rdd/wacore.c
  * src/rdd/sdf1.c
  * src/rdd/dbcmdx.c
  * src/rdd/dbfnsx/dbfnsx1.c
  * src/rdd/dbcmd.c
  * src/rdd/dbfcdx/dbfcdx1.c
  * src/rdd/delim1.c
  * src/rdd/dbf1.c
  * src/rdd/hsx/hsx.c
  * src/rdd/usrrdd/usrrdd.c
  * src/rdd/wafunc.c
  * src/rdd/dbffpt/dbffpt1.c
  * src/rdd/hbsix/sxord.c
  * src/rdd/hbsix/sxfname.c
  * src/rdd/hbsix/sxtable.c
  * src/rdd/hbsix/sxutil.c
  * src/rdd/hbsix/sxcrypt.c
  * src/compiler/ppcomp.c
  * src/compiler/hbmain.c
  * src/compiler/compi18n.c
  * src/compiler/cmdcheck.c
  * src/compiler/hbdbginf.c
  * src/compiler/hbpcode.c
  * src/compiler/genhrb.c
  * src/compiler/hbdead.c
  * src/compiler/complex.c
  * src/compiler/genobj32.c
  * src/compiler/genc.c
  * src/compiler/hbopt.c
  * src/compiler/hbident.c
  * src/compiler/gencc.c
  * src/compiler/hbcmplib.c
  * src/compiler/hblbl.c
  * src/compiler/harbour.yyc
  * src/compiler/harbour.y
  * include/hbpp.h
  * include/hbrdddbf.h
  * include/hbvmpub.h
  * include/hbrddnsx.h
  * include/hbstack.h
  * include/hbgtcore.h
  * include/hbapifs.h
  * include/hbthread.h
  * include/hbdefs.h
  * include/hbmacro.h
  * include/hbinit.h
  * include/hbtypes.h
  * include/hbrddsdf.h
  * include/hbapi.h
  * include/hbapiitm.h
  * include/hbrddntx.h
  * include/hbvm.h
  * include/hbapidbg.h
  * include/hbcomp.h
  * include/hbapirdd.h
  * include/hbcompdf.h
  * include/hbrdddel.h
  * include/hbexpra.c
  * include/hbexprop.h
  * include/hbrddcdx.h
  * include/hbapicls.h
  * include/hbapierr.h
  * include/hbrddfpt.h
  * include/hbhash.h
  * include/hbregex.h
  * include/hbexprb.c
  * contrib/hbct/screen2.c
  * contrib/hbct/token2.c
  * contrib/hbct/dbftools.c
  * contrib/hbct/atadjust.c
  * contrib/hbct/ctwin.c
  * contrib/hbct/files.c
  * contrib/hbct/dattime3.c
  * contrib/hbct/ctstr.c
  * contrib/hbct/screen1.c
  * contrib/hbct/token1.c
  * contrib/hbct/ctc.c
  * contrib/hbct/ct.h
  * contrib/hbct/atnum.c
  * contrib/hbct/asciisum.c
  * contrib/hbct/numat.c
  * contrib/hbct/atrepl.c
  * contrib/xhb/bkgtsks.c
  * contrib/xhb/hbcrypt.c
  * contrib/xhb/fparse.c
  * contrib/xhb/datesxhb.c
  * contrib/xhb/hbnxs.h
  * contrib/hbqt/gtqtc/gtqtc.cpp
  * contrib/xpp/dbcmdx.c
  * contrib/hbnf/dispc.c
  * contrib/hbnf/ftattr.c
  * contrib/hbmemio/memio.c
  * contrib/hbnetio/netiocli.c
  * contrib/rddsql/sddmy/mysqldd.c
  * contrib/rddsql/sddpg/pgsqldd.c
  * contrib/rddsql/sddfb/fbirddd.c
  * contrib/rddsql/sddodbc/odbcdd.c
  * contrib/rddsql/hbrddsql.h
  * contrib/rddsql/sqlbase.c
  * contrib/rddsql/sqlmix.c
  * contrib/rddads/adsx.c
  * contrib/rddads/adsfunc.c
  * contrib/rddads/rddads.h
  * contrib/rddads/ads1.c
  * contrib/rddads/adsmgmnt.c
  * contrib/hbmisc/spd.c
  * contrib/hbtip/utils.c
  * contrib/hbtip/encmthd.c
  * contrib/hbbmcdx/bmdbfcdx.c
  * contrib/hbbmcdx/hbbmcdx.h
  * contrib/hbbtree/hb_btree.h
  * contrib/hbbtree/hb_btree.c
    * ULONG -> HB_ULONG, HB_SIZE
      (except for external (OS) API specific usage)
    * Formatting.

    ; NOTE: I converted ULONG to HB_SIZE where I felt it appropriate,
            but didn't touch compiler, codeblock handling, low-level
            RDD (Set/GetVarLen method) and high-level contrib RDDs, so
            this needs to be cleaned.
            Also there may be cases where I didn't change the whole
            call chain to HB_SIZE.

    ; NOTE: It would be probably worthy to add new types for these purposes:
           - line number (HB_USHORT)
           - record number (HB_ULONG)
           - RDD connection (HB_ULONG)
           - parameter count / stack position / class member positions / etc (HB_USHORT, sometimes HB_ULONG)
           - pcode (HB_BYTE and char)
           - flags / modes (HB_USHORT / HB_ULONG)
           - timers (HB_ULONG, HB_MAXINT)
           - GT API character (HB_USHORT)

    ; REQUESTS:
          - Pls don't over-align variable declarations. It makes
            modification much much slower. Sometimes declarations are
            aligned even if there was only one or two of them in a block.
          - Pls always add variable names in declarations, otherwise the purpose
            of the function is very slow to decipher when looking at it.
          - Keep up the nice formatting according to Harbour standards,
            it makes modifications much much easier.

    ; TODO:
          - Verify with grep script
          - Verify with HB_USER_CFLAGS=-DHB_LEGACY_TYPES_OFF
          - Make HB_LEGACY_TYPES_OFF default for Harbour builds.
          - Tie HB_LEGACY_TYPES_OFF to HB_LEGACY_LEVEL3
          - Replace current windows.h inclusion hack with regular method
          - Delete hacks dealing with former type chaos:
               HB_CLIPPER_INT_ITEMS, HB_DONT_DEFINE_BASIC_TYPES, HB_DONT_DEFINE_BOOL, HB_DONT_DEFINE_BYTE, HB_DONT_DEFINE_LONG
          - Retest hbfimage on *nix, delete hacks
          - Normalize HB_BYTE vs. HB_UCHAR usage
          - Type cleanups, f.e. HB_SIZE vs. HB_ULONG
          - Add new special types (see above)
          - Switch HB_SIZE to signed (big project), and delete HB_ISIZ afterwards.
This commit is contained in:
Viktor Szakats
2010-02-08 21:52:47 +00:00
parent 42d8c77acc
commit b1cd0953df
147 changed files with 2208 additions and 2038 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
harbour/ChangeLog
View File

@@ -17,6 +17,197 @@
past entries belonging to author(s): Viktor Szakats.
*/
2010-02-08 22:49 UTC+0100 Viktor Szakats (harbour.01 syenar.hu)
* src/pp/ppcore.c
* src/pp/hbpp.c
* src/vm/macro.c
* src/vm/runner.c
* src/vm/estack.c
* src/vm/itemapi.c
* src/vm/hvm.c
* src/vm/cmdarg.c
* src/vm/maindllp.c
* src/vm/fm.c
* src/vm/thread.c
* src/vm/memvars.c
* src/vm/eval.c
* src/vm/extend.c
* src/vm/classes.c
* src/debug/dbgentry.c
* src/common/expropt1.c
* src/common/expropt2.c
* src/common/hbhash.c
* src/nortl/nortl.c
* src/macro/macrolex.c
* src/rtl/gtxwc/gtxwc.c
* src/rtl/gtstd/gtstd.c
* src/rtl/gtcgi/gtcgi.c
* src/rtl/errapi.c
* src/rtl/hbprocfn.c
* src/rtl/hbsocket.c
* src/rtl/gtpca/gtpca.c
* src/rtl/filebuf.c
* src/rtl/hbproces.c
* src/rdd/dbfntx/dbfntx1.c
* src/rdd/dbsql.c
* src/rdd/hbdbsort.c
* src/rdd/workarea.c
* src/rdd/wacore.c
* src/rdd/sdf1.c
* src/rdd/dbcmdx.c
* src/rdd/dbfnsx/dbfnsx1.c
* src/rdd/dbcmd.c
* src/rdd/dbfcdx/dbfcdx1.c
* src/rdd/delim1.c
* src/rdd/dbf1.c
* src/rdd/hsx/hsx.c
* src/rdd/usrrdd/usrrdd.c
* src/rdd/wafunc.c
* src/rdd/dbffpt/dbffpt1.c
* src/rdd/hbsix/sxord.c
* src/rdd/hbsix/sxfname.c
* src/rdd/hbsix/sxtable.c
* src/rdd/hbsix/sxutil.c
* src/rdd/hbsix/sxcrypt.c
* src/compiler/ppcomp.c
* src/compiler/hbmain.c
* src/compiler/compi18n.c
* src/compiler/cmdcheck.c
* src/compiler/hbdbginf.c
* src/compiler/hbpcode.c
* src/compiler/genhrb.c
* src/compiler/hbdead.c
* src/compiler/complex.c
* src/compiler/genobj32.c
* src/compiler/genc.c
* src/compiler/hbopt.c
* src/compiler/hbident.c
* src/compiler/gencc.c
* src/compiler/hbcmplib.c
* src/compiler/hblbl.c
* src/compiler/harbour.yyc
* src/compiler/harbour.y
* include/hbpp.h
* include/hbrdddbf.h
* include/hbvmpub.h
* include/hbrddnsx.h
* include/hbstack.h
* include/hbgtcore.h
* include/hbapifs.h
* include/hbthread.h
* include/hbdefs.h
* include/hbmacro.h
* include/hbinit.h
* include/hbtypes.h
* include/hbrddsdf.h
* include/hbapi.h
* include/hbapiitm.h
* include/hbrddntx.h
* include/hbvm.h
* include/hbapidbg.h
* include/hbcomp.h
* include/hbapirdd.h
* include/hbcompdf.h
* include/hbrdddel.h
* include/hbexpra.c
* include/hbexprop.h
* include/hbrddcdx.h
* include/hbapicls.h
* include/hbapierr.h
* include/hbrddfpt.h
* include/hbhash.h
* include/hbregex.h
* include/hbexprb.c
* contrib/hbct/screen2.c
* contrib/hbct/token2.c
* contrib/hbct/dbftools.c
* contrib/hbct/atadjust.c
* contrib/hbct/ctwin.c
* contrib/hbct/files.c
* contrib/hbct/dattime3.c
* contrib/hbct/ctstr.c
* contrib/hbct/screen1.c
* contrib/hbct/token1.c
* contrib/hbct/ctc.c
* contrib/hbct/ct.h
* contrib/hbct/atnum.c
* contrib/hbct/asciisum.c
* contrib/hbct/numat.c
* contrib/hbct/atrepl.c
* contrib/xhb/bkgtsks.c
* contrib/xhb/hbcrypt.c
* contrib/xhb/fparse.c
* contrib/xhb/datesxhb.c
* contrib/xhb/hbnxs.h
* contrib/hbqt/gtqtc/gtqtc.cpp
* contrib/xpp/dbcmdx.c
* contrib/hbnf/dispc.c
* contrib/hbnf/ftattr.c
* contrib/hbmemio/memio.c
* contrib/hbnetio/netiocli.c
* contrib/rddsql/sddmy/mysqldd.c
* contrib/rddsql/sddpg/pgsqldd.c
* contrib/rddsql/sddfb/fbirddd.c
* contrib/rddsql/sddodbc/odbcdd.c
* contrib/rddsql/hbrddsql.h
* contrib/rddsql/sqlbase.c
* contrib/rddsql/sqlmix.c
* contrib/rddads/adsx.c
* contrib/rddads/adsfunc.c
* contrib/rddads/rddads.h
* contrib/rddads/ads1.c
* contrib/rddads/adsmgmnt.c
* contrib/hbmisc/spd.c
* contrib/hbtip/utils.c
* contrib/hbtip/encmthd.c
* contrib/hbbmcdx/bmdbfcdx.c
* contrib/hbbmcdx/hbbmcdx.h
* contrib/hbbtree/hb_btree.h
* contrib/hbbtree/hb_btree.c
* ULONG -> HB_ULONG, HB_SIZE
(except for external (OS) API specific usage)
* Formatting.
; NOTE: I converted ULONG to HB_SIZE where I felt it appropriate,
but didn't touch compiler, codeblock handling, low-level
RDD (Set/GetVarLen method) and high-level contrib RDDs, so
this needs to be cleaned.
Also there may be cases where I didn't change the whole
call chain to HB_SIZE.
; NOTE: It would be probably worthy to add new types for these purposes:
- line number (HB_USHORT)
- record number (HB_ULONG)
- RDD connection (HB_ULONG)
- parameter count / stack position / class member positions / etc (HB_USHORT, sometimes HB_ULONG)
- pcode (HB_BYTE and char)
- flags / modes (HB_USHORT / HB_ULONG)
- timers (HB_ULONG, HB_MAXINT)
- GT API character (HB_USHORT)
; REQUESTS:
- Pls don't over-align variable declarations. It makes
modification much much slower. Sometimes declarations are
aligned even if there was only one or two of them in a block.
- Pls always add variable names in declarations, otherwise the purpose
of the function is very slow to decipher when looking at it.
- Keep up the nice formatting according to Harbour standards,
it makes modifications much much easier.
; TODO:
- Verify with grep script
- Verify with HB_USER_CFLAGS=-DHB_LEGACY_TYPES_OFF
- Make HB_LEGACY_TYPES_OFF default for Harbour builds.
- Tie HB_LEGACY_TYPES_OFF to HB_LEGACY_LEVEL3
- Replace current windows.h inclusion hack with regular method
- Delete hacks dealing with former type chaos:
HB_CLIPPER_INT_ITEMS, HB_DONT_DEFINE_BASIC_TYPES, HB_DONT_DEFINE_BOOL, HB_DONT_DEFINE_BYTE, HB_DONT_DEFINE_LONG
- Retest hbfimage on *nix, delete hacks
- Normalize HB_BYTE vs. HB_UCHAR usage
- Type cleanups, f.e. HB_SIZE vs. HB_ULONG
- Add new special types (see above)
- Switch HB_SIZE to signed (big project), and delete HB_ISIZ afterwards.
2010-02-08 20:24 UTC+0100 Przemyslaw Czerpak (druzus/at/priv.onet.pl)
* harbour/include/hbapicdp.h
* harbour/src/rtl/cdpapi.c

266
harbour/contrib/hbbmcdx/bmdbfcdx.c
View File

@@ -336,8 +336,8 @@ static CDXDBGTIME hb_cdxGetTime()
}
#endif
#ifdef HB_CDX_DBGUPDT
static ULONG cdxWriteNO = 0;
static ULONG cdxReadNO = 0;
static HB_ULONG cdxWriteNO = 0;
static HB_ULONG cdxReadNO = 0;
static HB_SHORT cdxStackSize = 0;
static HB_SHORT cdxTmpStackSize = 0;
#endif
@@ -489,7 +489,7 @@ static LPCDXKEY hb_cdxKeyCopy( LPCDXKEY pKeyDest, LPCDXKEY pKey )
/*
* store bytes value in inkdex key
*/
static LPCDXKEY hb_cdxKeyPut( LPCDXKEY pKey, HB_BYTE * pbVal, HB_USHORT uiLen, ULONG ulRec )
static LPCDXKEY hb_cdxKeyPut( LPCDXKEY pKey, HB_BYTE * pbVal, HB_USHORT uiLen, HB_ULONG ulRec )
{
if( !pKey )
pKey = hb_cdxKeyNew();
@@ -518,7 +518,7 @@ static LPCDXKEY hb_cdxKeyPut( LPCDXKEY pKey, HB_BYTE * pbVal, HB_USHORT uiLen, U
/*
* store string0 value in index key
*/
static LPCDXKEY hb_cdxKeyPutC( LPCDXKEY pKey, const char * szText, HB_USHORT uiRealLen, ULONG ulRec )
static LPCDXKEY hb_cdxKeyPutC( LPCDXKEY pKey, const char * szText, HB_USHORT uiRealLen, HB_ULONG ulRec )
{
HB_USHORT uiLen;
@@ -652,10 +652,10 @@ static HB_BYTE hb_cdxItemTypeCmp( HB_BYTE bType )
* store Item in index key
* TODO: uiType check and generate RT error if necessary
*/
static LPCDXKEY hb_cdxKeyPutItem( LPCDXKEY pKey, PHB_ITEM pItem, ULONG ulRec, LPCDXTAG pTag, HB_BOOL fTrans, int iMode )
static LPCDXKEY hb_cdxKeyPutItem( LPCDXKEY pKey, PHB_ITEM pItem, HB_ULONG ulRec, LPCDXTAG pTag, HB_BOOL fTrans, int iMode )
{
HB_BYTE buf[ CDX_MAXKEY ], *ptr;
ULONG ulLen = 0;
HB_ULONG ulLen = 0;
double d;
ptr = &buf[0];
@@ -664,9 +664,9 @@ static LPCDXKEY hb_cdxKeyPutItem( LPCDXKEY pKey, PHB_ITEM pItem, ULONG ulRec, LP
{
case 'C':
ulLen = hb_itemGetCLen( pItem );
if( ulLen > ( ULONG ) pTag->uiLen )
if( ulLen > ( HB_ULONG ) pTag->uiLen )
ulLen = pTag->uiLen;
if( iMode == CDX_CMP_EXACT && ulLen < ( ULONG ) pTag->uiLen )
if( iMode == CDX_CMP_EXACT && ulLen < ( HB_ULONG ) pTag->uiLen )
{
memcpy( ptr, hb_itemGetCPtr( pItem ), ulLen );
memset( ptr + ulLen, pTag->bTrail, pTag->uiLen - ulLen );
@@ -986,7 +986,7 @@ static void hb_cdxTagSetScope( LPCDXTAG pTag, HB_USHORT nScope, PHB_ITEM pItem )
{
PHB_ITEM *pScope;
LPCDXKEY *pScopeKey;
ULONG ulRec;
HB_ULONG ulRec;
if( pTag->UsrAscend ? nScope == 0 : nScope != 0 )
{
@@ -1128,11 +1128,11 @@ static void hb_cdxIndexCheckBuffers( LPCDXINDEX pIndex )
/*
* get free index page
*/
static ULONG hb_cdxIndexGetAvailPage( LPCDXINDEX pIndex, HB_BOOL bHeader )
static HB_ULONG hb_cdxIndexGetAvailPage( LPCDXINDEX pIndex, HB_BOOL bHeader )
{
PHB_FILE pFile = pIndex->pFile;
HB_BYTE byBuf[ 4 ];
ULONG ulPos;
HB_ULONG ulPos;
if( pIndex->fReadonly )
{
@@ -1170,7 +1170,7 @@ static ULONG hb_cdxIndexGetAvailPage( LPCDXINDEX pIndex, HB_BOOL bHeader )
if( pIndex->nextAvail != CDX_DUMMYNODE )
ulPos = pIndex->nextAvail;
else
ulPos = ( ULONG ) hb_fileSize( pFile );
ulPos = ( HB_ULONG ) hb_fileSize( pFile );
pIndex->nextAvail = ulPos + iCnt * CDX_PAGELEN;
/* TODO: ### */
@@ -1195,7 +1195,7 @@ static ULONG hb_cdxIndexGetAvailPage( LPCDXINDEX pIndex, HB_BOOL bHeader )
/*
* free index page
*/
static void hb_cdxIndexPutAvailPage( LPCDXINDEX pIndex, ULONG ulPos, HB_BOOL bHeader )
static void hb_cdxIndexPutAvailPage( LPCDXINDEX pIndex, HB_ULONG ulPos, HB_BOOL bHeader )
{
if( ulPos != 0 && ulPos != CDX_DUMMYNODE )
{
@@ -1227,7 +1227,7 @@ static void hb_cdxIndexFlushAvailPage( LPCDXINDEX pIndex )
{
LPCDXLIST pLst = pIndex->freeLst;
HB_BYTE byPageBuf[CDX_PAGELEN];
ULONG ulPos;
HB_ULONG ulPos;
HB_BOOL fClean = HB_TRUE;
if( pIndex->fReadonly )
@@ -1276,7 +1276,7 @@ static void hb_cdxIndexDropAvailPage( LPCDXINDEX pIndex )
/*
* write index page
*/
static void hb_cdxIndexPageWrite( LPCDXINDEX pIndex, ULONG ulPos, HB_BYTE * pBuffer,
static void hb_cdxIndexPageWrite( LPCDXINDEX pIndex, HB_ULONG ulPos, HB_BYTE * pBuffer,
HB_USHORT uiSize )
{
if( pIndex->fReadonly )
@@ -1284,7 +1284,7 @@ static void hb_cdxIndexPageWrite( LPCDXINDEX pIndex, ULONG ulPos, HB_BYTE * pBuf
if( pIndex->fShared && !pIndex->lockWrite )
hb_errInternal( 9102, "hb_cdxIndexPageWrite on not locked index file.", NULL, NULL );
if( hb_fileWriteAt( pIndex->pFile, pBuffer, uiSize, ulPos ) != ( ULONG ) uiSize )
if( hb_fileWriteAt( pIndex->pFile, pBuffer, uiSize, ulPos ) != ( HB_ULONG ) uiSize )
hb_errInternal( EDBF_WRITE, "Write in index page failed.", NULL, NULL );
pIndex->fChanged = HB_TRUE;
#ifdef HB_CDX_DBGUPDT
@@ -1295,13 +1295,13 @@ static void hb_cdxIndexPageWrite( LPCDXINDEX pIndex, ULONG ulPos, HB_BYTE * pBuf
/*
* read index page
*/
static void hb_cdxIndexPageRead( LPCDXINDEX pIndex, ULONG ulPos, HB_BYTE * pBuffer,
static void hb_cdxIndexPageRead( LPCDXINDEX pIndex, HB_ULONG ulPos, HB_BYTE * pBuffer,
HB_USHORT uiSize )
{
if( pIndex->fShared && !( pIndex->lockRead || pIndex->lockWrite ) )
hb_errInternal( 9103, "hb_cdxIndexPageRead on not locked index file.", NULL, NULL );
if( hb_fileReadAt( pIndex->pFile, pBuffer, uiSize, ulPos ) != ( ULONG ) uiSize )
if( hb_fileReadAt( pIndex->pFile, pBuffer, uiSize, ulPos ) != ( HB_ULONG ) uiSize )
hb_errInternal( EDBF_READ, "hb_cdxIndexPageRead: Read index page failed.", NULL, NULL );
#ifdef HB_CDX_DBGUPDT
cdxReadNO++;
@@ -1314,7 +1314,7 @@ static void hb_cdxIndexPageRead( LPCDXINDEX pIndex, ULONG ulPos, HB_BYTE * pBuff
static void hb_cdxIndexCheckVersion( LPCDXINDEX pIndex )
{
HB_BYTE byBuf[8];
ULONG ulVer, ulFree;
HB_ULONG ulVer, ulFree;
if( hb_fileReadAt( pIndex->pFile, byBuf, 8, 0x04 ) != 8 )
{
@@ -1689,7 +1689,7 @@ static HB_BYTE * hb_cdxPageGetKeyVal( LPCDXPAGE pPage, int iKey )
/*
* get record number from index page
*/
static ULONG hb_cdxPageGetKeyRec( LPCDXPAGE pPage, int iKey )
static HB_ULONG hb_cdxPageGetKeyRec( LPCDXPAGE pPage, int iKey )
{
#ifdef HB_CDX_DBGCODE
if( iKey < 0 || iKey >= pPage->iKeys )
@@ -1707,7 +1707,7 @@ static ULONG hb_cdxPageGetKeyRec( LPCDXPAGE pPage, int iKey )
/*
* get child page number from interrior index page
*/
static ULONG hb_cdxPageGetKeyPage( LPCDXPAGE pPage, int iKey )
static HB_ULONG hb_cdxPageGetKeyPage( LPCDXPAGE pPage, int iKey )
{
#ifdef HB_CDX_DBGCODE
if( iKey < 0 || iKey >= pPage->iKeys )
@@ -1759,7 +1759,7 @@ static LPCDXKEY hb_cdxPageGetKey( LPCDXPAGE pPage, int iKey, LPCDXKEY pKey )
static void hb_cdxPageCheckKeys( LPCDXPAGE pPage )
{
int i, K, iLen = pPage->TagParent->uiLen;
ULONG ulRec, ulRecPrev;
HB_ULONG ulRec, ulRecPrev;
HB_BYTE * pbVal, pbValPrev[CDX_MAXKEY];
if( pPage->iKeys > 1 )
@@ -1841,8 +1841,8 @@ static void hb_cdxPageCheckDupTrl( LPCDXPAGE pPage, HB_BYTE * pKeyBuf, int iKeys
{
printf( "\r\nikey=%d, iKeys=%d, K=%d, ulRecPrev=%ld, ulRec=%ld",
iKey, iKeys, K,
( ULONG ) HB_GET_LE_UINT32( &pKeyBuf[ iPos + iNum - iLen ] ),
( ULONG ) HB_GET_LE_UINT32( &pKeyBuf[ iPos + iNum ] ) );
( HB_ULONG ) HB_GET_LE_UINT32( &pKeyBuf[ iPos + iNum - iLen ] ),
( HB_ULONG ) HB_GET_LE_UINT32( &pKeyBuf[ iPos + iNum ] ) );
printf( "\r\npbValPrev=[%s] pbVal=[%s], [%d], pKeyBuf=%p",
&pKeyBuf[ iPos - iLen ], &pKeyBuf[ iPos ],
memcmp( &pKeyBuf[ iPos - iLen ], &pKeyBuf[ iPos ], iNum ),
@@ -1882,7 +1882,7 @@ static void hb_cdxPageCheckDupTrlRaw( LPCDXPAGE pPage )
/*
* put record and duplicate + trailing counters into leaf page
*/
static void hb_cdxSetLeafRecord( HB_BYTE *pDst, ULONG ulRec, int iDup, int iTrl,
static void hb_cdxSetLeafRecord( HB_BYTE *pDst, HB_ULONG ulRec, int iDup, int iTrl,
int iReq, int iDCbits, int iTCbits )
{
int i;
@@ -1983,7 +1983,7 @@ static void hb_cdxPageLeafDecode( LPCDXPAGE pPage, HB_BYTE * pKeyBuf )
{
int iKey, iTmp, iBits, iDup, iTrl, iNew, iReq, iLen = pPage->TagParent->uiLen;
HB_BYTE *pDst, *pSrc, *pRec, *pTmp, bTrail = pPage->TagParent->bTrail;
ULONG ulRec;
HB_ULONG ulRec;
#ifdef HB_CDX_DBGCODE
if( ( pPage->PageType & CDX_NODE_LEAF ) == 0 )
@@ -2068,7 +2068,7 @@ static void hb_cdxPageCalcLeafSpace( LPCDXPAGE pPage, HB_BYTE * pKeyBuf, int iKe
int iNum = pPage->TagParent->uiLen, iKey, iSize;
int iLen = iNum + 6;
HB_BYTE bDup, bTrl, ReqByte, *bPtr;
ULONG ulRec, RNMask;
HB_ULONG ulRec, RNMask;
hb_cdxPageLeafInitSpace( pPage );
pPage->iKeys = 0;
@@ -2139,7 +2139,7 @@ static int hb_cdxPageLeafDelKey( LPCDXPAGE pPage )
#ifdef HB_CDX_DSPDBG_INFO
printf("\r\ndelkey: Page=%lx, iKey=%d/%d, rec=%ld, iFree=%d",
pPage->Page, iKey, pPage->iKeys,
( ULONG ) HB_GET_LE_UINT32( &pPage->pKeyBuf[ ( iKey + 1 ) * iLen - 6 ] ),
( HB_ULONG ) HB_GET_LE_UINT32( &pPage->pKeyBuf[ ( iKey + 1 ) * iLen - 6 ] ),
pPage->iFree );
fflush(stdout);
#endif
@@ -2330,7 +2330,7 @@ static int hb_cdxPageLeafAddKey( LPCDXPAGE pPage, LPCDXKEY pKey )
/*
* set (insert) key in interior node record to (with) given value
*/
static void hb_cdxPageIntSetKey( LPCDXPAGE pPage, int iKey, HB_BOOL fIns, HB_BYTE * pbVal, ULONG ulRec, ULONG ulPag )
static void hb_cdxPageIntSetKey( LPCDXPAGE pPage, int iKey, HB_BOOL fIns, HB_BYTE * pbVal, HB_ULONG ulRec, HB_ULONG ulPag )
{
int iLen = pPage->TagParent->uiLen;
int iPos = iKey * ( iLen + 8 );
@@ -2379,7 +2379,7 @@ static void hb_cdxPageIntDelKey( LPCDXPAGE pPage, int iKey )
#ifdef HB_CDX_DSPDBG_INFO
printf("\r\nintDelKey: Page=%lx, iKey=%d/%d, ulPag=%lx",
pPage->Page, iKey, pPage->iKeys,
( ULONG ) HB_GET_BE_UINT32( &pPage->node.intNode.keyPool[ (iKey+1) * iLen - 4 ] ) );
( HB_ULONG ) HB_GET_BE_UINT32( &pPage->node.intNode.keyPool[ (iKey+1) * iLen - 4 ] ) );
fflush(stdout);
#endif
#ifdef HB_CDX_DBGCODE
@@ -2501,7 +2501,7 @@ static void hb_cdxPageStore( LPCDXPAGE pPage )
* create new empty page and allocate space for it in index file if ulPage == 0
* or load it from index file if ulPage != CDX_DUMMYNODE
*/
static LPCDXPAGE hb_cdxPageNew( LPCDXTAG pTag, LPCDXPAGE pOwnerPage, ULONG ulPage )
static LPCDXPAGE hb_cdxPageNew( LPCDXTAG pTag, LPCDXPAGE pOwnerPage, HB_ULONG ulPage )
{
LPCDXPAGE pPage = NULL;
@@ -2637,7 +2637,7 @@ static void hb_cdxPageFree( LPCDXPAGE pPage, HB_BOOL fReal )
*/
static void hb_cdxPageGetChild( LPCDXPAGE pPage )
{
ULONG ulPage;
HB_ULONG ulPage;
#ifdef HB_CDX_DBGCODE
if( ( pPage->PageType & CDX_NODE_LEAF ) != 0 )
@@ -2670,7 +2670,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
iKeys = 0, iFree = 0, iSkip = 0, iBufSize = 0;
HB_BYTE * pKeyPool = NULL, * pPtr;
HB_BOOL fIns;
ULONG ulPage;
HB_ULONG ulPage;
int iRet = 0, i;
#ifdef HB_CDX_DBGCODE_EXT
@@ -2836,7 +2836,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
if( !fIns && lpTmpPage != NULL )
{
int j, iSize = 0, iMaxReq;
ULONG ulMaxRec = 0, ul;
HB_ULONG ulMaxRec = 0, ul;
HB_BYTE * pbKey, bMax;
for( j = 0; j < iKeys; j++ )
@@ -2874,7 +2874,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
{
#ifdef HB_CDX_DSPDBG_INFO
printf("\r\ninserting bDup=%d #keys=%d/%d (%d) parent=%lx, child=%lx (%d), rec=%ld",
j, iKeys, lpTmpPage->iKeys, i, pPage->Page, lpTmpPage->Page, iSize, ( ULONG ) HB_GET_LE_UINT32( pPtr + iLen - 6 ));
j, iKeys, lpTmpPage->iKeys, i, pPage->Page, lpTmpPage->Page, iSize, ( HB_ULONG ) HB_GET_LE_UINT32( pPtr + iLen - 6 ));
fflush(stdout);
#endif
if( iBufSize >= iKeys + lpTmpPage->iKeys )
@@ -3008,7 +3008,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
if( childs[iBlncKeys-1]->Right != CDX_DUMMYNODE &&
( i > 1 || ( i == 1 && childs[0]->Left == CDX_DUMMYNODE ) ) )
{
ULONG Page;
HB_ULONG Page;
Page = childs[iBlncKeys-1]->Page;
childs[iBlncKeys-1]->Page = childs[i-1]->Page;
childs[i-1]->Page = Page;
@@ -3024,7 +3024,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
else
#endif
{
ULONG Left, Right;
HB_ULONG Left, Right;
Right = childs[iBlncKeys-1]->Right;
if( i > 0 )
{
@@ -3096,7 +3096,7 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
int iFirstKey, iBlncKeys = CDX_BALANCE_INTPAGES;
int iLen = pPage->TagParent->uiLen + 8, iKeys = 0, iNeedKeys, iNodeKeys,
iMin = pPage->TagParent->MaxKeys, iMax = 0, iDiv;
ULONG ulPage;
HB_ULONG ulPage;
HB_BYTE * pKeyPool = NULL, *pPtr;
HB_BOOL fForce = ( iChildRet & ( NODE_SPLIT | NODE_JOIN ) ) != 0;
int iRet = 0, i;
@@ -3283,7 +3283,7 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
}
else if( iNeedKeys < iBlncKeys )
{
ULONG Left, Right;
HB_ULONG Left, Right;
/* Update siblings links */
if( iNeedKeys > 1 )
@@ -3453,7 +3453,7 @@ static int hb_cdxPageBalance( LPCDXPAGE pPage, int iChildRet )
static int hb_cdxPageRootSplit( LPCDXPAGE pPage )
{
LPCDXPAGE pNewRoot;
ULONG ulPage;
HB_ULONG ulPage;
pNewRoot = hb_cdxPageNew( pPage->TagParent, NULL, 0 );
/*
@@ -3607,7 +3607,7 @@ static void hb_cdxTagLoad( LPCDXTAG pTag )
{
CDXTAGHEADER tagHeader;
HB_USHORT uiForPos, uiForLen, uiKeyPos, uiKeyLen;
ULONG ulRecNo;
HB_ULONG ulRecNo;
/* read the page from a file */
hb_cdxIndexPageRead( pTag->pIndex, pTag->TagBlock, ( HB_BYTE * ) &tagHeader, sizeof( CDXTAGHEADER ) );
@@ -3783,7 +3783,7 @@ static void hb_cdxTagFree( LPCDXTAG pTag )
* TagHdr = offset of index page where a tag header is stored
* if CDX_DUMMYNODE then allocate space ofor a new tag header
*/
static LPCDXTAG hb_cdxTagNew( LPCDXINDEX pIndex, const char *szTagName, ULONG TagHdr )
static LPCDXTAG hb_cdxTagNew( LPCDXINDEX pIndex, const char *szTagName, HB_ULONG TagHdr )
{
LPCDXTAG pTag;
char szName[ CDX_MAXTAGNAMELEN + 1 ];
@@ -3921,7 +3921,7 @@ static void hb_cdxSetCurKey( LPCDXPAGE pPage )
/*
* seek given Key in the Page or in its children
*/
static int hb_cdxPageSeekKey( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec )
static int hb_cdxPageSeekKey( LPCDXPAGE pPage, LPCDXKEY pKey, HB_ULONG ulKeyRec )
{
int l, r, n, k;
HB_BOOL fLeaf = ( pPage->PageType & CDX_NODE_LEAF ) != 0;
@@ -3950,7 +3950,7 @@ static int hb_cdxPageSeekKey( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec )
k = 1;
else if( ulKeyRec != CDX_IGNORE_REC_NUM )
{
ULONG ulRec = hb_cdxPageGetKeyRec( pPage, n );
HB_ULONG ulRec = hb_cdxPageGetKeyRec( pPage, n );
if( ulKeyRec > ulRec )
k = 1;
else if( ulKeyRec < ulRec )
@@ -3995,7 +3995,7 @@ static int hb_cdxPageSeekKey( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec )
if( k == 0 && ulKeyRec != CDX_MAX_REC_NUM &&
ulKeyRec != CDX_IGNORE_REC_NUM )
{
ULONG ulRec = hb_cdxPageGetKeyRec( pPage, pPage->iCurKey );
HB_ULONG ulRec = hb_cdxPageGetKeyRec( pPage, pPage->iCurKey );
if( ulKeyRec > ulRec )
k = 1;
else if( ulKeyRec < ulRec )
@@ -4026,7 +4026,7 @@ static int hb_cdxPageSeekKey( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec )
/*
* an interface for fast check record number in record filter
*/
static HB_BOOL hb_cdxCheckRecordScope( CDXAREAP pArea, ULONG ulRec )
static HB_BOOL hb_cdxCheckRecordScope( CDXAREAP pArea, HB_ULONG ulRec )
{
HB_LONG lRecNo = ( HB_LONG ) ulRec;
@@ -4040,7 +4040,7 @@ static HB_BOOL hb_cdxCheckRecordScope( CDXAREAP pArea, ULONG ulRec )
/*
* check and avaluate record filter
*/
static HB_BOOL hb_cdxCheckRecordFilter( CDXAREAP pArea, ULONG ulRecNo )
static HB_BOOL hb_cdxCheckRecordFilter( CDXAREAP pArea, HB_ULONG ulRecNo )
{
HB_BOOL lResult = HB_FALSE;
HB_BOOL fDeleted = hb_setGetDeleted();
@@ -4418,10 +4418,10 @@ static void hb_cdxTagKeyRead( LPCDXTAG pTag, HB_BYTE bTypRead )
/*
* find pKey in pTag return 0 or TagNO
*/
static ULONG hb_cdxTagKeyFind( LPCDXTAG pTag, LPCDXKEY pKey )
static HB_ULONG hb_cdxTagKeyFind( LPCDXTAG pTag, LPCDXKEY pKey )
{
int K;
ULONG ulKeyRec = pKey->rec;
HB_ULONG ulKeyRec = pKey->rec;
pTag->fRePos = HB_FALSE;
hb_cdxTagOpen( pTag );
@@ -4449,10 +4449,10 @@ static ULONG hb_cdxTagKeyFind( LPCDXTAG pTag, LPCDXKEY pKey )
/*
* find pKey in pTag return 0 or record number, respect descend/unique flags
*/
static ULONG hb_cdxTagKeySeek( LPCDXTAG pTag, LPCDXKEY pKey )
static HB_ULONG hb_cdxTagKeySeek( LPCDXTAG pTag, LPCDXKEY pKey )
{
int K;
ULONG ulKeyRec = pKey->rec;
HB_ULONG ulKeyRec = pKey->rec;
if( pTag->UsrUnique )
{
@@ -4536,7 +4536,7 @@ static HB_BOOL hb_cdxTagKeyDel( LPCDXTAG pTag, LPCDXKEY pKey )
static void hb_cdxTagGoTop( LPCDXTAG pTag )
{
LPCDXKEY pKey = pTag->UsrAscend ? pTag->topScopeKey : pTag->bottomScopeKey;
ULONG ulPos = 1;
HB_ULONG ulPos = 1;
if( pKey )
hb_cdxTagKeyFind( pTag, pKey );
@@ -4569,7 +4569,7 @@ static void hb_cdxTagGoTop( LPCDXTAG pTag )
static void hb_cdxTagGoBottom( LPCDXTAG pTag )
{
LPCDXKEY pKey = pTag->UsrAscend ? pTag->bottomScopeKey : pTag->topScopeKey;
ULONG ulPos = 0;
HB_ULONG ulPos = 0;
if( pKey )
hb_cdxTagKeyFind( pTag, pKey );
@@ -4605,7 +4605,7 @@ static void hb_cdxTagGoBottom( LPCDXTAG pTag )
static void hb_cdxTagSkipNext( LPCDXTAG pTag )
{
HB_BOOL fPos = CURKEY_RAWPOS( pTag ), fEof = HB_FALSE;
ULONG ulSkip = 1;
HB_ULONG ulSkip = 1;
if( pTag->CurKey->rec != 0 )
{
@@ -4648,7 +4648,7 @@ static void hb_cdxTagSkipNext( LPCDXTAG pTag )
static void hb_cdxTagSkipPrev( LPCDXTAG pTag )
{
HB_BOOL fPos = CURKEY_RAWPOS( pTag ), fBof = HB_FALSE;
ULONG ulSkip = 1;
HB_ULONG ulSkip = 1;
if( pTag->CurKey->rec == 0 )
{
@@ -5552,7 +5552,7 @@ static HB_BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForwa
break;
if( hb_cdxEvalSeekCond( pTag, pEval ) )
{
ULONG ulRecNo = pArea->dbfarea.ulRecNo;
HB_ULONG ulRecNo = pArea->dbfarea.ulRecNo;
SELF_SKIPFILTER( ( AREAP ) pArea, 1 );
if( pArea->dbfarea.ulRecNo == ulRecNo || hb_cdxEvalSeekCond( pTag, pEval ) )
{
@@ -5575,7 +5575,7 @@ static HB_BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForwa
break;
if( hb_cdxEvalSeekCond( pTag, pEval ) )
{
ULONG ulRecNo = pArea->dbfarea.ulRecNo;
HB_ULONG ulRecNo = pArea->dbfarea.ulRecNo;
SELF_SKIPFILTER( ( AREAP ) pArea, -1 );
if( pArea->dbfarea.ulRecNo == ulRecNo || hb_cdxEvalSeekCond( pTag, pEval ) )
{
@@ -5686,7 +5686,7 @@ static HB_BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForwa
{
if( hb_strMatchWild( (const char *) pTag->CurKey->val, szPattern ) )
{
ULONG ulRecNo = pTag->CurKey->rec;
HB_ULONG ulRecNo = pTag->CurKey->rec;
if( SELF_GOTO( ( AREAP ) pArea, ulRecNo ) != HB_SUCCESS )
break;
SELF_SKIPFILTER( ( AREAP ) pArea, 1 );
@@ -5716,7 +5716,7 @@ static HB_BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForwa
{
if( hb_strMatchWild( (const char *) pTag->CurKey->val, szPattern ) )
{
ULONG ulRecNo = pTag->CurKey->rec;
HB_ULONG ulRecNo = pTag->CurKey->rec;
if( SELF_GOTO( ( AREAP ) pArea, ulRecNo ) != HB_SUCCESS )
break;
SELF_SKIPFILTER( ( AREAP ) pArea, -1 );
@@ -5758,7 +5758,7 @@ static HB_BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForwa
static HB_BOOL hb_cdxRegexMatch( CDXAREAP pArea, PHB_REGEX pRegEx, LPCDXKEY pKey )
{
char * szKey = ( char * ) pKey->val;
ULONG ulLen = pKey->len;
HB_ULONG ulLen = pKey->len;
char szBuff[ CDX_MAXKEY + 1 ];
if( pArea->dbfarea.area.cdPage != hb_vmCDP() )
@@ -5816,7 +5816,7 @@ static HB_BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForw
{
if( hb_cdxRegexMatch( pArea, pRegEx, pTag->CurKey ) )
{
ULONG ulRecNo = pArea->dbfarea.ulRecNo;
HB_ULONG ulRecNo = pArea->dbfarea.ulRecNo;
SELF_SKIPFILTER( ( AREAP ) pArea, 1 );
if( pArea->dbfarea.ulRecNo == ulRecNo ||
hb_cdxRegexMatch( pArea, pRegEx, pTag->CurKey ) )
@@ -5837,7 +5837,7 @@ static HB_BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForw
{
if( hb_cdxRegexMatch( pArea, pRegEx, pTag->CurKey ) )
{
ULONG ulRecNo = pArea->dbfarea.ulRecNo;
HB_ULONG ulRecNo = pArea->dbfarea.ulRecNo;
SELF_SKIPFILTER( ( AREAP ) pArea, -1 );
if( pArea->dbfarea.ulRecNo == ulRecNo ||
hb_cdxRegexMatch( pArea, pRegEx, pTag->CurKey ) )
@@ -5872,9 +5872,9 @@ static HB_BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForw
/*
* evaluate given C function in given scope
*/
static ULONG hb_cdxDBOIScopeEval( LPCDXTAG pTag, HB_EVALSCOPE_FUNC pFunc, void *pParam, PHB_ITEM pItemLo, PHB_ITEM pItemHi )
static HB_ULONG hb_cdxDBOIScopeEval( LPCDXTAG pTag, HB_EVALSCOPE_FUNC pFunc, void *pParam, PHB_ITEM pItemLo, PHB_ITEM pItemHi )
{
ULONG ulCount = 0, ulLen = ( ULONG ) pTag->uiLen;
HB_ULONG ulCount = 0, ulLen = ( HB_ULONG ) pTag->uiLen;
LPCDXKEY pCurKey = hb_cdxKeyCopy( NULL, pTag->CurKey ),
pTopScopeKey = pTag->topScopeKey,
pBtmScopeKey = pTag->bottomScopeKey;
@@ -5922,13 +5922,13 @@ static ULONG hb_cdxDBOIScopeEval( LPCDXTAG pTag, HB_EVALSCOPE_FUNC pFunc, void *
*/
static HB_LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilters )
{
ULONG ulKeyCount = 0;
HB_ULONG ulKeyCount = 0;
HB_BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
if( pTag )
{
HB_BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
ULONG ulRecNo = pArea->dbfarea.ulRecNo;
HB_ULONG ulRecNo = pArea->dbfarea.ulRecNo;
LPCDXKEY pCurKey;
hb_cdxIndexLockRead( pTag->pIndex );
hb_cdxTagRefreshScope( pTag );
@@ -5969,7 +5969,7 @@ static HB_LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilte
ulKeyCount = pPage->iKeys;
if( pPage->Right != CDX_DUMMYNODE )
{
ULONG ulPage = pPage->Right;
HB_ULONG ulPage = pPage->Right;
pPage = hb_cdxPageNew( pTag, NULL, CDX_DUMMYNODE );
pPage->Page = ulPage;
while( pPage->Page != CDX_DUMMYNODE )
@@ -5999,7 +5999,7 @@ static HB_LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilte
{
if( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr )
{
ULONG ulRecNo = pArea->dbfarea.ulRecNo;
HB_ULONG ulRecNo = pArea->dbfarea.ulRecNo;
if( SELF_GOTOP( ( AREAP ) pArea ) == HB_SUCCESS )
{
@@ -6025,7 +6025,7 @@ static HB_LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilte
*/
static HB_LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilters )
{
ULONG ulKeyNo = 0;
HB_ULONG ulKeyNo = 0;
HB_BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
if( pArea->dbfarea.lpdbPendingRel )
@@ -6036,7 +6036,7 @@ static HB_LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilters
else if( pTag )
{
HB_BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
ULONG ulRecNo = pArea->dbfarea.ulRecNo;
HB_ULONG ulRecNo = pArea->dbfarea.ulRecNo;
hb_cdxIndexLockRead( pTag->pIndex );
hb_cdxTagRefreshScope( pTag );
@@ -6083,7 +6083,7 @@ static HB_LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilters
ulKeyNo = pPage->iCurKey + 1;
if( pPage->Left != CDX_DUMMYNODE )
{
ULONG ulPage = pPage->Left;
HB_ULONG ulPage = pPage->Left;
pPage = hb_cdxPageNew( pTag, NULL, CDX_DUMMYNODE );
pPage->Page = ulPage;
while( pPage->Page != CDX_DUMMYNODE )
@@ -6100,7 +6100,7 @@ static HB_LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilters
ulKeyNo = pPage->iKeys - pPage->iCurKey;
if( pPage->Right != CDX_DUMMYNODE )
{
ULONG ulPage = pPage->Right;
HB_ULONG ulPage = pPage->Right;
pPage = hb_cdxPageNew( pTag, NULL, CDX_DUMMYNODE );
pPage->Page = ulPage;
while( pPage->Page != CDX_DUMMYNODE )
@@ -6132,7 +6132,7 @@ static HB_LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilters
}
else
{
ULONG ulRecNo = pArea->dbfarea.ulRecNo;
HB_ULONG ulRecNo = pArea->dbfarea.ulRecNo;
if( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr )
{
@@ -6158,10 +6158,10 @@ static HB_LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilters
/*
* DBOI_KEYGOTO goto specific logical record in the index file
*/
static HB_ERRCODE hb_cdxDBOIKeyGoto( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulKeyNo, HB_BOOL fFilters )
static HB_ERRCODE hb_cdxDBOIKeyGoto( CDXAREAP pArea, LPCDXTAG pTag, HB_ULONG ulKeyNo, HB_BOOL fFilters )
{
HB_ERRCODE retval;
ULONG ulKeyCnt = ulKeyNo;
HB_ULONG ulKeyCnt = ulKeyNo;
HB_BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
if( ulKeyNo == 0 )
@@ -6199,7 +6199,7 @@ static HB_ERRCODE hb_cdxDBOIKeyGoto( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulKeyN
else
{
LPCDXPAGE pPage, pOwnerPage = NULL;
ULONG ulNextPg;
HB_ULONG ulNextPg;
hb_cdxTagGoTop( pTag );
pPage = pTag->RootPage;
while( pPage->Child )
@@ -6207,7 +6207,7 @@ static HB_ERRCODE hb_cdxDBOIKeyGoto( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulKeyN
pOwnerPage = pPage;
pPage = pPage->Child;
}
while( ( ULONG ) pPage->iKeys < ulKeyCnt && pOwnerPage &&
while( ( HB_ULONG ) pPage->iKeys < ulKeyCnt && pOwnerPage &&
( ulNextPg = pTag->UsrAscend ?
pPage->Right : pPage->Left ) != CDX_DUMMYNODE )
{
@@ -6216,7 +6216,7 @@ static HB_ERRCODE hb_cdxDBOIKeyGoto( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulKeyN
hb_cdxPageFree( pPage, HB_FALSE );
pPage = pOwnerPage->Child;
}
if( ( ULONG ) pPage->iKeys >= ulKeyCnt )
if( ( HB_ULONG ) pPage->iKeys >= ulKeyCnt )
{
pPage->iCurKey = pTag->UsrAscend ? ( int ) ulKeyCnt - 1 : pPage->iKeys - ( int ) ulKeyCnt;
hb_cdxSetCurKey( pPage );
@@ -6296,7 +6296,7 @@ static HB_BOOL hb_cdxGoToRelKeyPos( LPCDXPAGE pPage, double dPos )
static double hb_cdxDBOIGetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag )
{
ULONG ulRecNo = 0, ulRecCount = 0;
HB_ULONG ulRecNo = 0, ulRecCount = 0;
double dPos = 0.0;
/* resolve any pending relations */
@@ -6399,9 +6399,9 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
}
else
{
ULONG ulRecCount, ulRecNo;
HB_ULONG ulRecCount, ulRecNo;
SELF_RECCOUNT( ( AREAP ) pArea, &ulRecCount );
ulRecNo = ( ULONG ) dPos * ulRecCount + 1;
ulRecNo = ( HB_ULONG ) dPos * ulRecCount + 1;
if( ulRecNo >= ulRecCount )
ulRecNo = ulRecCount;
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
@@ -6536,7 +6536,7 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
* custom indexes when the same record can be stored more then once
* or when the used index key is unknown
*/
static HB_BOOL hb_cdxDBOIFindRec( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulRecNo, HB_BOOL fCont )
static HB_BOOL hb_cdxDBOIFindRec( CDXAREAP pArea, LPCDXTAG pTag, HB_ULONG ulRecNo, HB_BOOL fCont )
{
HB_BOOL fFound = HB_FALSE;
@@ -6710,7 +6710,7 @@ static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pKeyIt
LPCDXKEY pKey;
HB_ERRCODE retval = HB_SUCCESS;
HB_BOOL fEOF = HB_FALSE, fLast;
ULONG ulRec;
HB_ULONG ulRec;
if( pArea->dbfarea.lpdbPendingRel && pArea->dbfarea.lpdbPendingRel->isScoped )
SELF_FORCEREL( ( AREAP ) pArea );
@@ -6797,7 +6797,7 @@ static int hb_cdxValCompareWild( HB_BYTE * val1, HB_BYTE * val2, HB_BOOL fExact
/*
* seek given Key in the Page or in its children
*/
static int hb_cdxPageSeekKeyWild( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec, HB_BOOL fExact, HB_BOOL fNext )
static int hb_cdxPageSeekKeyWild( LPCDXPAGE pPage, LPCDXKEY pKey, HB_ULONG ulKeyRec, HB_BOOL fExact, HB_BOOL fNext )
{
int k;
@@ -6821,7 +6821,7 @@ static int hb_cdxPageSeekKeyWild( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec
k = 1;
else if( ulKeyRec != CDX_IGNORE_REC_NUM )
{
ULONG ulRec = hb_cdxPageGetKeyRec( pPage, pPage->iCurKey );
HB_ULONG ulRec = hb_cdxPageGetKeyRec( pPage, pPage->iCurKey );
if( ulKeyRec > ulRec )
k = 1;
else if( ulKeyRec < ulRec )
@@ -6835,10 +6835,10 @@ static int hb_cdxPageSeekKeyWild( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec
/*
* find pKey in pTag return 0 or TagNO
*/
static ULONG hb_cdxTagKeyFindWild( LPCDXTAG pTag, LPCDXKEY pKey, HB_BOOL fNext )
static HB_ULONG hb_cdxTagKeyFindWild( LPCDXTAG pTag, LPCDXKEY pKey, HB_BOOL fNext )
{
int K;
ULONG ulKeyRec = pKey->rec;
HB_ULONG ulKeyRec = pKey->rec;
pTag->fRePos = HB_FALSE;
hb_cdxTagOpen( pTag );
@@ -6885,7 +6885,7 @@ static HB_ERRCODE hb_cdxSeekWild( CDXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pK
LPCDXKEY pKey;
HB_ERRCODE retval = HB_SUCCESS;
HB_BOOL fEOF = HB_FALSE, fLast;
ULONG ulRec;
HB_ULONG ulRec;
if( ! bAll && pArea->dbfarea.lpdbPendingRel && pArea->dbfarea.lpdbPendingRel->isScoped )
SELF_FORCEREL( ( AREAP ) pArea );
@@ -6955,12 +6955,12 @@ HB_FUNC( BM_DBGETFILTERARRAY )
{
CDXAREAP pArea = (CDXAREAP) hb_rddGetCurrentWorkAreaPointer();
PHB_ITEM pList = hb_itemArrayNew( 0 );
ULONG ulRec,ulRecOld;
HB_ULONG ulRec,ulRecOld;
if( pArea->dbfarea.area.dbfi.fOptimized )
{
ULONG ulSize = ( ( ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->Size+1) >> 5 ) + 1;
ULONG ulLong, ulByte, ulBytes, ulRecno;
HB_ULONG ulSize = ( ( ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->Size+1) >> 5 ) + 1;
HB_ULONG ulLong, ulByte, ulBytes, ulRecno;
PHB_ITEM pItem = hb_itemNew( NULL );
ulRecOld = pArea->dbfarea.ulRecNo;
@@ -6983,7 +6983,7 @@ HB_FUNC( BM_DBSETFILTERARRAY )
{
AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
ULONG ulPos,ulRecCount;
HB_ULONG ulPos,ulRecCount;
if( pArea )
{
@@ -7002,11 +7002,11 @@ HB_FUNC( BM_DBSETFILTERARRAY )
memset( pArea->dbfi.lpvCargo, 0, sizeof( BM_FILTER ) );
( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->Size = ulRecCount;
( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap = ( ULONG * ) hb_xgrab( sizeof( ULONG ) * (((ulRecCount+1) >> 5) + 1) );
memset( ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap, 0, sizeof( ULONG ) * (((ulRecCount+1) >> 5) + 1 ) );
( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap = ( HB_ULONG * ) hb_xgrab( sizeof( HB_ULONG ) * (((ulRecCount+1) >> 5) + 1) );
memset( ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap, 0, sizeof( HB_ULONG ) * (((ulRecCount+1) >> 5) + 1 ) );
for( ulPos = 1; ulPos <= hb_arrayLen( pArray ); ulPos++ )
BM_SetBit( ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap, ulRecCount, ( ULONG ) hb_arrayGetNL( pArray, ulPos ) );
BM_SetBit( ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap, ulRecCount, ( HB_ULONG ) hb_arrayGetNL( pArray, ulPos ) );
pTag = hb_cdxGetActiveTag( ( CDXAREAP ) pArea );
if( pTag ) /* Con índice activo */
{
@@ -7025,7 +7025,7 @@ HB_FUNC( BM_DBSETFILTERARRAYADD )
{
AREAP pArea = (AREAP) hb_rddGetCurrentWorkAreaPointer();
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
ULONG ulPos,ulAdd = 0;
HB_ULONG ulPos,ulAdd = 0;
if( pArea && pArea->dbfi.fOptimized )
{
@@ -7034,9 +7034,9 @@ HB_FUNC( BM_DBSETFILTERARRAYADD )
LPCDXTAG pTag;
for( ulPos = 1; ulPos <= hb_arrayLen( pArray ); ulPos++ )
if( ! BM_GetBit( ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap, ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->Size, ( ULONG ) hb_arrayGetNL( pArray, ulPos ) ) )
if( ! BM_GetBit( ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap, ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->Size, ( HB_ULONG ) hb_arrayGetNL( pArray, ulPos ) ) )
{
BM_SetBit( ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap, ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->Size, ( ULONG ) hb_arrayGetNL( pArray, ulPos ) );
BM_SetBit( ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap, ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->Size, ( HB_ULONG ) hb_arrayGetNL( pArray, ulPos ) );
ulAdd++;
}
pTag = hb_cdxGetActiveTag( (CDXAREAP) pArea );
@@ -7054,7 +7054,7 @@ HB_FUNC( BM_DBSETFILTERARRAYDEL )
{
AREAP pArea = (AREAP) hb_rddGetCurrentWorkAreaPointer();
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
ULONG ulPos,ulDel = 0;
HB_ULONG ulPos,ulDel = 0;
if( pArea && pArea->dbfi.fOptimized )
{
@@ -7063,9 +7063,9 @@ HB_FUNC( BM_DBSETFILTERARRAYDEL )
LPCDXTAG pTag;
for( ulPos = 1; ulPos <= hb_arrayLen( pArray ); ulPos++ )
if( BM_GetBit( ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap, ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->Size, ( ULONG ) hb_arrayGetNL( pArray, ulPos ) ) )
if( BM_GetBit( ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap, ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->Size, ( HB_ULONG ) hb_arrayGetNL( pArray, ulPos ) ) )
{
BM_ClrBit( ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap, ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->Size, ( ULONG ) hb_arrayGetNL( pArray, ulPos ) );
BM_ClrBit( ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->rmap, ( ( LPBM_FILTER ) pArea->dbfi.lpvCargo)->Size, ( HB_ULONG ) hb_arrayGetNL( pArray, ulPos ) );
ulDel++;
}
pTag = hb_cdxGetActiveTag( (CDXAREAP) pArea );
@@ -7139,7 +7139,7 @@ HB_FUNC( BM_DBSEEKWILD )
static HB_ERRCODE hb_cdxSkip( CDXAREAP pArea, HB_LONG lToSkip )
{
LPCDXTAG pTag;
ULONG ulPos, ulRec;
HB_ULONG ulPos, ulRec;
HB_TRACE(HB_TR_DEBUG, ("hb_cdxSkip(%p, %ld)", pArea, lToSkip));
@@ -7385,14 +7385,14 @@ static HB_ERRCODE hb_cdxAppend( CDXAREAP pArea, HB_BOOL bUnLockAll )
{
if( pArea->dbfarea.area.dbfi.fFilter && pArea->dbfarea.area.dbfi.fOptimized )
{
ULONG ulRecCount, bytes;
HB_ULONG ulRecCount, bytes;
SELF_RECCOUNT( ( AREAP ) pArea, &ulRecCount );
bytes = ( (ulRecCount + 1) >> 5 ) + 1;
if( ( (ulRecCount) >> 5 ) + 1 < bytes )
{
( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap = ( ULONG * ) hb_xrealloc( ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap, bytes << 2 );
( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap = ( HB_ULONG * ) hb_xrealloc( ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap, bytes << 2 );
( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->Size = ulRecCount;
}
pArea->dbfarea.area.dbfi.fFilter = HB_FALSE;
@@ -8167,7 +8167,7 @@ static HB_ERRCODE hb_cdxOrderListRebuild( CDXAREAP pArea )
*/
static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderInfo )
{
ULONG ulRecNo;
HB_ULONG ulRecNo;
HB_BOOL fNewFile, fOpenedIndex, fProd, fAscend = HB_TRUE, fNoCase = HB_FALSE,
fCustom = HB_FALSE, fTemporary = HB_FALSE, fExclusive = HB_FALSE;
PHB_ITEM pKeyExp, pForExp = NULL, pResult;
@@ -9379,7 +9379,7 @@ static HB_ERRCODE hb_cdxCountScope( CDXAREAP pArea, void * pPtr, HB_LONG * plRec
{
LPBM_FILTER pMap = (LPBM_FILTER) pArea->dbfarea.area.dbfi.lpvCargo;
if( pArea->dbfarea.area.dbfi.fFilter && pMap &&
!BM_GetBit( pMap->rmap, pMap->Size, ( ULONG ) *plRec ) )
!BM_GetBit( pMap->rmap, pMap->Size, ( HB_ULONG ) *plRec ) )
{
*plRec = 0;
}
@@ -9394,7 +9394,7 @@ static HB_ERRCODE hb_cdxCountScope( CDXAREAP pArea, void * pPtr, HB_LONG * plRec
/* ( DBENTRYP_VFI ) hb_cdxSetFilter */
static HB_ERRCODE hb_cdxSetFilter( CDXAREAP pArea, LPDBFILTERINFO pFilterInfo )
{
ULONG ulRecCount = 0, ulLogKeyCount = 0;
HB_ULONG ulRecCount = 0, ulLogKeyCount = 0;
LPCDXTAG pTag;
PHB_ITEM pResult;
@@ -9417,8 +9417,8 @@ static HB_ERRCODE hb_cdxSetFilter( CDXAREAP pArea, LPDBFILTERINFO pFilterInfo )
pTag = hb_cdxGetActiveTag( pArea );
SELF_RECCOUNT( ( AREAP ) pArea, &ulRecCount );
( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->Size = ulRecCount;
( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap = ( ULONG * ) hb_xgrab( sizeof( ULONG ) * (((ulRecCount+1) >> 5) + 1 ) );
memset( ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap, 0, sizeof( ULONG ) * (((ulRecCount+1) >> 5) + 1 ) );
( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap = ( HB_ULONG * ) hb_xgrab( sizeof( HB_ULONG ) * (((ulRecCount+1) >> 5) + 1 ) );
memset( ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap, 0, sizeof( HB_ULONG ) * (((ulRecCount+1) >> 5) + 1 ) );
if( pTag ) /* with active index */
{
@@ -9489,7 +9489,7 @@ static HB_ERRCODE hb_cdxSetFilter( CDXAREAP pArea, LPDBFILTERINFO pFilterInfo )
* Retrieve (set) information about RDD
* ( DBENTRYP_RSLV ) hb_fptFieldInfo
*/
static HB_ERRCODE hb_cdxRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem )
static HB_ERRCODE hb_cdxRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem )
{
LPDBFDATA pData;
@@ -9618,7 +9618,7 @@ static HB_BOOL hb_cdxQSort( LPCDXSORTINFO pSort, HB_BYTE * pSrc, HB_BYTE * pBuf,
static void hb_cdxSortSortPage( LPCDXSORTINFO pSort )
{
ULONG ulSize = pSort->ulKeys * ( pSort->keyLen + 4 );
HB_ULONG ulSize = pSort->ulKeys * ( pSort->keyLen + 4 );
#ifdef HB_CDX_DBGTIME
cdxTimeIdxBld -= hb_cdxGetTime();
#endif
@@ -9631,7 +9631,7 @@ static void hb_cdxSortSortPage( LPCDXSORTINFO pSort )
#endif
}
static void hb_cdxSortAddNodeKey( LPCDXSORTINFO pSort, int iLevel, HB_BYTE *pKeyVal, ULONG ulRec, ULONG ulPage )
static void hb_cdxSortAddNodeKey( LPCDXSORTINFO pSort, int iLevel, HB_BYTE *pKeyVal, HB_ULONG ulRec, HB_ULONG ulPage )
{
LPCDXPAGE pPage;
HB_BOOL fNew;
@@ -9745,7 +9745,7 @@ static void hb_cdxSortAddNodeKey( LPCDXSORTINFO pSort, int iLevel, HB_BYTE *pKey
static void hb_cdxSortWritePage( LPCDXSORTINFO pSort )
{
ULONG ulSize = pSort->ulKeys * ( pSort->keyLen + 4 );
HB_ULONG ulSize = pSort->ulKeys * ( pSort->keyLen + 4 );
hb_cdxSortSortPage( pSort );
@@ -9769,15 +9769,15 @@ static void hb_cdxSortWritePage( LPCDXSORTINFO pSort )
pSort->ulCurPage++;
}
static void hb_cdxSortGetPageKey( LPCDXSORTINFO pSort, ULONG ulPage,
HB_BYTE ** pKeyVal, ULONG *pulRec )
static void hb_cdxSortGetPageKey( LPCDXSORTINFO pSort, HB_ULONG ulPage,
HB_BYTE ** pKeyVal, HB_ULONG *pulRec )
{
int iLen = pSort->keyLen;
if( pSort->pSwapPage[ ulPage ].ulKeyBuf == 0 )
{
ULONG ulKeys = HB_MIN( pSort->ulPgKeys, pSort->pSwapPage[ ulPage ].ulKeys );
ULONG ulSize = ulKeys * ( iLen + 4 );
HB_ULONG ulKeys = HB_MIN( pSort->ulPgKeys, pSort->pSwapPage[ ulPage ].ulKeys );
HB_ULONG ulSize = 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, ulSize ) != ulSize )
@@ -9797,11 +9797,11 @@ static void hb_cdxSortOrderPages( LPCDXSORTINFO pSort )
{
int iLen = pSort->keyLen, i;
HB_LONG l, r, m;
ULONG n, ulPage, ulRec;
HB_ULONG n, ulPage, ulRec;
HB_BYTE *pKey = NULL, *pTmp;
pSort->ulFirst = 0;
pSort->pSortedPages = ( ULONG * ) hb_xgrab( pSort->ulPages * sizeof( ULONG ) );
pSort->pSortedPages = ( HB_ULONG * ) hb_xgrab( pSort->ulPages * sizeof( HB_ULONG ) );
pSort->pSortedPages[ 0 ] = 0;
if( pSort->ulTotKeys > 0 )
@@ -9831,11 +9831,11 @@ static void hb_cdxSortOrderPages( LPCDXSORTINFO pSort )
}
}
static HB_BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, HB_BYTE ** pKeyVal, ULONG *pulRec )
static HB_BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, HB_BYTE ** pKeyVal, HB_ULONG *pulRec )
{
int iLen = pSort->keyLen, i;
HB_LONG l, r, m;
ULONG ulPage;
HB_ULONG ulPage;
ulPage = pSort->pSortedPages[ pSort->ulFirst ];
@@ -9843,7 +9843,7 @@ static HB_BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, HB_BYTE ** pKeyVal, ULONG
if( pSort->pSwapPage[ ulPage ].ulKeys > 0 )
{
HB_BYTE *pKey, *pTmp;
ULONG ulRec;
HB_ULONG ulRec;
/*
* last key was taken from this page - we have to resort it.
@@ -9897,10 +9897,10 @@ static HB_BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, HB_BYTE ** pKeyVal, ULONG
#else
static HB_BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, HB_BYTE ** pKeyVal, ULONG *pulRec )
static HB_BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, HB_BYTE ** pKeyVal, HB_ULONG *pulRec )
{
int i, iLen = pSort->keyLen;
ULONG ulPage, ulKeyPage = 0, ulRec = 0, ulRecTmp;
HB_ULONG ulPage, ulKeyPage = 0, ulRec = 0, ulRecTmp;
HB_BYTE *pKey = NULL, *pTmp;
for( ulPage = 0; ulPage < pSort->ulPages; ulPage++ )
@@ -9942,7 +9942,7 @@ static HB_BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, HB_BYTE ** pKeyVal, ULONG
#endif
static void hb_cdxSortKeyAdd( LPCDXSORTINFO pSort, ULONG ulRec, HB_BYTE * pKeyVal, int iKeyLen )
static void hb_cdxSortKeyAdd( LPCDXSORTINFO pSort, HB_ULONG ulRec, HB_BYTE * pKeyVal, int iKeyLen )
{
int iLen = pSort->keyLen;
HB_BYTE *pDst;
@@ -9969,19 +9969,19 @@ static void hb_cdxSortKeyAdd( LPCDXSORTINFO pSort, ULONG ulRec, HB_BYTE * pKeyVa
pSort->ulTotKeys++;
}
static LPCDXSORTINFO hb_cdxSortNew( LPCDXTAG pTag, ULONG ulRecCount )
static LPCDXSORTINFO hb_cdxSortNew( LPCDXTAG pTag, HB_ULONG ulRecCount )
{
LPCDXSORTINFO pSort;
HB_BYTE * pBuf;
int iLen = pTag->uiLen;
ULONG ulSize, ulMax, ulMin;
HB_ULONG ulSize, ulMax, ulMin;
if( ulRecCount == 0 )
ulRecCount = 1;
pSort = ( LPCDXSORTINFO ) hb_xgrab( sizeof( CDXSORTINFO ) );
memset( pSort, 0, sizeof( CDXSORTINFO ) );
ulMax = ulMin = ( ULONG ) ceil( sqrt( ( double ) ulRecCount ) );
ulMax = ulMin = ( HB_ULONG ) ceil( sqrt( ( double ) ulRecCount ) );
ulSize = ( 1L << 20 ) / ( iLen + 4 );
while( ulMax < ulSize )
ulMax <<= 1;
@@ -10077,7 +10077,7 @@ static void hb_cdxSortFree( LPCDXSORTINFO pSort )
static void hb_cdxSortOut( LPCDXSORTINFO pSort )
{
HB_BOOL fUnique = pSort->fUnique, fNext;
ULONG ulPage, ulRec, ulKey;
HB_ULONG ulPage, ulRec, ulKey;
HB_BYTE * pKeyVal;
int iLen = pSort->keyLen, iLevel;
@@ -10194,7 +10194,7 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, HB_BOOL fReindex )
LPCDXAREA pArea = pTag->pIndex->pArea;
LPCDXSORTINFO pSort;
PHB_ITEM pForItem, pWhileItem = NULL, pEvalItem = NULL, pItem = NULL;
ULONG ulRecCount, ulRecNo = pArea->dbfarea.ulRecNo;
HB_ULONG ulRecCount, ulRecNo = pArea->dbfarea.ulRecNo;
HB_LONG lStep = 0;
PHB_CODEPAGE cdpTmp = hb_cdpSelect( pArea->dbfarea.area.cdPage );
@@ -10237,7 +10237,7 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, HB_BOOL fReindex )
else
{
HB_USHORT uiSaveTag = pArea->uiTag;
ULONG ulStartRec = 0, ulNextCount = 0;
HB_ULONG ulStartRec = 0, ulNextCount = 0;
HB_BOOL fDirectRead, fUseFilter = HB_FALSE;
HB_BYTE * pSaveRecBuff = pArea->dbfarea.pRecord, cTemp[8];
int iRecBuff = 0, iRecBufSize = USHRT_MAX / pArea->dbfarea.uiRecordLen, iRec;
@@ -10307,11 +10307,11 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, HB_BOOL fReindex )
break;
if( iRecBuff == 0 || iRecBuff >= iRecBufSize )
{
if( ulRecCount - ulRecNo >= ( ULONG ) iRecBufSize )
if( ulRecCount - ulRecNo >= ( HB_ULONG ) iRecBufSize )
iRec = iRecBufSize;
else
iRec = ulRecCount - ulRecNo + 1;
if( ulNextCount > 0 && ulNextCount < ( ULONG ) iRec )
if( ulNextCount > 0 && ulNextCount < ( HB_ULONG ) iRec )
iRec = ( int ) ulNextCount;
hb_fileReadAt( pArea->dbfarea.pDataFile, pSort->pRecBuff, pArea->dbfarea.uiRecordLen * iRec,
( HB_FOFFSET ) pArea->dbfarea.uiHeaderLen +

96
harbour/contrib/hbbmcdx/hbbmcdx.h
View File

@@ -256,15 +256,15 @@ typedef struct _CDXKEY
HB_BYTE * val;
HB_USHORT len;
HB_USHORT mode;
ULONG rec;
HB_ULONG rec;
} CDXKEY;
typedef CDXKEY * LPCDXKEY;
typedef struct _CDXPAGE
{
ULONG Page;
ULONG Left;
ULONG Right;
HB_ULONG Page;
HB_ULONG Left;
HB_ULONG Right;
HB_BYTE PageType;
int iKeys;
@@ -273,7 +273,7 @@ typedef struct _CDXPAGE
HB_BOOL fChanged;
HB_BYTE bUsed;
ULONG RNMask;
HB_ULONG RNMask;
HB_BYTE ReqByte;
HB_BYTE RNBits;
HB_BYTE DCBits;
@@ -311,7 +311,7 @@ typedef CDXSTACK * LPCDXSTACK;
typedef struct _CDXLIST
{
ULONG ulAddr;
HB_ULONG ulAddr;
HB_BOOL fStat;
struct _CDXLIST * pNext;
} CDXLIST;
@@ -347,15 +347,15 @@ typedef struct _CDXTAG
HB_BOOL fRePos;
int curKeyState; /* see: CDX_CURKEY_* */
ULONG rawKeyCount;
ULONG rawKeyPos;
ULONG rawKeyRec;
ULONG logKeyCount;
ULONG logKeyPos;
ULONG logKeyRec;
HB_ULONG rawKeyCount;
HB_ULONG rawKeyPos;
HB_ULONG rawKeyRec;
HB_ULONG logKeyCount;
HB_ULONG logKeyPos;
HB_ULONG logKeyRec;
ULONG TagBlock; /* a page offset where a tag header is stored */
ULONG RootBlock; /* a page offset with the root of keys tree */
HB_ULONG TagBlock; /* a page offset where a tag header is stored */
HB_ULONG RootBlock; /* a page offset with the root of keys tree */
HB_USHORT MaxKeys; /* maximum number of keys in Interior node */
struct _CDXINDEX * pIndex; /* a parent index info */
@@ -388,8 +388,8 @@ typedef struct _CDXINDEX
HB_BOOL fShared; /* Shared file */
HB_BOOL fReadonly; /* Read only file */
HB_BOOL fDelete; /* delete on close flag */
ULONG nextAvail; /* offset to next free page in the end of index file */
ULONG freePage; /* offset to next free page inside index file */
HB_ULONG nextAvail; /* offset to next free page in the end of index file */
HB_ULONG freePage; /* offset to next free page inside index file */
LPCDXLIST freeLst; /* list of free pages in index file */
int lockWrite; /* number of write lock set */
int lockRead; /* number of read lock set */
@@ -399,7 +399,7 @@ typedef struct _CDXINDEX
HB_BOOL WrLck;
#endif
HB_BOOL fChanged; /* changes written to index, need upadte ulVersion */
ULONG ulVersion; /* network version/update flag */
HB_ULONG ulVersion; /* network version/update flag */
HB_BOOL fFlush; /* changes written to index, need upadte ulVersion */
} CDXINDEX;
typedef CDXINDEX * LPCDXINDEX;
@@ -408,39 +408,39 @@ typedef CDXINDEX * LPCDXINDEX;
typedef struct
{
HB_FOFFSET nOffset; /* offset in temporary file */
ULONG ulKeys; /* number of keys in page */
ULONG ulKeyBuf; /* number of keys in memory buffer */
ULONG ulCurKey; /* current key in memory buffer */
HB_ULONG ulKeys; /* number of keys in page */
HB_ULONG ulKeyBuf; /* number of keys in memory buffer */
HB_ULONG ulCurKey; /* current key in memory buffer */
HB_BYTE * pKeyPool; /* memory buffer */
} CDXSWAPPAGE;
typedef CDXSWAPPAGE * LPCDXSWAPPAGE;
typedef struct
{
LPCDXTAG pTag; /* current Tag */
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 */
ULONG ulMaxRec; /* the highest record number */
ULONG ulTotKeys; /* total number of keys indexed */
ULONG ulKeys; /* keys in curently created page */
ULONG ulPages; /* number of pages */
ULONG ulCurPage; /* current page */
ULONG ulPgKeys; /* maximum number of key in page memory buffer */
ULONG ulMaxKey; /* maximum number of keys in single page */
HB_BYTE * pKeyPool; /* memory buffer for current page then for pages */
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 */
ULONG ulFirst;
ULONG * pSortedPages;
HB_BYTE pLastKey[ CDX_MAXKEY ]; /* last key val */
ULONG ulLastRec;
HB_BYTE * pRecBuff;
LPCDXPAGE NodeList[ CDX_STACKSIZE ]; /* Stack of pages */
HB_ULONG ulFirst;
HB_ULONG * pSortedPages;
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;
@@ -487,12 +487,12 @@ typedef CDXAREA * LPCDXAREA;
typedef struct _BM_FILTER_
{
PHB_ITEM itmCobExpr; /* Block representation of the FILTER expression */
PHB_ITEM abFilterText; /* String representation of FILTER expression */
HB_BOOL fFilter; /* flag to indicate that filter is active */
HB_BOOL fOptimized; /* Is (should be) filter optimized */
ULONG * rmap;
ULONG Size;
PHB_ITEM itmCobExpr; /* Block representation of the FILTER expression */
PHB_ITEM abFilterText; /* String representation of FILTER expression */
HB_BOOL fFilter; /* flag to indicate that filter is active */
HB_BOOL fOptimized; /* Is (should be) filter optimized */
HB_ULONG * rmap;
HB_ULONG Size;
} BM_FILTER;
typedef BM_FILTER * LPBM_FILTER;
@@ -603,7 +603,7 @@ static HB_ERRCODE hb_cdxSetFilter( CDXAREAP pArea, LPDBFILTERINFO pFilterInfo );
#define hb_cdxDrop NULL
#define hb_cdxExists NULL
#define hb_cdxRename NULL
static HB_ERRCODE hb_cdxRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem );
static HB_ERRCODE hb_cdxRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem );
#define hb_cdxWhoCares NULL
HB_EXTERN_END

152
harbour/contrib/hbbtree/hb_btree.c
View File

@@ -115,8 +115,8 @@ HB_EXTERN_BEGIN
typedef struct stack_item
{
ULONG ulNode;
int iPosition;
HB_ULONG ulNode;
int iPosition;
} BTreeStackItem;
typedef struct stack_tag
@@ -133,14 +133,14 @@ typedef struct ioBuffer_tag
{
struct ioBuffer_tag *prev, *next;
union {
ULONG ulPage; /* not in-memory */
HB_ULONG ulPage; /* not in-memory */
struct ioBuffer_tag * pPage; /* in-memory */
} xPage;
HB_BOOL IsDirty;
/* was: Buffer_T pBuffer; */
ULONG * pulPageCount; /* TODO: use LE get macro to retrieve this; better yet, dont use this */
ULONG * pulBranch;
HB_ULONG * pulPageCount; /* TODO: use LE get macro to retrieve this; better yet, dont use this */
HB_ULONG * pulBranch;
union {
HB_LONG * plData; /* not in-memory */
PHB_ITEM * ppData; /* in-memory */
@@ -190,14 +190,14 @@ struct hb_BTree
{
char * szFileName;
HB_FHANDLE hFile;
ULONG ulRootPage;
ULONG ulFreePage;
HB_ULONG ulRootPage;
HB_ULONG ulFreePage;
HB_USHORT usPageSize;
HB_USHORT usKeySize;
HB_USHORT usMaxKeys;
HB_USHORT usMinKeys;
hb_BTreeFlags_T ulFlags;
ULONG ulKeyCount;
HB_ULONG ulKeyCount;
hb_KeyData_T * pThisKeyData;
BTreeStack * pStack;
ioBuffer_T * ioBuffer;
@@ -218,19 +218,19 @@ static int s_BTree_List_Count = 0;
/* forward declarations */
static HB_USHORT CountGet( struct hb_BTree * pBTree, ULONG ulNode );
static hb_KeyData_T *KeyGet( struct hb_BTree * pBTree, ULONG ulNode, int iPosition, hb_KeyData_T *buffer );
static ULONG BranchGet( struct hb_BTree * pBTree, ULONG ulNode, int iPosition );
static HB_USHORT CountGet( struct hb_BTree * pBTree, HB_ULONG ulNode );
static hb_KeyData_T *KeyGet( struct hb_BTree * pBTree, HB_ULONG ulNode, int iPosition, hb_KeyData_T *buffer );
static HB_ULONG BranchGet( struct hb_BTree * pBTree, HB_ULONG ulNode, int iPosition );
/* end of forward declarations */
static void raiseError( ULONG ulGenCode, ULONG ulSubCode, const char * szDescription, const char * szOperation, int uiArguments )
static void raiseError( HB_ULONG ulGenCode, HB_ULONG ulSubCode, const char * szDescription, const char * szOperation, int uiArguments )
{
PHB_ITEM pErr = hb_errRT_New(
ES_ERROR /* HB_USHORT uiSeverity */,
"HB_BTREE" /* const char * szSubSystem */,
ulGenCode /* ULONG ulGenCode */,
ulSubCode /* ULONG ulSubCode */,
ulGenCode /* HB_ULONG ulGenCode */,
ulSubCode /* HB_ULONG ulSubCode */,
szDescription /* const char * szDescription */,
szOperation /* const char * szOperation */,
0 /* HB_ERRCODE uiOsCode */,
@@ -246,7 +246,7 @@ static void raiseError( ULONG ulGenCode, ULONG ulSubCode, const char * szDescrip
hb_errRelease( pErr );
}
static void * BufferRealloc( void *buffer, ULONG size )
static void * BufferRealloc( void *buffer, HB_ULONG size )
{
void *tmpBuffer = hb_xgrab( size );
@@ -272,8 +272,8 @@ static ioBuffer_T * ioOneBufferAlloc( struct hb_BTree * pBTree, ioBuffer_T * pre
thisptr = ( ioBuffer_T * ) BufferAlloc( sizeof( ioBuffer_T ) + pBTree->usPageSize );
hb_xmemset( thisptr, '\0', sizeof( ioBuffer_T ) + pBTree->usPageSize );
thisptr->pulPageCount = ( ULONG * )( thisptr->Buffer );
thisptr->pulBranch = ( ULONG * )&thisptr->pulPageCount[ 1 ];
thisptr->pulPageCount = ( HB_ULONG * )( thisptr->Buffer );
thisptr->pulBranch = ( HB_ULONG * )&thisptr->pulPageCount[ 1 ];
if ( GETFLAG( pBTree, IsInMemory ) )
{
@@ -297,7 +297,7 @@ static ioBuffer_T * ioOneBufferAlloc( struct hb_BTree * pBTree, ioBuffer_T * pre
}
/* a link list 'most recently access' page buffering system */
static void ioBufferAlloc( struct hb_BTree * pBTree, ULONG ulBuffers )
static void ioBufferAlloc( struct hb_BTree * pBTree, HB_ULONG ulBuffers )
{
ioBuffer_T *thisptr = NULL, *last = NULL;
@@ -333,7 +333,7 @@ static void ioBufferWrite( struct hb_BTree * pBTree, ioBuffer_T *thisptr )
thisptr->IsDirty = HB_FALSE;
}
static void ioBufferRead( struct hb_BTree * pBTree, ULONG ulNode )
static void ioBufferRead( struct hb_BTree * pBTree, HB_ULONG ulNode )
{
ioBuffer_T *thisptr = pBTree->ioBuffer;
@@ -350,7 +350,7 @@ static void ioBufferRead( struct hb_BTree * pBTree, ULONG ulNode )
static void ioBufferRelease( struct hb_BTree * pBTree )
{
ioBuffer_T *next, *thisptr;
ULONG n;
HB_ULONG n;
for ( thisptr = pBTree->ioBuffer; thisptr; thisptr = next )
{
@@ -384,7 +384,7 @@ static void ioBufferRelease( struct hb_BTree * pBTree )
}
#endif
static void ioBufferScan( struct hb_BTree * pBTree, ULONG page )
static void ioBufferScan( struct hb_BTree * pBTree, HB_ULONG page )
{
ioBuffer_T *thisptr;
ioBuffer_T *thisnext, *thisprev;
@@ -432,7 +432,7 @@ static void StackNew( BTreeStack **pStack )
( *pStack )->usCount = 0;
}
static void StackPush( BTreeStack **pStack, ULONG ulNode, int iPosition )
static void StackPush( BTreeStack **pStack, HB_ULONG ulNode, int iPosition )
{
*pStack = ( BTreeStack * )BufferRealloc( *pStack, sizeof( **pStack ) + ( ( *pStack )->usCount + 1 ) * sizeof( ( *pStack )->items[ 0 ] ) );
( *pStack )->items[ ( *pStack )->usCount ].ulNode = ulNode;
@@ -440,7 +440,7 @@ static void StackPush( BTreeStack **pStack, ULONG ulNode, int iPosition )
( *pStack )->usCount++;
}
static void StackPop( BTreeStack **pStack, ULONG *pulNode, int *piPosition )
static void StackPop( BTreeStack **pStack, HB_ULONG *pulNode, int *piPosition )
{
if ( ( *pStack )->usCount )
{
@@ -451,7 +451,7 @@ static void StackPop( BTreeStack **pStack, ULONG *pulNode, int *piPosition )
}
}
static void StackPeek( BTreeStack **pStack, ULONG *pulNode, int *piPosition )
static void StackPeek( BTreeStack **pStack, HB_ULONG *pulNode, int *piPosition )
{
if ( ( *pStack )->usCount )
{
@@ -467,7 +467,7 @@ static void StackPeek( BTreeStack **pStack, ULONG *pulNode, int *piPosition )
static HB_LONG StackSkip( struct hb_BTree * pBTree, BTreeStack **pStack, HB_LONG records )
{
ULONG ulNode;
HB_ULONG ulNode;
int iPosition;
HB_LONG recordsskipped = 0;
@@ -619,7 +619,7 @@ static void HeaderWrite( struct hb_BTree * pBTree )
}
}
static ULONG Grow( struct hb_BTree * pBTree )
static HB_ULONG Grow( struct hb_BTree * pBTree )
{
HB_TRACE( HB_TR_DEBUG, ( SRCLINENO ) );
@@ -661,12 +661,12 @@ static ULONG Grow( struct hb_BTree * pBTree )
return pBTree->ioBuffer->xPage.ulPage;
}
static void Prune( struct hb_BTree * pBTree, ULONG ulNode )
static void Prune( struct hb_BTree * pBTree, HB_ULONG ulNode )
{
if ( GETFLAG( pBTree, IsInMemory ) )
{
ioBuffer_T * thisptr;
ULONG n;
HB_ULONG n;
for ( thisptr = pBTree->ioBuffer; thisptr && thisptr->xPage.ulPage != ulNode; thisptr = thisptr->next )
;
@@ -696,20 +696,20 @@ static void Prune( struct hb_BTree * pBTree, ULONG ulNode )
}
}
static HB_USHORT CountGet( struct hb_BTree * pBTree, ULONG ulNode )
static HB_USHORT CountGet( struct hb_BTree * pBTree, HB_ULONG ulNode )
{
READPAGE_IF_NEEDED( pBTree, ulNode );
return ( HB_USHORT )( *pBTree->ioBuffer->pulPageCount );
}
static void CountSet( struct hb_BTree * pBTree, ULONG ulNode, ULONG newPageCount )
static void CountSet( struct hb_BTree * pBTree, HB_ULONG ulNode, HB_ULONG newPageCount )
{
READPAGE_IF_NEEDED( pBTree, ulNode );
*pBTree->ioBuffer->pulPageCount = newPageCount;
pBTree->ioBuffer->IsDirty = pBTree->IsDirtyFlagAssignment;
}
static HB_USHORT CountAdj( struct hb_BTree * pBTree, ULONG ulNode, HB_LONG adjPageCount )
static HB_USHORT CountAdj( struct hb_BTree * pBTree, HB_ULONG ulNode, HB_LONG adjPageCount )
{
READPAGE_IF_NEEDED( pBTree, ulNode );
@@ -719,9 +719,9 @@ static HB_USHORT CountAdj( struct hb_BTree * pBTree, ULONG ulNode, HB_LONG adjPa
return ( HB_USHORT )*pBTree->ioBuffer->pulPageCount;
}
static void NodeCopy( struct hb_BTree * pBTree, ULONG toNode, int toPosition, ULONG fromNode, int fromPosition, hb_KeyData_T *buffer )
static void NodeCopy( struct hb_BTree * pBTree, HB_ULONG toNode, int toPosition, HB_ULONG fromNode, int fromPosition, hb_KeyData_T *buffer )
{
ULONG ulBranch;
HB_ULONG ulBranch;
HB_LONG lData = 0;
PHB_ITEM pData = NULL;
@@ -754,14 +754,14 @@ static void NodeCopy( struct hb_BTree * pBTree, ULONG toNode, int toPosition, UL
pBTree->ioBuffer->IsDirty = pBTree->IsDirtyFlagAssignment;
}
static ULONG BranchGet( struct hb_BTree * pBTree, ULONG ulNode, int iPosition )
static HB_ULONG BranchGet( struct hb_BTree * pBTree, HB_ULONG ulNode, int iPosition )
{
READPAGE_IF_NEEDED( pBTree, ulNode );
return pBTree->ioBuffer->pulBranch[ iPosition ];
}
#if defined( DEBUG )
static void Chk4Loop( struct hb_BTree * pBTree, ULONG ulNode, int iPosition, ULONG ulBranch )
static void Chk4Loop( struct hb_BTree * pBTree, HB_ULONG ulNode, int iPosition, HB_ULONG ulBranch )
{
/*
int i;
@@ -785,7 +785,7 @@ static void Chk4Loop( struct hb_BTree * pBTree, ULONG ulNode, int iPosition, ULO
}
#endif
static void BranchSet( struct hb_BTree * pBTree, ULONG ulNode, int iPosition, ULONG ulBranch )
static void BranchSet( struct hb_BTree * pBTree, HB_ULONG ulNode, int iPosition, HB_ULONG ulBranch )
{
READPAGE_IF_NEEDED( pBTree, ulNode );
/*
@@ -804,7 +804,7 @@ static void BranchSet( struct hb_BTree * pBTree, ULONG ulNode, int iPosition, UL
/* if the parameter is null, allocate a buffer - it is the */
/* callers responsibility to release the buffer */
static hb_KeyData_T *KeyGet( struct hb_BTree * pBTree, ULONG ulNode, int iPosition, hb_KeyData_T *buffer )
static hb_KeyData_T *KeyGet( struct hb_BTree * pBTree, HB_ULONG ulNode, int iPosition, hb_KeyData_T *buffer )
{
READPAGE_IF_NEEDED( pBTree, ulNode );
@@ -825,7 +825,7 @@ static hb_KeyData_T *KeyGet( struct hb_BTree * pBTree, ULONG ulNode, int iPositi
return buffer;
}
static void KeySet( struct hb_BTree * pBTree, ULONG ulNode, int iPosition, hb_KeyData_T *key )
static void KeySet( struct hb_BTree * pBTree, HB_ULONG ulNode, int iPosition, hb_KeyData_T *key )
{
READPAGE_IF_NEEDED( pBTree, ulNode );
@@ -855,7 +855,7 @@ static HB_LONG KeyCompare( struct hb_BTree * pBTree, hb_KeyData_T *left, hb_KeyD
return lResults;
}
static HB_BOOL SearchNode( struct hb_BTree * pBTree, hb_KeyData_T *target, ULONG ulNode, int *iPosition )
static HB_BOOL SearchNode( struct hb_BTree * pBTree, hb_KeyData_T *target, HB_ULONG ulNode, int *iPosition )
{
HB_BOOL results;
hb_KeyData_T *buffer = ( hb_KeyData_T * ) BufferAlloc( sizeof( hb_KeyData_T ) + pBTree->usKeySize + 1 );
@@ -905,9 +905,9 @@ static HB_BOOL SearchNode( struct hb_BTree * pBTree, hb_KeyData_T *target, ULONG
return results;
}
static ULONG hb_BTreeSearch( struct hb_BTree * pBTree, hb_KeyData_T *target, int *targetpos, BTreeStack **pStack )
static HB_ULONG hb_BTreeSearch( struct hb_BTree * pBTree, hb_KeyData_T *target, int *targetpos, BTreeStack **pStack )
{
ULONG ulNode = pBTree->ulRootPage;
HB_ULONG ulNode = pBTree->ulRootPage;
while ( ulNode && !SearchNode( pBTree, target, ulNode, targetpos ) )
{
@@ -926,7 +926,7 @@ static ULONG hb_BTreeSearch( struct hb_BTree * pBTree, hb_KeyData_T *target, int
return ulNode;
}
static void PushIn( struct hb_BTree * pBTree, hb_KeyData_T *xkey, ULONG xbranch, ULONG ulNode, int iPosition )
static void PushIn( struct hb_BTree * pBTree, hb_KeyData_T *xkey, HB_ULONG xbranch, HB_ULONG ulNode, int iPosition )
{
hb_KeyData_T *buffer = ( hb_KeyData_T * ) BufferAlloc( sizeof( hb_KeyData_T ) + pBTree->usKeySize + 1 );
int i;
@@ -942,7 +942,7 @@ static void PushIn( struct hb_BTree * pBTree, hb_KeyData_T *xkey, ULONG xbranch,
BufferRelease( buffer );
}
static void Split( struct hb_BTree * pBTree, hb_KeyData_T *xkey, ULONG xbranch, ULONG ulNode, int iPosition, hb_KeyData_T **ykey, ULONG *ybranch )
static void Split( struct hb_BTree * pBTree, hb_KeyData_T *xkey, HB_ULONG xbranch, HB_ULONG ulNode, int iPosition, hb_KeyData_T **ykey, HB_ULONG *ybranch )
{
int i;
int median;
@@ -977,14 +977,14 @@ static void Split( struct hb_BTree * pBTree, hb_KeyData_T *xkey, ULONG xbranch,
}
#ifdef DEBUG
static ULONG sulMaxPushDownDepth = 0;
static HB_ULONG sulMaxPushDownDepth = 0;
#endif
static HB_BOOL PushDown( struct hb_BTree * pBTree, hb_KeyData_T *newkey, ULONG ulNode, hb_KeyData_T **xkey, ULONG *xbranch )
static HB_BOOL PushDown( struct hb_BTree * pBTree, hb_KeyData_T *newkey, HB_ULONG ulNode, hb_KeyData_T **xkey, HB_ULONG *xbranch )
{
int iPosition;
#ifdef DEBUG
static ULONG PushDownDepth = 0;
static HB_ULONG PushDownDepth = 0;
if( ++PushDownDepth > sulMaxPushDownDepth )
{
@@ -1028,8 +1028,8 @@ static HB_BOOL PushDown( struct hb_BTree * pBTree, hb_KeyData_T *newkey, ULONG u
HB_BOOL hb_BTreeInsert( struct hb_BTree * pBTree, const char * szKey, PHB_ITEM pData )
{
hb_KeyData_T *xkey = ( hb_KeyData_T * ) BufferAlloc( sizeof( hb_KeyData_T ) + pBTree->usKeySize + 1 );
ULONG xbranch;
ULONG newnode;
HB_ULONG xbranch;
HB_ULONG newnode;
HB_TRACE( HB_TR_DEBUG, ( SRCLINENO ) );
@@ -1068,10 +1068,10 @@ HB_BOOL hb_BTreeInsert( struct hb_BTree * pBTree, const char * szKey, PHB_ITEM p
return !GETFLAG( pBTree, IsDuplicateKey );
}
static void MoveRight( struct hb_BTree * pBTree, ULONG ulNode, int iPosition )
static void MoveRight( struct hb_BTree * pBTree, HB_ULONG ulNode, int iPosition )
{
int c;
ULONG tmpnode;
HB_ULONG tmpnode;
hb_KeyData_T *buffer = ( hb_KeyData_T * ) BufferAlloc( sizeof( hb_KeyData_T ) + pBTree->usKeySize + 1 );
tmpnode = BranchGet( pBTree, ulNode, iPosition );
@@ -1091,10 +1091,10 @@ static void MoveRight( struct hb_BTree * pBTree, ULONG ulNode, int iPosition )
BufferRelease( buffer );
}
static void MoveLeft( struct hb_BTree * pBTree, ULONG ulNode, int iPosition )
static void MoveLeft( struct hb_BTree * pBTree, HB_ULONG ulNode, int iPosition )
{
int c, c_count;
ULONG tmpnode;
HB_ULONG tmpnode;
hb_KeyData_T *buffer = ( hb_KeyData_T * ) BufferAlloc( sizeof( hb_KeyData_T ) + pBTree->usKeySize + 1 );
tmpnode = BranchGet( pBTree, ulNode, iPosition - 1 );
@@ -1115,12 +1115,12 @@ static void MoveLeft( struct hb_BTree * pBTree, ULONG ulNode, int iPosition )
BufferRelease( buffer );
}
static void Combine( struct hb_BTree * pBTree, ULONG ulNode, int iPosition )
static void Combine( struct hb_BTree * pBTree, HB_ULONG ulNode, int iPosition )
{
int c, c_count;
ULONG tmpnode;
ULONG leftnode;
ULONG leftpagecount;
HB_ULONG tmpnode;
HB_ULONG leftnode;
HB_ULONG leftpagecount;
hb_KeyData_T *buffer = ( hb_KeyData_T * ) BufferAlloc( sizeof( hb_KeyData_T ) + pBTree->usKeySize + 1 );
tmpnode = BranchGet( pBTree, ulNode, iPosition );
@@ -1147,7 +1147,7 @@ static void Combine( struct hb_BTree * pBTree, ULONG ulNode, int iPosition )
BufferRelease( buffer );
}
static void Restore( struct hb_BTree * pBTree, ULONG ulNode, int iPosition )
static void Restore( struct hb_BTree * pBTree, HB_ULONG ulNode, int iPosition )
{
READPAGE_IF_NEEDED( pBTree, ulNode );
@@ -1185,7 +1185,7 @@ static void Restore( struct hb_BTree * pBTree, ULONG ulNode, int iPosition )
Combine( pBTree, ulNode, iPosition );
}
static void Remove( struct hb_BTree * pBTree, ULONG ulNode, int iPosition )
static void Remove( struct hb_BTree * pBTree, HB_ULONG ulNode, int iPosition )
{
int c, c_count;
hb_KeyData_T *buffer = ( hb_KeyData_T * ) BufferAlloc( sizeof( hb_KeyData_T ) + pBTree->usKeySize + 1 );
@@ -1199,9 +1199,9 @@ static void Remove( struct hb_BTree * pBTree, ULONG ulNode, int iPosition )
BufferRelease( buffer );
}
static void Successor( struct hb_BTree * pBTree, ULONG ulNode, int iPosition )
static void Successor( struct hb_BTree * pBTree, HB_ULONG ulNode, int iPosition )
{
ULONG tmpnode;
HB_ULONG tmpnode;
hb_KeyData_T *buffer;
for ( tmpnode = BranchGet( pBTree, ulNode, iPosition );
@@ -1213,12 +1213,12 @@ static void Successor( struct hb_BTree * pBTree, ULONG ulNode, int iPosition )
}
#ifdef DEBUG
static ULONG sulMaxRecDeleteDepth = 0;
static HB_ULONG sulMaxRecDeleteDepth = 0;
#endif
static HB_BOOL RecDelete( struct hb_BTree * pBTree, hb_KeyData_T *target, ULONG ulNode )
static HB_BOOL RecDelete( struct hb_BTree * pBTree, hb_KeyData_T *target, HB_ULONG ulNode )
{
#ifdef DEBUG
static ULONG RecDeleteDepth = 0;
static HB_ULONG RecDeleteDepth = 0;
#endif
int iPosition;
@@ -1270,9 +1270,9 @@ static HB_BOOL RecDelete( struct hb_BTree * pBTree, hb_KeyData_T *target, ULONG
}
#if 0
static HB_BOOL __RecDelete( struct hb_BTree * pBTree, hb_KeyData_T target, ULONG ulNode )
static HB_BOOL __RecDelete( struct hb_BTree * pBTree, hb_KeyData_T target, HB_ULONG ulNode )
{
static ULONG RecDeleteDepth = 0;
static HB_ULONG RecDeleteDepth = 0;
HB_BOOL found = HB_FALSE;
if( ++RecDeleteDepth > sulMaxRecDeleteDepth )
@@ -1314,7 +1314,7 @@ static HB_BOOL RecDelete( struct hb_BTree * pBTree, hb_KeyData_T *target, ULONG
/* if ( GETFLAG( pBTree, IsRecordFound )*/ /*!tree->bRecordNotFound )*/
{
ULONG tmpNode;
HB_ULONG tmpNode;
tmpNode = BranchGet( pBTree, ulNode, iPosition );
if ( !BTREENODEISNULL( pBTree, tmpNode ) )
@@ -1336,7 +1336,7 @@ static HB_BOOL RecDelete( struct hb_BTree * pBTree, hb_KeyData_T *target, ULONG
HB_BOOL hb_BTreeDelete( struct hb_BTree * pBTree, const char *target, HB_LONG lData )
{
ULONG ulNode;
HB_ULONG ulNode;
int iPosition;
hb_KeyData_T *tmpTarget;
HB_BOOL found = HB_FALSE;
@@ -1378,8 +1378,8 @@ HB_BOOL hb_BTreeDelete( struct hb_BTree * pBTree, const char *target, HB_LONG lD
void hb_BTreeGoTop( struct hb_BTree * pBTree )
{
ULONG ulNode;
ULONG ulLastNode;
HB_ULONG ulNode;
HB_ULONG ulLastNode;
for ( ulLastNode = ulNode = pBTree->ulRootPage; !BTREENODEISNULL( pBTree, ulNode ); ulLastNode = ulNode, ulNode = BranchGet( pBTree, ulNode, 0 ) )
;
@@ -1392,8 +1392,8 @@ void hb_BTreeGoTop( struct hb_BTree * pBTree )
void hb_BTreeGoBottom( struct hb_BTree * pBTree )
{
ULONG ulNode;
ULONG ulLastNode;
HB_ULONG ulNode;
HB_ULONG ulLastNode;
for ( ulLastNode = ulNode = pBTree->ulRootPage; !BTREENODEISNULL( pBTree, ulNode ); ulLastNode = ulNode, ulNode = BranchGet( pBTree, ulNode, CountGet( pBTree, ulNode ) ) )
;
@@ -1472,7 +1472,7 @@ static int hb_BTstrncmp( const char *s1, const char *s2, size_t n )
}
/* allocate hb_BTree structure */
struct hb_BTree * hb_BTreeNew( const char * FileName, HB_USHORT usPageSize, HB_USHORT usKeySize, ULONG ulFlags, ULONG ulBuffers )
struct hb_BTree * hb_BTreeNew( const char * FileName, HB_USHORT usPageSize, HB_USHORT usKeySize, HB_ULONG ulFlags, HB_ULONG ulBuffers )
{
struct hb_BTree *pBTree = ( struct hb_BTree * ) BufferAlloc( sizeof( struct hb_BTree ) );
int iFileIOmode;
@@ -1577,7 +1577,7 @@ struct hb_BTree * hb_BTreeNew( const char * FileName, HB_USHORT usPageSize, HB_U
}
/* open an existing structure */
struct hb_BTree *hb_BTreeOpen( const char *FileName, ULONG ulFlags, ULONG ulBuffers )
struct hb_BTree *hb_BTreeOpen( const char *FileName, HB_ULONG ulFlags, HB_ULONG ulBuffers )
{
struct hb_BTree *pBTree = ( struct hb_BTree * ) BufferAlloc( sizeof( struct hb_BTree ) );
HB_BYTE TmpHeader[ HB_BTREE_HEADERSIZE ];
@@ -1715,7 +1715,7 @@ static struct hb_BTree *BTree_GetTreeIndex( const char * GetSource )
return s_BTree_List[ index - 1 ];
}
HB_FUNC( HB_BTREEOPEN ) /* hb_BTreeOpen( CHAR cFileName, ULONG ulFlags [ , int nBuffers=1 ] ) -> hb_Btree_Handle */
HB_FUNC( HB_BTREEOPEN ) /* hb_BTreeOpen( CHAR cFileName, HB_ULONG ulFlags [ , int nBuffers=1 ] ) -> hb_Btree_Handle */
{
HB_TRACE( HB_TR_DEBUG, ( SRCLINENO ) );
if ( HB_ISCHAR( 1 ) && hb_parclen( 1 ) > 0 )
@@ -1729,11 +1729,11 @@ HB_FUNC( HB_BTREEOPEN ) /* hb_BTreeOpen( CHAR cFileName, ULONG ulFlags [ , int
}
}
HB_FUNC( HB_BTREENEW ) /* hb_BTreeNew( CHAR cFileName, int nPageSize, int nKeySize, [ ULONG ulFlags ], [ int nBuffers=1 ] ) -> hb_Btree_Handle */
HB_FUNC( HB_BTREENEW ) /* hb_BTreeNew( CHAR cFileName, int nPageSize, int nKeySize, [ HB_ULONG ulFlags ], [ int nBuffers=1 ] ) -> hb_Btree_Handle */
{
int iPageSize = hb_parni( 2 );
int iKeySize = hb_parni( 3 );
ULONG ulFlags = hb_parnl( 4 );
HB_ULONG ulFlags = hb_parnl( 4 );
int iMaxKeys = MAXKEYS( ( HB_U32 ) iPageSize, ( HB_U32 ) iKeySize, ulFlags );
int iMinKeys = MINKEYS( iMaxKeys );

4
harbour/contrib/hbbtree/hb_btree.h
View File

@@ -42,8 +42,8 @@ HB_EXTERN_BEGIN
struct hb_BTree;
struct hb_BTree * hb_BTreeNew( const char * FileName, HB_USHORT usPageSize, HB_USHORT usKeySize, ULONG ulFlags, ULONG ulBuffers );
struct hb_BTree *hb_BTreeOpen( const char *FileName, ULONG ulFlags, ULONG ulBuffers );
struct hb_BTree * hb_BTreeNew( const char * FileName, HB_USHORT usPageSize, HB_USHORT usKeySize, HB_ULONG ulFlags, HB_ULONG ulBuffers );
struct hb_BTree *hb_BTreeOpen( const char *FileName, HB_ULONG ulFlags, HB_ULONG ulBuffers );
void hb_BTreeClose( struct hb_BTree * pBTree );
HB_BOOL hb_BTreeInsert( struct hb_BTree * pBTree, const char * szKey, PHB_ITEM pData );
HB_BOOL hb_BTreeDelete( struct hb_BTree * pBTree, const char * szKey, HB_LONG lData );

4
harbour/contrib/hbct/asciisum.c
View File

@@ -101,10 +101,10 @@ HB_FUNC( ASCIISUM )
const char * pcString = hb_parc( 1 );
HB_SIZE sStrSize = hb_parclen( 1 );
HB_SIZE sPos;
ULONG ulResult = 0;
HB_ULONG ulResult = 0;
for( sPos = 0; sPos < sStrSize; sPos++ )
ulResult += ( ULONG ) pcString[ sPos ];
ulResult += ( HB_ULONG ) pcString[ sPos ];
hb_retnl( ulResult );
}

4
harbour/contrib/hbct/atadjust.c
View File

@@ -112,7 +112,7 @@ HB_FUNC( ATADJUST )
int iAtLike = ct_getatlike();
char cAtLike = ct_getatlikechar();
HB_SIZE sIgnore, sMatchStrLen = 0;
ULONG ulCounter;
HB_SIZE ulCounter;
const char *pc = NULL;
char cFillChar;
@@ -166,7 +166,7 @@ HB_FUNC( ATADJUST )
/* find the <ulCounter>th match */
const char *pcSubStr;
HB_SIZE sSubStrLen;
ULONG ulMatchCounter = 0;
HB_SIZE ulMatchCounter = 0;
pcSubStr = pcString;
sSubStrLen = sStrLen;

4
harbour/contrib/hbct/atnum.c
View File

@@ -75,7 +75,7 @@ static void do_atnum( int iSwitch )
int iAtLike = ct_getatlike();
char cAtLike = ct_getatlikechar();
HB_SIZE sIgnore, sMatchStrLen = 0;
ULONG ulCounter;
HB_SIZE ulCounter;
const char *pc = NULL;
/* eventually ignore some characters */
@@ -142,7 +142,7 @@ static void do_atnum( int iSwitch )
/* find the <ulCounter>th match */
const char *pcSubStr;
HB_SIZE sSubStrLen;
ULONG ulMatchCounter = 0;
HB_SIZE ulMatchCounter = 0;
pcSubStr = pcString;
sSubStrLen = sStrLen;

4
harbour/contrib/hbct/atrepl.c
View File

@@ -133,7 +133,7 @@ HB_FUNC( ATREPL )
int iAtLike = ct_getatlike();
char cAtLike = ct_getatlikechar();
HB_SIZE sIgnore, sMatchStrLen = 0;
ULONG ulCounter;
HB_SIZE ulCounter;
char *pc;
const char *pcReplacement;
@@ -197,7 +197,7 @@ HB_FUNC( ATREPL )
all occurences are replaced */
char *pcRetSubStr;
HB_SIZE sRetSubStrLen;
ULONG ulMatchCounter = 0;
HB_SIZE ulMatchCounter = 0;
sRetStrLen = sStrLen;
pcRetStr = ( char * ) hb_xgrab( sRetStrLen );

4
harbour/contrib/hbct/ct.h
View File

@@ -79,10 +79,10 @@ HB_EXTERN_BEGIN
/* CT subsystem error throwing functions */
extern USHORT ct_error( USHORT uiSeverity, HB_ERRCODE ulGenCode, HB_ERRCODE ulSubCode,
const char *szDescription, const char *szOperation, HB_ERRCODE uiOsCode, USHORT uiFlags, ULONG uiArgCount, ... );
const char *szDescription, const char *szOperation, HB_ERRCODE uiOsCode, USHORT uiFlags, HB_ULONG uiArgCount, ... );
extern PHB_ITEM ct_error_subst( USHORT uiSeverity, HB_ERRCODE ulGenCode, HB_ERRCODE ulSubCode,
const char *szDescription, const char *szOperation, HB_ERRCODE uiOsCode, USHORT uiFlags, ULONG uiArgCount, ... );
const char *szDescription, const char *szOperation, HB_ERRCODE uiOsCode, USHORT uiFlags, HB_ULONG uiArgCount, ... );
/* set argument error behaviour */
extern void ct_setargerrormode( int iMode );

8
harbour/contrib/hbct/ctc.c
View File

@@ -62,14 +62,14 @@
- function adapted from errorapi.c */
HB_USHORT ct_error( HB_USHORT uiSeverity, HB_ERRCODE errGenCode, HB_ERRCODE errSubCode,
const char * szDescription, const char * szOperation,
HB_ERRCODE errOsCode, HB_USHORT uiFlags, ULONG ulArgCount, ... )
HB_ERRCODE errOsCode, HB_USHORT uiFlags, HB_ULONG ulArgCount, ... )
{
HB_USHORT uiAction;
PHB_ITEM pError;
PHB_ITEM pArray;
va_list va;
ULONG ulArgPos;
HB_ULONG ulArgPos;
HB_TRACE( HB_TR_DEBUG, ( "ct_error(%hu, %d, %d, %s, %s, %d, %hu, %lu)",
uiSeverity, errGenCode, errSubCode, szDescription, szOperation, errOsCode, uiFlags, ulArgCount ) );
@@ -130,14 +130,14 @@ HB_USHORT ct_error( HB_USHORT uiSeverity, HB_ERRCODE errGenCode, HB_ERRCODE errS
- function adapted from errorapi.c */
PHB_ITEM ct_error_subst( HB_USHORT uiSeverity, HB_ERRCODE errGenCode, HB_ERRCODE errSubCode,
const char * szDescription, const char * szOperation,
HB_ERRCODE errOsCode, HB_USHORT uiFlags, ULONG ulArgCount, ... )
HB_ERRCODE errOsCode, HB_USHORT uiFlags, HB_ULONG ulArgCount, ... )
{
PHB_ITEM pRetVal;
PHB_ITEM pError;
PHB_ITEM pArray;
va_list va;
ULONG ulArgPos;
HB_ULONG ulArgPos;
HB_TRACE( HB_TR_DEBUG, ( "ct_error_subst(%hu, %d, %d, %s, %s, %d, %hu, %lu)",
uiSeverity, errGenCode, errSubCode, szDescription, szOperation, errOsCode, uiFlags, ulArgCount ) );

12
harbour/contrib/hbct/ctstr.c
View File

@@ -82,7 +82,7 @@ const char *ct_at_exact_forward( const char *pcString, HB_SIZE sStrLen,
HB_SIZE sPos;
HB_TRACE( HB_TR_DEBUG, ( "ct_at_exact_forward (\"%s\", %lu, \"%s\", %lu, %p)",
pcString, ( ULONG ) sStrLen, pcMatch, ( ULONG ) sMatchLen, psMatchStrLen ) );
pcString, ( HB_ULONG ) sStrLen, pcMatch, ( HB_ULONG ) sMatchLen, psMatchStrLen ) );
if( ( sMatchLen == 0 ) || ( sStrLen < sMatchLen ) )
return NULL;
@@ -113,7 +113,7 @@ const char *ct_at_exact_backward( const char *pcString, HB_SIZE sStrLen,
const char *pcRet;
HB_TRACE( HB_TR_DEBUG, ( "ct_at_exact_backward (\"%s\", %lu, \"%s\", %lu, %p)",
pcString, ( ULONG ) sStrLen, pcMatch, ( ULONG ) sMatchLen, psMatchStrLen ) );
pcString, ( HB_ULONG ) sStrLen, pcMatch, ( HB_ULONG ) sMatchLen, psMatchStrLen ) );
if( ( sMatchLen == 0 ) || ( sStrLen < sMatchLen ) )
return NULL;
@@ -148,7 +148,7 @@ const char *ct_at_wildcard_forward( const char *pcString, HB_SIZE sStrLen,
const char *pcRet, *pcStop;
HB_TRACE( HB_TR_DEBUG, ( "ct_at_wildcard_forward (\"%s\", %lu, \"%s\", %lu, \'%c\', %p)",
pcString, ( ULONG ) sStrLen, pcMatch, ( ULONG ) sMatchLen, cWildCard, psMatchStrLen ) );
pcString, ( HB_ULONG ) sStrLen, pcMatch, ( HB_ULONG ) sMatchLen, cWildCard, psMatchStrLen ) );
if( ( sMatchLen == 0 ) || ( sStrLen < sMatchLen ) )
return NULL;
@@ -187,7 +187,7 @@ const char *ct_at_wildcard_backward( const char *pcString, HB_SIZE sStrLen,
const char *pcRet;
HB_TRACE( HB_TR_DEBUG, ( "ct_at_wildcard_backward (\"%s\", %lu, \"%s\", %lu, \'%c\', %p)",
pcString, ( ULONG ) sStrLen, pcMatch, ( ULONG ) sMatchLen, cWildCard, psMatchStrLen ) );
pcString, ( HB_ULONG ) sStrLen, pcMatch, ( HB_ULONG ) sMatchLen, cWildCard, psMatchStrLen ) );
if( ( sMatchLen == 0 ) || ( sStrLen < sMatchLen ) )
return NULL;
@@ -224,7 +224,7 @@ const char *ct_at_charset_forward( const char *pcString, HB_SIZE sStrLen,
const char *pcRet, *pcSet, *pcStop1, *pcStop2;
HB_TRACE( HB_TR_DEBUG, ( "ct_at_charset_forward (\"%s\", %lu, \"%s\", %lu, %p)",
pcString, ( ULONG ) sStrLen, pcCharSet, ( ULONG ) sCharSetLen, psMatchedCharPos ) );
pcString, ( HB_ULONG ) sStrLen, pcCharSet, ( HB_ULONG ) sCharSetLen, psMatchedCharPos ) );
*( psMatchedCharPos ) = sCharSetLen;
@@ -258,7 +258,7 @@ const char *ct_at_charset_backward( const char *pcString, HB_SIZE sStrLen,
const char *pcRet, *pcSet, *pcStop;
HB_TRACE( HB_TR_DEBUG, ( "ct_at_charset_backward (\"%s\", %lu, \"%s\", %lu, %p)",
pcString, ( ULONG ) sStrLen, pcCharSet, ( ULONG ) sCharSetLen, psMatchedCharPos ) );
pcString, ( HB_ULONG ) sStrLen, pcCharSet, ( HB_ULONG ) sCharSetLen, psMatchedCharPos ) );
*( psMatchedCharPos ) = sCharSetLen;

22
harbour/contrib/hbct/ctwin.c
View File

@@ -177,7 +177,7 @@ static int hb_ctw_CalcShadowWidth( int iRows, int iCols )
static void hb_ctw_SetMap( PHB_GTCTW pCTW, int * piMap, int iWindow, int iTop, int iLeft, int iBottom, int iRight, int iNested )
{
ULONG lIndex;
HB_SIZE lIndex;
int i;
HB_TRACE(HB_TR_DEBUG, ("hb_ctw_SetMap(%p,%p,%d,%d,%d,%d,%d,%d)", pCTW, piMap, iWindow, iTop, iLeft, iBottom, iRight, iNested));
@@ -215,11 +215,11 @@ static void hb_ctw_SetMap( PHB_GTCTW pCTW, int * piMap, int iWindow, int iTop, i
static void hb_ctw_ClearMap( PHB_GTCTW pCTW )
{
ULONG ulSize;
HB_SIZE ulSize;
HB_TRACE(HB_TR_DEBUG, ("hb_ctw_ClearMap(%p)", pCTW));
ulSize = ( ULONG ) pCTW->iMapHeight * pCTW->iMapWidth * sizeof( int );
ulSize = ( HB_SIZE ) pCTW->iMapHeight * pCTW->iMapWidth * sizeof( int );
memset( pCTW->pWindowMap, 0, ulSize );
memset( pCTW->pShadowMap, 0, ulSize );
}
@@ -594,13 +594,13 @@ static int hb_ctw_CreateWindow( PHB_GTCTW pCTW, int iTop, int iLeft, int iBottom
if( pCTW->iMaxWindow == 0 )
{
ULONG ulSize;
HB_SIZE ulSize;
HB_GTSELF_GETSIZE( pCTW->pGT, &pCTW->iMapHeight, &pCTW->iMapWidth );
pCTW->iShadowWidth = hb_ctw_CalcShadowWidth( pCTW->iMapHeight, pCTW->iMapWidth );
if( !pCTW->fBoardSet )
hb_ctw_SetWindowBoard( pCTW, 0, 0, pCTW->iMapHeight - 1, pCTW->iMapWidth - 1 );
ulSize = ( ULONG ) pCTW->iMapHeight * pCTW->iMapWidth * sizeof( int );
ulSize = ( HB_SIZE ) pCTW->iMapHeight * pCTW->iMapWidth * sizeof( int );
pCTW->pWindowMap = ( int * ) hb_xgrab( ulSize );
pCTW->pShadowMap = ( int * ) hb_xgrab( ulSize );
hb_ctw_ClearMap( pCTW );
@@ -669,7 +669,7 @@ static int hb_ctw_CreateWindow( PHB_GTCTW pCTW, int iTop, int iLeft, int iBottom
HB_GTSELF_GETCOLORDATA( pCTW->pGT, &pWnd->piColors, &pWnd->iColorCount, &pWnd->iColorIndex );
pWnd->screenBuffer = ( PHB_SCREENCELL ) hb_xgrab( ( ULONG ) pWnd->iHeight *
pWnd->screenBuffer = ( PHB_SCREENCELL ) hb_xgrab( ( HB_SIZE ) pWnd->iHeight *
pWnd->iWidth * sizeof( HB_SCREENCELL ) );
if( pWnd->iShadowAttr >= 0 )
@@ -1318,7 +1318,7 @@ static int hb_ctw_gt_MaxRow( PHB_GT pGT )
*/
#define WRITECON_BUFFER_SIZE 512
static void hb_ctw_gt_WriteCon( PHB_GT pGT, const char * pText, ULONG ulLength )
static void hb_ctw_gt_WriteCon( PHB_GT pGT, const char * pText, HB_SIZE ulLength )
{
int iLen = 0;
HB_BOOL bDisp = HB_FALSE;
@@ -1814,12 +1814,12 @@ static HB_BOOL hb_ctw_gt_Resize( PHB_GT pGT, int iRows, int iCols )
if( pCTW->iMaxWindow > 0 )
{
ULONG ulSize;
HB_SIZE ulSize;
pCTW->iMapHeight = iRows;
pCTW->iMapWidth = iCols;
pCTW->iShadowWidth = hb_ctw_CalcShadowWidth( pCTW->iMapHeight, pCTW->iMapWidth );
ulSize = ( ULONG ) pCTW->iMapHeight * pCTW->iMapWidth * sizeof( int );
ulSize = ( HB_SIZE ) pCTW->iMapHeight * pCTW->iMapWidth * sizeof( int );
pCTW->pWindowMap = ( int * ) hb_xrealloc( pCTW->pWindowMap, ulSize );
pCTW->pShadowMap = ( int * ) hb_xrealloc( pCTW->pShadowMap, ulSize );
}
@@ -1919,11 +1919,11 @@ static int hb_ctw_gt_Alert( PHB_GT pGT, PHB_ITEM pMessage, PHB_ITEM pOptions,
if( fScreen )
{
PHB_GTCTW pCTW = HB_GTCTW_GET( pGT );
ULONG ulWidth = 0, ulCurrWidth = 0, ul = 0, ul2, ulMaxWidth, ulLast;
HB_SIZE ulWidth = 0, ulCurrWidth = 0, ul = 0, ul2, ulMaxWidth, ulLast;
int iKey, iDspCount, iLines = 0, iTop, iLeft, iBottom, iRight,
iMnuCol, iPos, iClr, iWnd, iPrevWnd, i;
const char * szMessage = hb_itemGetCPtr( pMessage );
ULONG ulLen = hb_itemGetCLen( pMessage );
HB_SIZE ulLen = hb_itemGetCLen( pMessage );
ulMaxWidth = iCols - 4;
while( ul < ulLen )

6
harbour/contrib/hbct/dattime3.c
View File

@@ -134,7 +134,7 @@ HB_FUNC( WAITPERIOD )
hb_retl( d < s_dTimeCounter );
}
static HB_BOOL _hb_timeValid( const char * szTime, ULONG ulLen, int * piDecode )
static HB_BOOL _hb_timeValid( const char * szTime, HB_SIZE ulLen, int * piDecode )
{
HB_BOOL fValid = HB_FALSE;
@@ -142,7 +142,7 @@ static HB_BOOL _hb_timeValid( const char * szTime, ULONG ulLen, int * piDecode )
{
static const int s_iMax[] = { 23, 59, 59, 99 };
int i, iVal;
ULONG ul;
HB_SIZE ul;
fValid = HB_TRUE;
for( ul = 0; fValid && ul < ulLen; ++ul )
@@ -298,7 +298,7 @@ HB_FUNC( SETTIME )
fResult = SetLocalTime( &st );
#elif defined( HB_OS_LINUX ) && !defined( __WATCOMC__ )
/* stime exists only in SVr4, SVID, X/OPEN and Linux */
ULONG lNewTime;
HB_ULONG lNewTime;
time_t tm;
lNewTime = iTime[0] * 3600 + iTime[1] * 60 + iTime[2];

2
harbour/contrib/hbct/dbftools.c
View File

@@ -83,7 +83,7 @@ HB_FUNC( DBFSIZE )
if( ( pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer() ) != NULL )
{
PHB_ITEM pSize = hb_itemNew( NULL );
ULONG ulRecSize, ulRecCount;
HB_ULONG ulRecSize, ulRecCount;
if( SELF_INFO( pArea, DBI_GETHEADERSIZE, pSize ) == HB_SUCCESS )
{

4
harbour/contrib/hbct/files.c
View File

@@ -314,11 +314,11 @@ HB_FUNC( FILESMAX )
#if defined( __DJGPP__ )
__dpmi_regs r;
unsigned handles;
ULONG psp;
HB_ULONG psp;
r.h.ah = 0x62; /* Get PSP address */
__dpmi_int( 0x21, &r );
psp = ( ( ( ULONG ) r.x.bx ) << 4 ) & 0xFFFFF;
psp = ( ( ( HB_ULONG ) r.x.bx ) << 4 ) & 0xFFFFF;
handles = _farpeekw( _dos_ds, psp + 0x32 );
hb_retni( handles );

2
harbour/contrib/hbct/numat.c
View File

@@ -95,7 +95,7 @@ HB_FUNC( NUMAT )
int iAtLike = ct_getatlike();
char cAtLike = ct_getatlikechar();
HB_SIZE sIgnore, sMatchStrLen = 0, sSubStrLen;
ULONG ulCounter;
HB_SIZE ulCounter;
const char *pc, *pcSubStr;
/* eventually ignore some characters */

10
harbour/contrib/hbct/screen1.c
View File

@@ -146,13 +146,13 @@ HB_FUNC( SCREENATTR )
HB_FUNC( SCREENMIX )
{
ULONG ulLen = hb_parclen( 1 );
HB_SIZE ulLen = hb_parclen( 1 );
if( ulLen )
{
const char * szText = hb_parc( 1 );
const char * szAttr;
ULONG ulAttr = hb_parclen( 2 ), ul = 0;
HB_SIZE ulAttr = hb_parclen( 2 ), ul = 0;
int iRow, iCol, i;
if( ulAttr == 0 )
@@ -229,7 +229,7 @@ HB_FUNC( SCREENMIX )
HB_FUNC( SAYSCREEN )
{
ULONG ulLen = hb_parclen( 1 );
HB_SIZE ulLen = hb_parclen( 1 );
if( ulLen )
{
@@ -702,11 +702,11 @@ HB_FUNC( SCREENTEXT )
{
int iTop, iLeft, iBottom, iRight;
char * pBuffer, * szText;
ULONG ulSize;
HB_SIZE ulSize;
if( hb_ctGetWinCord( &iTop, &iLeft, &iBottom, &iRight ) )
{
ulSize = ( ULONG ) ( iBottom - iTop + 1 ) * ( iRight - iLeft + 1 );
ulSize = ( HB_SIZE ) ( iBottom - iTop + 1 ) * ( iRight - iLeft + 1 );
szText = pBuffer = ( char * ) hb_xgrab( ulSize + 1 );
while( iTop <= iBottom )
{

20
harbour/contrib/hbct/screen2.c
View File

@@ -58,7 +58,7 @@
HB_FUNC( SAYDOWN )
{
ULONG ulLen = hb_parclen( 1 );
HB_SIZE ulLen = hb_parclen( 1 );
if( ulLen )
{
@@ -80,8 +80,8 @@ HB_FUNC( SAYDOWN )
{
int iColor = hb_gtGetCurrColor();
if( ulLen > ( ULONG ) ( iMaxRow - iRow + 1 ) )
ulLen = ( ULONG ) ( iMaxRow - iRow + 1 );
if( ulLen > ( HB_SIZE ) ( iMaxRow - iRow + 1 ) )
ulLen = ( HB_SIZE ) ( iMaxRow - iRow + 1 );
hb_gtBeginWrite();
while( ulLen-- )
@@ -103,12 +103,12 @@ HB_FUNC( SAYDOWN )
HB_FUNC( SAYSPREAD )
{
ULONG ulLen = hb_parclen( 1 );
HB_SIZE ulLen = hb_parclen( 1 );
if( ulLen )
{
const char * szText = hb_parc( 1 );
ULONG ulPos, ul;
HB_SIZE ulPos, ul;
int iRow, iCol, iMaxRow, iMaxCol;
long lDelay;
@@ -159,12 +159,12 @@ HB_FUNC( SAYSPREAD )
HB_FUNC( SAYMOVEIN )
{
ULONG ulLen = hb_parclen( 1 );
HB_SIZE ulLen = hb_parclen( 1 );
if( ulLen )
{
const char * szText = hb_parc( 1 );
ULONG ulChars, ul;
HB_SIZE ulChars, ul;
int iRow, iCol, iMaxRow, iMaxCol, iNewCol;
long lDelay;
HB_BOOL fBack;
@@ -316,7 +316,7 @@ HB_FUNC( SCREENSTR )
{
int iRow, iCol, iMaxRow, iMaxCol, iC;
char * pBuffer, * szText;
ULONG ulSize, ulCount = ULONG_MAX;
HB_SIZE ulSize, ulCount = ULONG_MAX;
hb_gtGetPos( &iRow, &iCol );
if( HB_ISNUM( 1 ) )
@@ -330,7 +330,7 @@ HB_FUNC( SCREENSTR )
if( iRow >= 0 && iRow <= iMaxRow && iCol >= 0 && iCol <= iMaxCol && ulCount )
{
ulSize = ( ULONG ) ( iMaxRow - iRow + 1 ) * ( iMaxCol - iCol + 1 );
ulSize = ( HB_SIZE ) ( iMaxRow - iRow + 1 ) * ( iMaxCol - iCol + 1 );
if( ulSize > ulCount )
ulSize = ulCount;
ulCount = ulSize;
@@ -360,7 +360,7 @@ HB_FUNC( SCREENSTR )
HB_FUNC( STRSCREEN )
{
ULONG ulLen = hb_parclen( 1 );
HB_SIZE ulLen = hb_parclen( 1 );
if( ulLen & 1 )
ulLen--;

8
harbour/contrib/hbct/token1.c
View File

@@ -104,14 +104,14 @@ static void do_token1( int iSwitch )
HB_SIZE sStrLen = hb_parclen( 1 );
const char *pcSeparatorStr;
HB_SIZE sSeparatorStrLen;
ULONG ulTokenCounter = 0;
ULONG ulSkip;
HB_ULONG ulTokenCounter = 0;
HB_ULONG ulSkip;
const char *pcSubStr;
char *pcRet = NULL;
HB_SIZE sSubStrLen;
HB_SIZE sRetStrLen = 0;
ULONG ulToken = 0;
ULONG ulSkipCnt;
HB_ULONG ulToken = 0;
HB_ULONG ulSkipCnt;
const char *pc;
/* separator string */

2
harbour/contrib/hbct/token2.c
View File

@@ -375,7 +375,7 @@ HB_FUNC( TOKENINIT )
HB_SIZE sStrLen = hb_parclen( 1 );
const char *pcSeparatorStr;
HB_SIZE sSeparatorStrLen;
ULONG ulSkipCnt, ulSkip;
HB_ULONG ulSkipCnt, ulSkip;
const char *pcSubStr, *pc;
HB_SIZE sSubStrLen;
TOKEN_ENVIRONMENT sTokenEnvironment;

54
harbour/contrib/hbmemio/memio.c
View File

@@ -111,11 +111,11 @@ typedef struct _HB_MEMFS_FILE
typedef struct _HB_MEMFS_FS
{
ULONG ulInodeCount;
ULONG ulInodeAlloc;
HB_ULONG ulInodeCount;
HB_ULONG ulInodeAlloc;
PHB_MEMFS_INODE * pInodes;
ULONG ulFileAlloc;
ULONG ulFileLast;
HB_ULONG ulFileAlloc;
HB_ULONG ulFileLast;
PHB_MEMFS_FILE * pFiles;
} HB_MEMFS_FS, * PHB_MEMFS_FS;
@@ -133,7 +133,7 @@ static void memfsInodeFree( PHB_MEMFS_INODE pInode );
static void memfsExit( void * cargo )
{
ULONG ul;
HB_ULONG ul;
HB_SYMBOL_UNUSED( cargo );
@@ -167,10 +167,10 @@ static void memfsInit( void )
/* Note: returns 1 based index! */
static ULONG memfsInodeFind( const char * szName, ULONG * pulPos )
static HB_ULONG memfsInodeFind( const char * szName, HB_ULONG * pulPos )
{
ULONG ulLeft, ulRight, ulMiddle;
int i;
HB_ULONG ulLeft, ulRight, ulMiddle;
int i;
ulLeft = 0;
ulRight = s_fs.ulInodeCount;
@@ -193,12 +193,12 @@ static ULONG memfsInodeFind( const char * szName, ULONG * pulPos )
static PHB_MEMFS_INODE memfsInodeAlloc( const char* szName )
{
PHB_MEMFS_INODE pInode = ( PHB_MEMFS_INODE ) hb_xgrab( sizeof( HB_MEMFS_INODE ) );
ULONG ulInode = 0;
PHB_MEMFS_INODE pInode = ( PHB_MEMFS_INODE ) hb_xgrab( sizeof( HB_MEMFS_INODE ) );
HB_ULONG ulInode = 0;
pInode->llSize = 0;
pInode->llAlloc = HB_MEMFS_INITSIZE;
pInode->pData = ( char * ) hb_xgrab( ( ULONG ) pInode->llAlloc );
pInode->pData = ( char * ) hb_xgrab( ( HB_ULONG ) pInode->llAlloc );
memset( pInode->pData, 0, pInode->llAlloc );
pInode->szName = hb_strdup( szName );
@@ -251,19 +251,19 @@ static PHB_MEMFS_FILE memfsFileAlloc( PHB_MEMFS_INODE pInode )
static PHB_MEMFS_FILE memfsHandleToFile( HB_FHANDLE hFile )
{
if( hFile == FS_ERROR || ( ULONG ) hFile == 0 || ( ULONG ) hFile > s_fs.ulFileAlloc || s_fs.pFiles[ ( ULONG ) hFile - 1 ] == NULL )
if( hFile == FS_ERROR || ( HB_ULONG ) hFile == 0 || ( HB_ULONG ) hFile > s_fs.ulFileAlloc || s_fs.pFiles[ ( HB_ULONG ) hFile - 1 ] == NULL )
{
/* hb_errInternal( 9999, "memfsHandleToFile: Invalid file handle", NULL, NULL ); */
return NULL;
}
else
return s_fs.pFiles[ ( ULONG ) hFile - 1 ];
return s_fs.pFiles[ ( HB_ULONG ) hFile - 1 ];
}
static HB_FHANDLE memfsHandleAlloc( PHB_MEMFS_FILE pFile )
{
ULONG ul;
HB_ULONG ul;
/* This allocation will help to avoid reallocation of just released file handle. */
for( ul = s_fs.ulFileLast; ul < s_fs.ulFileAlloc; ul++ )
@@ -317,8 +317,8 @@ HB_MEMFS_EXPORT HB_BOOL hb_memfsFileExists( const char * szName )
HB_MEMFS_EXPORT HB_BOOL hb_memfsDelete( const char * szName )
{
PHB_MEMFS_INODE pInode;
ULONG ulFile;
PHB_MEMFS_INODE pInode;
HB_ULONG ulFile;
HB_MEMFSMT_LOCK
if( ( ulFile = memfsInodeFind( szName, NULL ) ) == 0 )
@@ -342,7 +342,7 @@ HB_MEMFS_EXPORT HB_BOOL hb_memfsDelete( const char * szName )
HB_MEMFS_EXPORT HB_BOOL hb_memfsRename( const char * szName, const char * szNewName )
{
ULONG ulInode;
HB_ULONG ulInode;
HB_MEMFSMT_LOCK
if( ( ulInode = memfsInodeFind( szName, NULL ) ) == 0 )
@@ -368,7 +368,7 @@ HB_MEMFS_EXPORT HB_FHANDLE hb_memfsOpen( const char * szName, HB_USHORT uiFlags
{
PHB_MEMFS_FILE pFile = NULL;
HB_FHANDLE hFile;
ULONG ulInode;
HB_ULONG ulInode;
HB_ERRCODE uiError = 0;
/*
@@ -512,7 +512,7 @@ HB_MEMFS_EXPORT HB_SIZE hb_memfsReadAt( HB_FHANDLE hFile, void * pBuff, HB_SIZE
else
ulRead = ( HB_SIZE ) ( pInode->llSize - llOffset );
memcpy( pBuff, pInode->pData + ( ULONG ) llOffset, ulRead );
memcpy( pBuff, pInode->pData + ( HB_ULONG ) llOffset, ulRead );
HB_MEMFSMT_UNLOCK
pFile->llPos = llOffset + ( HB_FOFFSET ) ulCount;
return ulRead;
@@ -544,11 +544,11 @@ HB_MEMFS_EXPORT HB_SIZE hb_memfsWriteAt( HB_FHANDLE hFile, const void * pBuff, H
if( llNewAlloc < llOffset + ( HB_FOFFSET ) ulCount )
llNewAlloc = llOffset + ( HB_FOFFSET ) ulCount;
pInode->pData = ( char * ) hb_xrealloc( pInode->pData, ( ULONG ) llNewAlloc );
memset( pInode->pData + ( ULONG ) pInode->llAlloc, 0, llNewAlloc - pInode->llAlloc );
pInode->pData = ( char * ) hb_xrealloc( pInode->pData, ( HB_ULONG ) llNewAlloc );
memset( pInode->pData + ( HB_ULONG ) pInode->llAlloc, 0, llNewAlloc - pInode->llAlloc );
pInode->llAlloc = llNewAlloc;
}
memcpy( pInode->pData + ( ULONG ) llOffset, pBuff, ulCount );
memcpy( pInode->pData + ( HB_ULONG ) llOffset, pBuff, ulCount );
if( pInode->llSize < llOffset + ( HB_FOFFSET ) ulCount )
pInode->llSize = llOffset + ( HB_FOFFSET ) ulCount;
@@ -598,17 +598,17 @@ HB_MEMFS_EXPORT HB_BOOL hb_memfsTruncAt( HB_FHANDLE hFile, HB_FOFFSET llOffset )
if( llNewAlloc < llOffset )
llNewAlloc = llOffset;
pInode->pData = ( char * ) hb_xrealloc( pInode->pData, ( ULONG ) llNewAlloc );
memset( pInode->pData + ( ULONG ) pInode->llAlloc, 0, llNewAlloc - pInode->llAlloc );
pInode->pData = ( char * ) hb_xrealloc( pInode->pData, ( HB_ULONG ) llNewAlloc );
memset( pInode->pData + ( HB_ULONG ) pInode->llAlloc, 0, llNewAlloc - pInode->llAlloc );
pInode->llAlloc = llNewAlloc;
}
else if( ( pInode->llAlloc >> 2 ) > ( llOffset > HB_MEMFS_INITSIZE ? llOffset : HB_MEMFS_INITSIZE ) )
{
pInode->llAlloc = ( llOffset > HB_MEMFS_INITSIZE ? llOffset : HB_MEMFS_INITSIZE );
pInode->pData = ( char * ) hb_xrealloc( pInode->pData, ( ULONG ) pInode->llAlloc );
pInode->pData = ( char * ) hb_xrealloc( pInode->pData, ( HB_ULONG ) pInode->llAlloc );
}
memset( pInode->pData + ( ULONG ) llOffset, 0, pInode->llAlloc - llOffset );
memset( pInode->pData + ( HB_ULONG ) llOffset, 0, pInode->llAlloc - llOffset );
pInode->llSize = llOffset;
HB_MEMFSMT_UNLOCK
@@ -732,7 +732,7 @@ static PHB_FILE s_fileOpen( const char * szName, const char * szDefExt, HB_USHOR
HB_FHANDLE hFile;
char szNameNew[ HB_PATH_MAX + 1 ];
HB_USHORT uiFlags;
ULONG ulLen;
HB_ULONG ulLen;
HB_SYMBOL_UNUSED( pPaths );
HB_SYMBOL_UNUSED( pError );

10
harbour/contrib/hbmisc/spd.c
View File

@@ -57,7 +57,7 @@
static void STAItm( PHB_ITEM pItmPar )
{
ULONG i, ulItmPar = hb_itemGetCLen( pItmPar );
HB_SIZE i, ulItmPar = hb_itemGetCLen( pItmPar );
const char *cItmPar = hb_itemGetCPtr( pItmPar ), *c;
char *cRes;
@@ -74,9 +74,9 @@ static void STAItm( PHB_ITEM pItmPar )
hb_itemPutCLPtr( pItmPar, cRes, i );
}
static ULONG SCItm( char *cBuffer, ULONG ulMaxBuf, char *cParFrm, int iCOut, int IsIndW, int iIndWidth, int IsIndP, int iIndPrec, PHB_ITEM pItmPar )
static HB_SIZE SCItm( char *cBuffer, HB_SIZE ulMaxBuf, char *cParFrm, int iCOut, int IsIndW, int iIndWidth, int IsIndP, int iIndPrec, PHB_ITEM pItmPar )
{
ULONG s;
HB_SIZE s;
/* NOTE: In DJGPP (4.2.3) hb_snprintf() will be preprocessed to sprintf(), which
makes ulMaxBuf unused, and this in turn causes a warning, so we're
@@ -186,7 +186,7 @@ static ULONG SCItm( char *cBuffer, ULONG ulMaxBuf, char *cParFrm, int iCOut, int
HB_FUNC( SQL_SPRINTF )
{
ULONG ulItmFrm;
HB_SIZE ulItmFrm;
const char *cItmFrm;
char *cRes;
int argc = hb_pcount() - 1;
@@ -205,7 +205,7 @@ HB_FUNC( SQL_SPRINTF )
char *cIntMod, *cBuffer, *cParFrm;
const char *c;
int p, arg, iCOut, IsType, IsIndW, IsIndP, iIndWidth, iIndPrec, iErrorPar = 0;
ULONG s, f, i, ulWidth, ulParPos = 0, ulResPos = 0, ulMaxBuf = DK_INCBUF, ulMaxRes = DK_INCRES;
HB_SIZE s, f, i, ulWidth, ulParPos = 0, ulResPos = 0, ulMaxBuf = DK_INCBUF, ulMaxRes = DK_INCRES;
static char cToken[] = "stTcdiouxXaAeEfgGpnSC";
cIntMod = NULL;

6
harbour/contrib/hbnetio/netiocli.c
View File

@@ -754,9 +754,9 @@ static const char * s_netio_params( int iMsg, const char * pszName, HB_U32 * pSi
{
int iPCount = iMsg == NETIO_PROCIS ? 0 : hb_pcount(), i;
char * data = NULL, * itmData;
ULONG size, itmSize;
HB_SIZE size, itmSize;
size = ( ULONG ) strlen( pszName ) + 1;
size = ( HB_SIZE ) strlen( pszName ) + 1;
for( i = 2; i <= iPCount; ++i )
{
@@ -800,7 +800,7 @@ static HB_BOOL s_netio_procexec( const char * pszProcName, int iMsg )
fResult = s_fileSendMsg( conn, msgbuf, data, size, iMsg != NETIO_PROC );
if( fResult && iMsg == NETIO_FUNC )
{
ULONG ulResult = HB_GET_LE_UINT32( &msgbuf[ 4 ] );
HB_ULONG ulResult = HB_GET_LE_UINT32( &msgbuf[ 4 ] );
if( ulResult > 0 )
{

2
harbour/contrib/hbnf/dispc.c
View File

@@ -542,7 +542,7 @@ static void filebot()
HB_FUNC( _FT_DFINIT )
{
int rval, i, j;
ULONG ulSize;
HB_SIZE ulSize;
rval = 0;

4
harbour/contrib/hbnf/ftattr.c
View File

@@ -180,7 +180,7 @@ HB_FUNC( FT_SAVEATT )
int iBottom = HB_ISNUM( 3 ) ? hb_parni( 3 ) : iMaxRow;
int iRight = HB_ISNUM( 4 ) ? hb_parni( 4 ) : iMaxRow;
ULONG ulSize;
HB_SIZE ulSize;
char * pBuffer;
char * pAttrib;
@@ -388,7 +388,7 @@ End
HB_FUNC( FT_RESTATT )
{
ULONG ulLen = hb_parclen( 5 );
HB_SIZE ulLen = hb_parclen( 5 );
if( ulLen )
{
int iTop = hb_parni( 1 ); /* Defaults to zero on bad type */

2
harbour/contrib/hbqt/gtqtc/gtqtc.cpp
View File

@@ -1390,7 +1390,7 @@ void DrawingArea::copyTextOnClipboard( void )
int right = rectRC.right();
int bottom = rectRC.bottom();
ULONG ulSize = ( ( bottom - top + 1 ) * ( right - left + 1 + 2 ) );
HB_SIZE ulSize = ( ( bottom - top + 1 ) * ( right - left + 1 + 2 ) );
char * sBuffer = ( char * ) hb_xgrab( ulSize + 1 );
int j, irow, icol;

10
harbour/contrib/hbtip/encmthd.c
View File

@@ -61,10 +61,10 @@ HB_FUNC( TIPENCODERBASE64_ENCODE )
{
const char * cData = hb_parc( 1 );
char * cRet;
int nLen = hb_parclen( 1 );
int nPos = 0, nPosRet = 0;
int nPosBlock = 0, nLineCount = 0;
ULONG nFinalLen;
HB_ISIZ nLen = hb_parclen( 1 );
HB_ISIZ nPos = 0, nPosRet = 0, nPosBlock = 0;
HB_SIZE nFinalLen;
int nLineCount = 0;
unsigned char cElem, cElem1;
HB_BOOL bExcept;
@@ -93,7 +93,7 @@ HB_FUNC( TIPENCODERBASE64_ENCODE )
bExcept = hb_parl( -1 );
}
/* we know exactly the renturned length. */
nFinalLen = ( ULONG ) ( ( nLen / 3 + 2 ) * 4 );
nFinalLen = ( HB_SIZE ) ( ( nLen / 3 + 2 ) * 4 );
/* add line termination padding, CRLF each 76 output bytes */
nFinalLen += ( nFinalLen / 72 + 1 ) * 2;
cRet = ( char * ) hb_xgrab( nFinalLen );

4
harbour/contrib/hbtip/utils.c
View File

@@ -95,7 +95,7 @@ HB_FUNC( TIP_TIMESTAMP )
/* For compatibility */
if( HB_ISNUM( 2 ) )
{
ULONG ulHour = hb_parnl( 2 );
HB_SIZE ulHour = hb_parnl( 2 );
iHour = ( int ) ( ulHour / 3600 );
iMinute = ( int ) ( ( ulHour % 3600 ) / 60 );
@@ -476,7 +476,7 @@ static const char * s_findFileMimeType( HB_FHANDLE fileIn )
{
char buf[ 512 ];
int iLen;
ULONG ulPos;
HB_SIZE ulPos;
ulPos = hb_fsSeek( fileIn, 0, FS_RELATIVE );
hb_fsSeek( fileIn, 0, FS_SET );

68
harbour/contrib/rddads/ads1.c
View File

@@ -630,7 +630,7 @@ static HB_ERRCODE adsScopeSet( ADSAREAP pArea, ADSHANDLE hOrder, HB_USHORT nScop
static double adsGetRelPos( ADSAREAP pArea, ADSHANDLE hOrder )
{
ULONG ulRecNo, ulRecCount;
HB_ULONG ulRecNo, ulRecCount;
/* resolve any pending relations */
if( pArea->lpdbPendingRel )
@@ -689,10 +689,10 @@ static void adsSetRelPos( ADSAREAP pArea, ADSHANDLE hOrder, double dPos )
}
else
{
ULONG ulRecCount, ulRecNo;
HB_ULONG ulRecCount, ulRecNo;
SELF_RECCOUNT( ( AREAP ) pArea, &ulRecCount );
ulRecNo = ( ULONG ) dPos * ulRecCount + 1;
ulRecNo = ( HB_ULONG ) dPos * ulRecCount + 1;
if( ulRecNo >= ulRecCount )
ulRecNo = ulRecCount;
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
@@ -717,7 +717,7 @@ HB_ERRCODE hb_adsCloseCursor( ADSAREAP pArea )
if( u32RetVal != AE_SUCCESS )
{
HB_TRACE(HB_TR_DEBUG, ("adsCloseTable(%lu, %s) failed", ( ULONG ) u32RetVal, pArea->szDataFileName));
HB_TRACE(HB_TR_DEBUG, ("adsCloseTable(%lu, %s) failed", ( HB_ULONG ) u32RetVal, pArea->szDataFileName));
}
pArea->hTable = 0;
}
@@ -818,7 +818,7 @@ static HB_ERRCODE adsGoBottom( ADSAREAP pArea )
return SELF_SKIPFILTER( ( AREAP ) pArea, -1 );
}
static HB_ERRCODE adsGoTo( ADSAREAP pArea, ULONG ulRecNo )
static HB_ERRCODE adsGoTo( ADSAREAP pArea, HB_ULONG ulRecNo )
{
/*
* TODO: bh: Note Explicitly moving to a deleted record when using the
@@ -830,7 +830,7 @@ static HB_ERRCODE adsGoTo( ADSAREAP pArea, ULONG ulRecNo )
* IMHO such GOTO operation should reposition our RDD to phantom record
*/
UNSIGNED32 u32RetVal, u32RecNo;
ULONG ulRecCount;
HB_ULONG ulRecCount;
HB_TRACE(HB_TR_DEBUG, ("adsGoTo(%p, %lu)", pArea, ulRecNo));
@@ -915,7 +915,7 @@ static HB_ERRCODE adsGoTo( ADSAREAP pArea, ULONG ulRecNo )
static HB_ERRCODE adsGoToId( ADSAREAP pArea, PHB_ITEM pItem )
{
ULONG ulRecNo;
HB_ULONG ulRecNo;
HB_TRACE(HB_TR_DEBUG, ("adsGoToId(%p, %p)", pArea, pItem));
@@ -1410,7 +1410,7 @@ static HB_ERRCODE adsSkipFilter( ADSAREAP pArea, HB_LONG lUpDown )
}
else if( !pArea->fPositioned )
{
ULONG ulRecCount;
HB_ULONG ulRecCount;
/* set our record number value */
errCode = SELF_RECCOUNT( ( AREAP ) pArea, &ulRecCount );
pArea->ulRecNo = ulRecCount + 1;
@@ -1448,7 +1448,7 @@ static HB_ERRCODE adsAppend( ADSAREAP pArea, HB_BOOL fUnLockAll )
{
if( pArea->fShared && !pArea->fFLocked )
{
ULONG ulRecNo;
HB_ULONG ulRecNo;
if( SELF_RECNO( ( AREAP ) pArea, &ulRecNo ) == HB_SUCCESS )
{
@@ -2390,7 +2390,7 @@ static HB_ERRCODE adsGetValue( ADSAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem
return HB_SUCCESS;
}
static HB_ERRCODE adsGetVarLen( ADSAREAP pArea, HB_USHORT uiIndex, ULONG * ulLen )
static HB_ERRCODE adsGetVarLen( ADSAREAP pArea, HB_USHORT uiIndex, HB_ULONG * ulLen )
{
LPFIELD pField;
@@ -2596,7 +2596,7 @@ static HB_ERRCODE adsPutValue( ADSAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem
case HB_FT_IMAGE:
if( HB_IS_STRING( pItem ) )
{
ULONG ulLen;
HB_ULONG ulLen;
bTypeError = HB_FALSE;
ulLen = hb_itemGetCLen( pItem );
@@ -2676,21 +2676,21 @@ static HB_ERRCODE adsRecall( ADSAREAP pArea )
return u32RetVal == AE_SUCCESS ? HB_SUCCESS : HB_FAILURE;
}
static HB_ERRCODE adsRecCount( ADSAREAP pArea, ULONG * pRecCount )
static HB_ERRCODE adsRecCount( ADSAREAP pArea, HB_ULONG * pRecCount )
{
UNSIGNED32 u32RecCount = 0, u32Result;
HB_TRACE(HB_TR_DEBUG, ("adsRecCount(%p, %p)", pArea, pRecCount));
u32Result = AdsGetRecordCount( pArea->hTable, ADS_IGNOREFILTERS | ADS_REFRESHCOUNT, &u32RecCount );
*pRecCount = ( ULONG ) u32RecCount;
*pRecCount = ( HB_ULONG ) u32RecCount;
return u32Result == AE_SUCCESS ? HB_SUCCESS : HB_FAILURE;
}
static HB_ERRCODE adsRecInfo( ADSAREAP pArea, PHB_ITEM pRecID, HB_USHORT uiInfoType, PHB_ITEM pInfo )
{
ULONG ulRecNo = hb_itemGetNL( pRecID );
HB_ULONG ulRecNo = hb_itemGetNL( pRecID );
HB_ERRCODE uiRetVal = HB_SUCCESS;
HB_TRACE(HB_TR_DEBUG, ("adsRecInfo(%p, %p, %hu, %p)", pArea, pRecID, uiInfoType, pInfo));
@@ -2700,7 +2700,7 @@ static HB_ERRCODE adsRecInfo( ADSAREAP pArea, PHB_ITEM pRecID, HB_USHORT uiInfoT
case DBRI_DELETED:
{
HB_BOOL fDeleted = HB_FALSE;
ULONG ulCurrRec = 0;
HB_ULONG ulCurrRec = 0;
if( ulRecNo != 0 )
{
@@ -2752,7 +2752,7 @@ static HB_ERRCODE adsRecInfo( ADSAREAP pArea, PHB_ITEM pRecID, HB_USHORT uiInfoT
}
static HB_ERRCODE adsRecNo( ADSAREAP pArea, ULONG * ulRecNo )
static HB_ERRCODE adsRecNo( ADSAREAP pArea, HB_ULONG * ulRecNo )
{
UNSIGNED32 u32RecNo, u32Result;
@@ -2774,7 +2774,7 @@ static HB_ERRCODE adsRecNo( ADSAREAP pArea, ULONG * ulRecNo )
static HB_ERRCODE adsRecId( ADSAREAP pArea, PHB_ITEM pRecNo )
{
HB_ERRCODE errCode;
ULONG ulRecNo;
HB_ULONG ulRecNo;
HB_TRACE(HB_TR_DEBUG, ("adsRecId(%p, %p)", pArea, pRecNo));
@@ -2836,7 +2836,7 @@ static HB_ERRCODE adsCreate( ADSAREAP pArea, LPDBOPENINFO pCreateInfo )
pField = pArea->area.lpFields;
for( uiCount = 0; uiCount < pArea->area.uiFieldCount; uiCount++ )
{
if( ( ULONG ) pField->uiLen > pArea->maxFieldLen )
if( ( HB_ULONG ) pField->uiLen > pArea->maxFieldLen )
pArea->maxFieldLen = pField->uiLen;
cType = NULL;
@@ -3084,7 +3084,7 @@ static HB_ERRCODE adsInfo( ADSAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem )
hb_arrayNew( pItem, u16Count );
for( u16 = 0; u16 < u16Count; ++u16 )
{
hb_itemPutNL( hb_arrayGetItemPtr( pItem, ( ULONG ) u16 + 1 ),
hb_itemPutNL( hb_arrayGetItemPtr( pItem, ( HB_ULONG ) u16 + 1 ),
puLocks[ u16 ] );
}
}
@@ -3153,7 +3153,7 @@ static HB_ERRCODE adsInfo( ADSAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem )
AdsGetVersion( &ulMajor, &ulMinor, &ucLetter, ucDesc, &usDescLen);
hb_snprintf( ( char * ) ucVersion, sizeof( ucVersion ), "%s, v%lu.%lu%c",
( char * ) ucDesc, ( ULONG ) ulMajor, ( ULONG ) ulMinor, ucLetter );
( char * ) ucDesc, ( HB_ULONG ) ulMajor, ( HB_ULONG ) ulMinor, ucLetter );
hb_itemPutC( pItem, ( char * ) ucVersion );
break;
}
@@ -3541,7 +3541,7 @@ static HB_ERRCODE adsSysName( ADSAREAP pArea, HB_BYTE * pBuffer )
u32RetVal = AdsGetTableType( pArea->hTable, &u16TableType );
if( u32RetVal != AE_SUCCESS )
{
HB_TRACE(HB_TR_DEBUG, ("Error in adsSysName: %lu pArea->hTable %p\n", ( ULONG ) u32RetVal, ( void * ) ( HB_PTRDIFF ) pArea->hTable));
HB_TRACE(HB_TR_DEBUG, ("Error in adsSysName: %lu pArea->hTable %p\n", ( HB_ULONG ) u32RetVal, ( void * ) ( HB_PTRDIFF ) pArea->hTable));
u16TableType = ( UNSIGNED16 ) pArea->iFileType;
}
}
@@ -4233,7 +4233,7 @@ static HB_ERRCODE adsOrderInfo( ADSAREAP pArea, HB_USHORT uiIndex, LPDBORDERINFO
}
else
{
ULONG ulRecNo;
HB_ULONG ulRecNo;
SELF_RECNO( ( AREAP ) pArea, &ulRecNo );
hb_itemPutNL( pOrderInfo->itmResult, ulRecNo );
}
@@ -4334,7 +4334,7 @@ static HB_ERRCODE adsOrderInfo( ADSAREAP pArea, HB_USHORT uiIndex, LPDBORDERINFO
if( u16len )
{
ULONG ulRecNo;
HB_ULONG ulRecNo;
/* Have a scope, so walk it. Need Skips to obey filters with a scope.
With ADS_RESPECTFILTERS, ADS will respect both the
scope and the filter BUT it will walk all keys in the index
@@ -4619,7 +4619,7 @@ static HB_ERRCODE adsSetFilter( ADSAREAP pArea, LPDBFILTERINFO pFilterInfo )
#define adsError NULL
#define adsEvalBlock NULL
static HB_ERRCODE adsRawLock( ADSAREAP pArea, HB_USHORT uiAction, ULONG ulRecNo )
static HB_ERRCODE adsRawLock( ADSAREAP pArea, HB_USHORT uiAction, HB_ULONG ulRecNo )
{
UNSIGNED32 u32RetVal;
HB_TRACE(HB_TR_DEBUG, ("adsRawLock(%p, %hu, %lu)", pArea, uiAction, ulRecNo));
@@ -4637,7 +4637,7 @@ static HB_ERRCODE adsRawLock( ADSAREAP pArea, HB_USHORT uiAction, ULONG ulRecNo
/* Update phantom record status after locking */
if( !pArea->fPositioned )
{
ULONG ulCurRec;
HB_ULONG ulCurRec;
SELF_RECNO( ( AREAP ) pArea, &ulCurRec );
SELF_GOTO( ( AREAP ) pArea, ulCurRec );
}
@@ -4664,7 +4664,7 @@ static HB_ERRCODE adsRawLock( ADSAREAP pArea, HB_USHORT uiAction, ULONG ulRecNo
/* Update phantom record status after locking */
if( !pArea->fPositioned )
{
ULONG ulCurRec;
HB_ULONG ulCurRec;
SELF_RECNO( ( AREAP ) pArea, &ulCurRec );
SELF_GOTO( ( AREAP ) pArea, ulCurRec );
}
@@ -4688,11 +4688,11 @@ static HB_ERRCODE adsRawLock( ADSAREAP pArea, HB_USHORT uiAction, ULONG ulRecNo
static HB_ERRCODE adsLock( ADSAREAP pArea, LPDBLOCKINFO pLockInfo )
{
HB_USHORT uiAction;
ULONG ulRecNo;
HB_ULONG ulRecNo;
HB_TRACE(HB_TR_DEBUG, ("adsLock(%p, %p)", pArea, pLockInfo));
ulRecNo = ( ULONG ) hb_itemGetNL( pLockInfo->itmRecID );
ulRecNo = ( HB_ULONG ) hb_itemGetNL( pLockInfo->itmRecID );
switch( pLockInfo->uiMethod )
{
@@ -4731,7 +4731,7 @@ static HB_ERRCODE adsLock( ADSAREAP pArea, LPDBLOCKINFO pLockInfo )
static HB_ERRCODE adsUnLock( ADSAREAP pArea, PHB_ITEM pRecNo )
{
ULONG ulRecNo;
HB_ULONG ulRecNo;
HB_TRACE(HB_TR_DEBUG, ("adsUnLock(%p, %p)", pArea, pRecNo));
@@ -4814,7 +4814,7 @@ static HB_ERRCODE adsPutValueFile( ADSAREAP pArea, HB_USHORT uiIndex, const char
/* TODO: Use AdsDeleteFile() */
static HB_ERRCODE adsDrop( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, ULONG ulConnect )
static HB_ERRCODE adsDrop( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, HB_ULONG ulConnect )
{
char szFileName[ HB_PATH_MAX ];
const char * szFile;
@@ -4902,7 +4902,7 @@ static HB_ERRCODE adsDrop( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIn
UNSIGNED8 *pucFileName,
UNSIGNED16 *pusOnDisk );
*/
static HB_ERRCODE adsExists( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, ULONG ulConnect )
static HB_ERRCODE adsExists( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, HB_ULONG ulConnect )
{
char szFileName[ HB_PATH_MAX ];
const char * szFile;
@@ -4938,7 +4938,7 @@ static HB_ERRCODE adsExists( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItem
return hb_spFile( szFileName, NULL ) ? HB_SUCCESS : HB_FAILURE;
}
static HB_ERRCODE adsRename( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, PHB_ITEM pNewName, ULONG ulConnect )
static HB_ERRCODE adsRename( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, PHB_ITEM pNewName, HB_ULONG ulConnect )
{
HB_SYMBOL_UNUSED( pRDD );
HB_SYMBOL_UNUSED( pItemTable );
@@ -4980,7 +4980,7 @@ static HB_ERRCODE adsExit( LPRDDNODE pRDD )
}
static HB_ERRCODE adsRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem )
static HB_ERRCODE adsRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("adsRddInfo(%p, %hu, %lu, %p)", pRDD, uiIndex, ulConnect, pItem));
@@ -5302,7 +5302,7 @@ HB_FUNC( ADSSETRELKEYPOS )
HB_FUNC( ADSCUSTOMIZEAOF )
{
ADSAREAP pArea;
ULONG ulRecord = 0;
HB_ULONG ulRecord = 0;
UNSIGNED32 u32NumRecs = 0;
UNSIGNED32 u32RetVal = ( UNSIGNED32 ) ~AE_SUCCESS; /* initialize to something other than success */
UNSIGNED16 u16Option = ADS_AOF_ADD_RECORD;

14
harbour/contrib/rddads/adsfunc.c
View File

@@ -82,7 +82,7 @@ ADSHANDLE hb_ads_hConnect = 0;
HB_BOOL hb_ads_bOEM = HB_FALSE;
char * hb_adsOemToAnsi( const char * pszSrc, ULONG nLen )
char * hb_adsOemToAnsi( const char * pszSrc, HB_SIZE nLen )
{
if( hb_ads_bOEM )
{
@@ -106,7 +106,7 @@ char * hb_adsOemToAnsi( const char * pszSrc, ULONG nLen )
return ( char * ) pszSrc;
}
char * hb_adsAnsiToOem( const char * pszSrc, ULONG nLen )
char * hb_adsAnsiToOem( const char * pszSrc, HB_SIZE nLen )
{
if( hb_ads_bOEM )
{
@@ -319,7 +319,7 @@ HB_FUNC( ADSISRECORDLOCKED )
if( pArea )
{
ULONG ulRec;
HB_ULONG ulRec;
UNSIGNED16 pbLocked = 0;
if( HB_ISNUM( 1 ) )
@@ -605,7 +605,7 @@ HB_FUNC( ADSKEYCOUNT )
if( usBufLen ) /* had a scope with AOF or filter, walk it. Skips obey filters */
{
ULONG ulRecNo;
HB_ULONG ulRecNo;
UNSIGNED16 u16eof;
SELF_RECNO( ( AREAP ) pArea, &ulRecNo );
@@ -939,7 +939,7 @@ HB_FUNC( ADSGETFILTER )
}
else
{
HB_TRACE(HB_TR_DEBUG, ("adsGetFilter() error %lu", ( ULONG ) ulRetVal));
HB_TRACE(HB_TR_DEBUG, ("adsGetFilter() error %lu", ( HB_ULONG ) ulRetVal));
hb_retc_null();
}
@@ -1586,11 +1586,11 @@ HB_FUNC( ADSVERSION )
{
case 0:
hb_snprintf( ucVersion, sizeof( ucVersion ), "%lu.%lu%c",
( ULONG ) ulMajor, ( ULONG ) ulMinor, ucLetter );
( HB_ULONG ) ulMajor, ( HB_ULONG ) ulMinor, ucLetter );
break;
case 3:
hb_snprintf( ucVersion, sizeof( ucVersion ), "%s, v%lu.%lu%c",
( char * ) ucDesc, ( ULONG ) ulMajor, ( ULONG ) ulMinor, ucLetter );
( char * ) ucDesc, ( HB_ULONG ) ulMajor, ( HB_ULONG ) ulMinor, ucLetter );
break;
default:
ucVersion[ 0 ] = '\0';

6
harbour/contrib/rddads/adsmgmnt.c
View File

@@ -489,7 +489,7 @@ HB_FUNC( ADSMGGETOPENTABLES ) /* nMaxNumberOfFilesToReturn, cUserName, nConnecti
UNSIGNED16 ulCount;
for( ulCount = 1; ulCount <= usArrayLen; ulCount++ )
hb_arraySetC( pArray, ( ULONG ) ulCount, ( char * ) astOpenTableInfo[ ulCount - 1 ].aucTableName );
hb_arraySetC( pArray, ( HB_ULONG ) ulCount, ( char * ) astOpenTableInfo[ ulCount - 1 ].aucTableName );
hb_itemReturnRelease( pArray );
}
@@ -560,7 +560,7 @@ HB_FUNC( ADSMGGETOPENINDEXES ) /* nMaxNumberOfFilesToReturn, cTableName, cUserNa
UNSIGNED16 ulCount;
for( ulCount = 1; ulCount <= usArrayLen; ulCount++ )
hb_arraySetC( pArray, ( ULONG ) ulCount, ( char * ) astOpenIndexInfo[ ulCount - 1 ].aucIndexName );
hb_arraySetC( pArray, ( HB_ULONG ) ulCount, ( char * ) astOpenIndexInfo[ ulCount - 1 ].aucIndexName );
hb_itemReturnRelease( pArray );
}
@@ -593,7 +593,7 @@ HB_FUNC( ADSMGGETLOCKS )
UNSIGNED16 ulCount;
for( ulCount = 1; ulCount <= usArrayLen; ulCount++ )
hb_arraySetNL( pArray, ( ULONG ) ulCount, astRecordInfo[ ulCount - 1 ].ulRecordNumber );
hb_arraySetNL( pArray, ( HB_ULONG ) ulCount, astRecordInfo[ ulCount - 1 ].ulRecordNumber );
hb_itemReturnRelease( pArray );
}

70
harbour/contrib/rddads/adsx.c
View File

@@ -80,7 +80,7 @@
typedef struct _MIXKEY
{
ULONG rec;
HB_ULONG rec;
HB_BYTE val[ 1 ];
} MIXKEY, *LPMIXKEY;
@@ -98,12 +98,12 @@ typedef struct _MIXTAG
HB_USHORT uiLen;
LPMIXKEY* pKeys;
ULONG ulRecMax;
ULONG ulRecCount;
HB_ULONG ulRecMax;
HB_ULONG ulRecCount;
PHB_CODEPAGE pCodepage; /* National sorttable for character key tags, NULL otherwise */
ULONG ulKeyNo;
HB_ULONG ulKeyNo;
} MIXTAG, *LPMIXTAG;
@@ -178,25 +178,25 @@ static HB_ERRCODE hb_adsUpdateAreaFlags( ADSXAREAP pArea )
* Memory Index
*************************************************************************/
static LPMIXKEY mixKeyNew( PHB_ITEM pItem, ULONG ulRecNo, HB_BYTE bType, HB_USHORT uiLen )
static LPMIXKEY mixKeyNew( PHB_ITEM pItem, HB_ULONG ulRecNo, HB_BYTE bType, HB_USHORT uiLen )
{
LPMIXKEY pKey;
ULONG ul;
HB_ULONG ul;
double dbl;
HB_BYTE buf[ 8 ];
pKey = (LPMIXKEY) hb_xgrab( sizeof( ULONG ) + uiLen );
pKey = (LPMIXKEY) hb_xgrab( sizeof( HB_ULONG ) + uiLen );
pKey->rec = ulRecNo;
switch ( bType )
{
case 'C':
ul = hb_itemGetCLen( pItem );
if( ul > ( ULONG ) uiLen )
if( ul > ( HB_ULONG ) uiLen )
ul = uiLen;
memcpy( pKey->val, hb_itemGetCPtr( pItem ), ul );
if( ul < ( ULONG ) uiLen )
memset( pKey->val + ul, ' ', ( ULONG ) uiLen - ul );
if( ul < ( HB_ULONG ) uiLen )
memset( pKey->val + ul, ' ', ( HB_ULONG ) uiLen - ul );
break;
case 'N':
@@ -283,7 +283,7 @@ static int mixQSortCompare( LPMIXKEY p1, LPMIXKEY p2, HB_USHORT uiLen, PHB_CODEP
if( pCodepage )
{
i = hb_cdpcmp( ( const char * ) p1->val, ( ULONG ) uiLen, ( const char * ) p2->val, ( ULONG ) uiLen, pCodepage, 0 );
i = hb_cdpcmp( ( const char * ) p1->val, ( HB_ULONG ) uiLen, ( const char * ) p2->val, ( HB_ULONG ) uiLen, pCodepage, 0 );
}
else
i = memcmp( p1->val, p2->val, uiLen );
@@ -306,9 +306,9 @@ static int mixQSortCompare( LPMIXKEY p1, LPMIXKEY p2, HB_USHORT uiLen, PHB_CODEP
}
static void mixQSort( LPMIXKEY* pKeys, ULONG left, ULONG right, HB_USHORT uiLen, PHB_CODEPAGE pCodepage )
static void mixQSort( LPMIXKEY* pKeys, HB_ULONG left, HB_ULONG right, HB_USHORT uiLen, PHB_CODEPAGE pCodepage )
{
ULONG l, r;
HB_ULONG l, r;
LPMIXKEY x, h;
l = left;
@@ -338,9 +338,9 @@ static void mixQSort( LPMIXKEY* pKeys, ULONG left, ULONG right, HB_USHORT uiLen,
}
static LPMIXKEY mixFindKey( LPMIXTAG pTag, LPMIXKEY pKey, ULONG* ulKeyPos )
static LPMIXKEY mixFindKey( LPMIXTAG pTag, LPMIXKEY pKey, HB_ULONG* ulKeyPos )
{
ULONG l, r;
HB_ULONG l, r;
int i = 1;
if( ! pTag->ulRecCount )
@@ -379,7 +379,7 @@ static LPMIXKEY mixFindKey( LPMIXTAG pTag, LPMIXKEY pKey, ULONG* ulKeyPos )
}
static int mixCompareKey( LPMIXTAG pTag, ULONG ulKeyPos, LPMIXKEY pKey )
static int mixCompareKey( LPMIXTAG pTag, HB_ULONG ulKeyPos, LPMIXKEY pKey )
{
return mixQSortCompare( pTag->pKeys[ ulKeyPos ], pKey, pTag->uiLen, pTag->pCodepage );
}
@@ -393,7 +393,7 @@ static LPMIXTAG mixTagCreate( const char * szTagName, PHB_ITEM pKeyExpr, PHB_ITE
LPMIXKEY pKey;
LPDBORDERCONDINFO pOrdCondInfo = pArea->adsarea.area.lpdbOrdCondInfo;
ADSHANDLE hOrder;
ULONG ulRec, ulStartRec, ulNextCount = 0;
HB_ULONG ulRec, ulStartRec, ulNextCount = 0;
HB_LONG lStep = 0;
PHB_ITEM pItem, pEvalItem = NULL;
@@ -527,7 +527,7 @@ static LPMIXTAG mixTagCreate( const char * szTagName, PHB_ITEM pKeyExpr, PHB_ITE
static void mixTagDestroy( LPMIXTAG pTag )
{
ULONG ul;
HB_ULONG ul;
hb_xfree( pTag->szName );
hb_xfree( pTag->szKeyExpr );
@@ -585,7 +585,7 @@ static LPMIXTAG mixFindTag( ADSXAREAP pArea, PHB_ITEM pOrder )
static HB_ERRCODE adsxGoBottom( ADSXAREAP pArea )
{
LPMIXTAG pTag;
ULONG ulRecNo;
HB_ULONG ulRecNo;
pTag = pArea->pTagCurrent;
@@ -613,7 +613,7 @@ static HB_ERRCODE adsxGoBottom( ADSXAREAP pArea )
static HB_ERRCODE adsxGoTop( ADSXAREAP pArea )
{
LPMIXTAG pTag;
ULONG ulRecNo;
HB_ULONG ulRecNo;
pTag = pArea->pTagCurrent;
@@ -641,7 +641,7 @@ static HB_ERRCODE adsxGoTop( ADSXAREAP pArea )
static HB_ERRCODE adsxSeek( ADSXAREAP pArea, HB_BOOL bSoftSeek, PHB_ITEM pKey, HB_BOOL bFindLast )
{
LPMIXKEY pMixKey;
ULONG ulKeyPos, ulRecNo;
HB_ULONG ulKeyPos, ulRecNo;
HB_ERRCODE errCode;
HB_BOOL fFound = HB_FALSE;
@@ -649,7 +649,7 @@ static HB_ERRCODE adsxSeek( ADSXAREAP pArea, HB_BOOL bSoftSeek, PHB_ITEM pKey, H
return SUPER_SEEK( ( AREAP ) pArea, bSoftSeek, pKey, bFindLast );
/* TODO: pKey type validation, EG_DATATYPE runtime error */
pMixKey = mixKeyNew( pKey, bFindLast ? ( ULONG ) ( -1 ) : 0, pArea->pTagCurrent->bType,
pMixKey = mixKeyNew( pKey, bFindLast ? ( HB_ULONG ) ( -1 ) : 0, pArea->pTagCurrent->bType,
pArea->pTagCurrent->uiLen );
/* reset any pending relations - I hope ACE make the same and the problem
@@ -698,7 +698,7 @@ static HB_ERRCODE adsxSeek( ADSXAREAP pArea, HB_BOOL bSoftSeek, PHB_ITEM pKey, H
static HB_ERRCODE adsxSkip( ADSXAREAP pArea, HB_LONG lToSkip )
{
LPMIXKEY pKey;
ULONG ulKeyPos;
HB_ULONG ulKeyPos;
HB_ERRCODE errCode = HB_SUCCESS;
if( ! pArea->pTagCurrent || lToSkip == 0 )
@@ -724,8 +724,8 @@ static HB_ERRCODE adsxSkip( ADSXAREAP pArea, HB_LONG lToSkip )
pKey = mixKeyEval( pArea->pTagCurrent, pArea );
if( mixFindKey( pArea->pTagCurrent, pKey, &ulKeyPos ) &&
pArea->pTagCurrent->ulRecCount > ( ULONG ) lToSkip &&
ulKeyPos < pArea->pTagCurrent->ulRecCount - ( ULONG ) lToSkip )
pArea->pTagCurrent->ulRecCount > ( HB_ULONG ) lToSkip &&
ulKeyPos < pArea->pTagCurrent->ulRecCount - ( HB_ULONG ) lToSkip )
{
if( SELF_GOTO( ( AREAP ) pArea, pArea->pTagCurrent->pKeys[ ulKeyPos + lToSkip ]->rec ) == HB_FAILURE )
errCode = HB_FAILURE;
@@ -756,8 +756,8 @@ static HB_ERRCODE adsxSkip( ADSXAREAP pArea, HB_LONG lToSkip )
pKey = mixKeyEval( pArea->pTagCurrent, pArea );
if( mixFindKey( pArea->pTagCurrent, pKey, &ulKeyPos ) &&
pArea->pTagCurrent->ulRecCount >= ( ULONG ) ( -lToSkip ) &&
ulKeyPos >= ( ULONG ) ( -lToSkip ) )
pArea->pTagCurrent->ulRecCount >= ( HB_ULONG ) ( -lToSkip ) &&
ulKeyPos >= ( HB_ULONG ) ( -lToSkip ) )
{
if( SELF_GOTO( ( AREAP ) pArea, pArea->pTagCurrent->pKeys[ ulKeyPos + lToSkip ]->rec ) == HB_FAILURE )
errCode = HB_FAILURE;
@@ -871,7 +871,7 @@ static HB_ERRCODE adsxOrderCreate( ADSXAREAP pArea, LPDBORDERCREATEINFO pOrderIn
{
LPMIXTAG pTagNew, pTag;
PHB_ITEM pKeyItem, pForItem = NULL, pWhileItem = NULL, pResult;
ULONG ulRecNo;
HB_ULONG ulRecNo;
HB_USHORT uiLen;
HB_BYTE bType;
UNSIGNED16 bValidExpr;
@@ -1169,7 +1169,7 @@ static HB_ERRCODE adsxOrderInfo( ADSXAREAP pArea, HB_USHORT uiIndex, LPDBORDERIN
case DBOI_KEYNORAW :
if( uiIndex == DBOI_POSITION && pOrderInfo->itmNewVal && HB_IS_NUMERIC( pOrderInfo->itmNewVal ) )
{
ULONG ulPos;
HB_ULONG ulPos;
ulPos = hb_itemGetNL( pOrderInfo->itmNewVal ) ;
@@ -1180,8 +1180,8 @@ static HB_ERRCODE adsxOrderInfo( ADSXAREAP pArea, HB_USHORT uiIndex, LPDBORDERIN
}
else
{
LPMIXKEY pKey;
ULONG ulKeyPos;
LPMIXKEY pKey;
HB_ULONG ulKeyPos;
if( !pArea->adsarea.fPositioned )
SELF_GOTO( ( AREAP ) pArea, pArea->adsarea.ulRecNo );
@@ -1199,9 +1199,9 @@ static HB_ERRCODE adsxOrderInfo( ADSXAREAP pArea, HB_USHORT uiIndex, LPDBORDERIN
case DBOI_RELKEYPOS:
if( pOrderInfo->itmNewVal && HB_IS_NUMERIC( pOrderInfo->itmNewVal ) )
{
ULONG ulPos;
HB_ULONG ulPos;
ulPos = ( ULONG ) ( hb_itemGetND( pOrderInfo->itmNewVal ) * (double) pTag->ulRecCount );
ulPos = ( HB_ULONG ) ( hb_itemGetND( pOrderInfo->itmNewVal ) * (double) pTag->ulRecCount );
if( ulPos > 0 && ulPos <= pTag->ulRecCount )
SELF_GOTO( ( AREAP ) pArea, pTag->pKeys[ ulPos - 1 ]->rec );
@@ -1210,8 +1210,8 @@ static HB_ERRCODE adsxOrderInfo( ADSXAREAP pArea, HB_USHORT uiIndex, LPDBORDERIN
}
else
{
LPMIXKEY pKey;
ULONG ulKeyPos;
LPMIXKEY pKey;
HB_ULONG ulKeyPos;
if( !pArea->adsarea.fPositioned )
SELF_GOTO( ( AREAP ) pArea, pArea->adsarea.ulRecNo );

10
harbour/contrib/rddads/rddads.h
View File

@@ -145,10 +145,10 @@ typedef struct _ADSAREA_
LPDBRELINFO lpdbPendingRel; /* Pointer to parent rel struct */
char * szDataFileName; /* Name of data file */
ULONG ulRecordLen; /* Size of record */
ULONG ulRecNo; /* Current record */
HB_ULONG ulRecordLen; /* Size of record */
HB_ULONG ulRecNo; /* Current record */
HB_BYTE * pRecord; /* Buffer of record data */
ULONG maxFieldLen; /* Max field length in table record */
HB_ULONG maxFieldLen; /* Max field length in table record */
HB_BOOL fPositioned; /* HB_TRUE if we are not at phantom record */
HB_BOOL fShared; /* Shared file */
@@ -200,8 +200,8 @@ extern ADSAREAP hb_adsGetWorkAreaPointer( void );
#ifdef ADS_USE_OEM_TRANSLATION
extern HB_BOOL hb_ads_bOEM;
extern char * hb_adsOemToAnsi( const char * pcString, ULONG ulLen );
extern char * hb_adsAnsiToOem( const char * pcString, ULONG ulLen );
extern char * hb_adsOemToAnsi( const char * pcString, HB_SIZE ulLen );
extern char * hb_adsAnsiToOem( const char * pcString, HB_SIZE ulLen );
extern void hb_adsOemAnsiFree( char * pcString );
/* NOTE: Undocumented ACE function. */

14
harbour/contrib/rddsql/hbrddsql.h
View File

@@ -85,15 +85,15 @@ typedef struct _SQLBASEAREA
LPDBRELINFO lpdbPendingRel;
ULONG ulConnection;
HB_ULONG ulConnection;
struct _SQLDDCONNECTION * pConnection;
struct _SDDNODE * pSDD;
char * szQuery; /* SQL query */
ULONG ulRecNo; /* Current record number */
ULONG ulRecCount; /* Total records */
ULONG ulRecMax; /* Size of pRow, pRowFlags buffer */
HB_ULONG ulRecNo; /* Current record number */
HB_ULONG ulRecCount; /* Total records */
HB_ULONG ulRecMax; /* Size of pRow, pRowFlags buffer */
void ** pRow; /* array of native pointers or cached PHB_ITEM */
HB_BYTE * pRowFlags;
@@ -139,7 +139,7 @@ typedef struct _SQLDDCONNECTION
typedef struct _MIXKEY
{
ULONG rec;
HB_ULONG rec;
HB_BYTE notnul;
HB_BYTE val[ 1 ];
} MIXKEY, * PMIXKEY;
@@ -219,9 +219,9 @@ typedef HB_ERRCODE (* SDDFUNC_DISCONNECT )( SQLDDCONNECTION * pConnection );
typedef HB_ERRCODE (* SDDFUNC_EXECUTE )( SQLDDCONNECTION * pConnection, PHB_ITEM pItem );
typedef HB_ERRCODE (* SDDFUNC_OPEN )( SQLBASEAREAP pArea );
typedef HB_ERRCODE (* SDDFUNC_CLOSE )( SQLBASEAREAP pArea );
typedef HB_ERRCODE (* SDDFUNC_GOTO )( SQLBASEAREAP pArea, ULONG ulRecNo );
typedef HB_ERRCODE (* SDDFUNC_GOTO )( SQLBASEAREAP pArea, HB_ULONG ulRecNo );
typedef HB_ERRCODE (* SDDFUNC_GETVALUE )( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem );
typedef HB_ERRCODE (* SDDFUNC_GETVARLEN )( SQLBASEAREAP pArea, HB_USHORT uiIndex, ULONG * pLength );
typedef HB_ERRCODE (* SDDFUNC_GETVARLEN )( SQLBASEAREAP pArea, HB_USHORT uiIndex, HB_ULONG * pLength );
typedef struct _SDDNODE

6
harbour/contrib/rddsql/sddfb/fbirddd.c
View File

@@ -74,7 +74,7 @@ static HB_ERRCODE fbDisconnect( SQLDDCONNECTION * pConnection );
static HB_ERRCODE fbExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem );
static HB_ERRCODE fbOpen( SQLBASEAREAP pArea );
static HB_ERRCODE fbClose( SQLBASEAREAP pArea );
static HB_ERRCODE fbGoTo( SQLBASEAREAP pArea, ULONG ulRecNo );
static HB_ERRCODE fbGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo );
static SDDNODE firebirddd = {
@@ -144,7 +144,7 @@ static HB_ERRCODE fbConnect( SQLDDCONNECTION * pConnection, PHB_ITEM pItem )
isc_db_handle db = ( isc_db_handle ) 0;
char parambuf[ 520 ];
int i;
ULONG ul;
HB_ULONG ul;
i = 0;
parambuf[ i++ ] = isc_dpb_version1;
@@ -441,7 +441,7 @@ static HB_ERRCODE fbClose( SQLBASEAREAP pArea )
}
static HB_ERRCODE fbGoTo( SQLBASEAREAP pArea, ULONG ulRecNo )
static HB_ERRCODE fbGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo )
{
ISC_STATUS status[ 5 ];
XSQLVAR* pVar;

18
harbour/contrib/rddsql/sddmy/mysqldd.c
View File

@@ -76,7 +76,7 @@ static HB_ERRCODE mysqlDisconnect( SQLDDCONNECTION * pConnection );
static HB_ERRCODE mysqlExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem );
static HB_ERRCODE mysqlOpen( SQLBASEAREAP pArea );
static HB_ERRCODE mysqlClose( SQLBASEAREAP pArea );
static HB_ERRCODE mysqlGoTo( SQLBASEAREAP pArea, ULONG ulRecNo );
static HB_ERRCODE mysqlGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo );
static HB_ERRCODE mysqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem );
@@ -171,7 +171,7 @@ static HB_ERRCODE mysqlDisconnect( SQLDDCONNECTION * pConnection )
static HB_ERRCODE mysqlExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem )
{
MYSQL_RES * pResult;
ULONG ulAffectedRows;
HB_ULONG ulAffectedRows;
PHB_ITEM pNewID = NULL;
if ( mysql_real_query( ( MYSQL * ) pConnection->hConnection, hb_itemGetCPtr( pItem ), hb_itemGetCLen( pItem ) ) )
@@ -183,7 +183,7 @@ static HB_ERRCODE mysqlExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem )
pResult = mysql_store_result( ( MYSQL * ) pConnection->hConnection );
if ( pResult )
{
ulAffectedRows = ( ULONG ) mysql_num_rows( pResult );
ulAffectedRows = ( HB_ULONG ) mysql_num_rows( pResult );
mysql_free_result( pResult );
hb_rddsqlSetError( 0, NULL, hb_itemGetCPtr( pItem ), NULL, ulAffectedRows );
}
@@ -191,7 +191,7 @@ static HB_ERRCODE mysqlExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem )
{
if ( mysql_field_count( ( MYSQL * ) pConnection->hConnection ) == 0 )
{
ulAffectedRows = ( ULONG ) mysql_affected_rows( ( MYSQL * ) pConnection->hConnection );
ulAffectedRows = ( HB_ULONG ) mysql_affected_rows( ( MYSQL * ) pConnection->hConnection );
if( mysql_insert_id( ( MYSQL * ) pConnection->hConnection ) != 0 )
{
pNewID = hb_itemPutNInt( NULL, mysql_insert_id( ( MYSQL * ) pConnection->hConnection ) );
@@ -213,7 +213,7 @@ static HB_ERRCODE mysqlExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem )
static HB_ERRCODE mysqlOpen( SQLBASEAREAP pArea )
{
PHB_ITEM pItemEof, pItem;
ULONG ulIndex;
HB_ULONG ulIndex;
HB_USHORT uiFields, uiCount;
HB_ERRCODE errCode = 0;
HB_BOOL bError;
@@ -392,7 +392,7 @@ static HB_ERRCODE mysqlOpen( SQLBASEAREAP pArea )
return HB_FAILURE;
}
pArea->ulRecCount = ( ULONG ) mysql_num_rows( ( MYSQL_RES * ) pArea->pResult );
pArea->ulRecCount = ( HB_ULONG ) mysql_num_rows( ( MYSQL_RES * ) pArea->pResult );
pArea->pRow = ( void ** ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) );
@@ -427,7 +427,7 @@ static HB_ERRCODE mysqlClose( SQLBASEAREAP pArea )
}
static HB_ERRCODE mysqlGoTo( SQLBASEAREAP pArea, ULONG ulRecNo )
static HB_ERRCODE mysqlGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo )
{
if ( ulRecNo == 0 || ulRecNo > pArea->ulRecCount )
{
@@ -461,7 +461,7 @@ static HB_ERRCODE mysqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM
char szBuffer[ 64 ];
HB_BOOL bError;
PHB_ITEM pError;
ULONG ulLen;
HB_ULONG ulLen;
bError = HB_FALSE;
uiIndex--;
@@ -489,7 +489,7 @@ static HB_ERRCODE mysqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM
if ( pValue )
memcpy( pStr, pValue, ulLen );
if ( ( ULONG )pField->uiLen > ulLen )
if ( ( HB_ULONG )pField->uiLen > ulLen )
memset( pStr + ulLen, ' ', pField->uiLen - ulLen );
pStr[ pField->uiLen ] = '\0';

8
harbour/contrib/rddsql/sddodbc/odbcdd.c
View File

@@ -85,7 +85,7 @@ static HB_ERRCODE odbcDisconnect( SQLDDCONNECTION * pConnection );
static HB_ERRCODE odbcExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem );
static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea );
static HB_ERRCODE odbcClose( SQLBASEAREAP pArea );
static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, ULONG ulRecNo );
static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo );
static SDDNODE odbcdd =
@@ -425,7 +425,7 @@ static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea )
{
char* pStr;
pStr = ( char * ) hb_xgrab( ( ULONG ) pFieldInfo.uiLen + 1 );
pStr = ( char * ) hb_xgrab( ( HB_ULONG ) pFieldInfo.uiLen + 1 );
memset( pStr, ' ', pFieldInfo.uiLen );
pStr[ pFieldInfo.uiLen ] = '\0';
@@ -521,7 +521,7 @@ static HB_ERRCODE odbcClose( SQLBASEAREAP pArea )
}
static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, ULONG ulRecNo )
static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo )
{
SQLHSTMT hStmt = ( SQLHSTMT ) pArea->pStmt;
SQLRETURN res;
@@ -556,7 +556,7 @@ static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, ULONG ulRecNo )
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_CHAR, ( SQLCHAR * ) val, 1024, &iLen ) ) )
{
if( iLen > 0 )
pItem = hb_itemPutCL( NULL, val, ( ULONG ) iLen );
pItem = hb_itemPutCL( NULL, val, ( HB_ULONG ) iLen );
}
hb_xfree( val );
break;

6
harbour/contrib/rddsql/sddpg/pgsqldd.c
View File

@@ -444,7 +444,7 @@ static HB_ERRCODE pgsqlOpen( SQLBASEAREAP pArea )
return HB_FAILURE;
}
pArea->ulRecCount = ( ULONG ) PQntuples( pResult );
pArea->ulRecCount = ( HB_ULONG ) PQntuples( pResult );
pArea->pRow = ( void ** ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) );
@@ -475,7 +475,7 @@ static HB_ERRCODE pgsqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM
char* pValue;
HB_BOOL bError;
PHB_ITEM pError;
ULONG ulLen;
HB_ULONG ulLen;
bError = HB_FALSE;
uiIndex--;
@@ -485,7 +485,7 @@ static HB_ERRCODE pgsqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM
return HB_SUCCESS;
pValue = PQgetvalue( ( PGresult * ) pArea->pResult, pArea->ulRecNo - 1, uiIndex );
ulLen = ( ULONG ) PQgetlength( ( PGresult * ) pArea->pResult, pArea->ulRecNo - 1, uiIndex );
ulLen = ( HB_ULONG ) PQgetlength( ( PGresult * ) pArea->pResult, pArea->ulRecNo - 1, uiIndex );
/* printf( "fieldget recno:%d index:%d value:%s len:%d\n", pArea->ulRecNo, uiIndex, pValue, ulLen ); */

44
harbour/contrib/rddsql/sqlbase.c
View File

@@ -64,8 +64,8 @@
static HB_USHORT s_rddidSQLBASE = 0;
static SQLDDCONNECTION * s_pConnection = NULL;
static ULONG s_ulConnectionCount = 0;
static ULONG s_ulConnectionCurrent = 0;
static HB_ULONG s_ulConnectionCount = 0;
static HB_ULONG s_ulConnectionCurrent = 0;
static char * s_szError = NULL;
static HB_ERRCODE s_errCode = 0;
static char * s_szQuery = NULL;
@@ -126,9 +126,9 @@ static HB_ERRCODE sddDisconnect( SQLDDCONNECTION * pConnection );
static HB_ERRCODE sddExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem );
static HB_ERRCODE sddOpen( SQLBASEAREAP pArea );
static HB_ERRCODE sddClose( SQLBASEAREAP pArea );
static HB_ERRCODE sddGoTo( SQLBASEAREAP pArea, ULONG ulRecNo );
static HB_ERRCODE sddGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo );
static HB_ERRCODE sddGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem );
static HB_ERRCODE sddGetVarLen( SQLBASEAREAP pArea, HB_USHORT uiIndex, ULONG * pLength );
static HB_ERRCODE sddGetVarLen( SQLBASEAREAP pArea, HB_USHORT uiIndex, HB_ULONG * pLength );
static SDDNODE sddNull = {
@@ -186,7 +186,7 @@ static HB_ERRCODE sddClose( SQLBASEAREAP pArea )
}
static HB_ERRCODE sddGoTo( SQLBASEAREAP pArea, ULONG ulRecNo )
static HB_ERRCODE sddGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo )
{
if ( ulRecNo == 0 || ulRecNo > pArea->ulRecCount )
{
@@ -216,7 +216,7 @@ static HB_ERRCODE sddGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM p
}
static HB_ERRCODE sddGetVarLen( SQLBASEAREAP pArea, HB_USHORT uiIndex, ULONG * pLength )
static HB_ERRCODE sddGetVarLen( SQLBASEAREAP pArea, HB_USHORT uiIndex, HB_ULONG * pLength )
{
HB_SYMBOL_UNUSED( pArea );
HB_SYMBOL_UNUSED( uiIndex );
@@ -273,7 +273,7 @@ static HB_ERRCODE sqlbaseGoBottom( SQLBASEAREAP pArea )
return HB_FAILURE;
if ( ! pArea->fFetched && pArea->pSDD->GoTo( pArea, ( ULONG ) -1 ) == HB_FAILURE )
if ( ! pArea->fFetched && pArea->pSDD->GoTo( pArea, ( HB_ULONG ) -1 ) == HB_FAILURE )
return HB_FAILURE;
pArea->area.fTop = HB_FALSE;
@@ -286,7 +286,7 @@ static HB_ERRCODE sqlbaseGoBottom( SQLBASEAREAP pArea )
}
static HB_ERRCODE sqlbaseGoTo( SQLBASEAREAP pArea, ULONG ulRecNo )
static HB_ERRCODE sqlbaseGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo )
{
if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
return HB_FAILURE;
@@ -400,7 +400,7 @@ static HB_ERRCODE sqlbaseSkipRaw( SQLBASEAREAP pArea, HB_LONG lToSkip )
pArea->area.fBof = bBof;
pArea->area.fEof = bEof;
}
else if ( lToSkip < 0 && ( ULONG ) ( -lToSkip ) >= pArea->ulRecNo )
else if ( lToSkip < 0 && ( HB_ULONG ) ( -lToSkip ) >= pArea->ulRecNo )
{
errCode = SELF_GOTO( ( AREAP ) pArea, 1 );
pArea->area.fBof = HB_TRUE;
@@ -471,7 +471,7 @@ static HB_ERRCODE sqlbaseGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_IT
}
static HB_ERRCODE sqlbaseGetVarLen( SQLBASEAREAP pArea, HB_USHORT uiIndex, ULONG * pLength )
static HB_ERRCODE sqlbaseGetVarLen( SQLBASEAREAP pArea, HB_USHORT uiIndex, HB_ULONG * pLength )
{
/* TODO: should we use this code?
if ( pArea->area.lpFields[ uiIndex ].uiType == HB_IT_MEMO )
@@ -576,14 +576,14 @@ static HB_ERRCODE sqlbaseRecall( SQLBASEAREAP pArea )
}
static HB_ERRCODE sqlbaseRecCount( SQLBASEAREAP pArea, ULONG * pRecCount )
static HB_ERRCODE sqlbaseRecCount( SQLBASEAREAP pArea, HB_ULONG * pRecCount )
{
* pRecCount = pArea->ulRecCount;
return HB_SUCCESS;
}
static HB_ERRCODE sqlbaseRecNo( SQLBASEAREAP pArea, ULONG * ulRecNo )
static HB_ERRCODE sqlbaseRecNo( SQLBASEAREAP pArea, HB_ULONG * ulRecNo )
{
* ulRecNo = pArea->ulRecNo;
return HB_SUCCESS;
@@ -593,7 +593,7 @@ static HB_ERRCODE sqlbaseRecNo( SQLBASEAREAP pArea, ULONG * ulRecNo )
static HB_ERRCODE sqlbaseRecId( SQLBASEAREAP pArea, PHB_ITEM pRecNo )
{
HB_ERRCODE errCode;
ULONG ulRecNo;
HB_ULONG ulRecNo;
errCode = SELF_RECNO( ( AREAP ) pArea, &ulRecNo );
hb_itemPutNInt( pRecNo, ulRecNo );
@@ -613,7 +613,7 @@ static HB_ERRCODE sqlbaseClose( SQLBASEAREAP pArea )
if ( pArea->pRow )
{
ULONG ulIndex;
HB_ULONG ulIndex;
for ( ulIndex = 0; ulIndex <= pArea->ulRecCount; ulIndex++ )
{
@@ -902,7 +902,7 @@ static HB_ERRCODE sqlbaseInit( LPRDDNODE pRDD )
static HB_ERRCODE sqlbaseExit( LPRDDNODE pRDD )
{
ULONG ul;
HB_ULONG ul;
HB_SYMBOL_UNUSED( pRDD );
@@ -938,10 +938,10 @@ static HB_ERRCODE sqlbaseExit( LPRDDNODE pRDD )
}
static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem )
static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem )
{
ULONG ulConn;
SQLDDCONNECTION* pConn;
HB_ULONG ulConn;
SQLDDCONNECTION * pConn;
HB_SYMBOL_UNUSED( pRDD );
@@ -960,7 +960,7 @@ static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulCon
case RDDI_CONNECTION:
{
ULONG ulNewConnection = 0;
HB_ULONG ulNewConnection = 0;
if ( hb_itemType( pItem ) & HB_IT_NUMERIC )
{
@@ -985,9 +985,9 @@ static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulCon
case RDDI_CONNECT:
{
PSDDNODE pNode = NULL;
ULONG ul;
const char* pStr;
PSDDNODE pNode = NULL;
HB_ULONG ul;
const char * pStr;
/* Find free connection handle */
for ( ul = 0; ul < s_ulConnectionCount; ul++ )

44
harbour/contrib/rddsql/sqlmix.c
View File

@@ -142,9 +142,9 @@ static PMIXKEY hb_mixKeyNew( PMIXTAG pTag )
}
static PMIXKEY hb_mixKeyPutItem( PMIXKEY pKey, PHB_ITEM pItem, ULONG ulRecNo, PMIXTAG pTag )
static PMIXKEY hb_mixKeyPutItem( PMIXKEY pKey, PHB_ITEM pItem, HB_ULONG ulRecNo, PMIXTAG pTag )
{
ULONG ul;
HB_ULONG ul;
double dbl;
HB_BYTE buf[ 8 ];
@@ -160,13 +160,13 @@ static PMIXKEY hb_mixKeyPutItem( PMIXKEY pKey, PHB_ITEM pItem, ULONG ulRecNo, PM
case 'C':
ul = hb_itemGetCLen( pItem );
if ( ul > ( ULONG ) pTag->uiKeyLen )
if ( ul > ( HB_ULONG ) pTag->uiKeyLen )
ul = pTag->uiKeyLen;
memcpy( pKey->val, hb_itemGetCPtr( pItem ), ul );
if ( ul < ( ULONG ) pTag->uiKeyLen )
memset( pKey->val + ul, ' ', ( ULONG ) pTag->uiKeyLen - ul );
if ( ul < ( HB_ULONG ) pTag->uiKeyLen )
memset( pKey->val + ul, ' ', ( HB_ULONG ) pTag->uiKeyLen - ul );
break;
@@ -264,7 +264,7 @@ static int hb_mixKeyCompare( PMIXTAG pTag, PMIXKEY pKey1, PMIXKEY pKey2, unsigne
if ( pTag->pCodepage )
{
i = hb_cdpcmp( ( const char * ) pKey1->val, ( ULONG ) uiSize, ( const char * ) pKey2->val, ( ULONG ) uiSize, pTag->pCodepage, 0 );
i = hb_cdpcmp( ( const char * ) pKey1->val, ( HB_ULONG ) uiSize, ( const char * ) pKey2->val, ( HB_ULONG ) uiSize, pTag->pCodepage, 0 );
}
else
{
@@ -274,7 +274,7 @@ static int hb_mixKeyCompare( PMIXTAG pTag, PMIXKEY pKey1, PMIXKEY pKey2, unsigne
if ( i == 0 )
{
if ( pKey2->rec == ( ULONG ) -1 )
if ( pKey2->rec == ( HB_ULONG ) -1 )
{
/* This condition seems inverted, but it's ok for seek last */
if ( pTag->uiKeyLen > uiLen )
@@ -353,7 +353,7 @@ static void hb_mixTagPrintNode( PMIXTAG pTag, PMIXNODE pNode, int iLevel )
static PMIXNODE hb_mixTagCreateNode( PMIXTAG pTag, HB_BOOL fLeaf )
{
PMIXNODE pNode;
ULONG ulSize;
HB_ULONG ulSize;
ulSize = ( fLeaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + MIX_NODE_ORDER * pTag->uiTotalLen;
@@ -797,7 +797,7 @@ static PMIXTAG hb_mixTagCreate( const char* szTagName, PHB_ITEM pKeyExpr, PHB_IT
PMIXTAG pTag;
PMIXKEY pKey = NULL;
LPDBORDERCONDINFO pOrdCondInfo = pArea->sqlarea.area.lpdbOrdCondInfo;
ULONG ulStartRec, ulNextCount = 0;
HB_ULONG ulStartRec, ulNextCount = 0;
HB_LONG lStep = 0;
PHB_ITEM pItem, pEvalItem = NULL;
@@ -1174,9 +1174,9 @@ static PMIXTAG hb_mixFindTag( SQLMIXAREAP pArea, PHB_ITEM pOrder )
/*=======================================================================*/
static ULONG hb_mixTagNodeKeyCount( PMIXNODE pNode )
static HB_ULONG hb_mixTagNodeKeyCount( PMIXNODE pNode )
{
ULONG ulKeyCount;
HB_ULONG ulKeyCount;
unsigned int ui;
ulKeyCount = pNode->KeyCount;
@@ -1189,7 +1189,7 @@ static ULONG hb_mixTagNodeKeyCount( PMIXNODE pNode )
}
static HB_BOOL hb_mixCheckRecordFilter( SQLMIXAREAP pArea, ULONG ulRecNo )
static HB_BOOL hb_mixCheckRecordFilter( SQLMIXAREAP pArea, HB_ULONG ulRecNo )
{
HB_BOOL lResult = HB_FALSE;
@@ -1211,9 +1211,9 @@ static HB_BOOL hb_mixCheckRecordFilter( SQLMIXAREAP pArea, ULONG ulRecNo )
}
static ULONG hb_mixDBOIKeyCount( PMIXTAG pTag, HB_BOOL fFilter )
static HB_ULONG hb_mixDBOIKeyCount( PMIXTAG pTag, HB_BOOL fFilter )
{
ULONG ulKeyCount;
HB_ULONG ulKeyCount;
if ( ! pTag )
return 0;
@@ -1222,7 +1222,7 @@ static ULONG hb_mixDBOIKeyCount( PMIXTAG pTag, HB_BOOL fFilter )
{
PMIXNODE pNode = pTag->CurNode;
unsigned int uiPos = pTag->CurPos;
ULONG ulRecNo = pTag->pArea->sqlarea.ulRecNo;
HB_ULONG ulRecNo = pTag->pArea->sqlarea.ulRecNo;
ulKeyCount = 0;
@@ -1245,9 +1245,9 @@ static ULONG hb_mixDBOIKeyCount( PMIXTAG pTag, HB_BOOL fFilter )
}
static ULONG hb_mixDBOIKeyNo( PMIXTAG pTag, HB_BOOL fFilter )
static HB_ULONG hb_mixDBOIKeyNo( PMIXTAG pTag, HB_BOOL fFilter )
{
ULONG ulKeyCount;
HB_ULONG ulKeyCount;
if ( ! pTag )
return 0;
@@ -1361,7 +1361,7 @@ static HB_ERRCODE sqlmixSeek( SQLMIXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pIt
pArea->sqlarea.area.fTop = pArea->sqlarea.area.fBottom = HB_FALSE;
pArea->sqlarea.area.fEof = HB_FALSE;
pKey = hb_mixKeyPutItem( NULL, pItem, fFindLast ? ( ULONG ) -1 : 0, pTag );
pKey = hb_mixKeyPutItem( NULL, pItem, fFindLast ? ( HB_ULONG ) -1 : 0, pTag );
uiKeyLen = pTag->uiKeyLen;
if ( pTag->bType == 'C' )
@@ -1381,14 +1381,14 @@ static HB_ERRCODE sqlmixSeek( SQLMIXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pIt
else
hb_mixTagSkip( pTag, -1 );
pArea->sqlarea.area.fFound = ! pTag->fEof && ( uiKeyLen == 0 || memcmp( pTag->CurKey->val, pKey->val, ( ULONG ) uiKeyLen ) == 0 );
pArea->sqlarea.area.fFound = ! pTag->fEof && ( uiKeyLen == 0 || memcmp( pTag->CurKey->val, pKey->val, ( HB_ULONG ) uiKeyLen ) == 0 );
if ( ! pArea->sqlarea.area.fFound )
hb_mixTagSetCurrent( pTag, pNode, ui );
}
else
{
pArea->sqlarea.area.fFound = ! pTag->fEof && ( uiKeyLen == 0 || memcmp( pTag->CurKey->val, pKey->val, ( ULONG ) uiKeyLen ) == 0 );
pArea->sqlarea.area.fFound = ! pTag->fEof && ( uiKeyLen == 0 || memcmp( pTag->CurKey->val, pKey->val, ( HB_ULONG ) uiKeyLen ) == 0 );
}
fEOF = pTag->fEof;
@@ -1401,7 +1401,7 @@ static HB_ERRCODE sqlmixSeek( SQLMIXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pIt
errCode = SELF_SKIPFILTER( ( AREAP ) pArea, fFindLast ? -1 : 1 );
if ( errCode != HB_FAILURE && pArea->sqlarea.fPositioned )
{
pArea->sqlarea.area.fFound = ( uiKeyLen == 0 || memcmp( pTag->CurKey->val, pKey->val, ( ULONG ) uiKeyLen ) == 0 );
pArea->sqlarea.area.fFound = ( uiKeyLen == 0 || memcmp( pTag->CurKey->val, pKey->val, ( HB_ULONG ) uiKeyLen ) == 0 );
if ( ! pArea->sqlarea.area.fFound && ! fSoftSeek )
fEOF = HB_TRUE;
}
@@ -1607,7 +1607,7 @@ static HB_ERRCODE sqlmixOrderCreate( SQLMIXAREAP pArea, LPDBORDERCREATEINFO pOrd
{
PMIXTAG pTagNew, pTag;
PHB_ITEM pKeyItem, pForItem = NULL, pWhileItem = NULL, pResult;
ULONG ulRecNo;
HB_ULONG ulRecNo;
HB_USHORT uiLen;
HB_BYTE bType;

28
harbour/contrib/xhb/bkgtsks.c
View File

@@ -80,30 +80,30 @@ HB_EXTERN_BEGIN
typedef struct HB_BACKGROUNDTASK_
{
ULONG ulTaskID; /* task identifier */
HB_ULONG ulTaskID; /* task identifier */
PHB_ITEM pTask; /* pointer to the task item */
double dSeconds; /* internal - last time this task has gone */
int millisec; /* milliseconds after this task must run */
HB_BOOL bActive; /* task is active ? */
} HB_BACKGROUNDTASK, * PHB_BACKGROUNDTASK, * HB_BACKGROUNDTASK_PTR;
extern void hb_backgroundRunSingle( ULONG ulID ); /* run a single background routine */
extern void hb_backgroundRunSingle( HB_ULONG ulID ); /* run a single background routine */
extern void hb_backgroundRunForced( void ); /* run all background routines also if them are not active*/
extern void hb_backgroundRun( void ); /* run all background routines but only if them are active*/
extern void hb_backgroundReset( void ); /* reset internal counter */
extern void hb_backgroundShutDown( void ); /* closes all background tasks */
extern ULONG hb_backgroundAddFunc( PHB_ITEM pBlock, int nMillisec, HB_BOOL bActive ); /* Adds a codeblock or an executable array */
extern PHB_ITEM hb_backgroundDelFunc( ULONG ulID ); /* Deletes a prevuiously added task */
extern PHB_BACKGROUNDTASK hb_backgroundFind( ULONG ulID );
extern HB_BOOL hb_backgroundActive( ULONG ulID, HB_BOOL bActive );
extern int hb_backgroundTime( ULONG ulID, int nMillisec );
extern HB_ULONG hb_backgroundAddFunc( PHB_ITEM pBlock, int nMillisec, HB_BOOL bActive ); /* Adds a codeblock or an executable array */
extern PHB_ITEM hb_backgroundDelFunc( HB_ULONG ulID ); /* Deletes a prevuiously added task */
extern PHB_BACKGROUNDTASK hb_backgroundFind( HB_ULONG ulID );
extern HB_BOOL hb_backgroundActive( HB_ULONG ulID, HB_BOOL bActive );
extern int hb_backgroundTime( HB_ULONG ulID, int nMillisec );
HB_EXTERN_END
#ifndef HB_THREAD_SUPPORT
/* Task ID */
static ULONG s_ulBackgroundID = 0;
static HB_ULONG s_ulBackgroundID = 0;
/* list of background tasks
* A pointer into an array of pointers to items with a codeblock
@@ -132,7 +132,7 @@ static HB_USHORT s_uiBackgroundMaxTask = 0;
/* ------------------------ C LEVEL ------------------------------ */
ULONG hb_backgroundAddFunc( PHB_ITEM pBlock, int nMillisec, HB_BOOL bActive )
HB_ULONG hb_backgroundAddFunc( PHB_ITEM pBlock, int nMillisec, HB_BOOL bActive )
{
PHB_BACKGROUNDTASK pBkgTask;
@@ -236,7 +236,7 @@ void hb_backgroundRunForced( void )
}
/* RUN only one tasks, intentionally no check if bacground are active is done */
void hb_backgroundRunSingle( ULONG ulID )
void hb_backgroundRunSingle( HB_ULONG ulID )
{
PHB_BACKGROUNDTASK pBkgTask;
@@ -280,7 +280,7 @@ void hb_backgroundShutDown( void )
}
/* caller have to free return ITEM by hb_itemRelease() if it's not NULL */
PHB_ITEM hb_backgroundDelFunc( ULONG ulID )
PHB_ITEM hb_backgroundDelFunc( HB_ULONG ulID )
{
int iTask;
PHB_BACKGROUNDTASK pBkgTask;
@@ -325,7 +325,7 @@ PHB_ITEM hb_backgroundDelFunc( ULONG ulID )
}
/* Find a task */
PHB_BACKGROUNDTASK hb_backgroundFind( ULONG ulID )
PHB_BACKGROUNDTASK hb_backgroundFind( HB_ULONG ulID )
{
int iTask;
PHB_BACKGROUNDTASK pBkgTask;
@@ -344,7 +344,7 @@ PHB_BACKGROUNDTASK hb_backgroundFind( ULONG ulID )
}
/* Set task as active */
HB_BOOL hb_backgroundActive( ULONG ulID, HB_BOOL bActive )
HB_BOOL hb_backgroundActive( HB_ULONG ulID, HB_BOOL bActive )
{
PHB_BACKGROUNDTASK pBkgTask;
HB_BOOL bOldState = HB_FALSE;
@@ -361,7 +361,7 @@ HB_BOOL hb_backgroundActive( ULONG ulID, HB_BOOL bActive )
}
/* Set task time */
int hb_backgroundTime( ULONG ulID, int nMillisec )
int hb_backgroundTime( HB_ULONG ulID, int nMillisec )
{
PHB_BACKGROUNDTASK pBkgTask;
int nOldState = 0;

10
harbour/contrib/xhb/datesxhb.c
View File

@@ -58,23 +58,23 @@
/* NOTE: szTime must be 9 chars large. */
static ULONG hb_TimeStrToSec( const char * pszTime )
static HB_ULONG hb_TimeStrToSec( const char * pszTime )
{
HB_SIZE ulLen;
ULONG ulTime = 0;
HB_ULONG ulTime = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_TimeStrToSec(%s)", pszTime));
ulLen = strlen( pszTime );
if( ulLen >= 1 )
ulTime += ( ULONG ) hb_strVal( pszTime, ulLen ) * 3600;
ulTime += ( HB_ULONG ) hb_strVal( pszTime, ulLen ) * 3600;
if( ulLen >= 4 )
ulTime += ( ULONG ) hb_strVal( pszTime + 3, ulLen - 3 ) * 60;
ulTime += ( HB_ULONG ) hb_strVal( pszTime + 3, ulLen - 3 ) * 60;
if( ulLen >= 7 )
ulTime += ( ULONG ) hb_strVal( pszTime + 6, ulLen - 6 );
ulTime += ( HB_ULONG ) hb_strVal( pszTime + 6, ulLen - 6 );
return ulTime;
}

6
harbour/contrib/xhb/fparse.c
View File

@@ -515,7 +515,7 @@ HB_FUNC( FWORDCOUNT )
char **tokens;
int iCharCount = 0;
HB_BYTE nByte = ' ';
ULONG ulWordCount = 0;
HB_ULONG ulWordCount = 0;
/* file parameter correctly passed */
if ( !pSrc )
@@ -571,7 +571,7 @@ HB_FUNC( FLINECOUNT )
{
FILE *inFile ;
PHB_ITEM pSrc = hb_param(1, HB_IT_STRING);
ULONG ulLineCount = 0;
HB_ULONG ulLineCount = 0;
int ch;
/* file parameter correctly passed */
@@ -618,7 +618,7 @@ HB_FUNC( FCHARCOUNT )
{
FILE *inFile ;
PHB_ITEM pSrc = hb_param(1, HB_IT_STRING);
ULONG ulResult = 0;
HB_ULONG ulResult = 0;
int ch;
/* file parameter correctly passed */

80
harbour/contrib/xhb/hbcrypt.c
View File

@@ -86,9 +86,7 @@ void nxs_crypt(
{
if( keylen > NXS_MAX_KEYLEN )
{
keylen = NXS_MAX_KEYLEN;
}
#ifdef DEBUG_0
memcpy( cipher, source, srclen );
@@ -113,9 +111,7 @@ void nxs_decrypt(
unsigned char *result )
{
if( keylen > NXS_MAX_KEYLEN )
{
keylen = NXS_MAX_KEYLEN;
}
memcpy( result, cipher, cipherlen );
@@ -140,15 +136,11 @@ void nxs_scramble(
int scramble[ NXS_MAX_KEYLEN ];
HB_SIZE len;
if ( keylen > NXS_MAX_KEYLEN )
{
if( keylen > NXS_MAX_KEYLEN )
keylen = NXS_MAX_KEYLEN;
}
if ( keylen > srclen )
{
if( keylen > srclen )
keylen = srclen;
}
/* First step: find key ordering */
nxs_make_scramble( scramble, key, keylen );
@@ -177,7 +169,7 @@ void nxs_partial_scramble(
{
cipher[ pos + scramble[ kpos ] ] = source[ pos + kpos ];
kpos++;
if ( kpos >= ( HB_USHORT ) keylen )
if( kpos >= ( HB_USHORT ) keylen )
{
kpos = 0;
pos += keylen;
@@ -193,15 +185,11 @@ void nxs_unscramble(
int scramble[ NXS_MAX_KEYLEN ];
HB_SIZE len;
if ( keylen > NXS_MAX_KEYLEN )
{
if( keylen > NXS_MAX_KEYLEN )
keylen = NXS_MAX_KEYLEN;
}
if ( keylen > cipherlen )
{
if( keylen > cipherlen )
keylen = cipherlen;
}
/* First step: find key ordering */
nxs_make_scramble( scramble, key, keylen );
@@ -231,7 +219,7 @@ void nxs_partial_unscramble(
{
buf[ kpos ] = cipher[ pos + scramble[ kpos ] ];
kpos++;
if ( kpos >= ( HB_USHORT ) keylen )
if( kpos >= ( HB_USHORT ) keylen )
{
memcpy( cipher + pos, buf, keylen );
kpos = 0;
@@ -252,24 +240,20 @@ void nxs_xorcode(
c_bitrest = cipher[ 0 ] >>5;
while ( pos < cipherlen )
while( pos < cipherlen )
{
cipher[pos] <<= 3;
if (keypos == ( HB_USHORT ) keylen-1 || pos == cipherlen -1 )
{
if(keypos == ( HB_USHORT ) keylen-1 || pos == cipherlen -1 )
cipher[pos] |= c_bitrest;
}
else
{
cipher[pos] |= cipher[pos+1] >> 5;
}
cipher[pos] ^= key[ keypos ];
keypos ++;
pos++;
if (keypos == ( HB_USHORT ) keylen )
if(keypos == ( HB_USHORT ) keylen )
{
keypos = 0;
c_bitrest = cipher[ pos ] >>5;
@@ -286,13 +270,12 @@ void nxs_xordecode(
unsigned char c_bitrest, c_bitleft;
/* A very short block? */
if ( keylen > cipherlen - pos )
{
if( keylen > cipherlen - pos )
keylen = ( HB_USHORT ) ( cipherlen - pos);
}
c_bitleft = ( cipher[ keylen -1 ] ^ key[ keylen -1 ])<< 5;
while ( pos < cipherlen )
while( pos < cipherlen )
{
cipher[pos] ^= key[ keypos ];
@@ -304,11 +287,11 @@ void nxs_xordecode(
keypos ++;
pos ++;
if (keypos == ( HB_USHORT ) keylen )
if(keypos == ( HB_USHORT ) keylen )
{
keypos = 0;
/* last block */
if ( keylen > cipherlen - pos )
if( keylen > cipherlen - pos )
{
keylen = ( HB_USHORT ) (cipherlen - pos);
}
@@ -320,12 +303,12 @@ void nxs_xordecode(
/* pass three: xor the source with the cyclic key */
void nxs_xorcyclic(
unsigned char *cipher, HB_SIZE cipherlen,
const unsigned char *key, HB_SIZE keylen )
unsigned char * cipher, HB_SIZE cipherlen,
const unsigned char * key, HB_SIZE keylen )
{
HB_SIZE pos=0l, crcpos=0l;
ULONG crc1, crc2, crc3;
ULONG crc1l, crc2l, crc3l;
HB_SIZE pos = 0l, crcpos = 0l;
HB_U32 crc1, crc2, crc3;
HB_U32 crc1l, crc2l, crc3l;
/* Build the cyclic key seed */
crc1 = keylen >= 2 ? hb_adler32( 0, ( const char * ) key + 0, keylen - 2 ) : 1;
@@ -336,27 +319,28 @@ void nxs_xorcyclic(
crc2l = crc2 = nxs_cyclic_sequence( crc2 );
crc3l = crc3 = nxs_cyclic_sequence( crc3 );
while ( pos < cipherlen)
while( pos < cipherlen )
{
if ( crcpos < 4 )
if( crcpos < 4 )
{
/* this ensures portability across platforms */
cipher[ pos ] ^= (unsigned char) (crc1l % 256 );
crc1l /= 256l;
}
else if ( crcpos < 8 )
else if( crcpos < 8 )
{
cipher[ pos ] ^= (unsigned char) (crc2l % 256 );
crc2l /= 256l;
}
else {
else
{
cipher[ pos ] ^= (unsigned char) (crc3l % 256 );
crc3l /= 256l;
}
crcpos++;
pos++;
if (crcpos == 12 )
if( crcpos == 12 )
{
crcpos = 0;
crc1l = crc1 = nxs_cyclic_sequence( crc1 );
@@ -366,11 +350,11 @@ void nxs_xorcyclic(
}
}
ULONG nxs_cyclic_sequence( ULONG input )
HB_U32 nxs_cyclic_sequence( HB_U32 input )
{
ULONG first = input & 0xffff;
ULONG second = input >> 16;
ULONG ret = ( ( second * BASE * BASE ) & 0xffff ) |
HB_U32 first = input & 0xffff;
HB_U32 second = input >> 16;
HB_U32 ret = ( ( second * BASE * BASE ) & 0xffff ) |
( (first * BASE * BASE) &0xffff0000);
return ret;
@@ -379,12 +363,10 @@ ULONG nxs_cyclic_sequence( ULONG input )
void nxs_make_scramble( int *scramble, const unsigned char *key, HB_SIZE keylen )
{
HB_SIZE i,j, tmp;
HB_SIZE i, j, tmp;
for (i = 0; i < keylen; i ++ )
{
for( i = 0; i < keylen; i ++ )
scramble[ i ] = i;
}
for( i = 0; i < keylen; i ++ )
{

2
harbour/contrib/xhb/hbnxs.h
View File

@@ -112,7 +112,7 @@ void nxs_xorcyclic(
unsigned char *cipher, HB_SIZE cipherlen,
const unsigned char *key, HB_SIZE keylen );
ULONG nxs_cyclic_sequence( ULONG input );
HB_U32 nxs_cyclic_sequence( HB_U32 input );
void nxs_make_scramble(
int *scramble,

2
harbour/contrib/xpp/dbcmdx.c
View File

@@ -132,7 +132,7 @@ HB_FUNC( DBSKIPPER )
HB_LONG lSkipped = 0;
HB_LONG lRecs = 1;
HB_BOOL fBEof;
ULONG ulRecords = 0;
HB_ULONG ulRecords = 0;
if( SELF_RECCOUNT( pArea, &ulRecords ) == HB_SUCCESS && ulRecords > 0 )
{

40
harbour/include/hbapi.h
View File

@@ -271,7 +271,7 @@ struct _HB_EXTREF;
typedef struct _HB_STACK_STATE
{
HB_LONG lBaseItem; /* stack base offset of previous func/proc */
ULONG ulPrivateBase; /* memvars base offset of previous func/proc */
HB_ULONG ulPrivateBase; /* memvars base offset of previous func/proc */
void * pStatics; /* statics frame of previous func/proc */
HB_USHORT uiClass; /* class when message is sent */
HB_USHORT uiMethod; /* number of class method */
@@ -385,7 +385,7 @@ struct hb_struSymbol
struct hb_struRecover
{
const HB_BYTE * recover; /* address of recover code */
ULONG base; /* previous recover base */
HB_ULONG base; /* previous recover base */
HB_USHORT flags; /* previous recovery state and recover type */
HB_USHORT request; /* requested action */
};
@@ -484,17 +484,17 @@ typedef unsigned int HB_ERRCODE;
extern HB_SYMB hb_symEval;
extern HB_EXPORT void hb_xinit( void ); /* Initialize fixed memory subsystem */
extern HB_EXPORT void hb_xexit( void ); /* Deinitialize fixed memory subsystem */
extern HB_EXPORT void * hb_xalloc( HB_SIZE ulSize ); /* allocates memory, returns NULL on failure */
extern HB_EXPORT void * hb_xgrab( HB_SIZE ulSize ) HB_MALLOC_ATTR HB_ALLOC_SIZE_ATTR( 1 ); /* allocates memory, exits on failure */
extern HB_EXPORT void hb_xfree( void * pMem ); /* frees memory */
extern HB_EXPORT void * hb_xrealloc( void * pMem, HB_SIZE ulSize ) HB_ALLOC_SIZE_ATTR( 2 ); /* reallocates memory */
extern HB_EXPORT HB_SIZE hb_xsize( void * pMem ); /* returns the size of an allocated memory block */
extern HB_EXPORT ULONG hb_xquery( int iMode ); /* Query different types of memory information */
extern HB_EXPORT HB_BOOL hb_xtraced( void );
extern HB_EXPORT void hb_xsetfilename( const char * szValue );
extern HB_EXPORT void hb_xsetinfo( const char * szValue );
extern HB_EXPORT void hb_xinit( void ); /* Initialize fixed memory subsystem */
extern HB_EXPORT void hb_xexit( void ); /* Deinitialize fixed memory subsystem */
extern HB_EXPORT void * hb_xalloc( HB_SIZE ulSize ); /* allocates memory, returns NULL on failure */
extern HB_EXPORT void * hb_xgrab( HB_SIZE ulSize ) HB_MALLOC_ATTR HB_ALLOC_SIZE_ATTR( 1 ); /* allocates memory, exits on failure */
extern HB_EXPORT void hb_xfree( void * pMem ); /* frees memory */
extern HB_EXPORT void * hb_xrealloc( void * pMem, HB_SIZE ulSize ) HB_ALLOC_SIZE_ATTR( 2 ); /* reallocates memory */
extern HB_EXPORT HB_SIZE hb_xsize( void * pMem ); /* returns the size of an allocated memory block */
extern HB_EXPORT HB_ULONG hb_xquery( int iMode ); /* Query different types of memory information */
extern HB_EXPORT HB_BOOL hb_xtraced( void );
extern HB_EXPORT void hb_xsetfilename( const char * szValue );
extern HB_EXPORT void hb_xsetinfo( const char * szValue );
#ifdef _HB_API_INTERNAL_
extern void hb_xinit_thread( void );
extern void hb_xexit_thread( void );
@@ -537,12 +537,12 @@ extern void * hb_xRefResize( void * pMem, HB_SIZE ulSave, HB_SIZE ulSize, HB
and only on 16bit platforms, so the below condition seems to be
more reasonable. */
#if UINT_MAX > USHRT_MAX
/* NOTE: memcpy/memset can work with ULONG data blocks */
/* NOTE: memcpy/memset can work with HB_ULONG data blocks */
#define hb_xmemcpy memcpy
#define hb_xmemset memset
#else
/* NOTE: otherwise, the hb_xmemcpy and hb_xmemset functions
will be used to copy and/or set ULONG data blocks */
will be used to copy and/or set HB_ULONG data blocks */
extern HB_EXPORT void * hb_xmemcpy( void * pDestArg, void * pSourceArg, HB_SIZE ulLen ); /* copy more than memcpy() can */
extern HB_EXPORT void * hb_xmemset( void * pDestArg, int iFill, HB_SIZE ulLen ); /* set more than memset() can */
#endif
@@ -620,7 +620,7 @@ extern void hb_gcCollect( void ); /* checks if a single memory block can b
extern void hb_gcCollectAll( HB_BOOL fForce ); /* checks if all memory blocks can be released */
/* Extend API */
extern HB_EXPORT ULONG hb_parinfo( int iParam ); /* Determine the param count or data type */
extern HB_EXPORT HB_ULONG hb_parinfo( int iParam ); /* Determine the param count or data type */
extern HB_EXPORT HB_SIZE hb_parinfa( int iParamNum, HB_SIZE uiArrayIndex ); /* retrieve length or element type of an array parameter */
extern HB_EXPORT PHB_ITEM hb_param( int iParam, long lMask ); /* retrieve a generic parameter */
extern HB_EXPORT PHB_ITEM hb_paramError( int iParam ); /* Returns either the generic parameter or a NIL item if param not provided */
@@ -701,7 +701,7 @@ extern HB_EXPORT void hb_retnll( HB_LONGLONG lNumber );/* returns a long long
extern HB_EXPORT void hb_retnlllen( HB_LONGLONG lNumber, int iWidth ); /* returns a long long number, with specific width */
#endif
#define HB_IS_VALID_INDEX( idx, max ) ( (idx) > 0 && ( ULONG ) (idx) <= (max) )
#define HB_IS_VALID_INDEX( idx, max ) ( (idx) > 0 && ( HB_ULONG ) (idx) <= (max) )
#ifdef HB_LEGACY_LEVEL2
/* xHarbour compatible functions */
@@ -1024,7 +1024,7 @@ extern HB_BOOL hb_cmdargIsInternal( const char * szArg, int * piLen ); /*
extern HB_BOOL hb_cmdargCheck( const char * pszName ); /* Check if a given internal switch (like //INFO) was set */
extern char * hb_cmdargString( const char * pszName ); /* Returns the string value of an internal switch (like //TEMPPATH:"C:\") */
extern int hb_cmdargNum( const char * pszName ); /* Returns the numeric value of an internal switch (like //F:90) */
extern ULONG hb_cmdargProcessVM( int*, int* ); /* Check for command line internal arguments */
extern HB_ULONG hb_cmdargProcessVM( int*, int* ); /* Check for command line internal arguments */
#if defined( HB_OS_WIN ) && defined( HB_OS_WIN_USED )
extern HB_EXPORT void hb_winmainArgInit( HANDLE hInstance, HANDLE hPrevInstance, int iCmdShow ); /* Set WinMain() parameters */
extern HB_EXPORT HB_BOOL hb_winmainArgGet( HANDLE * phInstance, HANDLE * phPrevInstance, int * piCmdShow ); /* Retrieve WinMain() parameters */
@@ -1044,8 +1044,8 @@ extern void hb_memvarSetValue( PHB_SYMB pMemvarSymb, HB_ITEM_PTR pItem );
extern HB_ERRCODE hb_memvarGet( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb ); /* copy an symbol value into an item */
extern void hb_memvarGetValue( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb ); /* copy an symbol value into an item, with error trapping */
extern void hb_memvarGetRefer( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb ); /* copy a reference to a symbol value into an item, with error trapping */
extern ULONG hb_memvarGetPrivatesBase( void ); /* retrieve current PRIVATE variables stack base */
extern void hb_memvarSetPrivatesBase( ULONG ulBase ); /* release PRIVATE variables created after specified base */
extern HB_ULONG hb_memvarGetPrivatesBase( void ); /* retrieve current PRIVATE variables stack base */
extern void hb_memvarSetPrivatesBase( HB_ULONG ulBase ); /* release PRIVATE variables created after specified base */
extern void hb_memvarUpdatePrivatesBase( void ); /* Update PRIVATE base ofsset so they will not be removed when function return */
extern void hb_memvarNewParameter( PHB_SYMB pSymbol, PHB_ITEM pValue );
extern char * hb_memvarGetStrValuePtr( char * szVarName, HB_SIZE * pulLen );

6
harbour/include/hbapicls.h
View File

@@ -105,7 +105,7 @@ extern void hb_objDestructorCall( PHB_ITEM pObject );
#ifndef HB_NO_PROFILER
/* profiler for object management */
extern void hb_mthAddTime( ULONG ); /* profiler from classes.c */
extern void hb_mthAddTime( HB_ULONG ); /* profiler from classes.c */
#endif
#endif /* _HB_API_INTERNAL_ */
@@ -125,8 +125,8 @@ HB_EXPORT extern const char * hb_objGetRealClsName( PHB_ITEM pObject, const char
HB_EXPORT extern HB_BOOL hb_objHasMsg( PHB_ITEM pObject, const char * szString ); /* returns HB_TRUE/HB_FALSE whether szString is an existing message for object */
HB_EXPORT extern HB_BOOL hb_objHasMessage( PHB_ITEM pObject, PHB_DYNS pMessage );
HB_EXPORT extern PHB_ITEM hb_objSendMsg( PHB_ITEM pObj, const char *sMsg, ULONG ulArg, ... );
HB_EXPORT extern PHB_ITEM hb_objSendMessage( PHB_ITEM pObj, PHB_DYNS pMessage, ULONG ulArg, ... );
HB_EXPORT extern PHB_ITEM hb_objSendMsg( PHB_ITEM pObj, const char *sMsg, HB_ULONG ulArg, ... );
HB_EXPORT extern PHB_ITEM hb_objSendMessage( PHB_ITEM pObj, PHB_DYNS pMessage, HB_ULONG ulArg, ... );
/* send message which allows to set execution context for debugger */
HB_EXPORT extern void hb_dbg_objSendMessage( int iProcLevel, PHB_ITEM pObject, PHB_ITEM pMessage, int iParamOffset );

4
harbour/include/hbapidbg.h
View File

@@ -63,10 +63,10 @@ HB_EXTERN_BEGIN
typedef void (*HB_DBGENTRY_FUNC) ( int , int , const char *, int , PHB_ITEM );
extern HB_DBGENTRY_FUNC hb_dbg_SetEntry( HB_DBGENTRY_FUNC pFunDbgEntry );
extern HB_BOOL hb_dbg_InvokeDebug( HB_BOOL bInvoke );
extern ULONG hb_dbg_ProcLevel( void );
extern HB_ULONG hb_dbg_ProcLevel( void );
extern PHB_ITEM hb_dbg_vmVarSGet( PHB_ITEM pStaticsBase, int nOffset );
extern PHB_ITEM hb_dbg_vmVarLGet( int iLevel, int iLocal );
extern ULONG hb_dbg_vmVarGCount( void );
extern HB_ULONG hb_dbg_vmVarGCount( void );
extern PHB_ITEM hb_dbg_vmVarGGet( int nGlobal, int nOffset );
/* internal debugger function */

10
harbour/include/hbapierr.h
View File

@@ -115,7 +115,7 @@ extern HB_EXPORT HB_USHORT hb_errLaunch ( PHB_ITEM pError );
extern HB_EXPORT PHB_ITEM hb_errNew ( void );
extern HB_EXPORT PHB_ITEM hb_errPutCargo ( PHB_ITEM pError, PHB_ITEM pCargo );
extern HB_EXPORT PHB_ITEM hb_errPutArgsArray ( PHB_ITEM pError, PHB_ITEM pArgs );
extern HB_EXPORT PHB_ITEM hb_errPutArgs ( PHB_ITEM pError, ULONG ulArgCount, ... );
extern HB_EXPORT PHB_ITEM hb_errPutArgs ( PHB_ITEM pError, HB_ULONG ulArgCount, ... );
extern HB_EXPORT PHB_ITEM hb_errPutDescription ( PHB_ITEM pError, const char * szDescription );
extern HB_EXPORT PHB_ITEM hb_errPutFileName ( PHB_ITEM pError, const char * szFileName );
extern HB_EXPORT PHB_ITEM hb_errPutFlags ( PHB_ITEM pError, HB_USHORT uiFlags );
@@ -159,10 +159,10 @@ extern HB_EXPORT PHB_ITEM hb_errRT_FileError( PHB_ITEM pError, const char * szSu
HB_ERRCODE errGenCode, HB_ERRCODE errSubCode,
const char * szFileName );
extern HB_EXPORT HB_USHORT hb_errRT_BASE ( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, ULONG ulArgCount, ... );
extern HB_EXPORT HB_USHORT hb_errRT_BASE_Ext1 ( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ERRCODE uiOsCode, HB_USHORT uiFlags, ULONG ulArgCount, ... );
extern HB_EXPORT PHB_ITEM hb_errRT_BASE_Subst ( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, ULONG ulArgCount, ... );
extern HB_EXPORT void hb_errRT_BASE_SubstR ( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, ULONG ulArgCount, ... );
extern HB_EXPORT HB_USHORT hb_errRT_BASE ( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ULONG ulArgCount, ... );
extern HB_EXPORT HB_USHORT hb_errRT_BASE_Ext1 ( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ERRCODE uiOsCode, HB_USHORT uiFlags, HB_ULONG ulArgCount, ... );
extern HB_EXPORT PHB_ITEM hb_errRT_BASE_Subst ( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ULONG ulArgCount, ... );
extern HB_EXPORT void hb_errRT_BASE_SubstR ( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ULONG ulArgCount, ... );
extern HB_EXPORT HB_USHORT hb_errRT_TERM ( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ERRCODE uiOSCode, HB_USHORT uiFlags );
extern HB_EXPORT HB_USHORT hb_errRT_DBCMD ( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation );
extern HB_EXPORT HB_USHORT hb_errRT_DBCMD_Ext ( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_USHORT uiFlags );

10
harbour/include/hbapifs.h
View File

@@ -294,11 +294,11 @@ extern HB_EXPORT HB_BOOL hb_fsFindNext( PHB_FFIND ffind );
extern HB_EXPORT void hb_fsFindClose( PHB_FFIND ffind );
/* functions to create, wait and terminate processes */
extern HB_FHANDLE hb_fsProcessOpen( const char *pszFilename,
HB_FHANDLE *phStdin, HB_FHANDLE *phStdout,
HB_FHANDLE *phStderr,
HB_BOOL fDetach, ULONG *pulPID );
extern int hb_fsProcessRun( const char *pszFilename,
extern HB_FHANDLE hb_fsProcessOpen( const char * pszFilename,
HB_FHANDLE * phStdin, HB_FHANDLE * phStdout,
HB_FHANDLE * phStderr,
HB_BOOL fDetach, HB_ULONG * pulPID );
extern int hb_fsProcessRun( const char * pszFilename,
const char * pStdInBuf, HB_SIZE ulStdInLen,
char ** pStdOutPtr, HB_SIZE * pulStdOut,
char ** pStdErrPtr, HB_SIZE * pulStdErr,

4
harbour/include/hbapiitm.h
View File

@@ -76,8 +76,8 @@ extern HB_EXPORT void hb_evalBlock1( PHB_ITEM pCodeBlock, PHB_ITEM pPara
extern HB_EXPORT HB_BOOL hb_execFromArray ( PHB_ITEM pParam );
extern HB_EXPORT PHB_ITEM hb_itemDo ( PHB_ITEM pItem, ULONG ulPCount, ... );
extern HB_EXPORT PHB_ITEM hb_itemDoC ( const char * szFunc, ULONG ulPCount, ... );
extern HB_EXPORT PHB_ITEM hb_itemDo ( PHB_ITEM pItem, HB_ULONG ulPCount, ... );
extern HB_EXPORT PHB_ITEM hb_itemDoC ( const char * szFunc, HB_ULONG ulPCount, ... );
extern HB_EXPORT PHB_ITEM hb_itemArrayGet ( PHB_ITEM pArray, HB_SIZE ulIndex );
extern HB_EXPORT PHB_ITEM hb_itemArrayNew ( HB_SIZE ulLen );

28
harbour/include/hbapirdd.h
View File

@@ -195,7 +195,7 @@ typedef struct
HB_BOOL fShared; /* Share mode of the data store */
HB_BOOL fReadonly; /* Readonly mode of the data store */
const char * cdpId; /* Id of a codepage */
ULONG ulConnection; /* connection handler for RDDs which support it */
HB_ULONG ulConnection; /* connection handler for RDDs which support it */
void * lpdbHeader; /* Pointer to a header of the data store */
} DBOPENINFO;
@@ -535,7 +535,7 @@ typedef FIELD * LPFIELD;
* prototype for function to evaluate against index keys
* only for local RDDs (DBFNTX, DBFCDX, ...)
*/
typedef void ( * HB_EVALSCOPE_FUNC )( ULONG, HB_BYTE *, ULONG, void * );
typedef void ( * HB_EVALSCOPE_FUNC )( HB_ULONG, HB_BYTE *, HB_ULONG, void * );
/*--------------------* WORKAREA structure *----------------------*/
@@ -592,7 +592,7 @@ typedef HB_ERRCODE ( * DBENTRYP_V )( AREAP area );
typedef HB_ERRCODE ( * DBENTRYP_BP )( AREAP area, HB_BOOL * param );
typedef HB_ERRCODE ( * DBENTRYP_B )( AREAP area, HB_BOOL param );
typedef HB_ERRCODE ( * DBENTRYP_L )( AREAP area, HB_LONG param );
typedef HB_ERRCODE ( * DBENTRYP_UL )( AREAP area, ULONG param );
typedef HB_ERRCODE ( * DBENTRYP_UL )( AREAP area, HB_ULONG param );
typedef HB_ERRCODE ( * DBENTRYP_I )( AREAP area, PHB_ITEM param );
typedef HB_ERRCODE ( * DBENTRYP_SI )( AREAP area, HB_USHORT index, PHB_ITEM param );
typedef HB_ERRCODE ( * DBENTRYP_VO )( AREAP area, LPDBOPENINFO param );
@@ -616,26 +616,26 @@ typedef HB_ERRCODE ( * DBENTRYP_CC )( AREAP area, const char * param );
typedef HB_ERRCODE ( * DBENTRYP_PP )( AREAP area, HB_BYTE ** param );
typedef HB_ERRCODE ( * DBENTRYP_S )( AREAP area, HB_USHORT param );
typedef HB_ERRCODE ( * DBENTRYP_LP )( AREAP area, HB_LONG * param );
typedef HB_ERRCODE ( * DBENTRYP_ULP )( AREAP area, ULONG * param );
typedef HB_ERRCODE ( * DBENTRYP_ULP )( AREAP area, HB_ULONG * param );
typedef HB_ERRCODE ( * DBENTRYP_SVP )( AREAP area, HB_USHORT index, void * param );
typedef HB_ERRCODE ( * DBENTRYP_SSP )( AREAP area, HB_USHORT index, HB_USHORT * param );
typedef HB_ERRCODE ( * DBENTRYP_SCP )( AREAP area, HB_USHORT index, char * param );
typedef HB_ERRCODE ( * DBENTRYP_SCCS )( AREAP area, HB_USHORT index, const char * param, HB_USHORT p3 );
typedef HB_ERRCODE ( * DBENTRYP_VSP )( AREAP area, HB_USHORT action, ULONG lRecord );
typedef HB_ERRCODE ( * DBENTRYP_SVL )( AREAP area, HB_USHORT index, ULONG * param );
typedef HB_ERRCODE ( * DBENTRYP_VSP )( AREAP area, HB_USHORT action, HB_ULONG lRecord );
typedef HB_ERRCODE ( * DBENTRYP_SVL )( AREAP area, HB_USHORT index, HB_ULONG * param );
typedef HB_ERRCODE ( * DBENTRYP_SSI )( AREAP area, HB_USHORT p1, HB_USHORT p2, PHB_ITEM p3 );
typedef HB_ERRCODE ( * DBENTRYP_ISI )( AREAP area, PHB_ITEM p1, HB_USHORT p2, PHB_ITEM p3 );
typedef HB_ERRCODE ( * DBENTRYP_BIB )( AREAP area, HB_BOOL p1, PHB_ITEM p2, HB_BOOL p3 );
typedef HB_ERRCODE ( * DBENTRYP_VPL )( AREAP area, void * p1, HB_LONG p2 );
typedef HB_ERRCODE ( * DBENTRYP_VPLP )( AREAP area, void * p1, HB_LONG * p2 );
typedef HB_ERRCODE ( * DBENTRYP_LSP )( AREAP area, ULONG p1, HB_BOOL * p2 );
typedef HB_ERRCODE ( * DBENTRYP_LSP )( AREAP area, HB_ULONG p1, HB_BOOL * p2 );
/* this methods DO USE take a Workarea but an RDDNODE */
typedef HB_ERRCODE ( * DBENTRYP_R )( struct _RDDNODE * pRDD );
typedef HB_ERRCODE ( * DBENTRYP_RVVL )( struct _RDDNODE * pRDD, PHB_ITEM p1, PHB_ITEM p2, ULONG p3 );
typedef HB_ERRCODE ( * DBENTRYP_RVVVL )( struct _RDDNODE * pRDD, PHB_ITEM p1, PHB_ITEM p2, PHB_ITEM p3, ULONG p4 );
typedef HB_ERRCODE ( * DBENTRYP_RSLV )( struct _RDDNODE * pRDD, HB_USHORT index, ULONG p1, PHB_ITEM p2 );
typedef HB_ERRCODE ( * DBENTRYP_RVVL )( struct _RDDNODE * pRDD, PHB_ITEM p1, PHB_ITEM p2, HB_ULONG p3 );
typedef HB_ERRCODE ( * DBENTRYP_RVVVL )( struct _RDDNODE * pRDD, PHB_ITEM p1, PHB_ITEM p2, PHB_ITEM p3, HB_ULONG p4 );
typedef HB_ERRCODE ( * DBENTRYP_RSLV )( struct _RDDNODE * pRDD, HB_USHORT index, HB_ULONG p1, PHB_ITEM p2 );
/*--------------------* Virtual Method Table *----------------------*/
typedef struct _RDDFUNCS
@@ -1195,18 +1195,18 @@ extern HB_EXPORT HB_ERRCODE hb_rddOpenTable(
const char * szFileName, const char * szDriver,
HB_USHORT uiArea, const char *szAlias,
HB_BOOL fShared, HB_BOOL fReadonly,
const char * szCpId, ULONG ulConnection,
const char * szCpId, HB_ULONG ulConnection,
PHB_ITEM pStruct, PHB_ITEM pDelim );
extern HB_EXPORT HB_ERRCODE hb_rddCreateTable(
const char * szFileName, const char * szDriver,
HB_USHORT uiArea, const char *szAlias,
HB_BOOL fKeepOpen,
const char * szCpId, ULONG ulConnection,
const char * szCpId, HB_ULONG ulConnection,
PHB_ITEM pStruct, PHB_ITEM pDelim );
extern HB_EXPORT HB_ERRCODE hb_rddCreateTableTemp(
const char * szDriver,
const char * szAlias,
const char * szCpId, ULONG ulConnection,
const char * szCpId, HB_ULONG ulConnection,
PHB_ITEM pStruct );
extern HB_EXPORT HB_ERRCODE hb_dbTransStruct(
AREAP lpaSource, AREAP lpaDest,
@@ -1215,7 +1215,7 @@ extern HB_EXPORT HB_ERRCODE hb_dbTransStruct(
extern HB_EXPORT HB_ERRCODE hb_rddTransRecords(
AREAP pArea,
const char *szFileName, const char *szDriver,
ULONG ulConnection,
HB_ULONG ulConnection,
PHB_ITEM pFields, HB_BOOL fExport,
PHB_ITEM pCobFor, PHB_ITEM pStrFor,
PHB_ITEM pCobWhile, PHB_ITEM pStrWhile,

46
harbour/include/hbcomp.h
View File

@@ -71,11 +71,11 @@ HB_EXTERN_BEGIN
/* definitions for hb_compPCodeEval() support */
typedef void * HB_VOID_PTR;
#define HB_PCODE_FUNC( func, type ) ULONG func( PFUNCTION pFunc, ULONG lPCodePos, type cargo )
#define HB_PCODE_FUNC( func, type ) HB_ULONG func( PFUNCTION pFunc, HB_ULONG lPCodePos, type cargo )
typedef HB_PCODE_FUNC( HB_PCODE_FUNC_, HB_VOID_PTR );
typedef HB_PCODE_FUNC_ * HB_PCODE_FUNC_PTR;
extern HB_LONG hb_compPCodeSize( PFUNCTION, ULONG );
extern HB_LONG hb_compPCodeSize( PFUNCTION, HB_ULONG );
extern void hb_compPCodeEval( PFUNCTION, const HB_PCODE_FUNC_PTR *, void * );
extern void hb_compPCodeTrace( PFUNCTION, const HB_PCODE_FUNC_PTR *, void * );
@@ -178,11 +178,11 @@ extern void hb_compLoopKill( PFUNCTION );
extern void hb_compGenError( HB_COMP_DECL, const char * szErrors[], char cPrefix, int iError, const char * szError1, const char * szError2 ); /* generic parsing error management function */
extern void hb_compGenWarning( HB_COMP_DECL, const char * szWarnings[], char cPrefix, int iWarning, const char * szWarning1, const char * szWarning2); /* generic parsing warning management function */
extern ULONG hb_compGenJump( HB_LONG, HB_COMP_DECL ); /* generates the pcode to jump to a specific offset */
extern ULONG hb_compGenJumpFalse( HB_LONG, HB_COMP_DECL ); /* generates the pcode to jump if false */
extern ULONG hb_compGenJumpTrue( HB_LONG, HB_COMP_DECL ); /* generates the pcode to jump if true */
extern void hb_compGenJumpHere( ULONG, HB_COMP_DECL ); /* returns the pcode pos where to set a jump offset */
extern void hb_compGenJumpThere( ULONG, ULONG, HB_COMP_DECL ); /* sets a jump offset */
extern HB_ULONG hb_compGenJump( HB_LONG, HB_COMP_DECL ); /* generates the pcode to jump to a specific offset */
extern HB_ULONG hb_compGenJumpFalse( HB_LONG, HB_COMP_DECL ); /* generates the pcode to jump if false */
extern HB_ULONG hb_compGenJumpTrue( HB_LONG, HB_COMP_DECL ); /* generates the pcode to jump if true */
extern void hb_compGenJumpHere( HB_ULONG, HB_COMP_DECL ); /* returns the pcode pos where to set a jump offset */
extern void hb_compGenJumpThere( HB_ULONG, HB_ULONG, HB_COMP_DECL ); /* sets a jump offset */
extern void hb_compGenModuleName( HB_COMP_DECL, const char * szFunName ); /* generates the pcode with the currently compiled module and function name */
extern void hb_compLinePush( HB_COMP_DECL ); /* generates the pcode with the currently compiled source code line */
@@ -207,7 +207,7 @@ extern void hb_compGenPushLong( HB_MAXINT lNumber, HB_COMP_DECL );
extern void hb_compGenPushDate( long lDate, HB_COMP_DECL ); /* Pushes a date constant on the virtual machine stack */
extern void hb_compGenPushTimeStamp( long lDate, long lTime, HB_COMP_DECL ); /* Pushes a timestamp constant on the virtual machine stack */
extern void hb_compGenPushNil( HB_COMP_DECL ); /* Pushes nil on the virtual machine stack */
extern void hb_compGenPushString( const char * szText, ULONG ulLen, HB_COMP_DECL ); /* Pushes a string on the virtual machine stack */
extern void hb_compGenPushString( const char * szText, HB_ULONG ulLen, HB_COMP_DECL ); /* Pushes a string on the virtual machine stack */
extern void hb_compGenPushSymbol( const char * szSymbolName, HB_BOOL bFunction, HB_COMP_DECL ); /* Pushes a symbol on to the Virtual machine stack */
extern void hb_compGenPushAliasedVar( const char *, HB_BOOL, const char *, HB_MAXINT, HB_COMP_DECL );
extern void hb_compGenPopAliasedVar( const char *, HB_BOOL, const char *, HB_MAXINT, HB_COMP_DECL );
@@ -215,12 +215,12 @@ extern void hb_compGenPCode1( HB_BYTE, HB_COMP_DECL ); /* generates 1 byte of pc
extern void hb_compGenPCode2( HB_BYTE, HB_BYTE, HB_COMP_DECL ); /* generates 2 bytes of pcode + flag for optional StrongType(). */
extern void hb_compGenPCode3( HB_BYTE, HB_BYTE, HB_BYTE, HB_COMP_DECL ); /* generates 3 bytes of pcode + flag for optional StrongType() */
extern void hb_compGenPCode4( HB_BYTE, HB_BYTE, HB_BYTE, HB_BYTE, HB_COMP_DECL ); /* generates 4 bytes of pcode + flag for optional StrongType() */
extern void hb_compGenPCodeN( const HB_BYTE * pBuffer, ULONG ulSize, HB_COMP_DECL ); /* copy bytes to a pcode buffer + flag for optional StrongType() */
extern void hb_compGenPCodeN( const HB_BYTE * pBuffer, HB_ULONG ulSize, HB_COMP_DECL ); /* copy bytes to a pcode buffer + flag for optional StrongType() */
extern ULONG hb_compSequenceBegin( HB_COMP_DECL );
extern ULONG hb_compSequenceEnd( HB_COMP_DECL );
extern ULONG hb_compSequenceAlways( HB_COMP_DECL );
extern void hb_compSequenceFinish( HB_COMP_DECL, ULONG, ULONG, ULONG, HB_BOOL, HB_BOOL, HB_BOOL );
extern HB_ULONG hb_compSequenceBegin( HB_COMP_DECL );
extern HB_ULONG hb_compSequenceEnd( HB_COMP_DECL );
extern HB_ULONG hb_compSequenceAlways( HB_COMP_DECL );
extern void hb_compSequenceFinish( HB_COMP_DECL, HB_ULONG, HB_ULONG, HB_ULONG, HB_BOOL, HB_BOOL, HB_BOOL );
/* support for FIELD declaration */
extern void hb_compFieldSetAlias( HB_COMP_DECL, const char *, int );
@@ -264,7 +264,7 @@ extern HB_BOOL hb_compCheckUnclosedStru( HB_COMP_DECL, PFUNCTION );
#define HB_GEN_FUNC3( func, p1,p2,p3 ) hb_compGen##func( p1, p2, p3, HB_COMP_PARAM )
#define HB_GEN_FUNC4( func, p1,p2,p3,p4 ) hb_compGen##func( p1, p2, p3, p4, HB_COMP_PARAM )
extern int hb_compMain( int argc, const char * const argv[], HB_BYTE ** pBufPtr, ULONG * pulSize, const char * szSource );
extern int hb_compMain( int argc, const char * const argv[], HB_BYTE ** pBufPtr, HB_ULONG * pulSize, const char * szSource );
extern void hb_compOutStd( HB_COMP_DECL, const char * szMessage );
extern void hb_compOutErr( HB_COMP_DECL, const char * szMessage );
@@ -287,7 +287,7 @@ extern void hb_compErrorVParams( HB_COMP_DECL, const char * );
extern HB_EXPR_PTR hb_compErrorStatic( HB_COMP_DECL, const char *, HB_EXPR_PTR );
extern void hb_compErrorCodeblock( HB_COMP_DECL, const char * );
extern HB_BOOL hb_compIsValidMacroText( HB_COMP_DECL, const char *, ULONG );
extern HB_BOOL hb_compIsValidMacroText( HB_COMP_DECL, const char *, HB_ULONG );
/* Codeblocks */
extern void hb_compCodeBlockStart( HB_COMP_DECL, HB_BOOL ); /* starts a codeblock creation */
@@ -298,8 +298,8 @@ extern void hb_compCodeBlockRewind( HB_COMP_DECL ); /* restart of fake c
#endif /* HB_MACRO_SUPPORT */
extern ULONG hb_compExprListEval( HB_COMP_DECL, HB_EXPR_PTR pExpr, HB_CARGO_FUNC_PTR pEval );
extern ULONG hb_compExprListEval2( HB_COMP_DECL, HB_EXPR_PTR pExpr1, HB_EXPR_PTR pExpr2, HB_CARGO2_FUNC_PTR pEval );
extern HB_ULONG hb_compExprListEval( HB_COMP_DECL, HB_EXPR_PTR pExpr, HB_CARGO_FUNC_PTR pEval );
extern HB_ULONG hb_compExprListEval2( HB_COMP_DECL, HB_EXPR_PTR pExpr1, HB_EXPR_PTR pExpr2, HB_CARGO2_FUNC_PTR pEval );
extern void hb_compChkCompilerSwitch( HB_COMP_DECL, int, const char * const args[] );
extern void hb_compChkPaths( HB_COMP_DECL );
@@ -311,8 +311,8 @@ extern void hb_compPrintLogo( HB_COMP_DECL );
extern void hb_compPrintModes( HB_COMP_DECL );
/* Misc functions defined in harbour.c */
extern void hb_compNOOPfill( PFUNCTION pFunc, ULONG ulFrom, int iCount, HB_BOOL fPop, HB_BOOL fCheck );
extern HB_BOOL hb_compHasJump( PFUNCTION pFunc, ULONG ulPos );
extern void hb_compNOOPfill( PFUNCTION pFunc, HB_ULONG ulFrom, int iCount, HB_BOOL fPop, HB_BOOL fCheck );
extern HB_BOOL hb_compHasJump( PFUNCTION pFunc, HB_ULONG ulPos );
/* Misc functions defined in hbfix.c */
extern void hb_compFixFuncPCode( HB_COMP_DECL, PFUNCTION pFunc );
@@ -332,10 +332,10 @@ extern void hb_compGenJava( HB_COMP_DECL, PHB_FNAME ); /* generates the Ja
extern void hb_compGenObj32( HB_COMP_DECL, PHB_FNAME ); /* generates OBJ 32 bits */
extern void hb_compGenCObj( HB_COMP_DECL, PHB_FNAME ); /* generates platform dependant object module */
extern void hb_compGenBufPortObj( HB_COMP_DECL, HB_BYTE ** pBufPtr, ULONG * pulSize ); /* generates the portable objects to memory buffer */
extern void hb_compGenBufPortObj( HB_COMP_DECL, HB_BYTE ** pBufPtr, HB_ULONG * pulSize ); /* generates the portable objects to memory buffer */
extern void hb_compGenCRealCode( HB_COMP_DECL, PFUNCTION pFunc, FILE * yyc );
extern void hb_compGenCString( FILE * yyc, const HB_BYTE * pText, ULONG ulLen );
extern void hb_compGenCString( FILE * yyc, const HB_BYTE * pText, HB_ULONG ulLen );
/* hbident.c */
extern const char * hb_compIdentifierNew( HB_COMP_DECL, const char * szName, int iType ); /* create the reusable identifier */
@@ -346,7 +346,7 @@ extern void hb_compIdentifierClose( HB_COMP_DECL ); /* release the table of iden
extern void hb_compI18nFree( HB_COMP_DECL );
extern HB_BOOL hb_compI18nSave( HB_COMP_DECL, HB_BOOL fFinal );
extern void hb_compI18nAdd( HB_COMP_DECL, const char* szText, const char* szContext, const char * szModule, HB_UINT uiLine );
extern void hb_compI18nAddPlural( HB_COMP_DECL, const char** szTexts, ULONG ulCount, const char* szContext, const char * szModule, HB_UINT uiLine );
extern void hb_compI18nAddPlural( HB_COMP_DECL, const char** szTexts, HB_ULONG ulCount, const char* szContext, const char * szModule, HB_UINT uiLine );
/* global readonly variables used by compiler
*/
@@ -374,7 +374,7 @@ extern const HB_BYTE hb_comp_pcode_len[];
#define HB_EXITLEVEL_DELTARGET 2
/* /kx command line setting types - compatibility modes
* (turn on a bit in ULONG word)
* (turn on a bit in HB_ULONG word)
*/
#define HB_COMPFLAG_HARBOUR HB_SM_HARBOUR /* 1 -kh */
#define HB_COMPFLAG_XBASE HB_SM_XBASE /* 2 -kx */

86
harbour/include/hbcompdf.h
View File

@@ -325,8 +325,8 @@ typedef struct HB_EXPR_
} asOperator;
struct HB_EXPR_ * asReference;
} value;
ULONG ulLength;
ULONG Counter;
HB_ULONG ulLength;
HB_ULONG Counter;
HB_EXPRTYPE ExprType; /* internal expression type */
HB_USHORT ValType; /* language level value type */
struct HB_EXPR_ *pNext; /* next expression in the list of expressions */
@@ -342,7 +342,7 @@ typedef struct HB_ENUMERATOR_
/* support structure for else if pcode fixups */
typedef struct HB_ELSEIF_
{
ULONG ulOffset;
HB_ULONG ulOffset;
struct HB_ELSEIF_ * pElseif; /* next ELSEIF in the current IF statement */
struct HB_ELSEIF_ * pPrev; /* previous IF statement */
} HB_ELSEIF, * HB_ELSEIF_PTR;
@@ -350,7 +350,7 @@ typedef struct HB_ELSEIF_
/* support structure for EXIT and LOOP statements */
typedef struct HB_LOOPEXIT_
{
ULONG ulOffset;
HB_ULONG ulOffset;
HB_BOOL fCanLoop;
HB_USHORT wSeqCounter;
HB_USHORT wAlwaysCounter;
@@ -363,18 +363,18 @@ typedef struct HB_LOOPEXIT_
/* support structure for SWITCH statement */
typedef struct HB_SWITCHCASE_
{
ULONG ulOffset;
HB_ULONG ulOffset;
HB_EXPR_PTR pExpr;
struct HB_SWITCHCASE_ *pNext;
} HB_SWITCHCASE, * HB_SWITCHCASE_PTR;
typedef struct HB_SWITCHCMD_
{
ULONG ulOffset;
HB_ULONG ulOffset;
HB_SWITCHCASE_PTR pCases;
HB_SWITCHCASE_PTR pLast;
HB_EXPR_PTR pExpr;
ULONG ulDefault;
HB_ULONG ulDefault;
struct HB_SWITCHCMD_ *pPrev;
} HB_SWITCHCMD, *HB_SWITCHCMD_PTR;
@@ -402,14 +402,14 @@ typedef struct __FUNC
PVAR pDetached; /* pointer to detached local variables list */
PVAR pPrivates; /* pointer to private variables list */
HB_BYTE * pCode; /* pointer to a memory block where pcode is stored */
ULONG lPCodeSize; /* total memory size for pcode */
ULONG lPCodePos; /* actual pcode offset */
HB_ULONG lPCodeSize; /* total memory size for pcode */
HB_ULONG lPCodePos; /* actual pcode offset */
int iStaticsBase; /* base for this function statics */
int iFuncSuffix; /* function suffix for multiple static functions with the same name */
ULONG * pNOOPs; /* pointer to the NOOP array */
ULONG * pJumps; /* pointer to the Jumps array */
ULONG iNOOPs; /* NOOPs Counter */
ULONG iJumps; /* Jumps Counter */
HB_ULONG * pNOOPs; /* pointer to the NOOP array */
HB_ULONG * pJumps; /* pointer to the Jumps array */
HB_ULONG iNOOPs; /* NOOPs Counter */
HB_ULONG iJumps; /* Jumps Counter */
HB_BOOL bLateEval; /* HB_TRUE if accessing of declared (compile time) variables is allowed */
HB_BOOL fVParams; /* HB_TRUE if variable number of parameters is used */
HB_BOOL bError; /* error during function compilation */
@@ -436,7 +436,7 @@ typedef struct __INLINE
{
const char * szName; /* name of a inline function */
HB_BYTE * pCode; /* pointer to a memory block where pcode is stored */
ULONG lPCodeSize; /* total memory size for pcode */
HB_ULONG lPCodeSize; /* total memory size for pcode */
const char * szFileName; /* Source file name */
int iLine; /* Source line number */
struct __INLINE * pNext; /* pointer to the next defined inline */
@@ -502,22 +502,22 @@ typedef struct _HB_MODULE
typedef struct _HB_DEBUGINFO
{
char * pszModuleName;
ULONG ulFirstLine;
ULONG ulLastLine;
ULONG ulAllocated;
HB_ULONG ulFirstLine;
HB_ULONG ulLastLine;
HB_ULONG ulAllocated;
HB_BYTE * pLineMap;
struct _HB_DEBUGINFO * pNext;
} HB_DEBUGINFO, * PHB_DEBUGINFO;
typedef struct _HB_LABEL_INFO
{
FILE * yyc;
HB_BOOL fVerbose;
HB_BOOL fSetSeqBegin;
HB_BOOL fCondJump;
HB_BOOL fEndRequest;
int iNestedBlock;
ULONG * pulLabels;
FILE * yyc;
HB_BOOL fVerbose;
HB_BOOL fSetSeqBegin;
HB_BOOL fCondJump;
HB_BOOL fEndRequest;
int iNestedBlock;
HB_ULONG * pulLabels;
} HB_LABEL_INFO, * PHB_LABEL_INFO;
#define HB_MODE_COMPILER 1
@@ -547,8 +547,8 @@ HB_COMMON, * HB_COMMON_PTR;
typedef struct HB_PCODE_INFO_ /* compiled pcode container for macro compiler */
{
HB_BYTE * pCode; /* pointer to a memory block where pcode is stored */
ULONG lPCodeSize; /* total memory size for pcode */
ULONG lPCodePos; /* actual pcode offset */
HB_ULONG lPCodeSize; /* total memory size for pcode */
HB_ULONG lPCodePos; /* actual pcode offset */
HB_BOOL fVParams; /* function/codeblock with variable parameters */
struct HB_PCODE_INFO_ * pPrev;
HB_CBVAR_PTR pLocals;
@@ -557,23 +557,23 @@ typedef struct HB_PCODE_INFO_ /* compiled pcode container for macro compiler */
typedef struct HB_MACRO_ /* a macro compiled pcode container */
{
/* common to compiler members */
int mode; /* HB_MODE_* */
int supported; /* various flags for supported capabilities */
int mode; /* HB_MODE_* */
int supported; /* various flags for supported capabilities */
const struct _HB_COMP_FUNCS * funcs;
/* macro compiler only members */
char * string; /* compiled string */
ULONG length; /* length of the string */
int Flags; /* some flags we may need */
int status; /* status of compilation */
HB_ITEM_PTR pError; /* error object returned from the parser */
char * string; /* compiled string */
HB_ULONG length; /* length of the string */
int Flags; /* some flags we may need */
int status; /* status of compilation */
HB_ITEM_PTR pError; /* error object returned from the parser */
HB_PCODE_INFO_PTR pCodeInfo; /* pointer to pcode buffer and info */
void * pLex; /* lexer buffer pointer */
void * pExprLst; /* list with allocated expressions */
void * pIdentLst; /* list with allocated identifiers */
int exprType; /* type of successfully compiled expression */
HB_USHORT uiListElements; /* number of elements in macro list expression */
HB_USHORT uiNameLen; /* the maximum symbol name length */
void * pLex; /* lexer buffer pointer */
void * pExprLst; /* list with allocated expressions */
void * pIdentLst; /* list with allocated identifiers */
int exprType; /* type of successfully compiled expression */
HB_USHORT uiListElements; /* number of elements in macro list expression */
HB_USHORT uiNameLen; /* the maximum symbol name length */
} HB_MACRO;
#else
@@ -603,8 +603,8 @@ typedef struct _HB_I18NSTRING
typedef struct _HB_I18NTABLE
{
PHB_I18NSTRING pString;
ULONG uiCount;
ULONG uiAllocated;
HB_ULONG uiCount;
HB_ULONG uiAllocated;
} HB_I18NTABLE, * PHB_I18NTABLE;
typedef struct _HB_COMP_LEX
@@ -671,10 +671,10 @@ typedef struct _HB_COMP
void ( * outErrFunc ) ( void *, const char* );
void * cargo;
ULONG ulOutBufSize; /* memory output buffer size */
HB_ULONG ulOutBufSize; /* memory output buffer size */
HB_BYTE * pOutBuf; /* memory output buffer address */
ULONG lastLinePos; /* position of last opcode with line number */
HB_ULONG lastLinePos; /* position of last opcode with line number */
int lastLine; /* last generated in PCODE line number */
int currLine; /* currently compiled line number */
const char * lastModule; /* last generated in PCODE module name */

6
harbour/include/hbdefs.h
View File

@@ -739,7 +739,7 @@ typedef HB_U32 HB_FATTR;
( ( ( HB_I32 ) ( b3 ) ) << 16 ) | \
( ( ( HB_I32 ) ( b2 ) ) << 8 ) | \
( ( ( HB_I32 ) ( b1 ) ) ) ) )
#define HB_MKULONG( b1, b2, b3, b4 ) ( ( ULONG ) \
#define HB_MKULONG( b1, b2, b3, b4 ) ( ( HB_ULONG ) \
( ( ( ( HB_U32 ) ( b4 ) ) << 24 ) | \
( ( ( HB_U32 ) ( b3 ) ) << 16 ) | \
( ( ( HB_U32 ) ( b2 ) ) << 8 ) | \
@@ -1446,12 +1446,12 @@ typedef HB_U32 HB_FATTR;
#define HB_PCODE_MKSHORT( p ) (( HB_SHORT ) HB_GET_LE_INT16( p ))
#define HB_PCODE_MKUSHORT( p ) (( HB_USHORT ) HB_GET_LE_UINT16( p ))
#define HB_PCODE_MKLONG( p ) (( HB_LONG ) HB_GET_LE_INT32( p ))
#define HB_PCODE_MKULONG( p ) (( ULONG ) HB_GET_LE_UINT32( p ))
#define HB_PCODE_MKULONG( p ) (( HB_ULONG ) HB_GET_LE_UINT32( p ))
#define HB_PCODE_MKLONGLONG( p ) (( HB_LONGLONG ) HB_GET_LE_INT64( p ))
#define HB_PCODE_MKULONGLONG( p ) (( HB_ULONGLONG ) HB_GET_LE_UINT64( p ))
#define HB_PCODE_MKDOUBLE( p ) (( double ) HB_GET_LE_DOUBLE( p ))
#define HB_PCODE_MKINT24( p ) (( HB_LONG ) HB_GET_LE_INT24( p ))
#define HB_PCODE_MKUINT24( p ) (( ULONG ) HB_GET_LE_UINT24( p ))
#define HB_PCODE_MKUINT24( p ) (( HB_ULONG ) HB_GET_LE_UINT24( p ))
/*
* Below are hacked version of INT64 macros which operates on double

12
harbour/include/hbexpra.c
View File

@@ -56,9 +56,9 @@
/* ************************************************************************ */
#ifndef HB_MACRO_SUPPORT
ULONG hb_compExprListEval( HB_COMP_DECL, HB_EXPR_PTR pExpr, HB_CARGO_FUNC_PTR pEval )
HB_ULONG hb_compExprListEval( HB_COMP_DECL, HB_EXPR_PTR pExpr, HB_CARGO_FUNC_PTR pEval )
{
ULONG ulLen = 0;
HB_ULONG ulLen = 0;
if( pEval && ( pExpr->ExprType == HB_ET_LIST ||
pExpr->ExprType == HB_ET_ARGLIST ) )
@@ -74,9 +74,9 @@ ULONG hb_compExprListEval( HB_COMP_DECL, HB_EXPR_PTR pExpr, HB_CARGO_FUNC_PTR pE
return ulLen;
}
ULONG hb_compExprListEval2( HB_COMP_DECL, HB_EXPR_PTR pExpr1, HB_EXPR_PTR pExpr2, HB_CARGO2_FUNC_PTR pEval )
HB_ULONG hb_compExprListEval2( HB_COMP_DECL, HB_EXPR_PTR pExpr1, HB_EXPR_PTR pExpr2, HB_CARGO2_FUNC_PTR pEval )
{
ULONG ulLen = 0;
HB_ULONG ulLen = 0;
if( !pEval )
return ulLen;
@@ -312,7 +312,7 @@ HB_EXPR_PTR hb_compExprNewFunCall( HB_EXPR_PTR pName, HB_EXPR_PTR pParms, HB_COM
pVar = pParms->value.asList.pExprList->pNext;
if( pVar->ExprType == HB_ET_STRING )
{
ULONG i = 0;
HB_ULONG i = 0;
char *szVar = pVar->value.asString.string;
/* NOTE: Clipper strips a string at the first '[' character too
@@ -621,7 +621,7 @@ HB_EXPR_PTR hb_compExprAssignStatic( HB_EXPR_PTR pLeftExpr, HB_EXPR_PTR pRightEx
return pExpr;
}
HB_EXPR_PTR hb_compExprSetCodeblockBody( HB_EXPR_PTR pExpr, HB_BYTE * pCode, ULONG ulLen )
HB_EXPR_PTR hb_compExprSetCodeblockBody( HB_EXPR_PTR pExpr, HB_BYTE * pCode, HB_ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_compExprSetCodeblockBody(%p,%p,%lu)", pExpr, pCode, ulLen));

10
harbour/include/hbexprb.c
View File

@@ -960,7 +960,7 @@ static HB_EXPR_FUNC( hb_compExprUseIIF )
HB_EXPR_USE( pSelf, HB_EA_PUSH_PCODE );
HB_GEN_FUNC1( PCode1, HB_P_POP ); /* remove a value if used in statement */
#else
ULONG ulPosFalse, ulPosEnd;
HB_ULONG ulPosFalse, ulPosEnd;
HB_EXPR_PTR pExpr = pSelf->value.asList.pExprList;
HB_EXPR_USE( pExpr, HB_EA_PUSH_PCODE );
@@ -1315,7 +1315,7 @@ static HB_EXPR_FUNC( hb_compExprUseArrayAt )
if( pExpr->ExprType == HB_ET_ARRAY ) /* is it a literal array */
{
ULONG ulSize = hb_compExprParamListCheck( HB_COMP_PARAM, pExpr );
HB_ULONG ulSize = hb_compExprParamListCheck( HB_COMP_PARAM, pExpr );
if( pExpr->ExprType == HB_ET_MACROARGLIST )
/* restore original expression type */
@@ -1891,7 +1891,7 @@ static HB_EXPR_FUNC( hb_compExprUseFunCall )
{
HB_EXPR_PTR pArg = pParms->value.asList.pExprList, pCount = NULL;
HB_BOOL fStrict, fNoop, fPlural, fI18nFunc;
ULONG ulPos = 8;
HB_ULONG ulPos = 8;
fStrict = fNoop = fPlural = fI18nFunc = HB_FALSE;
if( pName->value.asSymbol[ ulPos ] == 'N' )
@@ -1974,7 +1974,7 @@ static HB_EXPR_FUNC( hb_compExprUseFunCall )
{
if( HB_COMP_PARAM->fI18n )
{
ULONG ulLen = hb_compExprListLen( pArg ), ul;
HB_ULONG ulLen = hb_compExprListLen( pArg ), ul;
HB_EXPR_PTR pArgExp = pArg->value.asList.pExprList;
if( ulLen > HB_I18N_PLURAL_MAX )
@@ -5311,7 +5311,7 @@ static HB_EXPR_PTR hb_compExprReduceAliasString( HB_EXPR_PTR pExpr, HB_EXPR_PTR
if( HB_ISFIRSTIDCHAR( *szAlias ) )
{
ULONG ulLen = pAlias->ulLength;
HB_ULONG ulLen = pAlias->ulLength;
if( ulLen <= HB_SYMBOL_NAME_LEN )
{
HB_BOOL fLower = HB_FALSE;

16
harbour/include/hbexprop.h
View File

@@ -82,10 +82,10 @@ extern HB_EXPR_PTR hb_compExprNewDouble( double, HB_BYTE, HB_BYTE, HB_COMP_DECL
extern HB_EXPR_PTR hb_compExprNewLong( HB_MAXINT, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewDate( long, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewTimeStamp( long, long, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewString( const char *, ULONG, HB_BOOL, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewString( const char *, HB_ULONG, HB_BOOL, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewLogical( int, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewSelf( HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewCodeBlock( char *, ULONG, int, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewCodeBlock( char *, HB_ULONG, int, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewVar( const char *, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewAliasVar( HB_EXPR_PTR, HB_EXPR_PTR, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprNewAliasExpr( HB_EXPR_PTR, HB_EXPR_PTR, HB_COMP_DECL );
@@ -141,7 +141,7 @@ extern HB_EXPR_PTR hb_compExprAddListExpr( HB_EXPR_PTR, HB_EXPR_PTR );
extern HB_EXPR_PTR hb_compExprCBVarAdd( HB_EXPR_PTR, const char *, HB_BYTE, HB_COMP_DECL );
extern void hb_compExprCBVarDel( HB_CBVAR_PTR );
extern HB_EXPR_PTR hb_compExprAddCodeblockExpr( HB_EXPR_PTR, HB_EXPR_PTR );
extern HB_EXPR_PTR hb_compExprSetCodeblockBody( HB_EXPR_PTR pExpr, HB_BYTE * pCode, ULONG ulLen );
extern HB_EXPR_PTR hb_compExprSetCodeblockBody( HB_EXPR_PTR pExpr, HB_BYTE * pCode, HB_ULONG ulLen );
extern HB_EXPR_PTR hb_compExprNewIIF( HB_EXPR_PTR );
extern HB_EXPR_PTR hb_compExprMacroAsAlias( HB_EXPR_PTR );
extern HB_EXPR_PTR hb_compExprAssign( HB_EXPR_PTR, HB_EXPR_PTR, HB_COMP_DECL );
@@ -149,10 +149,10 @@ extern HB_EXPR_PTR hb_compExprEqual( HB_EXPR_PTR, HB_EXPR_PTR );
extern HB_EXPR_PTR hb_compExprAssignStatic( HB_EXPR_PTR, HB_EXPR_PTR, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprClone( HB_EXPR_PTR pSrc );
extern HB_BOOL hb_compExprListTypeCheck( HB_EXPR_PTR pExpr, HB_EXPRTYPE ExprType );
extern ULONG hb_compExprListLen( HB_EXPR_PTR );
extern ULONG hb_compExprParamListLen( HB_EXPR_PTR );
extern ULONG hb_compExprMacroListLen( HB_EXPR_PTR );
extern ULONG hb_compExprParamListCheck( HB_COMP_DECL, HB_EXPR_PTR );
extern HB_ULONG hb_compExprListLen( HB_EXPR_PTR );
extern HB_ULONG hb_compExprParamListLen( HB_EXPR_PTR );
extern HB_ULONG hb_compExprMacroListLen( HB_EXPR_PTR );
extern HB_ULONG hb_compExprParamListCheck( HB_COMP_DECL, HB_EXPR_PTR );
extern const char * hb_compExprDescription( HB_EXPR_PTR );
extern int hb_compExprType( HB_EXPR_PTR );
@@ -167,7 +167,7 @@ extern const char * hb_compExprAsString( HB_EXPR_PTR );
extern const char * hb_compExprAsSymbol( HB_EXPR_PTR );
extern HB_EXPR_PTR hb_compExprListStrip( HB_EXPR_PTR, HB_COMP_DECL );
extern HB_BOOL hb_compExprIsValidMacro( const char *, ULONG, HB_BOOL *, HB_COMP_DECL );
extern HB_BOOL hb_compExprIsValidMacro( const char *, HB_ULONG, HB_BOOL *, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprSetOperand( HB_EXPR_PTR, HB_EXPR_PTR, HB_COMP_DECL );
extern HB_EXPR_PTR hb_compExprSetGetBlock( HB_EXPR_PTR pExpr, HB_COMP_DECL );

4
harbour/include/hbgtcore.h
View File

@@ -329,8 +329,8 @@ typedef struct _HB_GT_BASE
int iLastPut;
int inkeyLast;
HB_BYTE * StrBuffer;
ULONG StrBufferSize;
ULONG StrBufferPos;
HB_SIZE StrBufferSize;
HB_SIZE StrBufferPos;
PHB_ITEM pNotifierBlock;
PHB_ITEM pCargo;

4
harbour/include/hbhash.h
View File

@@ -59,7 +59,7 @@ HB_EXTERN_BEGIN
struct HB_HASH_TABLE_;
#define HB_HASH_FUNC( hbfunc ) ULONG hbfunc( struct HB_HASH_TABLE_ * HashPtr, const void * Value, const void * Cargo )
#define HB_HASH_FUNC( hbfunc ) HB_ULONG hbfunc( struct HB_HASH_TABLE_ * HashPtr, const void * Value, const void * Cargo )
typedef HB_HASH_FUNC( HB_HASH_FUNC_ );
typedef HB_HASH_FUNC_ * HB_HASH_FUNC_PTR;
@@ -67,7 +67,7 @@ typedef struct HB_HASH_ITEM_
{
const void * ValPtr; /* value stored in the hash table */
const void * KeyPtr;
ULONG key;
HB_ULONG key;
struct HB_HASH_ITEM_ *next;
} HB_HASH_ITEM, * HB_HASH_ITEM_PTR;

2
harbour/include/hbinit.h
View File

@@ -57,7 +57,7 @@
HB_EXTERN_BEGIN
extern HB_EXPORT PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, HB_USHORT uiSymbols, const char * szModuleName, ULONG ulID, HB_USHORT uiPcodeVer ); /* module symbols initialization with extended information */
extern HB_EXPORT PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, HB_USHORT uiSymbols, const char * szModuleName, HB_ULONG ulID, HB_USHORT uiPcodeVer ); /* module symbols initialization with extended information */
#define HB_INIT_SYMBOLS_END( func ) HB_INIT_SYMBOLS_EX_END( func, __FILE__, 0L, 0x0000 )

18
harbour/include/hbmacro.h
View File

@@ -99,7 +99,7 @@ HB_EXTERN_BEGIN
extern void hb_macroError( int iError, HB_COMP_DECL );
extern int hb_macroYYParse( HB_MACRO_PTR pMacro );
extern int hb_macroSetMacro( HB_BOOL fSet, int flag );
extern ULONG hb_macroAutoSetMacro( ULONG ulFlag );
extern HB_ULONG hb_macroAutoSetMacro( HB_ULONG ulFlag );
extern HB_BOOL hb_macroLexNew( HB_MACRO_PTR pMacro );
extern void hb_macroLexDelete( HB_MACRO_PTR pMacro );
extern char * hb_macroIdentNew( HB_COMP_DECL, char * );
@@ -121,13 +121,13 @@ extern void hb_macroGenPCode1( HB_BYTE byte, HB_COMP_DECL );
extern void hb_macroGenPCode2( HB_BYTE byte1, HB_BYTE byte2, HB_COMP_DECL );
extern void hb_macroGenPCode3( HB_BYTE byte1, HB_BYTE byte2, HB_BYTE byte3, HB_COMP_DECL );
extern void hb_macroGenPCode4( HB_BYTE byte1, HB_BYTE byte2, HB_BYTE byte3, HB_BYTE byte4, HB_COMP_DECL );
extern void hb_macroGenPCodeN( HB_BYTE * pBuffer, ULONG ulSize, HB_COMP_DECL );
extern void hb_macroGenPCodeN( HB_BYTE * pBuffer, HB_ULONG ulSize, HB_COMP_DECL );
extern ULONG hb_macroGenJump( HB_LONG lOffset, HB_COMP_DECL );
extern ULONG hb_macroGenJumpFalse( HB_LONG lOffset, HB_COMP_DECL );
extern void hb_macroGenJumpThere( ULONG ulFrom, ULONG ulTo, HB_COMP_DECL );
extern void hb_macroGenJumpHere( ULONG ulOffset, HB_COMP_DECL );
extern ULONG hb_macroGenJumpTrue( HB_LONG lOffset, HB_COMP_DECL );
extern HB_ULONG hb_macroGenJump( HB_LONG lOffset, HB_COMP_DECL );
extern HB_ULONG hb_macroGenJumpFalse( HB_LONG lOffset, HB_COMP_DECL );
extern void hb_macroGenJumpThere( HB_ULONG ulFrom, HB_ULONG ulTo, HB_COMP_DECL );
extern void hb_macroGenJumpHere( HB_ULONG ulOffset, HB_COMP_DECL );
extern HB_ULONG hb_macroGenJumpTrue( HB_LONG lOffset, HB_COMP_DECL );
extern void hb_macroGenPushSymbol( const char * szSymbolName, HB_BOOL bFunction, HB_COMP_DECL );
extern void hb_macroGenPushLong( HB_MAXINT lNumber, HB_COMP_DECL );
@@ -153,13 +153,13 @@ extern void hb_macroGenPushDouble( double dNumber, HB_BYTE bWidth, HB_BYTE bDec,
extern void hb_macroGenPushFunCall( const char * szFunName, HB_COMP_DECL );
extern void hb_macroGenPushFunSym( const char * szFunName, HB_COMP_DECL );
extern void hb_macroGenPushFunRef( const char * szFunName, HB_COMP_DECL );
extern void hb_macroGenPushString( const char * szText, ULONG ulStrLen, HB_COMP_DECL );
extern void hb_macroGenPushString( const char * szText, HB_SIZE ulStrLen, HB_COMP_DECL );
extern void hb_macroCodeBlockStart( HB_COMP_DECL );
extern void hb_macroCodeBlockEnd( HB_COMP_DECL );
extern int hb_macroLocalVarGetPos( const char * szVarName, HB_COMP_DECL );
extern HB_BOOL hb_macroIsValidMacroText( const char *, ULONG );
extern HB_BOOL hb_macroIsValidMacroText( const char * szText, HB_SIZE ulLen );
#endif /* HB_MACRO_SUPPORT */

22
harbour/include/hbpp.h
View File

@@ -103,12 +103,12 @@ typedef HB_PP_DISP_FUNC_( HB_PP_DISP_FUNC );
typedef HB_PP_DISP_FUNC * PHB_PP_DISP_FUNC;
/* function for catching #pragma dump data */
#define HB_PP_DUMP_FUNC_( func ) void func( void *, char *, ULONG, int )
#define HB_PP_DUMP_FUNC_( func ) void func( void *, char *, HB_SIZE, int )
typedef HB_PP_DUMP_FUNC_( HB_PP_DUMP_FUNC );
typedef HB_PP_DUMP_FUNC * PHB_PP_DUMP_FUNC;
/* function for catching HB_INLINE(...){...} data */
#define HB_PP_INLINE_FUNC_( func ) void func( void *, char *, char *, ULONG, int )
#define HB_PP_INLINE_FUNC_( func ) void func( void *, char *, char *, HB_SIZE, int )
typedef HB_PP_INLINE_FUNC_( HB_PP_INLINE_FUNC );
typedef HB_PP_INLINE_FUNC * PHB_PP_INLINE_FUNC;
@@ -514,14 +514,14 @@ typedef struct _HB_PP_DEFRULE
PHB_PP_TOKEN pResult;
HB_USHORT mode;
HB_USHORT markers;
ULONG repeatbits;
HB_ULONG repeatbits;
}
HB_PP_DEFRULE, * PHB_PP_DEFRULE;
typedef struct
{
const char * name; /* input name */
ULONG len; /* input name length */
HB_SIZE len; /* input name length */
const char * value; /* output name */
HB_USHORT type; /* HB_PP_TOKEN_* */
}
@@ -530,8 +530,8 @@ HB_PP_OPERATOR, * PHB_PP_OPERATOR;
typedef struct
{
char * pBufPtr;
ULONG ulLen;
ULONG ulAllocated;
HB_SIZE ulLen;
HB_SIZE ulAllocated;
}
HB_MEM_BUFFER, * PHB_MEM_BUFFER;
@@ -548,7 +548,7 @@ typedef struct _HB_PP_FILE
HB_BOOL fEof; /* the end of file reached */
const char * pLineBuf; /* buffer for parsing external lines */
ULONG ulLineBufLen; /* size of external line buffer */
HB_SIZE ulLineBufLen; /* size of external line buffer */
struct _HB_PP_FILE * pPrev; /* previous file, the one which included this file */
}
@@ -659,7 +659,7 @@ extern void hb_pp_setStdRules( PHB_PP_STATE pState );
extern void hb_pp_setStdBase( PHB_PP_STATE pState );
extern void hb_pp_setStream( PHB_PP_STATE pState, int iMode );
extern void hb_pp_addSearchPath( PHB_PP_STATE pState, const char * szPath, HB_BOOL fReplace );
extern HB_BOOL hb_pp_inBuffer( PHB_PP_STATE pState, const char * pBuffer, ULONG ulLen );
extern HB_BOOL hb_pp_inBuffer( PHB_PP_STATE pState, const char * pBuffer, HB_SIZE ulLen );
extern HB_BOOL hb_pp_inFile( PHB_PP_STATE pState, const char * szFileName, HB_BOOL fSearchPath, FILE * file_in, HB_BOOL fError );
extern HB_BOOL hb_pp_outFile( PHB_PP_STATE pState, const char * szOutFileName, FILE * file_out );
extern HB_BOOL hb_pp_traceFile( PHB_PP_STATE pState, const char * szTraceFileName, FILE * file_trace );
@@ -669,8 +669,8 @@ extern HB_BOOL hb_pp_eof( PHB_PP_STATE pState );
extern int hb_pp_lineTot( PHB_PP_STATE pState );
extern char * hb_pp_outFileName( PHB_PP_STATE pState );
extern char * hb_pp_traceFileName( PHB_PP_STATE pState );
extern char * hb_pp_nextLine( PHB_PP_STATE pState, ULONG * pulLen );
extern char * hb_pp_parseLine( PHB_PP_STATE pState, const char * pLine, ULONG * pulLen );
extern char * hb_pp_nextLine( PHB_PP_STATE pState, HB_SIZE * pulLen );
extern char * hb_pp_parseLine( PHB_PP_STATE pState, const char * pLine, HB_SIZE * pulLen );
extern void hb_pp_addDefine( PHB_PP_STATE pState, const char * szDefName, const char * szDefValue );
extern void hb_pp_delDefine( PHB_PP_STATE pState, const char * szDefName );
extern HB_BOOL hb_pp_lasterror( PHB_PP_STATE pState );
@@ -680,7 +680,7 @@ extern HB_BOOL hb_pp_eof( PHB_PP_STATE pState );
extern void hb_pp_tokenUpper( PHB_PP_TOKEN pToken );
extern void hb_pp_tokenToString( PHB_PP_STATE pState, PHB_PP_TOKEN pToken );
extern char * hb_pp_tokenBlockString( PHB_PP_STATE pState, PHB_PP_TOKEN pToken, int * piType, int * piLen );
extern PHB_PP_STATE hb_pp_lexNew( const char * pString, ULONG ulLen );
extern PHB_PP_STATE hb_pp_lexNew( const char * pString, HB_SIZE ulLen );
extern PHB_PP_TOKEN hb_pp_lexGet( PHB_PP_STATE pState );
extern PHB_PP_TOKEN hb_pp_tokenGet( PHB_PP_STATE pState );
extern HB_BOOL hb_pp_tokenNextExp( PHB_PP_TOKEN * pTokenPtr );

60
harbour/include/hbrddcdx.h
View File

@@ -251,15 +251,15 @@ typedef struct _CDXKEY
HB_BYTE * val;
USHORT len;
USHORT mode;
ULONG rec;
HB_ULONG rec;
} CDXKEY;
typedef CDXKEY * LPCDXKEY;
typedef struct _CDXPAGE
{
ULONG Page;
ULONG Left;
ULONG Right;
HB_ULONG Page;
HB_ULONG Left;
HB_ULONG Right;
HB_BYTE PageType;
int iKeys;
@@ -268,7 +268,7 @@ typedef struct _CDXPAGE
HB_BOOL fChanged;
HB_BYTE bUsed;
ULONG RNMask;
HB_ULONG RNMask;
HB_BYTE ReqByte;
HB_BYTE RNBits;
HB_BYTE DCBits;
@@ -306,7 +306,7 @@ typedef CDXSTACK * LPCDXSTACK;
typedef struct _CDXLIST
{
ULONG ulAddr;
HB_ULONG ulAddr;
HB_BOOL fStat;
struct _CDXLIST * pNext;
} CDXLIST;
@@ -342,15 +342,15 @@ typedef struct _CDXTAG
HB_BOOL fRePos;
int curKeyState; /* see: CDX_CURKEY_* */
ULONG rawKeyCount;
ULONG rawKeyPos;
ULONG rawKeyRec;
ULONG logKeyCount;
ULONG logKeyPos;
ULONG logKeyRec;
HB_ULONG rawKeyCount;
HB_ULONG rawKeyPos;
HB_ULONG rawKeyRec;
HB_ULONG logKeyCount;
HB_ULONG logKeyPos;
HB_ULONG logKeyRec;
ULONG TagBlock; /* a page offset where a tag header is stored */
ULONG RootBlock; /* a page offset with the root of keys tree */
HB_ULONG TagBlock; /* a page offset where a tag header is stored */
HB_ULONG RootBlock; /* a page offset with the root of keys tree */
HB_USHORT MaxKeys; /* maximum number of keys in Interior node */
struct _CDXINDEX * pIndex; /* a parent index info */
@@ -383,8 +383,8 @@ typedef struct _CDXINDEX
HB_BOOL fShared; /* Shared file */
HB_BOOL fReadonly; /* Read only file */
HB_BOOL fDelete; /* delete on close flag */
ULONG nextAvail; /* offset to next free page in the end of index file */
ULONG freePage; /* offset to next free page inside index file */
HB_ULONG nextAvail; /* offset to next free page in the end of index file */
HB_ULONG freePage; /* offset to next free page inside index file */
LPCDXLIST freeLst; /* list of free pages in index file */
int lockWrite; /* number of write lock set */
int lockRead; /* number of read lock set */
@@ -394,7 +394,7 @@ typedef struct _CDXINDEX
HB_BOOL WrLck;
#endif
HB_BOOL fChanged; /* changes written to index, need upadte ulVersion */
ULONG ulVersion; /* network version/update flag */
HB_ULONG ulVersion; /* network version/update flag */
HB_BOOL fFlush; /* changes written to index, need upadte ulVersion */
} CDXINDEX;
typedef CDXINDEX * LPCDXINDEX;
@@ -403,9 +403,9 @@ typedef CDXINDEX * LPCDXINDEX;
typedef struct
{
HB_FOFFSET nOffset; /* offset in temporary file */
ULONG ulKeys; /* number of keys in page */
ULONG ulKeyBuf; /* number of keys in memory buffer */
ULONG ulCurKey; /* current key in memory buffer */
HB_ULONG ulKeys; /* number of keys in page */
HB_ULONG ulKeyBuf; /* number of keys in memory buffer */
HB_ULONG ulCurKey; /* current key in memory buffer */
HB_BYTE * pKeyPool; /* memory buffer */
} CDXSWAPPAGE;
typedef CDXSWAPPAGE * LPCDXSWAPPAGE;
@@ -419,20 +419,20 @@ typedef struct
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 */
ULONG ulMaxRec; /* the highest record number */
ULONG ulTotKeys; /* total number of keys indexed */
ULONG ulKeys; /* keys in curently created page */
ULONG ulPages; /* number of pages */
ULONG ulCurPage; /* current page */
ULONG ulPgKeys; /* maximum number of key in page memory buffer */
ULONG ulMaxKey; /* maximum number of keys in single page */
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 */
ULONG ulFirst;
ULONG * pSortedPages;
HB_ULONG ulFirst;
HB_ULONG * pSortedPages;
HB_BYTE pLastKey[ CDX_MAXKEY ]; /* last key val */
ULONG ulLastRec;
HB_ULONG ulLastRec;
HB_BYTE * pRecBuff;
#ifndef HB_CDX_PACKTRAIL
int iLastTrl; /* last key trailing spaces */

26
harbour/include/hbrdddbf.h
View File

@@ -141,7 +141,7 @@ typedef struct _DBFDATA
HB_BYTE bMemoType; /* DB_MEMO_FPT */
HB_BYTE bMemoExtType; /* DB_MEMOVER_FLEX */
HB_USHORT uiDirtyRead; /* HB_IDXREAD_CLEANMASK */
ULONG ulMemoBlockSize; /* 0 */
HB_ULONG ulMemoBlockSize; /* 0 */
HB_BOOL fSortRecNo;
HB_BOOL fMultiKey;
@@ -183,8 +183,8 @@ typedef struct _DBFAREA
char * szMemoFileName; /* Name of memo file */
HB_USHORT uiHeaderLen; /* Size of header */
HB_USHORT uiRecordLen; /* Size of record */
ULONG ulMemoBlockSize; /* Size of memo block */
ULONG ulNewBlockSize; /* Size of new memo block */
HB_ULONG ulMemoBlockSize; /* Size of memo block */
HB_ULONG ulNewBlockSize; /* Size of new memo block */
HB_USHORT uiMemoVersion; /* MEMO file version */
HB_USHORT uiDirtyRead; /* Index dirty read bit filed */
HB_USHORT uiNullOffset; /* Offset to _NullFlags filed */
@@ -197,8 +197,8 @@ typedef struct _DBFAREA
HB_USHORT * pFieldOffset; /* Pointer to field offset array */
PHB_DBFFIELDBITS pFieldBits; /* Pointer to extended DBF field info array */
HB_BYTE * pRecord; /* Buffer of record data */
ULONG ulRecCount; /* Total records */
ULONG ulRecNo; /* Current record */
HB_ULONG ulRecCount; /* Total records */
HB_ULONG ulRecNo; /* Current record */
HB_BOOL fAutoInc; /* WorkArea with auto increment fields */
HB_BOOL fHasMemo; /* WorkArea with Memo fields */
HB_BOOL fHasTags; /* WorkArea with MDX or CDX index */
@@ -222,8 +222,8 @@ typedef struct _DBFAREA
HB_BOOL fTrigger; /* Execute trigger function */
LPDBOPENINFO lpdbOpenInfo; /* Pointer to current dbOpenInfo structure in OPEN/CREATE methods */
LPDBRELINFO lpdbPendingRel; /* Pointer to parent rel struct */
ULONG * pLocksPos; /* List of records locked */
ULONG ulNumLocksPos; /* Number of records locked */
HB_ULONG * pLocksPos; /* List of records locked */
HB_ULONG ulNumLocksPos; /* Number of records locked */
char * pCryptKey; /* Pointer to encryption key */
PHB_DYNS pTriggerSym; /* DynSym pointer to trigger function */
} DBFAREA;
@@ -236,15 +236,15 @@ typedef DBFAREA * LPDBFAREA;
#define SUPERTABLE ( &dbfSuper )
extern HB_EXPORT ULONG hb_dbfGetMemoBlock( DBFAREAP pArea, HB_USHORT uiIndex );
extern HB_EXPORT HB_ULONG hb_dbfGetMemoBlock( DBFAREAP pArea, HB_USHORT uiIndex );
extern HB_EXPORT void hb_dbfPutMemoBlock( DBFAREAP pArea, HB_USHORT uiIndex,
ULONG ulBlock );
HB_ULONG ulBlock );
extern HB_EXPORT HB_ERRCODE hb_dbfGetMemoData( DBFAREAP pArea, HB_USHORT uiIndex,
ULONG * pulBlock, ULONG * pulSize,
ULONG * pulType );
HB_ULONG * pulBlock, HB_ULONG * pulSize,
HB_ULONG * pulType );
extern HB_EXPORT HB_ERRCODE hb_dbfSetMemoData( DBFAREAP pArea, HB_USHORT uiIndex,
ULONG ulBlock, ULONG ulSize,
ULONG ulType );
HB_ULONG ulBlock, HB_ULONG ulSize,
HB_ULONG ulType );
extern HB_EXPORT HB_ERRCODE hb_dbfGetEGcode( HB_ERRCODE errCode );
extern HB_EXPORT HB_BOOL hb_dbfLockIdxFile( PHB_FILE pFile, HB_BYTE bScheme, HB_USHORT usMode, HB_FOFFSET *pPoolPos );
extern HB_EXPORT HB_BOOL hb_dbfLockIdxGetData( HB_BYTE bScheme, HB_FOFFSET *ulPos, HB_FOFFSET *ulPool );

10
harbour/include/hbrdddel.h
View File

@@ -90,15 +90,15 @@ typedef struct _DELIMAREA
HB_USHORT * pFieldOffset; /* Pointer to field offset array */
HB_BYTE * pRecord; /* Buffer of record data */
HB_BYTE * pBuffer; /* Read/Write */
ULONG ulBufferSize; /* IO buffer size */
ULONG ulBufferRead; /* Number of bytes in read buffer */
ULONG ulBufferIndex; /* Index to read read buffer */
HB_SIZE ulBufferSize; /* IO buffer size */
HB_SIZE ulBufferRead; /* Number of bytes in read buffer */
HB_SIZE ulBufferIndex; /* Index to read read buffer */
HB_FOFFSET ulRecordOffset; /* Current record offest */
HB_FOFFSET ulNextOffset; /* Next record offest */
HB_FOFFSET ulFileSize; /* File table size in export mode */
HB_FOFFSET ulBufferStart; /* Start offset of read buffer */
ULONG ulRecNo; /* Current record */
ULONG ulRecCount; /* Number of records (in export) */
HB_ULONG ulRecNo; /* Current record */
HB_ULONG ulRecCount; /* Number of records (in export) */
HB_BOOL fTransRec; /* Can put whole records */
HB_BOOL fFlush; /* Data was written to table and not commited */
HB_BOOL fShared; /* Shared file */

18
harbour/include/hbrddfpt.h
View File

@@ -206,9 +206,9 @@ typedef FPTBLOCK * LPFPTBLOCK;
/* MEMO internal memory structures */
typedef struct _MEMOGCITEM
{
ULONG ulOffset; /* Number of blocks */
ULONG ulSize; /* Block number */
HB_BOOL fChanged; /* Mark the free page as changed */
HB_ULONG ulOffset; /* Number of blocks */
HB_ULONG ulSize; /* Block number */
HB_BOOL fChanged; /* Mark the free page as changed */
} MEMOGCITEM;
typedef MEMOGCITEM * LPMEMOGCITEM;
@@ -216,12 +216,12 @@ typedef struct _MEMOGCTABLE
{
HB_BYTE bType; /* MEMO_FPT_SIX or MEMO_FPT_FLEX */
HB_BYTE bChanged; /* Should we write GC data to disk */
ULONG ulNextBlock; /* Next free block in the file */
ULONG ulPrevBlock; /* Previous next free block in the file */
ULONG ulRevPage; /* FLEX Rev GC page offset */
ULONG ulDirPage; /* FLEX Dir GC page offset */
ULONG ulCounter; /* FLEX cyclic counter */
ULONG ulSize; /* FLEX GC page size in bytes */
HB_ULONG ulNextBlock; /* Next free block in the file */
HB_ULONG ulPrevBlock; /* Previous next free block in the file */
HB_ULONG ulRevPage; /* FLEX Rev GC page offset */
HB_ULONG ulDirPage; /* FLEX Dir GC page offset */
HB_ULONG ulCounter; /* FLEX cyclic counter */
HB_ULONG ulSize; /* FLEX GC page size in bytes */
HB_USHORT usMaxItem; /* max number of items in pGCitems */
HB_USHORT usItems; /* number of items in pGCitems */
LPMEMOGCITEM pGCitems; /* free block list */

62
harbour/include/hbrddnsx.h
View File

@@ -358,8 +358,8 @@ struct _NSXINDEX;
typedef struct _KEYINFO
{
ULONG page; /* page number */
ULONG rec; /* record number */
HB_ULONG page; /* page number */
HB_ULONG rec; /* record number */
int mode; /* comparison mode NSX_CMP_* */
HB_UCHAR val[ 1 ]; /* key value */
} KEYINFO;
@@ -367,7 +367,7 @@ typedef KEYINFO * LPKEYINFO;
typedef struct _TREE_STACK
{
ULONG page;
HB_ULONG page;
HB_SHORT ikey;
HB_UCHAR * value;
} TREE_STACK;
@@ -375,7 +375,7 @@ typedef TREE_STACK * LPTREESTACK;
typedef struct _HB_PAGEINFO
{
ULONG Page;
HB_ULONG Page;
HB_BOOL Changed;
int iUsed;
HB_USHORT uiKeys;
@@ -424,8 +424,8 @@ typedef struct _TAGINFO
HB_BOOL TagEOF;
HB_BOOL HotFor;
ULONG HeadBlock;
ULONG RootBlock;
HB_ULONG HeadBlock;
HB_ULONG RootBlock;
HB_UCHAR TagFlags;
HB_UCHAR KeyType;
@@ -442,7 +442,7 @@ typedef struct _TAGINFO
HB_USHORT stackLevel;
LPTREESTACK stack;
ULONG keyCount;
HB_ULONG keyCount;
LPKEYINFO CurKeyInfo;
LPKEYINFO HotKeyInfo;
@@ -454,9 +454,9 @@ typedef struct _NSXINDEX
{
char * IndexName;
char * RealName;
ULONG Version; /* index VERSION filed to signal index updates for other stations */
ULONG NextAvail; /* next free page in index file */
ULONG FileSize; /* index file size */
HB_ULONG Version; /* index VERSION filed to signal index updates for other stations */
HB_ULONG NextAvail; /* next free page in index file */
HB_ULONG FileSize; /* index file size */
struct _NSXAREA * pArea;
PHB_FILE pFile;
HB_BOOL fDelete; /* delete on close flag */
@@ -476,9 +476,9 @@ typedef struct _NSXINDEX
int iTags;
LPTAGINFO * lpTags;
ULONG ulPages;
ULONG ulPageLast;
ULONG ulPagesDepth;
HB_ULONG ulPages;
HB_ULONG ulPageLast;
HB_ULONG ulPagesDepth;
LPPAGEINFO *pages;
LPPAGEINFO pChanged;
LPPAGEINFO pFirst;
@@ -492,9 +492,9 @@ typedef NSXINDEX * LPNSXINDEX;
typedef struct
{
HB_FOFFSET nOffset; /* offset in temporary file */
ULONG ulKeys; /* number of keys in page */
ULONG ulKeyBuf; /* number of keys in memory buffer */
ULONG ulCurKey; /* current key in memory buffer */
HB_ULONG ulKeys; /* number of keys in page */
HB_ULONG ulKeyBuf; /* number of keys in memory buffer */
HB_ULONG ulCurKey; /* current key in memory buffer */
HB_UCHAR * pKeyPool; /* memory buffer */
} NSXSWAPPAGE;
typedef NSXSWAPPAGE * LPNSXSWAPPAGE;
@@ -509,28 +509,28 @@ typedef struct
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 */
ULONG ulMaxRec; /* the highest record number */
ULONG ulTotKeys; /* total number of keys indexed */
ULONG ulKeys; /* keys in curently created page */
ULONG ulPages; /* number of pages */
ULONG ulCurPage; /* current page */
ULONG ulPgKeys; /* maximum number of key in page memory buffer */
ULONG ulMaxKey; /* maximum number of keys in single page */
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 */
ULONG ulFirst;
ULONG * pSortedPages;
HB_ULONG ulFirst;
HB_ULONG * pSortedPages;
HB_UCHAR pLastKey[ NSX_MAXKEYLEN ]; /* last key val */
ULONG ulLastRec;
ULONG ulLastLeaf; /* last non empty leaf page written to tag */
HB_ULONG ulLastRec;
HB_ULONG ulLastLeaf; /* last non empty leaf page written to tag */
HB_UCHAR * pBuffIO; /* index IO buffer */
ULONG ulSizeIO; /* size of IO buffer in index pages */
ULONG ulPagesIO; /* number of index pages in buffer */
ULONG ulFirstIO; /* first page in buffer */
ULONG ulLastIO; /* last page in 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;

60
harbour/include/hbrddntx.h
View File

@@ -165,22 +165,22 @@ struct _NTXINDEX;
typedef struct _KEYINFO
{
ULONG Tag; /* page number */
ULONG Xtra; /* record number */
HB_ULONG Tag; /* page number */
HB_ULONG Xtra; /* record number */
char key[ 1 ]; /* key value */
} KEYINFO;
typedef KEYINFO * LPKEYINFO;
typedef struct _TREE_STACK
{
ULONG page;
HB_ULONG page;
HB_SHORT ikey;
} TREE_STACK;
typedef TREE_STACK * LPTREESTACK;
typedef struct _HB_PAGEINFO
{
ULONG Page;
HB_ULONG Page;
HB_BOOL Changed;
int iUsed;
HB_USHORT uiKeys;
@@ -229,8 +229,8 @@ typedef struct _TAGINFO
HB_BOOL HdrChanged;
HB_BOOL TagBOF;
HB_BOOL TagEOF;
ULONG HeadBlock;
ULONG RootBlock;
HB_ULONG HeadBlock;
HB_ULONG RootBlock;
HB_USHORT uiNumber;
HB_BYTE KeyType;
HB_USHORT nField;
@@ -240,7 +240,7 @@ typedef struct _TAGINFO
LPTREESTACK stack;
HB_USHORT stackSize;
HB_USHORT stackLevel;
ULONG keyCount;
HB_ULONG keyCount;
LPKEYINFO CurKeyInfo;
LPKEYINFO HotKeyInfo;
HB_BOOL HotFor;
@@ -253,9 +253,9 @@ typedef struct _NTXINDEX
{
char * IndexName;
char * RealName;
ULONG Version; /* The index VERSION filed to signal index updates for other stations */
ULONG NextAvail;
ULONG TagBlock; /* Index attr, next free page */
HB_ULONG Version; /* The index VERSION filed to signal index updates for other stations */
HB_ULONG NextAvail;
HB_ULONG TagBlock; /* Index attr, next free page */
struct _NTXAREA * Owner;
PHB_FILE DiskFile;
HB_BOOL fDelete; /* delete on close flag */
@@ -276,9 +276,9 @@ typedef struct _NTXINDEX
int iTags;
LPTAGINFO * lpTags;
ULONG ulPages;
ULONG ulPageLast;
ULONG ulPagesDepth;
HB_ULONG ulPages;
HB_ULONG ulPageLast;
HB_ULONG ulPagesDepth;
LPPAGEINFO *pages;
LPPAGEINFO pChanged;
LPPAGEINFO pFirst;
@@ -292,9 +292,9 @@ typedef NTXINDEX * LPNTXINDEX;
typedef struct
{
HB_FOFFSET nOffset; /* offset in temporary file */
ULONG ulKeys; /* number of keys in page */
ULONG ulKeyBuf; /* number of keys in memory buffer */
ULONG ulCurKey; /* current key in memory buffer */
HB_ULONG ulKeys; /* number of keys in page */
HB_ULONG ulKeyBuf; /* number of keys in memory buffer */
HB_ULONG ulCurKey; /* current key in memory buffer */
HB_BYTE * pKeyPool; /* memory buffer */
} NTXSWAPPAGE;
typedef NTXSWAPPAGE * LPNTXSWAPPAGE;
@@ -307,27 +307,27 @@ typedef struct
int keyLen; /* key length */
HB_BOOL fUnique; /* HB_TRUE if index is unique */
HB_BOOL fReindex; /* HB_TRUE if reindexing is in process */
ULONG ulMaxRec; /* the highest record number */
ULONG ulTotKeys; /* total number of keys indexed */
ULONG ulKeys; /* keys in curently created page */
ULONG ulPages; /* number of pages */
ULONG ulCurPage; /* current page */
ULONG ulPgKeys; /* maximum number of key in page memory buffer */
ULONG ulMaxKey; /* maximum number of keys in single page */
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 */
HB_BYTE * pStartKey; /* begining of key pool after sorting */
LPNTXSWAPPAGE pSwapPage; /* list of pages */
LPPAGEINFO NodeList[ NTX_STACKSIZE ]; /* Stack of pages */
ULONG ulFirst;
ULONG * pSortedPages;
HB_ULONG ulFirst;
HB_ULONG * pSortedPages;
HB_BYTE pLastKey[ NTX_MAX_KEY ]; /* last key val */
ULONG ulLastRec;
HB_ULONG ulLastRec;
HB_BYTE * pBuffIO; /* index IO buffer */
ULONG ulSizeIO; /* size of IO buffer in index pages */
ULONG ulPagesIO; /* number of index pages in buffer */
ULONG ulFirstIO; /* first page in buffer */
ULONG ulLastIO; /* last page in 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 */
} NTXSORTINFO;
typedef NTXSORTINFO * LPNTXSORTINFO;

4
harbour/include/hbrddsdf.h
View File

@@ -90,8 +90,8 @@ typedef struct _SDFAREA
HB_FOFFSET ulRecordOffset; /* Current record offest */
HB_FOFFSET ulNextOffset; /* Next record offest */
HB_FOFFSET ulFileSize; /* File table size in export mode */
ULONG ulRecNo; /* Current record */
ULONG ulRecCount; /* Number of records (in export) */
HB_ULONG ulRecNo; /* Current record */
HB_ULONG ulRecCount; /* Number of records (in export) */
HB_BOOL fTransRec; /* Can put whole records */
HB_BOOL fFlush; /* Data was written to SDF and not commited */
HB_BOOL fShared; /* Shared file */

6
harbour/include/hbregex.h
View File

@@ -103,7 +103,7 @@ typedef HB_REGEX * PHB_REGEX;
typedef void ( * HB_REG_FREE )( PHB_REGEX );
typedef int ( * HB_REG_COMP )( PHB_REGEX, const char * );
typedef int ( * HB_REG_EXEC )( PHB_REGEX, const char *, ULONG, int, HB_REGMATCH * );
typedef int ( * HB_REG_EXEC )( PHB_REGEX, const char *, HB_SIZE, int, HB_REGMATCH * );
extern void hb_regexInit( HB_REG_FREE pFree, HB_REG_COMP pComp, HB_REG_EXEC pExec );
extern HB_BOOL hb_regexIs( PHB_ITEM pItem );
@@ -135,10 +135,10 @@ typedef void * PHB_REGEX;
HB_EXTERN_BEGIN
extern HB_EXPORT PHB_REGEX hb_regexCompile( const char * szRegEx, ULONG ulLen, int iFlags );
extern HB_EXPORT PHB_REGEX hb_regexCompile( const char * szRegEx, HB_SIZE ulLen, int iFlags );
extern HB_EXPORT PHB_REGEX hb_regexGet( PHB_ITEM pRegExItm, int iFlags );
extern HB_EXPORT void hb_regexFree( PHB_REGEX pRegEx );
extern HB_EXPORT HB_BOOL hb_regexMatch( PHB_REGEX pRegEx, const char * szString, ULONG UlLen, HB_BOOL fFull );
extern HB_EXPORT HB_BOOL hb_regexMatch( PHB_REGEX pRegEx, const char * szString, HB_SIZE UlLen, HB_BOOL fFull );
HB_EXTERN_END

12
harbour/include/hbstack.h
View File

@@ -73,8 +73,8 @@ HB_EXTERN_BEGIN
typedef void (*PHB_TSD_FUNC)(void *);
typedef struct
{
int iHandle;
int iSize;
int iHandle;
int iSize;
PHB_TSD_FUNC pInitFunc;
PHB_TSD_FUNC pCleanFunc;
}
@@ -136,9 +136,9 @@ HB_PRIVATE_ITEM, * PHB_PRIVATE_ITEM;
typedef struct
{
PHB_PRIVATE_ITEM stack;
ULONG size;
ULONG count;
ULONG base;
HB_ULONG size;
HB_ULONG count;
HB_ULONG base;
}
HB_PRIVATE_STACK, * PHB_PRIVATE_STACK;
@@ -312,7 +312,7 @@ extern PHB_STACKRDD hb_stackRDD( void );
extern void ** hb_stackDebugInfo( void );
#ifdef _HB_API_INTERNAL_
extern void hb_stackDecrease( ULONG ulItems );
extern void hb_stackDecrease( HB_ULONG ulItems );
extern HB_ITEM_PTR hb_stackNewFrame( PHB_STACK_STATE pFrame, HB_USHORT uiParams );
extern void hb_stackOldFrame( PHB_STACK_STATE pFrame );
extern void hb_stackClearMemvarsBase( void );

12
harbour/include/hbthread.h
View File

@@ -247,7 +247,7 @@ HB_EXTERN_BEGIN
# define HB_THREAD_INFINITE_WAIT SEM_INDEFINITE_WAIT
# ifndef SEM_INDEFINITE_WAIT
# define SEM_INDEFINITE_WAIT ( ( ULONG ) -1 )
# define SEM_INDEFINITE_WAIT ( ( HB_ULONG ) -1 )
# endif
#else
@@ -355,7 +355,7 @@ HB_EXTERN_BEGIN
#endif
#ifndef HB_THREAD_INFINITE_WAIT
# define HB_THREAD_INFINITE_WAIT ( ( ULONG ) -1 )
# define HB_THREAD_INFINITE_WAIT ( ( HB_ULONG ) -1 )
#endif
typedef HB_THREAD_STARTFUNC( PHB_THREAD_STARTFUNC );
@@ -406,7 +406,7 @@ extern void hb_threadLeaveCriticalSection( HB_CRITICAL_T * critical );
extern HB_BOOL hb_threadCondSignal( HB_COND_T * cond );
extern HB_BOOL hb_threadCondBroadcast( HB_COND_T * cond );
extern HB_BOOL hb_threadCondWait( HB_COND_T * cond, HB_CRITICAL_T * mutex );
extern HB_BOOL hb_threadCondTimedWait( HB_COND_T * cond, HB_CRITICAL_T * mutex, ULONG ulMilliSec );
extern HB_BOOL hb_threadCondTimedWait( HB_COND_T * cond, HB_CRITICAL_T * mutex, HB_ULONG ulMilliSec );
extern HB_THREAD_HANDLE hb_threadCreate( HB_THREAD_ID * th_id, PHB_THREAD_STARTFUNC start_func, void * Cargo );
extern HB_BOOL hb_threadJoin( HB_THREAD_HANDLE th_h );
@@ -415,17 +415,17 @@ extern HB_BOOL hb_threadDetach( HB_THREAD_HANDLE th_h );
/* used by .prg code */
extern PHB_ITEM hb_threadMutexCreate( void );
extern HB_BOOL hb_threadMutexLock( PHB_ITEM pItem );
extern HB_BOOL hb_threadMutexTimedLock( PHB_ITEM pItem, ULONG ulMilliSec );
extern HB_BOOL hb_threadMutexTimedLock( PHB_ITEM pItem, HB_ULONG ulMilliSec );
extern HB_BOOL hb_threadMutexUnlock( PHB_ITEM pItem );
extern void hb_threadMutexNotify( PHB_ITEM pItem, PHB_ITEM pNotifier, HB_BOOL fWaiting );
extern PHB_ITEM hb_threadMutexSubscribe( PHB_ITEM pItem, HB_BOOL fClear );
extern PHB_ITEM hb_threadMutexTimedSubscribe( PHB_ITEM pItem, ULONG ulMilliSec, HB_BOOL fClear );
extern PHB_ITEM hb_threadMutexTimedSubscribe( PHB_ITEM pItem, HB_ULONG ulMilliSec, HB_BOOL fClear );
#if defined( HB_MT_VM ) && defined( _HB_API_INTERNAL_ )
extern void hb_threadMutexUnlockAll( void );
extern void hb_threadMutexSyncSignal( PHB_ITEM pItemMtx );
extern HB_BOOL hb_threadMutexSyncWait( PHB_ITEM pItemMtx, ULONG ulMilliSec, PHB_ITEM pItemSync );
extern HB_BOOL hb_threadMutexSyncWait( PHB_ITEM pItemMtx, HB_ULONG ulMilliSec, PHB_ITEM pItemSync );
#if defined( HB_NO_TLS ) || defined( HB_TASK_THREAD )
# undef HB_USE_TLS

18
harbour/include/hbtypes.h
View File

@@ -62,7 +62,7 @@ HB_EXTERN_BEGIN
typedef PHB_SYMB ( * VM_PROCESS_SYMBOLS )
( PHB_SYMB pModuleSymbols, HB_USHORT uiModuleSymbols,
const char * szModuleName, ULONG ulID, HB_USHORT uiPcodeVer );
const char * szModuleName, HB_ULONG ulID, HB_USHORT uiPcodeVer );
typedef void ( * VM_EXECUTE ) ( const HB_BYTE * pCode, PHB_SYMB pSymbols );
@@ -88,7 +88,7 @@ typedef void ( * HB_RETNILEN )( int iNumber, int iWidth );
typedef void ( * HB_RETNLLEN )( long lNumber, int iWidth );
typedef void ( * HB_RETA )( HB_SIZE ulLen );
typedef HB_SIZE ( * HB_PARINFA )( int iParamNum, HB_SIZE uiArrayIndex );
typedef ULONG ( * HB_PARINFO )( int iParam );
typedef HB_ULONG ( * HB_PARINFO )( int iParam );
typedef HB_SIZE ( * HB_PARCLEN )( int iParam );
typedef HB_SIZE ( * HB_PARCSIZ )( int iParam );
typedef char * ( * HB_PARDS )( int iParam );
@@ -129,13 +129,13 @@ typedef HB_BOOL ( * HB_ARRAYSIZE )( PHB_ITEM pArray, HB_SIZE ulLen );
typedef HB_BOOL ( * HB_ARRAYLAST )( PHB_ITEM pArray, PHB_ITEM pResult );
typedef HB_BOOL ( * HB_ARRAYSET )( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem );
typedef HB_BOOL ( * HB_ARRAYGET )( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem );
typedef void ( * HB_XINIT )( void ); /* Initialize fixed memory subsystem */
typedef void ( * HB_XEXIT )( void ); /* Deinitialize fixed memory subsystem */
typedef void * ( * HB_XALLOC )( ULONG ulSize ); /* allocates memory, returns NULL on failure */
typedef void * ( * HB_XGRAB )( ULONG ulSize ); /* allocates memory, exits on failure */
typedef void ( * HB_XFREE )( void * pMem ); /* frees memory */
typedef void * ( * HB_XREALLOC )( void * pMem, ULONG ulSize ); /* reallocates memory */
typedef ULONG ( * HB_XSIZE )( void * pMem ); /* returns the size of an allocated memory block */
typedef void ( * HB_XINIT )( void ); /* Initialize fixed memory subsystem */
typedef void ( * HB_XEXIT )( void ); /* Deinitialize fixed memory subsystem */
typedef void * ( * HB_XALLOC )( HB_ULONG ulSize ); /* allocates memory, returns NULL on failure */
typedef void * ( * HB_XGRAB )( HB_ULONG ulSize ); /* allocates memory, exits on failure */
typedef void ( * HB_XFREE )( void * pMem ); /* frees memory */
typedef void * ( * HB_XREALLOC )( void * pMem, HB_ULONG ulSize ); /* reallocates memory */
typedef HB_ULONG ( * HB_XSIZE )( void * pMem ); /* returns the size of an allocated memory block */
HB_EXTERN_END

20
harbour/include/hbvm.h
View File

@@ -74,8 +74,8 @@ extern HB_EXPORT void hb_vmAtQuit( HB_INIT_FUNC pFunc, void * cargo );
/* Harbour virtual machine functions */
extern HB_EXPORT void hb_vmExecute( const HB_BYTE * pCode, PHB_SYMB pSymbols ) HB_FLATTEN_ATTR; /* invokes the virtual machine */
extern HB_EXPORT PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, HB_USHORT uiSymbols, const char * szModuleName, ULONG ulID, HB_USHORT uiPcodeVer ); /* module symbols initialization with extended information */
extern HB_EXPORT PHB_SYMB hb_vmProcessDynLibSymbols( PHB_SYMB pSymbols, HB_USHORT uiSymbols, const char * szModuleName, ULONG ulID, HB_USHORT uiPcodeVer ); /* module symbols initialization with extended information */
extern HB_EXPORT PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, HB_USHORT uiSymbols, const char * szModuleName, HB_ULONG ulID, HB_USHORT uiPcodeVer ); /* module symbols initialization with extended information */
extern HB_EXPORT PHB_SYMB hb_vmProcessDynLibSymbols( PHB_SYMB pSymbols, HB_USHORT uiSymbols, const char * szModuleName, HB_ULONG ulID, HB_USHORT uiPcodeVer ); /* module symbols initialization with extended information */
#ifdef _HB_API_INTERNAL_
@@ -91,10 +91,10 @@ extern HB_EXPORT PHB_SYMB hb_vmProcessDynLibSymbols( PHB_SYMB pSymbols, HB_USHOR
HB_BOOL fActive; /* the symbol table is currently active */
HB_BOOL fInitStatics; /* static initialization should be executed */
char * szModuleName; /* module name */
ULONG ulID; /* module unique identifier */
HB_ULONG ulID; /* module unique identifier */
} HB_SYMBOLS, * PHB_SYMBOLS; /* structure to keep track of all modules symbol tables */
extern PHB_SYMBOLS hb_vmRegisterSymbols( PHB_SYMB pModuleSymbols, HB_USHORT uiSymbols, const char * szModuleName, ULONG ulID, HB_BOOL fDynLib, HB_BOOL fClone );
extern PHB_SYMBOLS hb_vmRegisterSymbols( PHB_SYMB pModuleSymbols, HB_USHORT uiSymbols, const char * szModuleName, HB_ULONG ulID, HB_BOOL fDynLib, HB_BOOL fClone );
extern HB_BOOL hb_vmLockModuleSymbols( void );
extern void hb_vmUnlockModuleSymbols( void );
extern void hb_vmFreeSymbols( PHB_SYMBOLS pSymbols );
@@ -142,7 +142,7 @@ extern HB_EXPORT void hb_vmFunction( HB_USHORT uiParams ); /* executes a fun
extern HB_EXPORT void hb_vmSend( HB_USHORT uiParams ); /* sends a message to an object */
extern HB_EXPORT PHB_ITEM hb_vmEvalBlock( PHB_ITEM pBlockItem ); /* executes passed codeblock with no arguments */
/* executes passed codeblock with variable number of arguments */
extern HB_EXPORT PHB_ITEM hb_vmEvalBlockV( PHB_ITEM pBlockItem, ULONG ulArgCount, ... );
extern HB_EXPORT PHB_ITEM hb_vmEvalBlockV( PHB_ITEM pBlockItem, HB_ULONG ulArgCount, ... );
extern HB_EXPORT PHB_ITEM hb_vmEvalBlockOrMacro( PHB_ITEM pItem ); /* executes codeblock or macro pointed by given item */
extern HB_EXPORT void hb_vmDestroyBlockOrMacro( PHB_ITEM pItem ); /* destroy codeblock or macro in given item */
@@ -186,11 +186,11 @@ extern HB_EXPORT void hb_vmTerminateThreads( void ); /* send QUIT request to
extern HB_EXPORT void * hb_vmThreadState( void );
/* various flags for supported features */
#define HB_VMFLAG_HARBOUR 1 /* enable Harbour extension */
#define HB_VMFLAG_ARRSTR 16 /* support for string as array of bytes -ks */
extern HB_EXPORT ULONG hb_vmFlagEnabled( ULONG flags );
extern HB_EXPORT void hb_vmFlagSet( ULONG flags );
extern HB_EXPORT void hb_vmFlagClear( ULONG flags );
#define HB_VMFLAG_HARBOUR 1 /* enable Harbour extension */
#define HB_VMFLAG_ARRSTR 16 /* support for string as array of bytes -ks */
extern HB_EXPORT HB_ULONG hb_vmFlagEnabled( HB_ULONG flags );
extern HB_EXPORT void hb_vmFlagSet( HB_ULONG flags );
extern HB_EXPORT void hb_vmFlagClear( HB_ULONG flags );
HB_EXTERN_END

6
harbour/include/hbvmpub.h
View File

@@ -148,9 +148,9 @@ struct _HB_SYMB;
# endif /* !HB_MT_VM */
HB_USHORT uiSymNum; /* dynamic symbol number */
# if !defined( HB_NO_PROFILER )
ULONG ulCalls; /* profiler support */
ULONG ulTime; /* profiler support */
ULONG ulRecurse; /* profiler support */
HB_ULONG ulCalls; /* profiler support */
HB_ULONG ulTime; /* profiler support */
HB_ULONG ulRecurse; /* profiler support */
# endif /* !HB_NO_PROFILER */
} HB_DYNS, * PHB_DYNS, * HB_DYNS_PTR;

20
harbour/src/common/expropt1.c
View File

@@ -367,7 +367,7 @@ HB_EXPR_PTR hb_compExprNewTimeStamp( long lDate, long lTime, HB_COMP_DECL )
return pExpr;
}
HB_EXPR_PTR hb_compExprNewString( const char *szValue, ULONG ulLen, HB_BOOL fDealloc, HB_COMP_DECL )
HB_EXPR_PTR hb_compExprNewString( const char *szValue, HB_ULONG ulLen, HB_BOOL fDealloc, HB_COMP_DECL )
{
HB_EXPR_PTR pExpr;
@@ -462,7 +462,7 @@ HB_EXPR_PTR hb_compExprNewHash( HB_EXPR_PTR pHashList, HB_COMP_DECL )
return pHashList;
}
HB_EXPR_PTR hb_compExprNewCodeBlock( char *string, ULONG ulLen, int iFlags, HB_COMP_DECL )
HB_EXPR_PTR hb_compExprNewCodeBlock( char *string, HB_ULONG ulLen, int iFlags, HB_COMP_DECL )
{
HB_EXPR_PTR pExpr;
@@ -1266,9 +1266,9 @@ HB_EXPR_PTR hb_compExprMacroAsAlias( HB_EXPR_PTR pExpr )
/* Return a number of elements on the linked list
*/
ULONG hb_compExprListLen( HB_EXPR_PTR pExpr )
HB_ULONG hb_compExprListLen( HB_EXPR_PTR pExpr )
{
ULONG ulLen = 0;
HB_ULONG ulLen = 0;
pExpr = pExpr->value.asList.pExprList;
while( pExpr )
@@ -1300,9 +1300,9 @@ HB_BOOL hb_compExprListTypeCheck( HB_EXPR_PTR pExpr, HB_EXPRTYPE ExprType )
/* Return a number of parameters passed to function or method
*/
ULONG hb_compExprParamListLen( HB_EXPR_PTR pExpr )
HB_ULONG hb_compExprParamListLen( HB_EXPR_PTR pExpr )
{
ULONG ulLen = 0;
HB_ULONG ulLen = 0;
if( pExpr )
{
@@ -1325,9 +1325,9 @@ ULONG hb_compExprParamListLen( HB_EXPR_PTR pExpr )
/* Return a number of macro group elements on the linked list
*/
ULONG hb_compExprMacroListLen( HB_EXPR_PTR pExpr )
HB_ULONG hb_compExprMacroListLen( HB_EXPR_PTR pExpr )
{
ULONG ulLen = 0, ulItems = 0;
HB_ULONG ulLen = 0, ulItems = 0;
pExpr = pExpr->value.asList.pExprList;
while( pExpr )
@@ -1352,9 +1352,9 @@ ULONG hb_compExprMacroListLen( HB_EXPR_PTR pExpr )
return ulLen;
}
ULONG hb_compExprParamListCheck( HB_COMP_DECL, HB_EXPR_PTR pExpr )
HB_ULONG hb_compExprParamListCheck( HB_COMP_DECL, HB_EXPR_PTR pExpr )
{
ULONG ulLen = 0, ulItems = 0;
HB_ULONG ulLen = 0, ulItems = 0;
if( pExpr )
{
HB_EXPR_PTR pElem;

10
harbour/src/common/expropt2.c
View File

@@ -60,7 +60,7 @@
#include "hbdate.h"
#include "hbmath.h"
static HB_BOOL hb_compExprHasMacro( const char * szText, ULONG ulLen, HB_COMP_DECL )
static HB_BOOL hb_compExprHasMacro( const char * szText, HB_ULONG ulLen, HB_COMP_DECL )
{
while( ulLen-- )
{
@@ -105,7 +105,7 @@ static HB_EXPR_PTR hb_compExprReducePlusStrings( HB_EXPR_PTR pLeft, HB_EXPR_PTR
static HB_EXPR_PTR hb_compExprReduceMinusStrings( HB_EXPR_PTR pLeft, HB_EXPR_PTR pRight, HB_COMP_DECL )
{
char * szText = pLeft->value.asString.string;
ULONG ulLen = pLeft->ulLength;
HB_ULONG ulLen = pLeft->ulLength;
while( ulLen && szText[ ulLen - 1 ] == ' ' )
--ulLen;
@@ -598,7 +598,7 @@ HB_EXPR_PTR hb_compExprReduceMinus( HB_EXPR_PTR pSelf, HB_COMP_DECL )
if( HB_SUPPORT_MACROTEXT )
{
char * szText = pLeft->value.asString.string;
ULONG ulLen = pLeft->ulLength;
HB_ULONG ulLen = pLeft->ulLength;
while( ulLen && szText[ ulLen - 1 ] == ' ' )
--ulLen;
while( ulLen-- )
@@ -903,7 +903,7 @@ HB_EXPR_PTR hb_compExprReducePlus( HB_EXPR_PTR pSelf, HB_COMP_DECL )
if( HB_SUPPORT_MACROTEXT )
{
char * szText = pLeft->value.asString.string;
ULONG ulLen = pLeft->ulLength;
HB_ULONG ulLen = pLeft->ulLength;
while( ulLen-- )
{
@@ -2264,7 +2264,7 @@ HB_BOOL hb_compExprReduceUPPER( HB_EXPR_PTR pSelf, HB_COMP_DECL )
if( pArg->ExprType == HB_ET_STRING )
{
ULONG ulLen = pArg->ulLength;
HB_ULONG ulLen = pArg->ulLength;
HB_BOOL fLower = HB_FALSE;
if( ulLen )

10
harbour/src/common/hbhash.c
View File

@@ -52,7 +52,7 @@
#include "hbhash.h"
static HB_HASH_ITEM_PTR hb_hashItemNew( ULONG ulKey, const void * pKey, const void * pValue )
static HB_HASH_ITEM_PTR hb_hashItemNew( HB_ULONG ulKey, const void * pKey, const void * pValue )
{
HB_HASH_ITEM_PTR pItem = (HB_HASH_ITEM_PTR) hb_xgrab( sizeof( HB_HASH_ITEM ) );
@@ -147,7 +147,7 @@ HB_HASH_TABLE_PTR hb_hashTableResize( HB_HASH_TABLE_PTR pTable, HB_SIZE ulNewSiz
pItem = pTable->pItems[ ulSize ];
while( pItem )
{
ULONG ulKey;
HB_ULONG ulKey;
HB_HASH_ITEM_PTR pNewItem, pNext;
pNext = pItem->next;
@@ -181,7 +181,7 @@ HB_HASH_TABLE_PTR hb_hashTableResize( HB_HASH_TABLE_PTR pTable, HB_SIZE ulNewSiz
/* add a new value into th ehash table */
HB_BOOL hb_hashTableAdd( HB_HASH_TABLE_PTR pTable, const void * pKey, const void * pValue )
{
ULONG ulKey;
HB_ULONG ulKey;
HB_HASH_ITEM_PTR pItem;
ulKey = ( pTable->pKeyFunc )( pTable, pKey, pValue );
@@ -206,7 +206,7 @@ HB_BOOL hb_hashTableAdd( HB_HASH_TABLE_PTR pTable, const void * pKey, const void
*/
const void * hb_hashTableFind( HB_HASH_TABLE_PTR pTable, const void * pKey )
{
ULONG ulKey;
HB_ULONG ulKey;
HB_HASH_ITEM_PTR pItem;
const void * pFound = NULL;
@@ -230,7 +230,7 @@ const void * hb_hashTableFind( HB_HASH_TABLE_PTR pTable, const void * pKey )
*/
HB_BOOL hb_hashTableDel( HB_HASH_TABLE_PTR pTable, const void *pKey )
{
ULONG ulKey;
HB_ULONG ulKey;
HB_HASH_ITEM_PTR pItem;
HB_HASH_ITEM_PTR pPrev = NULL;
HB_BOOL bFound = HB_FALSE;

4
harbour/src/compiler/cmdcheck.c
View File

@@ -55,7 +55,7 @@
/* NOTE: Making the date and time info to fit into 32 bits can only be done
in a "lossy" way, in practice that means it's not possible to unpack
the exact date/time info from the resulting ULONG. Since the year
the exact date/time info from the resulting HB_ULONG. Since the year
is only stored in 6 bits, 1980 will result in the same bit pattern
as 2044. The purpose of this value is only used to *differenciate*
between the dates ( the exact dates are not significant ), so this
@@ -70,7 +70,7 @@
|____| Minute 6 bits
|____| Second 6 bits */
static ULONG PackDateTime( void )
static HB_ULONG PackDateTime( void )
{
union
{

4
harbour/src/compiler/compi18n.c
View File

@@ -188,7 +188,7 @@ void hb_compI18nAdd( HB_COMP_DECL, const char* szText, const char* szContext,
hb_compI18nAddSingle( HB_COMP_PARAM, szText, szContext, szModule, uiLine );
}
void hb_compI18nAddPlural( HB_COMP_DECL, const char ** szTexts, ULONG ulCount, const char* szContext, const char * szModule, HB_UINT uiLine )
void hb_compI18nAddPlural( HB_COMP_DECL, const char ** szTexts, HB_ULONG ulCount, const char* szContext, const char * szModule, HB_UINT uiLine )
{
PHB_I18NSTRING pString;
@@ -204,7 +204,7 @@ void hb_compI18nAddPlural( HB_COMP_DECL, const char ** szTexts, ULONG ulCount, c
}
else
{
ULONG ul, ulPlural;
HB_ULONG ul, ulPlural;
for( ul = 1; ul < ulCount && pString->uiPlurals < HB_I18N_PLURAL_MAX; ++ul )
{

2
harbour/src/compiler/complex.c
View File

@@ -278,7 +278,7 @@ static const char * hb_comp_tokenString( YYSTYPE *yylval_ptr, HB_COMP_DECL, PHB_
yylval_ptr->valChar.dealloc = HB_FALSE;
if( HB_PP_TOKEN_ALLOC( pToken->type ) )
{
yylval_ptr->valChar.dealloc = ( ULONG ) pToken->len != strlen( pToken->value );
yylval_ptr->valChar.dealloc = ( HB_ULONG ) pToken->len != strlen( pToken->value );
pToken->value = hb_compIdentifierNew( HB_COMP_PARAM, pToken->value,
yylval_ptr->valChar.dealloc ? HB_IDENT_COPY : HB_IDENT_FREE );
if( !yylval_ptr->valChar.dealloc )

24
harbour/src/compiler/genc.c
View File

@@ -41,7 +41,7 @@ typedef struct HB_stru_genc_info
HB_COMP_DECL;
FILE * yyc;
HB_BOOL bVerbose;
ULONG ulEndBlockPos;
HB_ULONG ulEndBlockPos;
} HB_GENC_INFO, * HB_GENC_INFO_PTR;
#define HB_GENC_FUNC( func ) HB_PCODE_FUNC( func, HB_GENC_INFO_PTR )
@@ -486,9 +486,9 @@ static void hb_compGenCFunc( FILE * yyc, const char *cDecor, const char *szName,
}
}
static void hb_compGenCByteStr( FILE * yyc, const HB_BYTE * pText, ULONG ulLen )
static void hb_compGenCByteStr( FILE * yyc, const HB_BYTE * pText, HB_ULONG ulLen )
{
ULONG ulPos;
HB_ULONG ulPos;
for( ulPos = 0; ulPos < ulLen; ulPos++ )
{
HB_BYTE uchr = ( HB_BYTE ) pText[ ulPos ];
@@ -503,7 +503,7 @@ static void hb_compGenCByteStr( FILE * yyc, const HB_BYTE * pText, ULONG ulLen )
}
}
static void hb_compGenCLocalName( PFUNCTION pFunc, int iLocal, ULONG lPCodePos, HB_GENC_INFO_PTR cargo )
static void hb_compGenCLocalName( PFUNCTION pFunc, int iLocal, HB_ULONG lPCodePos, HB_GENC_INFO_PTR cargo )
{
/* Variable with negative order are local variables
* referenced in a codeblock -handle it with care
@@ -955,7 +955,7 @@ static HB_GENC_FUNC( hb_p_line )
static HB_GENC_FUNC( hb_p_localname )
{
ULONG ulStart = lPCodePos;
HB_ULONG ulStart = lPCodePos;
fprintf( cargo->yyc, "\tHB_P_LOCALNAME, %i, %i,",
pFunc->pCode[ lPCodePos + 1 ],
@@ -1127,7 +1127,7 @@ static HB_GENC_FUNC( hb_p_minus )
static HB_GENC_FUNC( hb_p_modulename )
{
ULONG ulStart = lPCodePos;
HB_ULONG ulStart = lPCodePos;
fprintf( cargo->yyc, "\tHB_P_MODULENAME," );
if( cargo->bVerbose )
@@ -1401,7 +1401,7 @@ static HB_GENC_FUNC( hb_p_pushblockshort )
static HB_GENC_FUNC( hb_p_pushblock )
{
HB_USHORT wVar, w;
ULONG ulStart = lPCodePos;
HB_ULONG ulStart = lPCodePos;
fprintf( cargo->yyc, "\tHB_P_PUSHBLOCK, %i, %i,",
pFunc->pCode[ lPCodePos + 1 ],
@@ -1456,7 +1456,7 @@ static HB_GENC_FUNC( hb_p_pushblock )
static HB_GENC_FUNC( hb_p_pushblocklarge )
{
HB_USHORT wVar, w;
ULONG ulStart = lPCodePos;
HB_ULONG ulStart = lPCodePos;
fprintf( cargo->yyc, "\tHB_P_PUSHBLOCKLARGE, %i, %i, %i,",
pFunc->pCode[ lPCodePos + 1 ],
@@ -1741,7 +1741,7 @@ static HB_GENC_FUNC( hb_p_pushstr )
static HB_GENC_FUNC( hb_p_pushstrlarge )
{
ULONG ulLen = HB_PCODE_MKUINT24( &pFunc->pCode[ lPCodePos + 1 ] );
HB_ULONG ulLen = HB_PCODE_MKUINT24( &pFunc->pCode[ lPCodePos + 1 ] );
fprintf( cargo->yyc, "\tHB_P_PUSHSTRLARGE, %i, %i, %i,",
pFunc->pCode[ lPCodePos + 1 ],
@@ -1974,7 +1974,7 @@ static HB_GENC_FUNC( hb_p_statics )
static HB_GENC_FUNC( hb_p_staticname )
{
ULONG ulStart = lPCodePos;
HB_ULONG ulStart = lPCodePos;
fprintf( cargo->yyc, "\tHB_P_STATICNAME, %i, %i, %i,",
pFunc->pCode[ lPCodePos + 1 ],
@@ -2020,7 +2020,7 @@ static HB_GENC_FUNC( hb_p_threadstatics )
lPCodePos +=2;
}
return ( ( ULONG ) w << 1 ) + 3;
return ( ( HB_ULONG ) w << 1 ) + 3;
}
static HB_GENC_FUNC( hb_p_swapalias )
@@ -2680,7 +2680,7 @@ static void hb_compGenCReadable( HB_COMP_DECL, PFUNCTION pFunc, FILE * yyc )
static void hb_compGenCCompact( PFUNCTION pFunc, FILE * yyc )
{
ULONG lPCodePos = 0;
HB_ULONG lPCodePos = 0;
int nChar;
fprintf( yyc, "{\n\tstatic const HB_BYTE pcode[] =\n\t{\n\t\t" );

28
harbour/src/compiler/gencc.c
View File

@@ -61,7 +61,7 @@ typedef HB_GENC_FUNC_ * HB_GENC_FUNC_PTR;
#define HB_GENC_GETLABEL(l) ( (l) < pFunc->lPCodePos ? cargo->pulLabels[ (l) ] : 0 )
#define HB_GENC_LABEL() do { \
ULONG ulLab = HB_GENC_GETLABEL( lPCodePos ); \
HB_ULONG ulLab = HB_GENC_GETLABEL( lPCodePos ); \
if( ulLab != 0 ) \
fprintf( cargo->yyc, "lab%05ld: ;\n", ulLab ); \
} while( 0 )
@@ -70,9 +70,9 @@ typedef HB_GENC_FUNC_ * HB_GENC_FUNC_PTR;
fprintf( cargo->yyc, "\t#error: \"" s "\"\n" ); \
} while( 0 )
void hb_compGenCString( FILE * yyc, const HB_BYTE * pText, ULONG ulLen )
void hb_compGenCString( FILE * yyc, const HB_BYTE * pText, HB_ULONG ulLen )
{
ULONG ulPos;
HB_ULONG ulPos;
fputc( '"', yyc );
for( ulPos = 0; ulPos < ulLen; ulPos++ )
@@ -108,7 +108,7 @@ static void hb_gencc_copyLocals( FILE * yyc, int iLocal1, int iLocal2 )
fprintf( yyc, "\thb_xvmCopyLocals( %d, %d );\n", iLocal1, iLocal2 );
}
static int hb_gencc_checkJumpCondAhead( HB_LONG lValue, PFUNCTION pFunc, ULONG lPCodePos, PHB_LABEL_INFO cargo,
static int hb_gencc_checkJumpCondAhead( HB_LONG lValue, PFUNCTION pFunc, HB_ULONG lPCodePos, PHB_LABEL_INFO cargo,
const char * szFunc )
{
if( HB_GENC_GETLABEL( lPCodePos + 1 ) == 0 )
@@ -167,7 +167,7 @@ static int hb_gencc_checkJumpCondAhead( HB_LONG lValue, PFUNCTION pFunc, ULONG l
return 1;
}
static int hb_gencc_checkNumAhead( HB_LONG lValue, PFUNCTION pFunc, ULONG lPCodePos, PHB_LABEL_INFO cargo )
static int hb_gencc_checkNumAhead( HB_LONG lValue, PFUNCTION pFunc, HB_ULONG lPCodePos, PHB_LABEL_INFO cargo )
{
if( HB_GENC_GETLABEL( lPCodePos ) == 0 )
{
@@ -244,7 +244,7 @@ static int hb_gencc_checkNumAhead( HB_LONG lValue, PFUNCTION pFunc, ULONG lPCode
return 0;
}
static int hb_gencc_checkPlusAhead( PFUNCTION pFunc, ULONG lPCodePos, PHB_LABEL_INFO cargo )
static int hb_gencc_checkPlusAhead( PFUNCTION pFunc, HB_ULONG lPCodePos, PHB_LABEL_INFO cargo )
{
if( HB_GENC_GETLABEL( lPCodePos ) == 0 )
{
@@ -1077,7 +1077,7 @@ static HB_GENC_FUNC( hb_p_pushblock )
static HB_GENC_FUNC( hb_p_pushblocklarge )
{
ULONG ulSize, ul;
HB_ULONG ulSize, ul;
HB_GENC_LABEL();
@@ -1351,7 +1351,7 @@ static HB_GENC_FUNC( hb_p_pushstr )
static HB_GENC_FUNC( hb_p_pushstrlarge )
{
ULONG ulLen = HB_PCODE_MKUINT24( &pFunc->pCode[ lPCodePos + 1 ] ) - 1;
HB_ULONG ulLen = HB_PCODE_MKUINT24( &pFunc->pCode[ lPCodePos + 1 ] ) - 1;
HB_GENC_LABEL();
@@ -1567,12 +1567,12 @@ static HB_GENC_FUNC( hb_p_staticname )
static HB_GENC_FUNC( hb_p_threadstatics )
{
HB_USHORT w;
ULONG ulSize, ul;
HB_ULONG ulSize, ul;
HB_GENC_LABEL();
w = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] );
ulSize = ( ULONG ) w << 1;
ulSize = ( HB_ULONG ) w << 1;
fprintf( cargo->yyc, "\t{\n\t\tstatic const HB_BYTE statics[ %lu ] = {", ulSize );
@@ -1681,7 +1681,7 @@ static HB_GENC_FUNC( hb_p_enumend )
static HB_GENC_FUNC( hb_p_switch )
{
HB_USHORT usCases = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), us;
ULONG ulStart = lPCodePos, ulNewPos;
HB_ULONG ulStart = lPCodePos, ulNewPos;
HB_BOOL fNum = HB_FALSE, fStr = HB_FALSE, fDefault = HB_FALSE;
HB_GENC_LABEL();
@@ -1727,7 +1727,7 @@ static HB_GENC_FUNC( hb_p_switch )
{
fprintf( cargo->yyc, "\t{\n\t\tPHB_ITEM pSwitch;\n\t\tHB_TYPE type;\n" );
if( fStr )
fprintf( cargo->yyc, "\t\tconst char * pszText;\n\t\tULONG ulLen;\n" );
fprintf( cargo->yyc, "\t\tconst char * pszText;\n\t\tHB_SIZE ulLen;\n" );
if( fNum )
fprintf( cargo->yyc, "\t\tlong lVal;\n" );
fprintf( cargo->yyc, "\t\tif( hb_xvmSwitchGet( &pSwitch ) ) break;\n"
@@ -2275,8 +2275,8 @@ void hb_compGenCRealCode( HB_COMP_DECL, PFUNCTION pFunc, FILE * yyc )
label_info.pulLabels = NULL;
else
{
label_info.pulLabels = ( ULONG * ) hb_xgrab( pFunc->lPCodePos * sizeof( ULONG ) );
memset( label_info.pulLabels, 0, pFunc->lPCodePos * sizeof( ULONG ) );
label_info.pulLabels = ( HB_ULONG * ) hb_xgrab( pFunc->lPCodePos * sizeof( HB_ULONG ) );
memset( label_info.pulLabels, 0, pFunc->lPCodePos * sizeof( HB_ULONG ) );
hb_compGenLabelTable( pFunc, &label_info );
}

10
harbour/src/compiler/genhrb.c
View File

@@ -36,11 +36,11 @@
#define SYM_EXTERN 2 /* function defined in other module */
#define SYM_DEFERRED 3 /* lately bound function */
static ULONG hb_compHrbSize( HB_COMP_DECL, ULONG * pulSymbols, ULONG * pulFunctions )
static HB_ULONG hb_compHrbSize( HB_COMP_DECL, HB_ULONG * pulSymbols, HB_ULONG * pulFunctions )
{
PFUNCTION pFunc;
PCOMSYMBOL pSym;
ULONG ulSize;
HB_ULONG ulSize;
* pulSymbols = * pulFunctions = 0;
@@ -69,11 +69,11 @@ static ULONG hb_compHrbSize( HB_COMP_DECL, ULONG * pulSymbols, ULONG * pulFuncti
return ulSize;
}
void hb_compGenBufPortObj( HB_COMP_DECL, HB_BYTE ** pBufPtr, ULONG * pulSize )
void hb_compGenBufPortObj( HB_COMP_DECL, HB_BYTE ** pBufPtr, HB_ULONG * pulSize )
{
PFUNCTION pFunc;
PCOMSYMBOL pSym;
ULONG ulSymbols, ulFunctions, ulLen;
HB_ULONG ulSymbols, ulFunctions, ulLen;
HB_BYTE * ptr;
* pulSize = hb_compHrbSize( HB_COMP_PARAM, &ulSymbols, &ulFunctions );
@@ -140,7 +140,7 @@ void hb_compGenBufPortObj( HB_COMP_DECL, HB_BYTE ** pBufPtr, ULONG * pulSize )
void hb_compGenPortObj( HB_COMP_DECL, PHB_FNAME pFileName )
{
char szFileName[ HB_PATH_MAX ];
ULONG ulSize;
HB_ULONG ulSize;
HB_BYTE * pHrbBody;
FILE * yyc;

48
harbour/src/compiler/genobj32.c
View File

@@ -50,7 +50,7 @@ static HB_USHORT hb_compFunctionGetPos( HB_COMP_DECL, char * szFunctionName ) /*
return 0;
}
static ULONG GetSymbolsSize( HB_COMP_DECL )
static HB_ULONG GetSymbolsSize( HB_COMP_DECL )
{
return HB_COMP_PARAM->symbols.iCount * sizeof( HB_SYMB );
}
@@ -61,10 +61,10 @@ static PCOMSYMBOL GetFirstSymbol( HB_COMP_DECL )
return pSymbol;
}
static char * GetSymbolName( HB_COMP_DECL, ULONG ulPos )
static char * GetSymbolName( HB_COMP_DECL, HB_ULONG ulPos )
{
PCOMSYMBOL pSymbol = GetFirstSymbol( HB_COMP_PARAM );
ULONG ul = 0;
HB_ULONG ul = 0;
while( pSymbol && ( ul++ < ulPos ) )
pSymbol = pSymbol->pNext;
@@ -72,9 +72,9 @@ static char * GetSymbolName( HB_COMP_DECL, ULONG ulPos )
return pSymbol->szName;
}
static ULONG GetPCodesSize( HB_COMP_DECL )
static HB_ULONG GetPCodesSize( HB_COMP_DECL )
{
ULONG ulTotal = 0;
HB_ULONG ulTotal = 0;
PFUNCTION pFunction = HB_COMP_PARAM->functions.pFirst;
if( ! HB_COMP_PARAM->fStartProc )
@@ -88,10 +88,10 @@ static ULONG GetPCodesSize( HB_COMP_DECL )
return ulTotal;
}
static ULONG GetSymbolsAmount( HB_COMP_DECL )
static HB_ULONG GetSymbolsAmount( HB_COMP_DECL )
{
PCOMSYMBOL pSymbol = GetFirstSymbol( HB_COMP_PARAM );
ULONG ulAmount = 1;
HB_ULONG ulAmount = 1;
while( pSymbol->pNext )
{
@@ -101,10 +101,10 @@ static ULONG GetSymbolsAmount( HB_COMP_DECL )
return ulAmount;
}
static HB_BOOL IsExternal( HB_COMP_DECL, ULONG ulSymbol )
static HB_BOOL IsExternal( HB_COMP_DECL, HB_ULONG ulSymbol )
{
PCOMSYMBOL pSymbol = GetFirstSymbol( HB_COMP_PARAM );
ULONG ul = 0;
HB_ULONG ul = 0;
while( ul++ < ulSymbol )
pSymbol = pSymbol->pNext;
@@ -180,9 +180,9 @@ static void GenerateSymbolsSegment( HB_COMP_DECL, FILE * hObjFile )
static void GenerateDataSegment( HB_COMP_DECL, FILE * hObjFile )
{
HB_SYMB symbol;
ULONG ulSize = GetSymbolsSize( HB_COMP_PARAM );
HB_ULONG ulSize = GetSymbolsSize( HB_COMP_PARAM );
PCOMSYMBOL pSymbol = GetFirstSymbol( HB_COMP_PARAM );
ULONG ulSymbols = GetSymbolsAmount( HB_COMP_PARAM ), ul;
HB_ULONG ulSymbols = GetSymbolsAmount( HB_COMP_PARAM ), ul;
while( pSymbol )
{
@@ -229,7 +229,7 @@ static void GenerateDataSegment( HB_COMP_DECL, FILE * hObjFile )
static void GenerateCodeSegment( HB_COMP_DECL, FILE * hObjFile )
{
HB_USHORT wFunctions = HB_COMP_PARAM->functions.iCount - ( HB_COMP_PARAM->fStartProc ? 0: 1 );
ULONG ulSize = wFunctions * sizeof( s_prgFunction );
HB_ULONG ulSize = wFunctions * sizeof( s_prgFunction );
PFUNCTION pFunc = ( HB_COMP_PARAM->fStartProc ? HB_COMP_PARAM->functions.pFirst: HB_COMP_PARAM->functions.pFirst->pNext );
HB_USHORT w = 0;
@@ -409,14 +409,14 @@ static void ExternalNames( FILE * hObjFile, char * szNames[] )
putbyte( 256 - bChk, hObjFile, &bChk );
}
static void CodeSegment( HB_COMP_DECL, FILE * hObjFile, HB_BYTE * prgCode, ULONG ulPrgLen, HB_USHORT wFunctions )
static void CodeSegment( HB_COMP_DECL, FILE * hObjFile, HB_BYTE * prgCode, HB_ULONG ulPrgLen, HB_USHORT wFunctions )
{
HB_BYTE bChk = 0;
HB_USHORT y;
HB_USHORT wTotalLen = ( HB_USHORT ) ( ulPrgLen * wFunctions ) + 4;
ULONG ul;
HB_ULONG ul;
PFUNCTION pFunction = HB_COMP_PARAM->functions.pFirst;
ULONG ulPCodeOffset = HB_COMP_PARAM->symbols.iCount * sizeof( HB_SYMB );
HB_ULONG ulPCodeOffset = HB_COMP_PARAM->symbols.iCount * sizeof( HB_SYMB );
if( ! HB_COMP_PARAM->fStartProc )
pFunction = pFunction->pNext;
@@ -428,7 +428,7 @@ static void CodeSegment( HB_COMP_DECL, FILE * hObjFile, HB_BYTE * prgCode, ULONG
for( y = 0; y < wFunctions; y++ )
{
* ( ULONG * ) &prgCode[ 6 ] = ulPCodeOffset; /* function pcode offset */
* ( HB_ULONG * ) &prgCode[ 6 ] = ulPCodeOffset; /* function pcode offset */
for( ul = 0; ul < ulPrgLen; ul++ )
putbyte( * ( prgCode + ul ), hObjFile, &bChk );
ulPCodeOffset += pFunction->lPCodePos;
@@ -438,16 +438,16 @@ static void CodeSegment( HB_COMP_DECL, FILE * hObjFile, HB_BYTE * prgCode, ULONG
putbyte( 256 - bChk, hObjFile, &bChk );
}
static void DataSegment( HB_COMP_DECL, FILE * hObjFile, HB_BYTE * symbol, ULONG wSymLen, ULONG wSymbols,
ULONG ulSize )
static void DataSegment( HB_COMP_DECL, FILE * hObjFile, HB_BYTE * symbol, HB_ULONG wSymLen, HB_ULONG wSymbols,
HB_ULONG ulSize )
{
HB_BYTE bChk = 0;
ULONG w, y;
HB_ULONG w, y;
HB_USHORT wTotalLen = 4 + ( HB_USHORT ) ulSize;
PCOMSYMBOL pSymbol = GetFirstSymbol( HB_COMP_PARAM );
PFUNCTION pFunction = HB_COMP_PARAM->functions.pFirst;
ULONG ulSymbolNameOffset = GetSymbolsSize( HB_COMP_PARAM ) + GetPCodesSize( HB_COMP_PARAM );
ULONG ulFunctionOffset;
HB_ULONG ulSymbolNameOffset = GetSymbolsSize( HB_COMP_PARAM ) + GetPCodesSize( HB_COMP_PARAM );
HB_ULONG ulFunctionOffset;
if( ! HB_COMP_PARAM->fStartProc )
pFunction = pFunction->pNext;
@@ -459,16 +459,16 @@ static void DataSegment( HB_COMP_DECL, FILE * hObjFile, HB_BYTE * symbol, ULONG
for( y = 0; y < wSymbols; y++ )
{
* ( ULONG * ) symbol = ulSymbolNameOffset;
* ( HB_ULONG * ) symbol = ulSymbolNameOffset;
if( ! IsExternal( HB_COMP_PARAM, y ) )
{
ulFunctionOffset = ( hb_compFunctionGetPos( HB_COMP_PARAM, pSymbol->szName ) - 1 ) *
sizeof( s_prgFunction );
* ( ( ULONG * ) &symbol[ 8 ] ) = ulFunctionOffset; /* 8 offset of function pointer into symbol */
* ( ( HB_ULONG * ) &symbol[ 8 ] ) = ulFunctionOffset; /* 8 offset of function pointer into symbol */
}
else
* ( ( ULONG * ) &symbol[ 8 ] ) = 0; /* 8 offset of function pointer into symbol */
* ( ( HB_ULONG * ) &symbol[ 8 ] ) = 0; /* 8 offset of function pointer into symbol */
if( pSymbol->cScope == HB_FS_MESSAGE )
symbol[ 4 ] = HB_FS_PUBLIC;

42
harbour/src/compiler/harbour.y
View File

@@ -75,7 +75,7 @@ static void hb_compLoopExit( HB_COMP_DECL );
static void hb_compLoopHere( HB_COMP_DECL );
static long hb_compLoopCount( HB_COMP_DECL );
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirstElseIf, ULONG ulOffset ); /* generates a support structure for elseifs pcode fixups */
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirstElseIf, HB_ULONG ulOffset ); /* generates a support structure for elseifs pcode fixups */
static void hb_compElseIfFix( HB_COMP_DECL, void * pIfElseIfs ); /* implements the ElseIfs pcode fixups */
static void hb_compRTVariableAdd( HB_COMP_DECL, HB_EXPR_PTR, HB_BOOL );
@@ -1061,9 +1061,9 @@ CodeBlock : BlockHead
{ /* 6 */
hb_compCodeBlockEnd( HB_COMP_PARAM );
$$ = hb_compExprSetCodeblockBody( $1,
HB_COMP_PARAM->functions.pLast->pCode + ( ULONG ) $<lNumber>3,
HB_COMP_PARAM->functions.pLast->lPCodePos - ( ULONG ) $<lNumber>3 );
HB_COMP_PARAM->functions.pLast->lPCodePos = ( ULONG ) $<lNumber>3;
HB_COMP_PARAM->functions.pLast->pCode + ( HB_ULONG ) $<lNumber>3,
HB_COMP_PARAM->functions.pLast->lPCodePos - ( HB_ULONG ) $<lNumber>3 );
HB_COMP_PARAM->functions.pLast->lPCodePos = ( HB_ULONG ) $<lNumber>3;
HB_COMP_PARAM->lastLinePos = 0;
}
;
@@ -1504,11 +1504,11 @@ DoWhile : WhileBegin ExpList Crlf
EmptyStats
{
hb_compLoopHere( HB_COMP_PARAM );
hb_compGenJump( ( ULONG ) $1 - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM );
hb_compGenJump( ( HB_ULONG ) $1 - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM );
}
EndWhile
{
hb_compGenJumpHere( ( ULONG ) $<lNumber>4, HB_COMP_PARAM );
hb_compGenJumpHere( ( HB_ULONG ) $<lNumber>4, HB_COMP_PARAM );
if( HB_COMP_PARAM->functions.pLast->wWhileCounter )
--HB_COMP_PARAM->functions.pLast->wWhileCounter;
hb_compLoopEnd( HB_COMP_PARAM );
@@ -1577,7 +1577,7 @@ ForNext : FOR LValue ForAssign Expression /* 1 2 3 4 */
iSign = 1;
HB_COMP_EXPR_CLEAR( hb_compExprGenPush( hb_compExprNewPreInc( $2, HB_COMP_PARAM ), HB_COMP_PARAM ) );
}
hb_compGenJumpHere( ( ULONG ) $<lNumber>9, HB_COMP_PARAM );
hb_compGenJumpHere( ( HB_ULONG ) $<lNumber>9, HB_COMP_PARAM );
HB_COMP_EXPR_DELETE( hb_compExprGenPush( $7, HB_COMP_PARAM ) ); /* end */
if( iSign )
{
@@ -1591,7 +1591,7 @@ ForNext : FOR LValue ForAssign Expression /* 1 2 3 4 */
hb_compGenPCode1( HB_P_FORTEST, HB_COMP_PARAM );
}
hb_compGenJumpFalse( ( ULONG ) $<lNumber>11 - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM );
hb_compGenJumpFalse( ( HB_ULONG ) $<lNumber>11 - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM );
hb_compLoopEnd( HB_COMP_PARAM );
if( hb_compExprAsSymbol( $<asExpr>2 ) )
hb_compForEnd( HB_COMP_PARAM, hb_compExprAsSymbol( $<asExpr>2 ) );
@@ -1666,9 +1666,9 @@ ForEach : FOREACH ForList IN ForArgs /* 1 2 3 4 */
{
hb_compLoopHere( HB_COMP_PARAM );
hb_compEnumNext( HB_COMP_PARAM, $2, $6 );
hb_compGenJump( ( ULONG ) $<lNumber>7 - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM );
hb_compGenJump( ( HB_ULONG ) $<lNumber>7 - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM );
hb_compGenJumpHere( ( ULONG ) $<lNumber>9, HB_COMP_PARAM );
hb_compGenJumpHere( ( HB_ULONG ) $<lNumber>9, HB_COMP_PARAM );
hb_compLoopEnd( HB_COMP_PARAM );
HB_COMP_PARAM->functions.pLast->funFlags &= ~ ( FUN_WITH_RETURN | FUN_BREAK_CODE );
hb_compEnumEnd( HB_COMP_PARAM, $2 );
@@ -1765,7 +1765,7 @@ BeginSeq : BEGINSEQ /* 1 */
*/
if( $<lNumber>3 )
hb_compGenPCode1( HB_P_POP, HB_COMP_PARAM );
hb_compGenJumpHere( ( ULONG ) $<lNumber>2, HB_COMP_PARAM );
hb_compGenJumpHere( ( HB_ULONG ) $<lNumber>2, HB_COMP_PARAM );
$<lNumber>$ = hb_compSequenceEnd( HB_COMP_PARAM );
$<lNumber>4 = hb_compLoopCount( HB_COMP_PARAM );
}
@@ -1775,7 +1775,7 @@ BeginSeq : BEGINSEQ /* 1 */
* HB_P_SEQBEGIN opcode if there is RECOVER clause
*/
if( $<lNumber>7 )
hb_compGenJumpThere( ( ULONG ) $<lNumber>2, ( ULONG ) $<lNumber>7, HB_COMP_PARAM );
hb_compGenJumpThere( ( HB_ULONG ) $<lNumber>2, ( HB_ULONG ) $<lNumber>7, HB_COMP_PARAM );
else if( HB_COMP_PARAM->functions.pLast->wSeqCounter )
--HB_COMP_PARAM->functions.pLast->wSeqCounter;
}
@@ -1793,19 +1793,19 @@ BeginSeq : BEGINSEQ /* 1 */
--HB_COMP_PARAM->functions.pLast->wAlwaysCounter;
/* replace END address with ALWAYS address in
HB_P_SEQEND opcode */
hb_compGenJumpThere( ( ULONG ) $<lNumber>6, ( ULONG ) $<lNumber>9, HB_COMP_PARAM );
hb_compGenJumpThere( ( HB_ULONG ) $<lNumber>6, ( HB_ULONG ) $<lNumber>9, HB_COMP_PARAM );
/* Fix ALWAYS address in HB_P_SEQALWAYS opcode */
hb_compGenJumpThere( ( ULONG ) $<lNumber>2 - 4, ( ULONG ) $<lNumber>9, HB_COMP_PARAM );
hb_compGenJumpThere( ( HB_ULONG ) $<lNumber>2 - 4, ( HB_ULONG ) $<lNumber>9, HB_COMP_PARAM );
/* Fix ALWAYSEND address in HB_P_ALWAYSBEGIN opcode */
hb_compGenJumpHere( ( ULONG ) $<lNumber>9 + 1, HB_COMP_PARAM );
hb_compGenJumpHere( ( HB_ULONG ) $<lNumber>9 + 1, HB_COMP_PARAM );
hb_compGenPCode1( HB_P_ALWAYSEND, HB_COMP_PARAM );
}
else
{
/* Fix END address in HB_P_SEQEND opcode */
hb_compGenJumpHere( ( ULONG ) $<lNumber>6, HB_COMP_PARAM );
hb_compGenJumpHere( ( HB_ULONG ) $<lNumber>6, HB_COMP_PARAM );
}
hb_compSequenceFinish( HB_COMP_PARAM, ( ULONG ) $<lNumber>2, ( ULONG ) $<lNumber>6, ( ULONG ) $<lNumber>9,
hb_compSequenceFinish( HB_COMP_PARAM, ( HB_ULONG ) $<lNumber>2, ( HB_ULONG ) $<lNumber>6, ( HB_ULONG ) $<lNumber>9,
$<lNumber>5 != 0, $<lNumber>7 != 0, $<lNumber>4 == lLoopCount );
}
EndSeqID /* 10 */
@@ -1918,7 +1918,7 @@ WithObject : WITHOBJECT Expression Crlf
else
{
hb_compNOOPfill( HB_COMP_PARAM->functions.pLast,
( ULONG ) $<lNumber>4, 1, HB_FALSE, HB_TRUE );
( HB_ULONG ) $<lNumber>4, 1, HB_FALSE, HB_TRUE );
hb_compGenPCode1( HB_P_POP, HB_COMP_PARAM );
}
}
@@ -2216,7 +2216,7 @@ void hb_compLoopKill( PFUNCTION pFunc )
}
}
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirst, ULONG ulOffset )
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirst, HB_ULONG ulOffset )
{
HB_ELSEIF_PTR pElseIf = ( HB_ELSEIF_PTR ) hb_xgrab( sizeof( HB_ELSEIF ) ), pLast;
PFUNCTION pFunc = HB_COMP_PARAM->functions.pLast;
@@ -2504,7 +2504,7 @@ static HB_CARGO2_FUNC( hb_compEnumEvalStart )
static void hb_compEnumStart( HB_COMP_DECL, HB_EXPR_PTR pVars, HB_EXPR_PTR pExprs, int descend )
{
ULONG ulLen;
HB_ULONG ulLen;
if( hb_compExprListLen(pVars) != hb_compExprListLen(pExprs) )
{
@@ -2617,7 +2617,7 @@ static void hb_compSwitchEnd( HB_COMP_DECL )
HB_SWITCHCMD_PTR pSwitch = pFunc->pSwitch;
HB_EXPR_PTR pExpr = pSwitch->pExpr;
HB_SWITCHCASE_PTR pCase, pTmp;
ULONG ulExitPos, ulCountPos;
HB_ULONG ulExitPos, ulCountPos;
int iCount = 0;
/* skip switch pcode if there was no EXIT in the last CASE

42
harbour/src/compiler/harbour.yyc
View File

@@ -374,7 +374,7 @@ static void hb_compLoopExit( HB_COMP_DECL );
static void hb_compLoopHere( HB_COMP_DECL );
static long hb_compLoopCount( HB_COMP_DECL );
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirstElseIf, ULONG ulOffset ); /* generates a support structure for elseifs pcode fixups */
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirstElseIf, HB_ULONG ulOffset ); /* generates a support structure for elseifs pcode fixups */
static void hb_compElseIfFix( HB_COMP_DECL, void * pIfElseIfs ); /* implements the ElseIfs pcode fixups */
static void hb_compRTVariableAdd( HB_COMP_DECL, HB_EXPR_PTR, HB_BOOL );
@@ -5742,9 +5742,9 @@ yyreduce:
{ /* 6 */
hb_compCodeBlockEnd( HB_COMP_PARAM );
(yyval.asExpr) = hb_compExprSetCodeblockBody( (yyvsp[(1) - (5)].asExpr),
HB_COMP_PARAM->functions.pLast->pCode + ( ULONG ) (yyvsp[(3) - (5)].lNumber),
HB_COMP_PARAM->functions.pLast->lPCodePos - ( ULONG ) (yyvsp[(3) - (5)].lNumber) );
HB_COMP_PARAM->functions.pLast->lPCodePos = ( ULONG ) (yyvsp[(3) - (5)].lNumber);
HB_COMP_PARAM->functions.pLast->pCode + ( HB_ULONG ) (yyvsp[(3) - (5)].lNumber),
HB_COMP_PARAM->functions.pLast->lPCodePos - ( HB_ULONG ) (yyvsp[(3) - (5)].lNumber) );
HB_COMP_PARAM->functions.pLast->lPCodePos = ( HB_ULONG ) (yyvsp[(3) - (5)].lNumber);
HB_COMP_PARAM->lastLinePos = 0;
;}
break;
@@ -6368,14 +6368,14 @@ yyreduce:
#line 1506 "harbour.y"
{
hb_compLoopHere( HB_COMP_PARAM );
hb_compGenJump( ( ULONG ) (yyvsp[(1) - (5)].lNumber) - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM );
hb_compGenJump( ( HB_ULONG ) (yyvsp[(1) - (5)].lNumber) - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM );
;}
break;
case 525:
#line 1511 "harbour.y"
{
hb_compGenJumpHere( ( ULONG ) (yyvsp[(4) - (7)].lNumber), HB_COMP_PARAM );
hb_compGenJumpHere( ( HB_ULONG ) (yyvsp[(4) - (7)].lNumber), HB_COMP_PARAM );
if( HB_COMP_PARAM->functions.pLast->wWhileCounter )
--HB_COMP_PARAM->functions.pLast->wWhileCounter;
hb_compLoopEnd( HB_COMP_PARAM );
@@ -6452,7 +6452,7 @@ yyreduce:
iSign = 1;
HB_COMP_EXPR_CLEAR( hb_compExprGenPush( hb_compExprNewPreInc( (yyvsp[(2) - (12)].asExpr), HB_COMP_PARAM ), HB_COMP_PARAM ) );
}
hb_compGenJumpHere( ( ULONG ) (yyvsp[(9) - (12)].lNumber), HB_COMP_PARAM );
hb_compGenJumpHere( ( HB_ULONG ) (yyvsp[(9) - (12)].lNumber), HB_COMP_PARAM );
HB_COMP_EXPR_DELETE( hb_compExprGenPush( (yyvsp[(7) - (12)].asExpr), HB_COMP_PARAM ) ); /* end */
if( iSign )
{
@@ -6466,7 +6466,7 @@ yyreduce:
hb_compGenPCode1( HB_P_FORTEST, HB_COMP_PARAM );
}
hb_compGenJumpFalse( ( ULONG ) (yyvsp[(11) - (12)].lNumber) - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM );
hb_compGenJumpFalse( ( HB_ULONG ) (yyvsp[(11) - (12)].lNumber) - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM );
hb_compLoopEnd( HB_COMP_PARAM );
if( hb_compExprAsSymbol( (yyvsp[(2) - (12)].asExpr) ) )
hb_compForEnd( HB_COMP_PARAM, hb_compExprAsSymbol( (yyvsp[(2) - (12)].asExpr) ) );
@@ -6566,9 +6566,9 @@ yyreduce:
{
hb_compLoopHere( HB_COMP_PARAM );
hb_compEnumNext( HB_COMP_PARAM, (yyvsp[(2) - (10)].asExpr), (yyvsp[(6) - (10)].iNumber) );
hb_compGenJump( ( ULONG ) (yyvsp[(7) - (10)].lNumber) - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM );
hb_compGenJump( ( HB_ULONG ) (yyvsp[(7) - (10)].lNumber) - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM );
hb_compGenJumpHere( ( ULONG ) (yyvsp[(9) - (10)].lNumber), HB_COMP_PARAM );
hb_compGenJumpHere( ( HB_ULONG ) (yyvsp[(9) - (10)].lNumber), HB_COMP_PARAM );
hb_compLoopEnd( HB_COMP_PARAM );
HB_COMP_PARAM->functions.pLast->funFlags &= ~ ( FUN_WITH_RETURN | FUN_BREAK_CODE );
hb_compEnumEnd( HB_COMP_PARAM, (yyvsp[(2) - (10)].asExpr) );
@@ -6683,7 +6683,7 @@ yyreduce:
*/
if( (yyvsp[(3) - (5)].lNumber) )
hb_compGenPCode1( HB_P_POP, HB_COMP_PARAM );
hb_compGenJumpHere( ( ULONG ) (yyvsp[(2) - (5)].lNumber), HB_COMP_PARAM );
hb_compGenJumpHere( ( HB_ULONG ) (yyvsp[(2) - (5)].lNumber), HB_COMP_PARAM );
(yyval.lNumber) = hb_compSequenceEnd( HB_COMP_PARAM );
(yyvsp[(4) - (5)].lNumber) = hb_compLoopCount( HB_COMP_PARAM );
;}
@@ -6696,7 +6696,7 @@ yyreduce:
* HB_P_SEQBEGIN opcode if there is RECOVER clause
*/
if( (yyvsp[(7) - (7)].lNumber) )
hb_compGenJumpThere( ( ULONG ) (yyvsp[(2) - (7)].lNumber), ( ULONG ) (yyvsp[(7) - (7)].lNumber), HB_COMP_PARAM );
hb_compGenJumpThere( ( HB_ULONG ) (yyvsp[(2) - (7)].lNumber), ( HB_ULONG ) (yyvsp[(7) - (7)].lNumber), HB_COMP_PARAM );
else if( HB_COMP_PARAM->functions.pLast->wSeqCounter )
--HB_COMP_PARAM->functions.pLast->wSeqCounter;
;}
@@ -6717,19 +6717,19 @@ yyreduce:
--HB_COMP_PARAM->functions.pLast->wAlwaysCounter;
/* replace END address with ALWAYS address in
HB_P_SEQEND opcode */
hb_compGenJumpThere( ( ULONG ) (yyvsp[(6) - (9)].lNumber), ( ULONG ) (yyvsp[(9) - (9)].lNumber), HB_COMP_PARAM );
hb_compGenJumpThere( ( HB_ULONG ) (yyvsp[(6) - (9)].lNumber), ( HB_ULONG ) (yyvsp[(9) - (9)].lNumber), HB_COMP_PARAM );
/* Fix ALWAYS address in HB_P_SEQALWAYS opcode */
hb_compGenJumpThere( ( ULONG ) (yyvsp[(2) - (9)].lNumber) - 4, ( ULONG ) (yyvsp[(9) - (9)].lNumber), HB_COMP_PARAM );
hb_compGenJumpThere( ( HB_ULONG ) (yyvsp[(2) - (9)].lNumber) - 4, ( HB_ULONG ) (yyvsp[(9) - (9)].lNumber), HB_COMP_PARAM );
/* Fix ALWAYSEND address in HB_P_ALWAYSBEGIN opcode */
hb_compGenJumpHere( ( ULONG ) (yyvsp[(9) - (9)].lNumber) + 1, HB_COMP_PARAM );
hb_compGenJumpHere( ( HB_ULONG ) (yyvsp[(9) - (9)].lNumber) + 1, HB_COMP_PARAM );
hb_compGenPCode1( HB_P_ALWAYSEND, HB_COMP_PARAM );
}
else
{
/* Fix END address in HB_P_SEQEND opcode */
hb_compGenJumpHere( ( ULONG ) (yyvsp[(6) - (9)].lNumber), HB_COMP_PARAM );
hb_compGenJumpHere( ( HB_ULONG ) (yyvsp[(6) - (9)].lNumber), HB_COMP_PARAM );
}
hb_compSequenceFinish( HB_COMP_PARAM, ( ULONG ) (yyvsp[(2) - (9)].lNumber), ( ULONG ) (yyvsp[(6) - (9)].lNumber), ( ULONG ) (yyvsp[(9) - (9)].lNumber),
hb_compSequenceFinish( HB_COMP_PARAM, ( HB_ULONG ) (yyvsp[(2) - (9)].lNumber), ( HB_ULONG ) (yyvsp[(6) - (9)].lNumber), ( HB_ULONG ) (yyvsp[(9) - (9)].lNumber),
(yyvsp[(5) - (9)].lNumber) != 0, (yyvsp[(7) - (9)].lNumber) != 0, (yyvsp[(4) - (9)].lNumber) == lLoopCount );
;}
break;
@@ -6869,7 +6869,7 @@ yyreduce:
else
{
hb_compNOOPfill( HB_COMP_PARAM->functions.pLast,
( ULONG ) (yyvsp[(4) - (6)].lNumber), 1, HB_FALSE, HB_TRUE );
( HB_ULONG ) (yyvsp[(4) - (6)].lNumber), 1, HB_FALSE, HB_TRUE );
hb_compGenPCode1( HB_P_POP, HB_COMP_PARAM );
}
;}
@@ -7386,7 +7386,7 @@ void hb_compLoopKill( PFUNCTION pFunc )
}
}
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirst, ULONG ulOffset )
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirst, HB_ULONG ulOffset )
{
HB_ELSEIF_PTR pElseIf = ( HB_ELSEIF_PTR ) hb_xgrab( sizeof( HB_ELSEIF ) ), pLast;
PFUNCTION pFunc = HB_COMP_PARAM->functions.pLast;
@@ -7674,7 +7674,7 @@ static HB_CARGO2_FUNC( hb_compEnumEvalStart )
static void hb_compEnumStart( HB_COMP_DECL, HB_EXPR_PTR pVars, HB_EXPR_PTR pExprs, int descend )
{
ULONG ulLen;
HB_ULONG ulLen;
if( hb_compExprListLen(pVars) != hb_compExprListLen(pExprs) )
{
@@ -7787,7 +7787,7 @@ static void hb_compSwitchEnd( HB_COMP_DECL )
HB_SWITCHCMD_PTR pSwitch = pFunc->pSwitch;
HB_EXPR_PTR pExpr = pSwitch->pExpr;
HB_SWITCHCASE_PTR pCase, pTmp;
ULONG ulExitPos, ulCountPos;
HB_ULONG ulExitPos, ulCountPos;
int iCount = 0;
/* skip switch pcode if there was no EXIT in the last CASE

6
harbour/src/compiler/hbcmplib.c
View File

@@ -57,7 +57,7 @@ static void hb_compGenArgList( int iFirst, int iLast,
int * pArgC, const char *** pArgV )
{
PHB_ITEM pParam;
ULONG ul, ulLen;
HB_ULONG ul, ulLen;
int argc = 1, i;
const char ** argv;
@@ -123,7 +123,7 @@ HB_FUNC( HB_COMPILEBUF )
int iResult, argc;
const char ** argv;
HB_BYTE * pBuffer;
ULONG ulLen;
HB_ULONG ulLen;
hb_compGenArgList( 1, hb_pcount(), &argc, &argv );
iResult = hb_compMain( argc, argv, &pBuffer, &ulLen, NULL );
@@ -138,7 +138,7 @@ HB_FUNC( HB_COMPILEFROMBUF )
const char ** argv;
const char * szSource;
HB_BYTE * pBuffer;
ULONG ulLen;
HB_ULONG ulLen;
szSource = hb_parc( 1 );
if( szSource )

4
harbour/src/compiler/hbdbginf.c
View File

@@ -55,7 +55,7 @@
PHB_DEBUGINFO hb_compGetDebugInfo( HB_COMP_DECL )
{
PHB_DEBUGINFO pLineInfo = NULL, pInfo = NULL;
ULONG ulPos, ulSkip, ulLine, ulOffset;
HB_ULONG ulPos, ulSkip, ulLine, ulOffset;
const char * pszModuleName = "", * ptr;
PFUNCTION pFunc;
@@ -137,7 +137,7 @@ PHB_DEBUGINFO hb_compGetDebugInfo( HB_COMP_DECL )
ulOffset = ulLine >> 3;
if( pInfo->ulAllocated <= ulOffset )
{
ULONG ulNewSize = ( ( ulLine >> 3 ) + 0x100 ) & 0xFFFFFF00L;
HB_ULONG ulNewSize = ( ( ulLine >> 3 ) + 0x100 ) & 0xFFFFFF00L;
pInfo->pLineMap = ( HB_BYTE * ) hb_xrealloc( pInfo->pLineMap, ulNewSize + 1 );
memset( pInfo->pLineMap + pInfo->ulAllocated, 0, ulNewSize - pInfo->ulAllocated + 1 );
pInfo->ulAllocated = ulNewSize;

60
harbour/src/compiler/hbdead.c
View File

@@ -56,13 +56,13 @@
/* helper structure to pass information */
typedef struct _HB_CODETRACE_INFO
{
HB_BYTE * pCodeMark;
ULONG * plJumps;
ULONG ulJumpPos;
ULONG ulJumpSize;
ULONG ulJumpCount;
ULONG ulPCodeSize;
HB_BOOL fFinished;
HB_BYTE * pCodeMark;
HB_ULONG * plJumps;
HB_ULONG ulJumpPos;
HB_ULONG ulJumpSize;
HB_ULONG ulJumpCount;
HB_ULONG ulPCodeSize;
HB_BOOL fFinished;
} HB_CODETRACE_INFO, * PHB_CODETRACE_INFO;
#define HB_CODETRACE_FUNC( func ) HB_PCODE_FUNC( func, PHB_CODETRACE_INFO )
@@ -72,7 +72,7 @@ typedef HB_CODETRACE_FUNC_ * PHB_CODETRACE_FUNC;
#define HB_JUMPADDR_ALLOC 64
static void hb_compCodeTraceAddJump( PHB_CODETRACE_INFO pInfo, ULONG ulPCodePos )
static void hb_compCodeTraceAddJump( PHB_CODETRACE_INFO pInfo, HB_ULONG ulPCodePos )
{
/* Checking for ulPCodePos < pInfo->ulPCodeSize disabled intentionally
* for easier detecting bugs in generated PCODE
@@ -85,21 +85,21 @@ static void hb_compCodeTraceAddJump( PHB_CODETRACE_INFO pInfo, ULONG ulPCodePos
if( pInfo->ulJumpSize == 0 )
{
pInfo->ulJumpSize = HB_JUMPADDR_ALLOC;
pInfo->plJumps = ( ULONG * ) hb_xgrab( pInfo->ulJumpSize *
sizeof( ULONG ) );
pInfo->plJumps = ( HB_ULONG * ) hb_xgrab( pInfo->ulJumpSize *
sizeof( HB_ULONG ) );
}
else if( pInfo->ulJumpSize == pInfo->ulJumpCount )
{
pInfo->ulJumpSize += HB_JUMPADDR_ALLOC;
pInfo->plJumps = ( ULONG * ) hb_xrealloc( pInfo->plJumps,
pInfo->ulJumpSize * sizeof( ULONG ) );
pInfo->plJumps = ( HB_ULONG * ) hb_xrealloc( pInfo->plJumps,
pInfo->ulJumpSize * sizeof( HB_ULONG ) );
}
pInfo->plJumps[ pInfo->ulJumpCount++ ] = ulPCodePos;
pInfo->pCodeMark[ ulPCodePos ] = 1;
}
}
static ULONG hb_compCodeTraceNextPos( PHB_CODETRACE_INFO pInfo, ULONG ulPCodePos )
static HB_ULONG hb_compCodeTraceNextPos( PHB_CODETRACE_INFO pInfo, HB_ULONG ulPCodePos )
{
if( ulPCodePos < pInfo->ulPCodeSize && pInfo->pCodeMark[ ulPCodePos ] == 0 )
return ulPCodePos;
@@ -115,7 +115,7 @@ static ULONG hb_compCodeTraceNextPos( PHB_CODETRACE_INFO pInfo, ULONG ulPCodePos
return pInfo->ulPCodeSize;
}
static void hb_compCodeTraceMark( PHB_CODETRACE_INFO pInfo, ULONG ulPCodePos, ULONG ulSize )
static void hb_compCodeTraceMark( PHB_CODETRACE_INFO pInfo, HB_ULONG ulPCodePos, HB_ULONG ulSize )
{
memset( &pInfo->pCodeMark[ ulPCodePos ], 2, ulSize );
}
@@ -126,7 +126,7 @@ static void hb_compCodeTraceMark( PHB_CODETRACE_INFO pInfo, ULONG ulPCodePos, UL
static HB_CODETRACE_FUNC( hb_p_default )
{
ULONG ulSize = hb_compPCodeSize( pFunc, lPCodePos );
HB_ULONG ulSize = hb_compPCodeSize( pFunc, lPCodePos );
hb_compCodeTraceMark( cargo, lPCodePos, ulSize );
return hb_compCodeTraceNextPos( cargo, lPCodePos + ulSize );
@@ -134,7 +134,7 @@ static HB_CODETRACE_FUNC( hb_p_default )
static HB_CODETRACE_FUNC( hb_p_jumpnear )
{
ULONG ulNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ];
HB_ULONG ulNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ];
hb_compCodeTraceMark( cargo, lPCodePos, 2 );
return hb_compCodeTraceNextPos( cargo, ulNewPos );
@@ -143,7 +143,7 @@ static HB_CODETRACE_FUNC( hb_p_jumpnear )
static HB_CODETRACE_FUNC( hb_p_jump )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr );
HB_ULONG ulNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr );
hb_compCodeTraceMark( cargo, lPCodePos, 3 );
return hb_compCodeTraceNextPos( cargo, ulNewPos );
@@ -152,7 +152,7 @@ static HB_CODETRACE_FUNC( hb_p_jump )
static HB_CODETRACE_FUNC( hb_p_jumpfar )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
HB_ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
hb_compCodeTraceMark( cargo, lPCodePos, 4 );
return hb_compCodeTraceNextPos( cargo, ulNewPos );
@@ -160,7 +160,7 @@ static HB_CODETRACE_FUNC( hb_p_jumpfar )
static HB_CODETRACE_FUNC( hb_p_jumpfalsenear )
{
ULONG ulNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ];
HB_ULONG ulNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ];
hb_compCodeTraceMark( cargo, lPCodePos, 2 );
hb_compCodeTraceAddJump( cargo, ulNewPos );
@@ -171,7 +171,7 @@ static HB_CODETRACE_FUNC( hb_p_jumpfalsenear )
static HB_CODETRACE_FUNC( hb_p_jumpfalse )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr );
HB_ULONG ulNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr );
hb_compCodeTraceMark( cargo, lPCodePos, 3 );
hb_compCodeTraceAddJump( cargo, ulNewPos );
@@ -182,7 +182,7 @@ static HB_CODETRACE_FUNC( hb_p_jumpfalse )
static HB_CODETRACE_FUNC( hb_p_jumpfalsefar )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
HB_ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
hb_compCodeTraceMark( cargo, lPCodePos, 4 );
hb_compCodeTraceAddJump( cargo, ulNewPos );
@@ -192,7 +192,7 @@ static HB_CODETRACE_FUNC( hb_p_jumpfalsefar )
static HB_CODETRACE_FUNC( hb_p_jumptruenear )
{
ULONG ulNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ];
HB_ULONG ulNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ];
hb_compCodeTraceMark( cargo, lPCodePos, 2 );
hb_compCodeTraceAddJump( cargo, ulNewPos );
@@ -203,7 +203,7 @@ static HB_CODETRACE_FUNC( hb_p_jumptruenear )
static HB_CODETRACE_FUNC( hb_p_jumptrue )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr );
HB_ULONG ulNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr );
hb_compCodeTraceMark( cargo, lPCodePos, 3 );
hb_compCodeTraceAddJump( cargo, ulNewPos );
@@ -214,7 +214,7 @@ static HB_CODETRACE_FUNC( hb_p_jumptrue )
static HB_CODETRACE_FUNC( hb_p_jumptruefar )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
HB_ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
hb_compCodeTraceMark( cargo, lPCodePos, 4 );
hb_compCodeTraceAddJump( cargo, ulNewPos );
@@ -225,7 +225,7 @@ static HB_CODETRACE_FUNC( hb_p_jumptruefar )
static HB_CODETRACE_FUNC( hb_p_seqalways )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulAlwaysPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
HB_ULONG ulAlwaysPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
hb_compCodeTraceMark( cargo, lPCodePos, 4 );
hb_compCodeTraceAddJump( cargo, ulAlwaysPos );
@@ -236,7 +236,7 @@ static HB_CODETRACE_FUNC( hb_p_seqalways )
static HB_CODETRACE_FUNC( hb_p_alwaysbegin )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulAlwaysEndPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
HB_ULONG ulAlwaysEndPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
hb_compCodeTraceMark( cargo, lPCodePos, 4 );
hb_compCodeTraceAddJump( cargo, ulAlwaysEndPos );
@@ -247,7 +247,7 @@ static HB_CODETRACE_FUNC( hb_p_alwaysbegin )
static HB_CODETRACE_FUNC( hb_p_seqbegin )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulRecoverPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
HB_ULONG ulRecoverPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
/* this is a hack for -gc3 output - it's not really necessary
* for pure PCODE evaluation
@@ -267,7 +267,7 @@ static HB_CODETRACE_FUNC( hb_p_seqbegin )
static HB_CODETRACE_FUNC( hb_p_seqend )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
HB_ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
hb_compCodeTraceMark( cargo, lPCodePos, 4 );
@@ -278,7 +278,7 @@ static HB_CODETRACE_FUNC( hb_p_seqend )
static HB_CODETRACE_FUNC( hb_p_switch )
{
HB_USHORT usCases = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), us;
ULONG ulStart = lPCodePos, ulNewPos;
HB_ULONG ulStart = lPCodePos, ulNewPos;
lPCodePos += 3;
for( us = 0; us < usCases; ++us )
@@ -569,7 +569,7 @@ void hb_compCodeTraceMarkDead( HB_COMP_DECL, PFUNCTION pFunc )
if( code_info.fFinished )
{
ULONG ulPos = 0, ulCount = 0;
HB_ULONG ulPos = 0, ulCount = 0;
HB_BYTE bLastCode = HB_P_LAST_PCODE;
do

8
harbour/src/compiler/hbident.c
View File

@@ -62,10 +62,10 @@ const char * hb_compIdentifierNew( HB_COMP_DECL, const char * szName, int iType
}
/* returns a hash key */
static HB_HASH_FUNC( hb_comp_IdentKey ) /* ULONG func (void *Value, void *Cargo) */
static HB_HASH_FUNC( hb_comp_IdentKey ) /* HB_ULONG func (void *Value, void *Cargo) */
{
ULONG ulSum = 0;
const char *szName = ( char * )Value;
HB_ULONG ulSum = 0;
const char * szName = ( char * )Value;
while( *szName )
ulSum += *szName++;
@@ -89,7 +89,7 @@ static HB_HASH_FUNC( hb_comp_IdentDel )
static HB_HASH_FUNC( hb_comp_IdentComp )
{
HB_SYMBOL_UNUSED( HashPtr );
return strcmp( (char *)Value, (char *)Cargo );
return strcmp( ( char * ) Value, (char *)Cargo );
}
/* initialize the hash table for identifiers */

28
harbour/src/compiler/hblbl.c
View File

@@ -62,7 +62,7 @@ typedef HB_LABEL_FUNC_ * PHB_LABEL_FUNC;
*/
static HB_LABEL_FUNC( hb_p_jumpnear )
{
ULONG ulNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ];
HB_ULONG ulNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ];
cargo->pulLabels[ ulNewPos ]++;
return 2;
@@ -71,7 +71,7 @@ static HB_LABEL_FUNC( hb_p_jumpnear )
static HB_LABEL_FUNC( hb_p_jump )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr );
HB_ULONG ulNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr );
cargo->pulLabels[ ulNewPos ]++;
return 3;
@@ -80,7 +80,7 @@ static HB_LABEL_FUNC( hb_p_jump )
static HB_LABEL_FUNC( hb_p_jumpfar )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
HB_ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
cargo->pulLabels[ ulNewPos ]++;
return 4;
@@ -88,7 +88,7 @@ static HB_LABEL_FUNC( hb_p_jumpfar )
static HB_LABEL_FUNC( hb_p_jumpfalsenear )
{
ULONG ulNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ];
HB_ULONG ulNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ];
cargo->fCondJump = HB_TRUE;
cargo->pulLabels[ ulNewPos ]++;
@@ -98,7 +98,7 @@ static HB_LABEL_FUNC( hb_p_jumpfalsenear )
static HB_LABEL_FUNC( hb_p_jumpfalse )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr );
HB_ULONG ulNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr );
cargo->fCondJump = HB_TRUE;
cargo->pulLabels[ ulNewPos ]++;
@@ -108,7 +108,7 @@ static HB_LABEL_FUNC( hb_p_jumpfalse )
static HB_LABEL_FUNC( hb_p_jumpfalsefar )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
HB_ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
cargo->fCondJump = HB_TRUE;
cargo->pulLabels[ ulNewPos ]++;
@@ -117,7 +117,7 @@ static HB_LABEL_FUNC( hb_p_jumpfalsefar )
static HB_LABEL_FUNC( hb_p_jumptruenear )
{
ULONG ulNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ];
HB_ULONG ulNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ];
cargo->fCondJump = HB_TRUE;
cargo->pulLabels[ ulNewPos ]++;
@@ -127,7 +127,7 @@ static HB_LABEL_FUNC( hb_p_jumptruenear )
static HB_LABEL_FUNC( hb_p_jumptrue )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr );
HB_ULONG ulNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr );
cargo->fCondJump = HB_TRUE;
cargo->pulLabels[ ulNewPos ]++;
@@ -137,7 +137,7 @@ static HB_LABEL_FUNC( hb_p_jumptrue )
static HB_LABEL_FUNC( hb_p_jumptruefar )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
HB_ULONG ulNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
cargo->fCondJump = HB_TRUE;
cargo->pulLabels[ ulNewPos ]++;
@@ -147,7 +147,7 @@ static HB_LABEL_FUNC( hb_p_jumptruefar )
static HB_LABEL_FUNC( hb_p_seqalways )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulAlwaysPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
HB_ULONG ulAlwaysPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
if( cargo->fSetSeqBegin )
cargo->pulLabels[ ulAlwaysPos ]++;
@@ -157,7 +157,7 @@ static HB_LABEL_FUNC( hb_p_seqalways )
static HB_LABEL_FUNC( hb_p_alwaysbegin )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulAlwaysEndPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
HB_ULONG ulAlwaysEndPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
if( cargo->fSetSeqBegin )
cargo->pulLabels[ ulAlwaysEndPos ]++;
@@ -167,7 +167,7 @@ static HB_LABEL_FUNC( hb_p_alwaysbegin )
static HB_LABEL_FUNC( hb_p_seqbegin )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
ULONG ulRecoverPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
HB_ULONG ulRecoverPos = lPCodePos + HB_PCODE_MKINT24( pAddr );
if( cargo->fSetSeqBegin )
cargo->pulLabels[ ulRecoverPos ]++;
@@ -178,7 +178,7 @@ static HB_LABEL_FUNC( hb_p_seqend )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
HB_LONG lOffset = HB_PCODE_MKINT24( pAddr );
ULONG ulNewPos = lPCodePos + lOffset;
HB_ULONG ulNewPos = lPCodePos + lOffset;
if( cargo->fSetSeqBegin || lOffset != 4 )
cargo->pulLabels[ ulNewPos ]++;
@@ -378,7 +378,7 @@ static const PHB_LABEL_FUNC s_GenLabelFuncTable[] =
void hb_compGenLabelTable( PFUNCTION pFunc, PHB_LABEL_INFO label_info )
{
const PHB_LABEL_FUNC * pFuncTable = s_GenLabelFuncTable;
ULONG ulLabel = 0, ul;
HB_ULONG ulLabel = 0, ul;
assert( HB_P_LAST_PCODE == sizeof( s_GenLabelFuncTable ) / sizeof( PHB_LABEL_FUNC ) );

88
harbour/src/compiler/hbmain.c
View File

@@ -60,7 +60,7 @@ static HB_BOOL hb_compRegisterFunc( HB_COMP_DECL, PFUNCTION pFunc, HB_BOOL fErro
/* ************************************************************************* */
int hb_compMain( int argc, const char * const argv[],
HB_BYTE ** pBufPtr, ULONG * pulSize, const char * szSource )
HB_BYTE ** pBufPtr, HB_ULONG * pulSize, const char * szSource )
{
HB_COMP_DECL;
int iStatus = EXIT_SUCCESS;
@@ -883,10 +883,10 @@ int hb_compVariableScope( HB_COMP_DECL, const char * szVarName )
return iScope;
}
HB_BOOL hb_compIsValidMacroText( HB_COMP_DECL, const char * szText, ULONG ulLen )
HB_BOOL hb_compIsValidMacroText( HB_COMP_DECL, const char * szText, HB_ULONG ulLen )
{
HB_BOOL fFound = HB_FALSE;
ULONG ul = 0;
HB_ULONG ul = 0;
while( ul < ulLen )
{
@@ -1227,8 +1227,8 @@ PHB_VARTYPE hb_compVarTypeNew( HB_COMP_DECL, char cVarType, const char* szFromCl
static int hb_compSort_ULONG( const void * pLeft, const void * pRight )
{
ULONG ulLeft = *( ( ULONG * ) ( pLeft ) );
ULONG ulRight = *( ( ULONG * ) ( pRight ) );
HB_ULONG ulLeft = *( ( HB_ULONG * ) ( pLeft ) );
HB_ULONG ulRight = *( ( HB_ULONG * ) ( pRight ) );
if( ulLeft == ulRight )
return 0 ;
@@ -1242,8 +1242,8 @@ static int hb_compSort_ULONG( const void * pLeft, const void * pRight )
static void hb_compOptimizeJumps( HB_COMP_DECL )
{
HB_BYTE * pCode = HB_COMP_PARAM->functions.pLast->pCode;
ULONG * pNOOPs, * pJumps;
ULONG ulOptimized, ulNextByte, ulBytes2Copy, ulJumpAddr, iNOOP, iJump;
HB_ULONG * pNOOPs, * pJumps;
HB_ULONG ulOptimized, ulNextByte, ulBytes2Copy, ulJumpAddr, iNOOP, iJump;
HB_BOOL fLineStrip = !HB_COMP_PARAM->fDebugInfo && HB_COMP_PARAM->fLineNumbers;
int iPass;
@@ -1396,7 +1396,7 @@ static void hb_compOptimizeJumps( HB_COMP_DECL )
if( HB_COMP_PARAM->functions.pLast->iJumps > iJump + 1 )
memmove( &pJumps[ iJump ], &pJumps[ iJump + 1 ],
( HB_COMP_PARAM->functions.pLast->iJumps - iJump - 1 ) *
sizeof( ULONG ) );
sizeof( HB_ULONG ) );
HB_COMP_PARAM->functions.pLast->iJumps--;
}
}
@@ -1422,12 +1422,12 @@ static void hb_compOptimizeJumps( HB_COMP_DECL )
pNOOPs = HB_COMP_PARAM->functions.pLast->pNOOPs;
/* Needed so the pasting of PCODE pieces below will work correctly */
qsort( ( void * ) pNOOPs, HB_COMP_PARAM->functions.pLast->iNOOPs, sizeof( ULONG ), hb_compSort_ULONG );
qsort( ( void * ) pNOOPs, HB_COMP_PARAM->functions.pLast->iNOOPs, sizeof( HB_ULONG ), hb_compSort_ULONG );
if( HB_COMP_PARAM->functions.pLast->iJumps )
{
HB_LONG * plSizes, * plShifts;
ULONG ulSize;
HB_ULONG ulSize;
pJumps = HB_COMP_PARAM->functions.pLast->pJumps;
ulSize = sizeof( HB_LONG ) * HB_COMP_PARAM->functions.pLast->iJumps;
@@ -1479,14 +1479,14 @@ static void hb_compOptimizeJumps( HB_COMP_DECL )
{
/* Only if points to code beyond the current fix. */
if( pNOOPs[ iNOOP ] > ulJumpAddr &&
pNOOPs[ iNOOP ] < ( ULONG ) ( ulJumpAddr + lOffset ) )
pNOOPs[ iNOOP ] < ( HB_ULONG ) ( ulJumpAddr + lOffset ) )
plSizes[ iJump ]--;
}
else /* if( lOffset < 0 ) - backword (negative) jump */
{
/* Only if points to code prior the current fix. */
if( pNOOPs[ iNOOP ] < ulJumpAddr &&
pNOOPs[ iNOOP ] >= ( ULONG ) ( ulJumpAddr + lOffset ) )
pNOOPs[ iNOOP ] >= ( HB_ULONG ) ( ulJumpAddr + lOffset ) )
plSizes[ iJump ]++;
}
@@ -2215,14 +2215,14 @@ static void hb_compExternGen( HB_COMP_DECL )
}
}
static void hb_compNOOPadd( PFUNCTION pFunc, ULONG ulPos )
static void hb_compNOOPadd( PFUNCTION pFunc, HB_ULONG ulPos )
{
pFunc->pCode[ ulPos ] = HB_P_NOOP;
if( pFunc->iNOOPs )
pFunc->pNOOPs = ( ULONG * ) hb_xrealloc( pFunc->pNOOPs, sizeof( ULONG ) * ( pFunc->iNOOPs + 1 ) );
pFunc->pNOOPs = ( HB_ULONG * ) hb_xrealloc( pFunc->pNOOPs, sizeof( HB_ULONG ) * ( pFunc->iNOOPs + 1 ) );
else
pFunc->pNOOPs = ( ULONG * ) hb_xgrab( sizeof( ULONG ) );
pFunc->pNOOPs = ( HB_ULONG * ) hb_xgrab( sizeof( HB_ULONG ) );
pFunc->pNOOPs[ pFunc->iNOOPs++ ] = ulPos;
}
@@ -2231,13 +2231,13 @@ static void hb_compPrepareJumps( HB_COMP_DECL )
PFUNCTION pFunc = HB_COMP_PARAM->functions.pLast;
if( pFunc->iJumps )
pFunc->pJumps = ( ULONG * ) hb_xrealloc( pFunc->pJumps, sizeof( ULONG ) * ( pFunc->iJumps + 1 ) );
pFunc->pJumps = ( HB_ULONG * ) hb_xrealloc( pFunc->pJumps, sizeof( HB_ULONG ) * ( pFunc->iJumps + 1 ) );
else
pFunc->pJumps = ( ULONG * ) hb_xgrab( sizeof( ULONG ) );
pFunc->pJumps[ pFunc->iJumps++ ] = ( ULONG ) ( pFunc->lPCodePos - 4 );
pFunc->pJumps = ( HB_ULONG * ) hb_xgrab( sizeof( HB_ULONG ) );
pFunc->pJumps[ pFunc->iJumps++ ] = ( HB_ULONG ) ( pFunc->lPCodePos - 4 );
}
ULONG hb_compGenJump( HB_LONG lOffset, HB_COMP_DECL )
HB_ULONG hb_compGenJump( HB_LONG lOffset, HB_COMP_DECL )
{
if( !HB_LIM_INT24( lOffset ) )
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_JUMP_TOO_LONG, NULL, NULL );
@@ -2248,7 +2248,7 @@ ULONG hb_compGenJump( HB_LONG lOffset, HB_COMP_DECL )
return HB_COMP_PARAM->functions.pLast->lPCodePos - 3;
}
ULONG hb_compGenJumpFalse( HB_LONG lOffset, HB_COMP_DECL )
HB_ULONG hb_compGenJumpFalse( HB_LONG lOffset, HB_COMP_DECL )
{
if( !HB_LIM_INT24( lOffset ) )
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_JUMP_TOO_LONG, NULL, NULL );
@@ -2259,7 +2259,7 @@ ULONG hb_compGenJumpFalse( HB_LONG lOffset, HB_COMP_DECL )
return HB_COMP_PARAM->functions.pLast->lPCodePos - 3;
}
ULONG hb_compGenJumpTrue( HB_LONG lOffset, HB_COMP_DECL )
HB_ULONG hb_compGenJumpTrue( HB_LONG lOffset, HB_COMP_DECL )
{
if( !HB_LIM_INT24( lOffset ) )
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_JUMP_TOO_LONG, NULL, NULL );
@@ -2270,7 +2270,7 @@ ULONG hb_compGenJumpTrue( HB_LONG lOffset, HB_COMP_DECL )
return HB_COMP_PARAM->functions.pLast->lPCodePos - 3;
}
void hb_compGenJumpThere( ULONG ulFrom, ULONG ulTo, HB_COMP_DECL )
void hb_compGenJumpThere( HB_ULONG ulFrom, HB_ULONG ulTo, HB_COMP_DECL )
{
HB_BYTE * pCode = HB_COMP_PARAM->functions.pLast->pCode;
HB_LONG lOffset = ulTo - ulFrom + 1;
@@ -2283,7 +2283,7 @@ void hb_compGenJumpThere( ULONG ulFrom, ULONG ulTo, HB_COMP_DECL )
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_JUMP_TOO_LONG, NULL, NULL );
}
void hb_compGenJumpHere( ULONG ulOffset, HB_COMP_DECL )
void hb_compGenJumpHere( HB_ULONG ulOffset, HB_COMP_DECL )
{
hb_compGenJumpThere( ulOffset, HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM );
}
@@ -3006,7 +3006,7 @@ void hb_compGenPushTimeStamp( long lDate, long lTime, HB_COMP_DECL )
}
/* generates the pcode to push a string on the virtual machine stack */
void hb_compGenPushString( const char * szText, ULONG ulStrLen, HB_COMP_DECL )
void hb_compGenPushString( const char * szText, HB_ULONG ulStrLen, HB_COMP_DECL )
{
if( HB_COMP_PARAM->iHidden )
{
@@ -3035,9 +3035,9 @@ void hb_compGenPushString( const char * szText, ULONG ulStrLen, HB_COMP_DECL )
}
}
void hb_compNOOPfill( PFUNCTION pFunc, ULONG ulFrom, int iCount, HB_BOOL fPop, HB_BOOL fCheck )
void hb_compNOOPfill( PFUNCTION pFunc, HB_ULONG ulFrom, int iCount, HB_BOOL fPop, HB_BOOL fCheck )
{
ULONG ul;
HB_ULONG ul;
while( iCount-- )
{
@@ -3067,11 +3067,11 @@ void hb_compNOOPfill( PFUNCTION pFunc, ULONG ulFrom, int iCount, HB_BOOL fPop, H
* _ONLY_ in very limited situations when there is no jumps over the
* removed block
*/
static void hb_compRemovePCODE( HB_COMP_DECL, ULONG ulPos, ULONG ulCount,
static void hb_compRemovePCODE( HB_COMP_DECL, HB_ULONG ulPos, HB_ULONG ulCount,
HB_BOOL fCanMove )
{
PFUNCTION pFunc = HB_COMP_PARAM->functions.pLast;
ULONG ul;
HB_ULONG ul;
if( HB_COMP_ISSUPPORTED( HB_COMPFLAG_OPTJUMP ) || !fCanMove )
{
@@ -3107,13 +3107,13 @@ static void hb_compRemovePCODE( HB_COMP_DECL, ULONG ulPos, ULONG ulCount,
}
}
HB_BOOL hb_compHasJump( PFUNCTION pFunc, ULONG ulPos )
HB_BOOL hb_compHasJump( PFUNCTION pFunc, HB_ULONG ulPos )
{
ULONG iJump;
HB_ULONG iJump;
for( iJump = 0; iJump < pFunc->iJumps; iJump++ )
{
ULONG ulJumpAddr = pFunc->pJumps[ iJump ];
HB_ULONG ulJumpAddr = pFunc->pJumps[ iJump ];
switch( pFunc->pCode[ ulJumpAddr ] )
{
case HB_P_JUMPNEAR:
@@ -3152,7 +3152,7 @@ HB_BOOL hb_compHasJump( PFUNCTION pFunc, ULONG ulPos )
* - either the address of HB_P_SEQEND opcode if there is no RECOVER clause
* - or the address of RECOVER code
*/
ULONG hb_compSequenceBegin( HB_COMP_DECL )
HB_ULONG hb_compSequenceBegin( HB_COMP_DECL )
{
hb_compGenPCode4( HB_P_SEQALWAYS, 0, 0, 0, HB_COMP_PARAM );
hb_compPrepareJumps( HB_COMP_PARAM );
@@ -3170,7 +3170,7 @@ ULONG hb_compSequenceBegin( HB_COMP_DECL )
* last statement in code beetwen BEGIN ... RECOVER) or if BREAK was requested
* and there was no matching RECOVER clause.
*/
ULONG hb_compSequenceEnd( HB_COMP_DECL )
HB_ULONG hb_compSequenceEnd( HB_COMP_DECL )
{
hb_compGenPCode4( HB_P_SEQEND, 0, 0, 0, HB_COMP_PARAM );
@@ -3179,7 +3179,7 @@ ULONG hb_compSequenceEnd( HB_COMP_DECL )
return HB_COMP_PARAM->functions.pLast->lPCodePos - 3;
}
ULONG hb_compSequenceAlways( HB_COMP_DECL )
HB_ULONG hb_compSequenceAlways( HB_COMP_DECL )
{
hb_compGenPCode4( HB_P_ALWAYSBEGIN, 0, 0, 0, HB_COMP_PARAM );
@@ -3191,8 +3191,8 @@ ULONG hb_compSequenceAlways( HB_COMP_DECL )
/* Remove unnecessary opcodes in case there were no executable statements
* beetwen BEGIN and RECOVER sequence
*/
void hb_compSequenceFinish( HB_COMP_DECL, ULONG ulStartPos, ULONG ulEndPos,
ULONG ulAlways, HB_BOOL fUsualStmts, HB_BOOL fRecover,
void hb_compSequenceFinish( HB_COMP_DECL, HB_ULONG ulStartPos, HB_ULONG ulEndPos,
HB_ULONG ulAlways, HB_BOOL fUsualStmts, HB_BOOL fRecover,
HB_BOOL fCanMove )
{
--ulStartPos; /* HB_P_SEQBEGIN address */
@@ -3350,7 +3350,7 @@ static void hb_compStaticDefThreadSet( HB_COMP_DECL )
}
if( uiCount )
{
ULONG ulSize = ( ( ULONG ) uiCount << 1 ) + 3;
HB_ULONG ulSize = ( ( HB_ULONG ) uiCount << 1 ) + 3;
HB_BYTE * pBuffer = ( HB_BYTE * ) hb_xgrab( ulSize ), *ptr;
pBuffer[ 0 ] = HB_P_THREADSTATICS;
pBuffer[ 1 ] = HB_LOBYTE( uiCount );
@@ -3443,7 +3443,7 @@ void hb_compCodeBlockEnd( HB_COMP_DECL )
PFUNCTION pCodeblock; /* pointer to the current codeblock */
PFUNCTION pFunc; /* pointer to a function that owns a codeblock */
const char * pFuncName;
ULONG ulSize;
HB_ULONG ulSize;
HB_USHORT wLocals = 0; /* number of referenced local variables */
HB_USHORT wLocalsCnt, wLocalsLen;
HB_USHORT wPos;
@@ -3944,17 +3944,17 @@ static void hb_compGenIncluded( HB_COMP_DECL )
if( ( HB_COMP_PARAM->iTraceInclude & 0x100 ) != 0 )
{
ULONG ulLen = 0, u;
HB_ULONG ulLen = 0, u;
HB_BYTE * buffer;
while( pIncFile )
{
ulLen += ( ULONG ) strlen( pIncFile->szFileName ) + 1;
ulLen += ( HB_ULONG ) strlen( pIncFile->szFileName ) + 1;
pIncFile = pIncFile->pNext;
}
if( HB_COMP_PARAM->ulOutBufSize != 0 )
++ulLen;
u = ( ULONG ) strlen( szDestFile );
u = ( HB_ULONG ) strlen( szDestFile );
if( u )
ulLen += u + 2;
HB_COMP_PARAM->pOutBuf = ( HB_BYTE * ) hb_xrealloc(
@@ -3974,7 +3974,7 @@ static void hb_compGenIncluded( HB_COMP_DECL )
pIncFile = HB_COMP_PARAM->incfiles;
while( pIncFile )
{
u = ( ULONG ) strlen( pIncFile->szFileName );
u = ( HB_ULONG ) strlen( pIncFile->szFileName );
memcpy( buffer, pIncFile->szFileName, u );
buffer +=u;
pIncFile = pIncFile->pNext;
@@ -4234,8 +4234,8 @@ static int hb_compCompile( HB_COMP_DECL, const char * szPrg, const char * szBuff
hb_compLineNumberDefStart( HB_COMP_PARAM );
do
{
ULONG ulSkip = pInfo->ulFirstLine >> 3;
ULONG ulLen = ( ( pInfo->ulLastLine + 7 ) >> 3 ) - ulSkip;
HB_ULONG ulSkip = pInfo->ulFirstLine >> 3;
HB_ULONG ulLen = ( ( pInfo->ulLastLine + 7 ) >> 3 ) - ulSkip;
hb_compGenPushString( pInfo->pszModuleName, strlen( pInfo->pszModuleName ) + 1, HB_COMP_PARAM );
hb_compGenPushLong( ulSkip << 3, HB_COMP_PARAM );

28
harbour/src/compiler/hbopt.c
View File

@@ -320,7 +320,7 @@ static HB_OPT_FUNC( hb_p_duplicate )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 2 ];
HB_LONG lOffset = HB_PCODE_MKINT24( pAddr ), lLastOffset = 0;
ULONG ulNewPos = lPCodePos + 1 + lOffset;
HB_ULONG ulNewPos = lPCodePos + 1 + lOffset;
HB_BOOL fNot = HB_FALSE, fOK = HB_TRUE, fRepeat = HB_TRUE;
do
@@ -478,7 +478,7 @@ static HB_OPT_FUNC( hb_p_jumpfar )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
HB_LONG lOffset = HB_PCODE_MKINT24( pAddr );
ULONG ulNewPos = lPCodePos + lOffset;
HB_ULONG ulNewPos = lPCodePos + lOffset;
HB_BOOL fLine = HB_FALSE;
HB_SYMBOL_UNUSED( cargo );
@@ -533,7 +533,7 @@ static HB_OPT_FUNC( hb_p_jumpfalsefar )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
HB_LONG lOffset = HB_PCODE_MKINT24( pAddr );
ULONG ulNewPos = lPCodePos + lOffset;
HB_ULONG ulNewPos = lPCodePos + lOffset;
HB_BOOL fLine = HB_FALSE;
HB_SYMBOL_UNUSED( cargo );
@@ -577,7 +577,7 @@ static HB_OPT_FUNC( hb_p_jumptruefar )
{
HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ];
HB_LONG lOffset = HB_PCODE_MKINT24( pAddr );
ULONG ulNewPos = lPCodePos + lOffset;
HB_ULONG ulNewPos = lPCodePos + lOffset;
HB_BOOL fLine = HB_FALSE;
HB_SYMBOL_UNUSED( cargo );
@@ -620,7 +620,7 @@ static HB_OPT_FUNC( hb_p_jumptruefar )
static HB_OPT_FUNC( hb_p_switch )
{
HB_USHORT usCases = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), us;
ULONG ulStart = lPCodePos;
HB_ULONG ulStart = lPCodePos;
HB_SYMBOL_UNUSED( cargo );
@@ -1041,7 +1041,7 @@ static HB_LONG hb_compJumpGetOffset( HB_BYTE * pCode )
static void hb_compPCodeEnumScanLocals( PFUNCTION pFunc, PHB_OPT_LOCAL pLocals )
{
ULONG ulPos = 0, ulLastPos = 0;
HB_ULONG ulPos = 0, ulLastPos = 0;
HB_SHORT isVar = 0;
HB_BOOL fWasJump = 0;
@@ -1100,7 +1100,7 @@ static void hb_compPCodeEnumScanLocals( PFUNCTION pFunc, PHB_OPT_LOCAL pLocals )
case HB_P_PUSHLOCALREF:
if( isVar > 0 )
{
ULONG ulPosNext = ulPos + hb_compPCodeSize( pFunc, ulPos );
HB_ULONG ulPosNext = ulPos + hb_compPCodeSize( pFunc, ulPos );
HB_BYTE bCodeNext = pFunc->pCode[ ulPosNext ];
HB_BYTE bCodeNext2 = pFunc->pCode[ ulPosNext + hb_compPCodeSize( pFunc, ulPosNext ) ];
@@ -1197,7 +1197,7 @@ static void hb_compPCodeEnumScanLocals( PFUNCTION pFunc, PHB_OPT_LOCAL pLocals )
static void hb_compPCodeEnumSelfifyLocal( PFUNCTION pFunc, HB_SHORT isLocal )
{
ULONG ulPos = 0, ulLastPos = 0;
HB_ULONG ulPos = 0, ulLastPos = 0;
while( ulPos < pFunc->lPCodePos )
{
@@ -1247,7 +1247,7 @@ static void hb_compPCodeEnumSelfifyLocal( PFUNCTION pFunc, HB_SHORT isLocal )
}
static int hb_compPCodeTraceAssignedUnused( PFUNCTION pFunc, ULONG ulPos, HB_BYTE * pMap, HB_SHORT isLocal )
static int hb_compPCodeTraceAssignedUnused( PFUNCTION pFunc, HB_ULONG ulPos, HB_BYTE * pMap, HB_SHORT isLocal )
{
for( ;; )
{
@@ -1285,7 +1285,7 @@ static int hb_compPCodeTraceAssignedUnused( PFUNCTION pFunc, ULONG ulPos, HB_BYT
if( hb_compIsJump( pFunc->pCode[ ulPos ] ) )
{
ULONG ulPos2 = ulPos + hb_compJumpGetOffset( &pFunc->pCode[ ulPos ] );
HB_ULONG ulPos2 = ulPos + hb_compJumpGetOffset( &pFunc->pCode[ ulPos ] );
if( hb_compIsUncondJump( pFunc->pCode[ ulPos ] ) )
{
@@ -1324,7 +1324,7 @@ static int hb_compPCodeTraceAssignedUnused( PFUNCTION pFunc, ULONG ulPos, HB_BYT
static void hb_compPCodeEnumAssignedUnused( HB_COMP_DECL, PFUNCTION pFunc, PHB_OPT_LOCAL pLocals )
{
HB_BYTE * pMap;
ULONG ulPos = 0, ulLastPos = 0;
HB_ULONG ulPos = 0, ulLastPos = 0;
HB_SHORT isLocal;
HB_USHORT usLine = 0;
@@ -1349,7 +1349,7 @@ static void hb_compPCodeEnumAssignedUnused( HB_COMP_DECL, PFUNCTION pFunc, PHB_O
if( !fCheck && pFunc->pCode[ ulPos ] == HB_P_PUSHLOCALREF )
{
ULONG ulPosNext = ulPos + hb_compPCodeSize( pFunc, ulPos );
HB_ULONG ulPosNext = ulPos + hb_compPCodeSize( pFunc, ulPos );
HB_BYTE bCodeNext = pFunc->pCode[ ulPosNext ];
HB_BYTE bCodeNext2 = pFunc->pCode[ ulPosNext + hb_compPCodeSize( pFunc, ulPosNext ) ];
@@ -1445,7 +1445,7 @@ static void hb_compPCodeEnumAssignedUnused( HB_COMP_DECL, PFUNCTION pFunc, PHB_O
static void hb_compPCodeEnumRenumberLocals( PFUNCTION pFunc, PHB_OPT_LOCAL pLocals )
{
ULONG ulPos = 0;
HB_ULONG ulPos = 0;
while( ulPos < pFunc->lPCodePos )
{
@@ -1564,7 +1564,7 @@ void hb_compPCodeTraceOptimizer( HB_COMP_DECL )
/* TOFIX: Support for PARAMETER sentence is not implemented.
The temporary solution is to disable optmisation at all if PARAMETER is used. */
{
ULONG ulPos = 0;
HB_ULONG ulPos = 0;
while( ulPos < pFunc->lPCodePos )
{

18
harbour/src/compiler/hbpcode.c
View File

@@ -79,7 +79,7 @@ static HB_PSIZE_FUNC( hb_p_pushblocklarge )
static HB_PSIZE_FUNC( hb_p_localname )
{
ULONG ulStart = lPCodePos;
HB_ULONG ulStart = lPCodePos;
HB_SYMBOL_UNUSED( cargo );
lPCodePos += 3;
@@ -90,7 +90,7 @@ static HB_PSIZE_FUNC( hb_p_localname )
static HB_PSIZE_FUNC( hb_p_modulename )
{
ULONG ulStart = lPCodePos;
HB_ULONG ulStart = lPCodePos;
HB_SYMBOL_UNUSED( cargo );
lPCodePos += 3;
@@ -101,7 +101,7 @@ static HB_PSIZE_FUNC( hb_p_modulename )
static HB_PSIZE_FUNC( hb_p_staticname )
{
ULONG ulStart = lPCodePos;
HB_ULONG ulStart = lPCodePos;
HB_SYMBOL_UNUSED( cargo );
lPCodePos += 4;
@@ -113,7 +113,7 @@ static HB_PSIZE_FUNC( hb_p_staticname )
static HB_PSIZE_FUNC( hb_p_threadstatics )
{
HB_SYMBOL_UNUSED( cargo );
return 3 + ( ( ULONG ) HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) << 1 );
return 3 + ( ( HB_ULONG ) HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) << 1 );
}
const HB_BYTE hb_comp_pcode_len[] = {
@@ -493,7 +493,7 @@ static HB_PCODE_FUNC_PTR s_psize_table[] =
hb_p_threadstatics /* HB_P_THREADSTATICS */
};
LONG hb_compPCodeSize( PFUNCTION pFunc, ULONG ulOffset )
LONG hb_compPCodeSize( PFUNCTION pFunc, HB_ULONG ulOffset )
{
HB_LONG lSize = 0;
HB_BYTE opcode = pFunc->pCode[ ulOffset ];
@@ -515,8 +515,8 @@ LONG hb_compPCodeSize( PFUNCTION pFunc, ULONG ulOffset )
void hb_compPCodeEval( PFUNCTION pFunc, const HB_PCODE_FUNC_PTR * pFunctions, void * cargo )
{
ULONG ulPos = 0;
ULONG ulSkip;
HB_ULONG ulPos = 0;
HB_ULONG ulSkip;
HB_BYTE opcode;
/* Make sure that table is correct */
@@ -575,7 +575,7 @@ void hb_compPCodeEval( PFUNCTION pFunc, const HB_PCODE_FUNC_PTR * pFunctions, vo
void hb_compPCodeTrace( PFUNCTION pFunc, const HB_PCODE_FUNC_PTR * pFunctions, void * cargo )
{
ULONG ulPos = 0;
HB_ULONG ulPos = 0;
/* Make sure that table is correct */
assert( sizeof( hb_comp_pcode_len ) == HB_P_LAST_PCODE );
@@ -671,7 +671,7 @@ void hb_compGenPCode4( HB_BYTE byte1, HB_BYTE byte2, HB_BYTE byte3, HB_BYTE byte
pFunc->pCode[ pFunc->lPCodePos++ ] = byte4;
}
void hb_compGenPCodeN( const HB_BYTE * pBuffer, ULONG ulSize, HB_COMP_DECL )
void hb_compGenPCodeN( const HB_BYTE * pBuffer, HB_ULONG ulSize, HB_COMP_DECL )
{
PFUNCTION pFunc = HB_COMP_PARAM->functions.pLast; /* get the currently defined Clipper function */

4
harbour/src/compiler/ppcomp.c
View File

@@ -79,7 +79,7 @@ static void hb_pp_Disp( void * cargo, const char * szMessage )
hb_compOutStd( HB_COMP_PARAM, szMessage );
}
static void hb_pp_PragmaDump( void * cargo, char * pBuffer, ULONG ulSize,
static void hb_pp_PragmaDump( void * cargo, char * pBuffer, HB_SIZE ulSize,
int iLine )
{
PINLINE pInline;
@@ -92,7 +92,7 @@ static void hb_pp_PragmaDump( void * cargo, char * pBuffer, ULONG ulSize,
}
static void hb_pp_hb_inLine( void * cargo, char * szFunc,
char * pBuffer, ULONG ulSize, int iLine )
char * pBuffer, HB_SIZE ulSize, int iLine )
{
HB_COMP_DECL = ( HB_COMP_PTR ) cargo;

2
harbour/src/debug/dbgentry.c
View File

@@ -334,7 +334,7 @@ static PHB_ITEM hb_dbgActivateVarArray( int nVars, HB_VARINFO *aVars )
void hb_dbgEntry( int nMode, int nLine, const char *szName, int nIndex, PHB_ITEM pFrame )
{
int i;
ULONG nProcLevel;
HB_ULONG nProcLevel;
char szProcName[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 5 ];
HB_DEBUGINFO ** infoPtr = ( HB_DEBUGINFO ** ) hb_stackDebugInfo();
HB_DEBUGINFO *info = *infoPtr;

Some files were not shown because too many files have changed in this diff Show More