From b1cd0953df307a82d6bfe1bf6ee00eef90683e7c Mon Sep 17 00:00:00 2001 From: Viktor Szakats Date: Mon, 8 Feb 2010 21:52:47 +0000 Subject: [PATCH] 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. --- harbour/ChangeLog | 191 +++++++++++++++++ harbour/contrib/hbbmcdx/bmdbfcdx.c | 266 ++++++++++++------------ harbour/contrib/hbbmcdx/hbbmcdx.h | 96 ++++----- harbour/contrib/hbbtree/hb_btree.c | 152 +++++++------- harbour/contrib/hbbtree/hb_btree.h | 4 +- harbour/contrib/hbct/asciisum.c | 4 +- harbour/contrib/hbct/atadjust.c | 4 +- harbour/contrib/hbct/atnum.c | 4 +- harbour/contrib/hbct/atrepl.c | 4 +- harbour/contrib/hbct/ct.h | 4 +- harbour/contrib/hbct/ctc.c | 8 +- harbour/contrib/hbct/ctstr.c | 12 +- harbour/contrib/hbct/ctwin.c | 22 +- harbour/contrib/hbct/dattime3.c | 6 +- harbour/contrib/hbct/dbftools.c | 2 +- harbour/contrib/hbct/files.c | 4 +- harbour/contrib/hbct/numat.c | 2 +- harbour/contrib/hbct/screen1.c | 10 +- harbour/contrib/hbct/screen2.c | 20 +- harbour/contrib/hbct/token1.c | 8 +- harbour/contrib/hbct/token2.c | 2 +- harbour/contrib/hbmemio/memio.c | 54 ++--- harbour/contrib/hbmisc/spd.c | 10 +- harbour/contrib/hbnetio/netiocli.c | 6 +- harbour/contrib/hbnf/dispc.c | 2 +- harbour/contrib/hbnf/ftattr.c | 4 +- harbour/contrib/hbqt/gtqtc/gtqtc.cpp | 2 +- harbour/contrib/hbtip/encmthd.c | 10 +- harbour/contrib/hbtip/utils.c | 4 +- harbour/contrib/rddads/ads1.c | 68 +++--- harbour/contrib/rddads/adsfunc.c | 14 +- harbour/contrib/rddads/adsmgmnt.c | 6 +- harbour/contrib/rddads/adsx.c | 70 +++---- harbour/contrib/rddads/rddads.h | 10 +- harbour/contrib/rddsql/hbrddsql.h | 14 +- harbour/contrib/rddsql/sddfb/fbirddd.c | 6 +- harbour/contrib/rddsql/sddmy/mysqldd.c | 18 +- harbour/contrib/rddsql/sddodbc/odbcdd.c | 8 +- harbour/contrib/rddsql/sddpg/pgsqldd.c | 6 +- harbour/contrib/rddsql/sqlbase.c | 44 ++-- harbour/contrib/rddsql/sqlmix.c | 44 ++-- harbour/contrib/xhb/bkgtsks.c | 28 +-- harbour/contrib/xhb/datesxhb.c | 10 +- harbour/contrib/xhb/fparse.c | 6 +- harbour/contrib/xhb/hbcrypt.c | 80 +++---- harbour/contrib/xhb/hbnxs.h | 2 +- harbour/contrib/xpp/dbcmdx.c | 2 +- harbour/include/hbapi.h | 40 ++-- harbour/include/hbapicls.h | 6 +- harbour/include/hbapidbg.h | 4 +- harbour/include/hbapierr.h | 10 +- harbour/include/hbapifs.h | 10 +- harbour/include/hbapiitm.h | 4 +- harbour/include/hbapirdd.h | 28 +-- harbour/include/hbcomp.h | 46 ++-- harbour/include/hbcompdf.h | 86 ++++---- harbour/include/hbdefs.h | 6 +- harbour/include/hbexpra.c | 12 +- harbour/include/hbexprb.c | 10 +- harbour/include/hbexprop.h | 16 +- harbour/include/hbgtcore.h | 4 +- harbour/include/hbhash.h | 4 +- harbour/include/hbinit.h | 2 +- harbour/include/hbmacro.h | 18 +- harbour/include/hbpp.h | 22 +- harbour/include/hbrddcdx.h | 60 +++--- harbour/include/hbrdddbf.h | 26 +-- harbour/include/hbrdddel.h | 10 +- harbour/include/hbrddfpt.h | 18 +- harbour/include/hbrddnsx.h | 62 +++--- harbour/include/hbrddntx.h | 60 +++--- harbour/include/hbrddsdf.h | 4 +- harbour/include/hbregex.h | 6 +- harbour/include/hbstack.h | 12 +- harbour/include/hbthread.h | 12 +- harbour/include/hbtypes.h | 18 +- harbour/include/hbvm.h | 20 +- harbour/include/hbvmpub.h | 6 +- harbour/src/common/expropt1.c | 20 +- harbour/src/common/expropt2.c | 10 +- harbour/src/common/hbhash.c | 10 +- harbour/src/compiler/cmdcheck.c | 4 +- harbour/src/compiler/compi18n.c | 4 +- harbour/src/compiler/complex.c | 2 +- harbour/src/compiler/genc.c | 24 +-- harbour/src/compiler/gencc.c | 28 +-- harbour/src/compiler/genhrb.c | 10 +- harbour/src/compiler/genobj32.c | 48 ++--- harbour/src/compiler/harbour.y | 42 ++-- harbour/src/compiler/harbour.yyc | 42 ++-- harbour/src/compiler/hbcmplib.c | 6 +- harbour/src/compiler/hbdbginf.c | 4 +- harbour/src/compiler/hbdead.c | 60 +++--- harbour/src/compiler/hbident.c | 8 +- harbour/src/compiler/hblbl.c | 28 +-- harbour/src/compiler/hbmain.c | 88 ++++---- harbour/src/compiler/hbopt.c | 28 +-- harbour/src/compiler/hbpcode.c | 18 +- harbour/src/compiler/ppcomp.c | 4 +- harbour/src/debug/dbgentry.c | 2 +- harbour/src/macro/macrolex.c | 16 +- harbour/src/nortl/nortl.c | 24 +-- harbour/src/pp/hbpp.c | 4 +- harbour/src/pp/ppcore.c | 66 +++--- harbour/src/rdd/dbcmd.c | 31 ++- harbour/src/rdd/dbcmdx.c | 2 +- harbour/src/rdd/dbf1.c | 130 ++++++------ harbour/src/rdd/dbfcdx/dbfcdx1.c | 234 ++++++++++----------- harbour/src/rdd/dbffpt/dbffpt1.c | 204 +++++++++--------- harbour/src/rdd/dbfnsx/dbfnsx1.c | 216 +++++++++---------- harbour/src/rdd/dbfntx/dbfntx1.c | 202 +++++++++--------- harbour/src/rdd/dbsql.c | 14 +- harbour/src/rdd/delim1.c | 26 +-- harbour/src/rdd/hbdbsort.c | 10 +- harbour/src/rdd/hbsix/sxcrypt.c | 2 +- harbour/src/rdd/hbsix/sxfname.c | 2 +- harbour/src/rdd/hbsix/sxord.c | 6 +- harbour/src/rdd/hbsix/sxtable.c | 4 +- harbour/src/rdd/hbsix/sxutil.c | 2 +- harbour/src/rdd/hsx/hsx.c | 80 +++---- harbour/src/rdd/sdf1.c | 18 +- harbour/src/rdd/usrrdd/usrrdd.c | 36 ++-- harbour/src/rdd/wacore.c | 4 +- harbour/src/rdd/wafunc.c | 8 +- harbour/src/rdd/workarea.c | 4 +- harbour/src/rtl/errapi.c | 20 +- harbour/src/rtl/filebuf.c | 14 +- harbour/src/rtl/gtcgi/gtcgi.c | 2 +- harbour/src/rtl/gtpca/gtpca.c | 4 +- harbour/src/rtl/gtstd/gtstd.c | 4 +- harbour/src/rtl/gtxwc/gtxwc.c | 48 ++--- harbour/src/rtl/hbproces.c | 8 +- harbour/src/rtl/hbprocfn.c | 2 +- harbour/src/rtl/hbsocket.c | 2 +- harbour/src/vm/classes.c | 88 ++++---- harbour/src/vm/cmdarg.c | 4 +- harbour/src/vm/estack.c | 6 +- harbour/src/vm/eval.c | 12 +- harbour/src/vm/extend.c | 8 +- harbour/src/vm/fm.c | 4 +- harbour/src/vm/hvm.c | 66 +++--- harbour/src/vm/itemapi.c | 2 +- harbour/src/vm/macro.c | 20 +- harbour/src/vm/maindllp.c | 12 +- harbour/src/vm/memvars.c | 20 +- harbour/src/vm/runner.c | 22 +- harbour/src/vm/thread.c | 48 ++--- 147 files changed, 2208 insertions(+), 2038 deletions(-) diff --git a/harbour/ChangeLog b/harbour/ChangeLog index 246ba8f55a..8f903b0a31 100644 --- a/harbour/ChangeLog +++ b/harbour/ChangeLog @@ -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 diff --git a/harbour/contrib/hbbmcdx/bmdbfcdx.c b/harbour/contrib/hbbmcdx/bmdbfcdx.c index 8900648f8c..2d3dca84d7 100644 --- a/harbour/contrib/hbbmcdx/bmdbfcdx.c +++ b/harbour/contrib/hbbmcdx/bmdbfcdx.c @@ -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 + diff --git a/harbour/contrib/hbbmcdx/hbbmcdx.h b/harbour/contrib/hbbmcdx/hbbmcdx.h index 82eb64713b..e97be2f77a 100644 --- a/harbour/contrib/hbbmcdx/hbbmcdx.h +++ b/harbour/contrib/hbbmcdx/hbbmcdx.h @@ -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 diff --git a/harbour/contrib/hbbtree/hb_btree.c b/harbour/contrib/hbbtree/hb_btree.c index 115aa4f0cc..aac888c9a6 100644 --- a/harbour/contrib/hbbtree/hb_btree.c +++ b/harbour/contrib/hbbtree/hb_btree.c @@ -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 ); diff --git a/harbour/contrib/hbbtree/hb_btree.h b/harbour/contrib/hbbtree/hb_btree.h index 60c7cb017a..5be88d680b 100644 --- a/harbour/contrib/hbbtree/hb_btree.h +++ b/harbour/contrib/hbbtree/hb_btree.h @@ -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 ); diff --git a/harbour/contrib/hbct/asciisum.c b/harbour/contrib/hbct/asciisum.c index ac937da76f..e5fd8ce657 100644 --- a/harbour/contrib/hbct/asciisum.c +++ b/harbour/contrib/hbct/asciisum.c @@ -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 ); } diff --git a/harbour/contrib/hbct/atadjust.c b/harbour/contrib/hbct/atadjust.c index 4837701c3d..0994453604 100644 --- a/harbour/contrib/hbct/atadjust.c +++ b/harbour/contrib/hbct/atadjust.c @@ -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 th match */ const char *pcSubStr; HB_SIZE sSubStrLen; - ULONG ulMatchCounter = 0; + HB_SIZE ulMatchCounter = 0; pcSubStr = pcString; sSubStrLen = sStrLen; diff --git a/harbour/contrib/hbct/atnum.c b/harbour/contrib/hbct/atnum.c index 12aa56d626..fdd1bbeb99 100644 --- a/harbour/contrib/hbct/atnum.c +++ b/harbour/contrib/hbct/atnum.c @@ -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 th match */ const char *pcSubStr; HB_SIZE sSubStrLen; - ULONG ulMatchCounter = 0; + HB_SIZE ulMatchCounter = 0; pcSubStr = pcString; sSubStrLen = sStrLen; diff --git a/harbour/contrib/hbct/atrepl.c b/harbour/contrib/hbct/atrepl.c index 387e5268c8..cc91ce391f 100644 --- a/harbour/contrib/hbct/atrepl.c +++ b/harbour/contrib/hbct/atrepl.c @@ -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 ); diff --git a/harbour/contrib/hbct/ct.h b/harbour/contrib/hbct/ct.h index 16a28a346d..74e3aea050 100644 --- a/harbour/contrib/hbct/ct.h +++ b/harbour/contrib/hbct/ct.h @@ -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 ); diff --git a/harbour/contrib/hbct/ctc.c b/harbour/contrib/hbct/ctc.c index 1972a44799..15f36b0015 100644 --- a/harbour/contrib/hbct/ctc.c +++ b/harbour/contrib/hbct/ctc.c @@ -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 ) ); diff --git a/harbour/contrib/hbct/ctstr.c b/harbour/contrib/hbct/ctstr.c index e077dccf05..3f5f025f1c 100644 --- a/harbour/contrib/hbct/ctstr.c +++ b/harbour/contrib/hbct/ctstr.c @@ -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; diff --git a/harbour/contrib/hbct/ctwin.c b/harbour/contrib/hbct/ctwin.c index d35de9db75..eb74b0f713 100644 --- a/harbour/contrib/hbct/ctwin.c +++ b/harbour/contrib/hbct/ctwin.c @@ -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 ) diff --git a/harbour/contrib/hbct/dattime3.c b/harbour/contrib/hbct/dattime3.c index addce1ed74..b4a2b4b155 100644 --- a/harbour/contrib/hbct/dattime3.c +++ b/harbour/contrib/hbct/dattime3.c @@ -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]; diff --git a/harbour/contrib/hbct/dbftools.c b/harbour/contrib/hbct/dbftools.c index d4069cf5fd..e98e763ae3 100644 --- a/harbour/contrib/hbct/dbftools.c +++ b/harbour/contrib/hbct/dbftools.c @@ -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 ) { diff --git a/harbour/contrib/hbct/files.c b/harbour/contrib/hbct/files.c index eb11d6e16f..b562d97d9d 100644 --- a/harbour/contrib/hbct/files.c +++ b/harbour/contrib/hbct/files.c @@ -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 ); diff --git a/harbour/contrib/hbct/numat.c b/harbour/contrib/hbct/numat.c index 41ea82a803..64ee59e691 100644 --- a/harbour/contrib/hbct/numat.c +++ b/harbour/contrib/hbct/numat.c @@ -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 */ diff --git a/harbour/contrib/hbct/screen1.c b/harbour/contrib/hbct/screen1.c index d93e99d52d..d8f77c8100 100644 --- a/harbour/contrib/hbct/screen1.c +++ b/harbour/contrib/hbct/screen1.c @@ -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 ) { diff --git a/harbour/contrib/hbct/screen2.c b/harbour/contrib/hbct/screen2.c index 8b8d128eab..28af7900a0 100644 --- a/harbour/contrib/hbct/screen2.c +++ b/harbour/contrib/hbct/screen2.c @@ -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--; diff --git a/harbour/contrib/hbct/token1.c b/harbour/contrib/hbct/token1.c index 5b70e07e36..f447772987 100644 --- a/harbour/contrib/hbct/token1.c +++ b/harbour/contrib/hbct/token1.c @@ -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 */ diff --git a/harbour/contrib/hbct/token2.c b/harbour/contrib/hbct/token2.c index c2c33e99c0..1ad14ad787 100644 --- a/harbour/contrib/hbct/token2.c +++ b/harbour/contrib/hbct/token2.c @@ -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; diff --git a/harbour/contrib/hbmemio/memio.c b/harbour/contrib/hbmemio/memio.c index 4de2d8ed0d..2b73a167da 100644 --- a/harbour/contrib/hbmemio/memio.c +++ b/harbour/contrib/hbmemio/memio.c @@ -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 ); diff --git a/harbour/contrib/hbmisc/spd.c b/harbour/contrib/hbmisc/spd.c index cd1ddd1d2e..a1026735b8 100644 --- a/harbour/contrib/hbmisc/spd.c +++ b/harbour/contrib/hbmisc/spd.c @@ -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; diff --git a/harbour/contrib/hbnetio/netiocli.c b/harbour/contrib/hbnetio/netiocli.c index 7062cc94b0..ac429aa2dc 100644 --- a/harbour/contrib/hbnetio/netiocli.c +++ b/harbour/contrib/hbnetio/netiocli.c @@ -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 ) { diff --git a/harbour/contrib/hbnf/dispc.c b/harbour/contrib/hbnf/dispc.c index e3f1a5f251..4d085fdc2d 100644 --- a/harbour/contrib/hbnf/dispc.c +++ b/harbour/contrib/hbnf/dispc.c @@ -542,7 +542,7 @@ static void filebot() HB_FUNC( _FT_DFINIT ) { int rval, i, j; - ULONG ulSize; + HB_SIZE ulSize; rval = 0; diff --git a/harbour/contrib/hbnf/ftattr.c b/harbour/contrib/hbnf/ftattr.c index 09385812a1..2c091dbd17 100644 --- a/harbour/contrib/hbnf/ftattr.c +++ b/harbour/contrib/hbnf/ftattr.c @@ -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 */ diff --git a/harbour/contrib/hbqt/gtqtc/gtqtc.cpp b/harbour/contrib/hbqt/gtqtc/gtqtc.cpp index ea5eceb338..2dbe651ed5 100644 --- a/harbour/contrib/hbqt/gtqtc/gtqtc.cpp +++ b/harbour/contrib/hbqt/gtqtc/gtqtc.cpp @@ -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; diff --git a/harbour/contrib/hbtip/encmthd.c b/harbour/contrib/hbtip/encmthd.c index 7cbc777084..4757c02d46 100644 --- a/harbour/contrib/hbtip/encmthd.c +++ b/harbour/contrib/hbtip/encmthd.c @@ -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 ); diff --git a/harbour/contrib/hbtip/utils.c b/harbour/contrib/hbtip/utils.c index 85698e05fd..59737c4d1c 100644 --- a/harbour/contrib/hbtip/utils.c +++ b/harbour/contrib/hbtip/utils.c @@ -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 ); diff --git a/harbour/contrib/rddads/ads1.c b/harbour/contrib/rddads/ads1.c index abdb8320a9..c04af4e61b 100644 --- a/harbour/contrib/rddads/ads1.c +++ b/harbour/contrib/rddads/ads1.c @@ -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; diff --git a/harbour/contrib/rddads/adsfunc.c b/harbour/contrib/rddads/adsfunc.c index 8c27f6552a..bb6a09257e 100644 --- a/harbour/contrib/rddads/adsfunc.c +++ b/harbour/contrib/rddads/adsfunc.c @@ -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'; diff --git a/harbour/contrib/rddads/adsmgmnt.c b/harbour/contrib/rddads/adsmgmnt.c index 002627646f..87498d1fe4 100644 --- a/harbour/contrib/rddads/adsmgmnt.c +++ b/harbour/contrib/rddads/adsmgmnt.c @@ -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 ); } diff --git a/harbour/contrib/rddads/adsx.c b/harbour/contrib/rddads/adsx.c index bfb2a199ab..1d26b68360 100644 --- a/harbour/contrib/rddads/adsx.c +++ b/harbour/contrib/rddads/adsx.c @@ -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 ); diff --git a/harbour/contrib/rddads/rddads.h b/harbour/contrib/rddads/rddads.h index 93feffc2ea..7b08d6aacc 100644 --- a/harbour/contrib/rddads/rddads.h +++ b/harbour/contrib/rddads/rddads.h @@ -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. */ diff --git a/harbour/contrib/rddsql/hbrddsql.h b/harbour/contrib/rddsql/hbrddsql.h index 7e2c458aba..d24ed13763 100644 --- a/harbour/contrib/rddsql/hbrddsql.h +++ b/harbour/contrib/rddsql/hbrddsql.h @@ -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 diff --git a/harbour/contrib/rddsql/sddfb/fbirddd.c b/harbour/contrib/rddsql/sddfb/fbirddd.c index bb83eae6f0..dcfabce849 100644 --- a/harbour/contrib/rddsql/sddfb/fbirddd.c +++ b/harbour/contrib/rddsql/sddfb/fbirddd.c @@ -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; diff --git a/harbour/contrib/rddsql/sddmy/mysqldd.c b/harbour/contrib/rddsql/sddmy/mysqldd.c index 8c37a26008..e28bf981b8 100644 --- a/harbour/contrib/rddsql/sddmy/mysqldd.c +++ b/harbour/contrib/rddsql/sddmy/mysqldd.c @@ -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'; diff --git a/harbour/contrib/rddsql/sddodbc/odbcdd.c b/harbour/contrib/rddsql/sddodbc/odbcdd.c index 445e5d1243..4420a43c8d 100644 --- a/harbour/contrib/rddsql/sddodbc/odbcdd.c +++ b/harbour/contrib/rddsql/sddodbc/odbcdd.c @@ -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; diff --git a/harbour/contrib/rddsql/sddpg/pgsqldd.c b/harbour/contrib/rddsql/sddpg/pgsqldd.c index 9c0063bc9c..cede20e312 100644 --- a/harbour/contrib/rddsql/sddpg/pgsqldd.c +++ b/harbour/contrib/rddsql/sddpg/pgsqldd.c @@ -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 ); */ diff --git a/harbour/contrib/rddsql/sqlbase.c b/harbour/contrib/rddsql/sqlbase.c index 5ba9fd1c03..cf95db2a1b 100644 --- a/harbour/contrib/rddsql/sqlbase.c +++ b/harbour/contrib/rddsql/sqlbase.c @@ -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++ ) diff --git a/harbour/contrib/rddsql/sqlmix.c b/harbour/contrib/rddsql/sqlmix.c index 20048787a3..437a0bc6bc 100644 --- a/harbour/contrib/rddsql/sqlmix.c +++ b/harbour/contrib/rddsql/sqlmix.c @@ -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; diff --git a/harbour/contrib/xhb/bkgtsks.c b/harbour/contrib/xhb/bkgtsks.c index 38d3f0f55e..c5b20ca021 100644 --- a/harbour/contrib/xhb/bkgtsks.c +++ b/harbour/contrib/xhb/bkgtsks.c @@ -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; diff --git a/harbour/contrib/xhb/datesxhb.c b/harbour/contrib/xhb/datesxhb.c index 4c5b37fe59..6a15527345 100644 --- a/harbour/contrib/xhb/datesxhb.c +++ b/harbour/contrib/xhb/datesxhb.c @@ -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; } diff --git a/harbour/contrib/xhb/fparse.c b/harbour/contrib/xhb/fparse.c index 8a305d007c..39a2d9057d 100644 --- a/harbour/contrib/xhb/fparse.c +++ b/harbour/contrib/xhb/fparse.c @@ -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 */ diff --git a/harbour/contrib/xhb/hbcrypt.c b/harbour/contrib/xhb/hbcrypt.c index 4924e84493..7e40b314a6 100644 --- a/harbour/contrib/xhb/hbcrypt.c +++ b/harbour/contrib/xhb/hbcrypt.c @@ -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 ++ ) { diff --git a/harbour/contrib/xhb/hbnxs.h b/harbour/contrib/xhb/hbnxs.h index 9c41079310..5175c9adb6 100644 --- a/harbour/contrib/xhb/hbnxs.h +++ b/harbour/contrib/xhb/hbnxs.h @@ -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, diff --git a/harbour/contrib/xpp/dbcmdx.c b/harbour/contrib/xpp/dbcmdx.c index 88f5462d52..de85ee0c34 100644 --- a/harbour/contrib/xpp/dbcmdx.c +++ b/harbour/contrib/xpp/dbcmdx.c @@ -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 ) { diff --git a/harbour/include/hbapi.h b/harbour/include/hbapi.h index 887195b288..70655000a7 100644 --- a/harbour/include/hbapi.h +++ b/harbour/include/hbapi.h @@ -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 ); diff --git a/harbour/include/hbapicls.h b/harbour/include/hbapicls.h index 9c9277e840..dc18b8f1a0 100644 --- a/harbour/include/hbapicls.h +++ b/harbour/include/hbapicls.h @@ -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 ); diff --git a/harbour/include/hbapidbg.h b/harbour/include/hbapidbg.h index f60007de54..3788339e41 100644 --- a/harbour/include/hbapidbg.h +++ b/harbour/include/hbapidbg.h @@ -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 */ diff --git a/harbour/include/hbapierr.h b/harbour/include/hbapierr.h index 5703dccac6..f2a0babcaa 100644 --- a/harbour/include/hbapierr.h +++ b/harbour/include/hbapierr.h @@ -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 ); diff --git a/harbour/include/hbapifs.h b/harbour/include/hbapifs.h index ccab88987e..db340b54ba 100644 --- a/harbour/include/hbapifs.h +++ b/harbour/include/hbapifs.h @@ -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, diff --git a/harbour/include/hbapiitm.h b/harbour/include/hbapiitm.h index a95fb10dee..5100cd4614 100644 --- a/harbour/include/hbapiitm.h +++ b/harbour/include/hbapiitm.h @@ -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 ); diff --git a/harbour/include/hbapirdd.h b/harbour/include/hbapirdd.h index 089da41322..1057fdc2ee 100644 --- a/harbour/include/hbapirdd.h +++ b/harbour/include/hbapirdd.h @@ -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, diff --git a/harbour/include/hbcomp.h b/harbour/include/hbcomp.h index c87309fbe6..fbcef4dc03 100644 --- a/harbour/include/hbcomp.h +++ b/harbour/include/hbcomp.h @@ -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 */ diff --git a/harbour/include/hbcompdf.h b/harbour/include/hbcompdf.h index e8c9ee75ed..75e2a31dd2 100644 --- a/harbour/include/hbcompdf.h +++ b/harbour/include/hbcompdf.h @@ -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 */ diff --git a/harbour/include/hbdefs.h b/harbour/include/hbdefs.h index 6c2e955b92..57dc12b692 100644 --- a/harbour/include/hbdefs.h +++ b/harbour/include/hbdefs.h @@ -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 diff --git a/harbour/include/hbexpra.c b/harbour/include/hbexpra.c index dfa434852a..4b41946004 100644 --- a/harbour/include/hbexpra.c +++ b/harbour/include/hbexpra.c @@ -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)); diff --git a/harbour/include/hbexprb.c b/harbour/include/hbexprb.c index 6b574c6baf..005f2304f6 100644 --- a/harbour/include/hbexprb.c +++ b/harbour/include/hbexprb.c @@ -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; diff --git a/harbour/include/hbexprop.h b/harbour/include/hbexprop.h index 114ec20c9a..5098e5a32f 100644 --- a/harbour/include/hbexprop.h +++ b/harbour/include/hbexprop.h @@ -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 ); diff --git a/harbour/include/hbgtcore.h b/harbour/include/hbgtcore.h index de17e5678c..e4cf84512e 100644 --- a/harbour/include/hbgtcore.h +++ b/harbour/include/hbgtcore.h @@ -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; diff --git a/harbour/include/hbhash.h b/harbour/include/hbhash.h index 1869663fc7..8d9db15a2c 100644 --- a/harbour/include/hbhash.h +++ b/harbour/include/hbhash.h @@ -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; diff --git a/harbour/include/hbinit.h b/harbour/include/hbinit.h index bfdc36ea2c..b22acf8fe8 100644 --- a/harbour/include/hbinit.h +++ b/harbour/include/hbinit.h @@ -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 ) diff --git a/harbour/include/hbmacro.h b/harbour/include/hbmacro.h index 36adef0853..d56e5ce4d7 100644 --- a/harbour/include/hbmacro.h +++ b/harbour/include/hbmacro.h @@ -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 */ diff --git a/harbour/include/hbpp.h b/harbour/include/hbpp.h index e795028e0e..589eb14269 100644 --- a/harbour/include/hbpp.h +++ b/harbour/include/hbpp.h @@ -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 ); diff --git a/harbour/include/hbrddcdx.h b/harbour/include/hbrddcdx.h index 61e566cc0b..5302c5b19e 100644 --- a/harbour/include/hbrddcdx.h +++ b/harbour/include/hbrddcdx.h @@ -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 */ diff --git a/harbour/include/hbrdddbf.h b/harbour/include/hbrdddbf.h index 6eee023b1a..15336fe771 100644 --- a/harbour/include/hbrdddbf.h +++ b/harbour/include/hbrdddbf.h @@ -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 ); diff --git a/harbour/include/hbrdddel.h b/harbour/include/hbrdddel.h index d46ffb96fb..88d8f6ac0e 100644 --- a/harbour/include/hbrdddel.h +++ b/harbour/include/hbrdddel.h @@ -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 */ diff --git a/harbour/include/hbrddfpt.h b/harbour/include/hbrddfpt.h index 29eb4f5966..da4b0d409c 100644 --- a/harbour/include/hbrddfpt.h +++ b/harbour/include/hbrddfpt.h @@ -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 */ diff --git a/harbour/include/hbrddnsx.h b/harbour/include/hbrddnsx.h index 5796cf14cf..8cc09f1e68 100644 --- a/harbour/include/hbrddnsx.h +++ b/harbour/include/hbrddnsx.h @@ -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; diff --git a/harbour/include/hbrddntx.h b/harbour/include/hbrddntx.h index 0a9b9d4f19..4cbda17f1b 100644 --- a/harbour/include/hbrddntx.h +++ b/harbour/include/hbrddntx.h @@ -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; diff --git a/harbour/include/hbrddsdf.h b/harbour/include/hbrddsdf.h index 12151005c6..0a2fff78f9 100644 --- a/harbour/include/hbrddsdf.h +++ b/harbour/include/hbrddsdf.h @@ -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 */ diff --git a/harbour/include/hbregex.h b/harbour/include/hbregex.h index 37911f9093..7e8037112e 100644 --- a/harbour/include/hbregex.h +++ b/harbour/include/hbregex.h @@ -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 diff --git a/harbour/include/hbstack.h b/harbour/include/hbstack.h index 106ee2cc53..26cce4fff6 100644 --- a/harbour/include/hbstack.h +++ b/harbour/include/hbstack.h @@ -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 ); diff --git a/harbour/include/hbthread.h b/harbour/include/hbthread.h index 4583e15019..fe517f8dd6 100644 --- a/harbour/include/hbthread.h +++ b/harbour/include/hbthread.h @@ -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 diff --git a/harbour/include/hbtypes.h b/harbour/include/hbtypes.h index 2ed14ee852..6c17bead99 100644 --- a/harbour/include/hbtypes.h +++ b/harbour/include/hbtypes.h @@ -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 diff --git a/harbour/include/hbvm.h b/harbour/include/hbvm.h index 283c076d2e..b219a619bc 100644 --- a/harbour/include/hbvm.h +++ b/harbour/include/hbvm.h @@ -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 diff --git a/harbour/include/hbvmpub.h b/harbour/include/hbvmpub.h index 1bce0aa7ed..3c5898af0a 100644 --- a/harbour/include/hbvmpub.h +++ b/harbour/include/hbvmpub.h @@ -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; diff --git a/harbour/src/common/expropt1.c b/harbour/src/common/expropt1.c index 593cc334cd..9026e302af 100644 --- a/harbour/src/common/expropt1.c +++ b/harbour/src/common/expropt1.c @@ -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; diff --git a/harbour/src/common/expropt2.c b/harbour/src/common/expropt2.c index a489dacf36..8666c02c6e 100644 --- a/harbour/src/common/expropt2.c +++ b/harbour/src/common/expropt2.c @@ -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 ) diff --git a/harbour/src/common/hbhash.c b/harbour/src/common/hbhash.c index e73729adcd..3a2723ce06 100644 --- a/harbour/src/common/hbhash.c +++ b/harbour/src/common/hbhash.c @@ -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; diff --git a/harbour/src/compiler/cmdcheck.c b/harbour/src/compiler/cmdcheck.c index 9e549ab047..ee47c8a037 100644 --- a/harbour/src/compiler/cmdcheck.c +++ b/harbour/src/compiler/cmdcheck.c @@ -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 { diff --git a/harbour/src/compiler/compi18n.c b/harbour/src/compiler/compi18n.c index 2f0f05ed82..b110832f34 100644 --- a/harbour/src/compiler/compi18n.c +++ b/harbour/src/compiler/compi18n.c @@ -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 ) { diff --git a/harbour/src/compiler/complex.c b/harbour/src/compiler/complex.c index e09f423f60..03f130c85c 100644 --- a/harbour/src/compiler/complex.c +++ b/harbour/src/compiler/complex.c @@ -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 ) diff --git a/harbour/src/compiler/genc.c b/harbour/src/compiler/genc.c index 5cd3d743d3..a8a52e26ba 100644 --- a/harbour/src/compiler/genc.c +++ b/harbour/src/compiler/genc.c @@ -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" ); diff --git a/harbour/src/compiler/gencc.c b/harbour/src/compiler/gencc.c index 75f6316a26..d19c20caa4 100644 --- a/harbour/src/compiler/gencc.c +++ b/harbour/src/compiler/gencc.c @@ -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 ); } diff --git a/harbour/src/compiler/genhrb.c b/harbour/src/compiler/genhrb.c index aea63ad446..d2e87a6d77 100644 --- a/harbour/src/compiler/genhrb.c +++ b/harbour/src/compiler/genhrb.c @@ -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; diff --git a/harbour/src/compiler/genobj32.c b/harbour/src/compiler/genobj32.c index 89d881fc42..2a30c04317 100644 --- a/harbour/src/compiler/genobj32.c +++ b/harbour/src/compiler/genobj32.c @@ -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; diff --git a/harbour/src/compiler/harbour.y b/harbour/src/compiler/harbour.y index c875e0e3ab..4e6b36a833 100644 --- a/harbour/src/compiler/harbour.y +++ b/harbour/src/compiler/harbour.y @@ -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 ) $3, - HB_COMP_PARAM->functions.pLast->lPCodePos - ( ULONG ) $3 ); - HB_COMP_PARAM->functions.pLast->lPCodePos = ( ULONG ) $3; + HB_COMP_PARAM->functions.pLast->pCode + ( HB_ULONG ) $3, + HB_COMP_PARAM->functions.pLast->lPCodePos - ( HB_ULONG ) $3 ); + HB_COMP_PARAM->functions.pLast->lPCodePos = ( HB_ULONG ) $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 ) $4, HB_COMP_PARAM ); + hb_compGenJumpHere( ( HB_ULONG ) $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 ) $9, HB_COMP_PARAM ); + hb_compGenJumpHere( ( HB_ULONG ) $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 ) $11 - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM ); + hb_compGenJumpFalse( ( HB_ULONG ) $11 - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM ); hb_compLoopEnd( HB_COMP_PARAM ); if( hb_compExprAsSymbol( $2 ) ) hb_compForEnd( HB_COMP_PARAM, hb_compExprAsSymbol( $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 ) $7 - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM ); + hb_compGenJump( ( HB_ULONG ) $7 - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM ); - hb_compGenJumpHere( ( ULONG ) $9, HB_COMP_PARAM ); + hb_compGenJumpHere( ( HB_ULONG ) $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( $3 ) hb_compGenPCode1( HB_P_POP, HB_COMP_PARAM ); - hb_compGenJumpHere( ( ULONG ) $2, HB_COMP_PARAM ); + hb_compGenJumpHere( ( HB_ULONG ) $2, HB_COMP_PARAM ); $$ = hb_compSequenceEnd( HB_COMP_PARAM ); $4 = hb_compLoopCount( HB_COMP_PARAM ); } @@ -1775,7 +1775,7 @@ BeginSeq : BEGINSEQ /* 1 */ * HB_P_SEQBEGIN opcode if there is RECOVER clause */ if( $7 ) - hb_compGenJumpThere( ( ULONG ) $2, ( ULONG ) $7, HB_COMP_PARAM ); + hb_compGenJumpThere( ( HB_ULONG ) $2, ( HB_ULONG ) $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 ) $6, ( ULONG ) $9, HB_COMP_PARAM ); + hb_compGenJumpThere( ( HB_ULONG ) $6, ( HB_ULONG ) $9, HB_COMP_PARAM ); /* Fix ALWAYS address in HB_P_SEQALWAYS opcode */ - hb_compGenJumpThere( ( ULONG ) $2 - 4, ( ULONG ) $9, HB_COMP_PARAM ); + hb_compGenJumpThere( ( HB_ULONG ) $2 - 4, ( HB_ULONG ) $9, HB_COMP_PARAM ); /* Fix ALWAYSEND address in HB_P_ALWAYSBEGIN opcode */ - hb_compGenJumpHere( ( ULONG ) $9 + 1, HB_COMP_PARAM ); + hb_compGenJumpHere( ( HB_ULONG ) $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 ) $6, HB_COMP_PARAM ); + hb_compGenJumpHere( ( HB_ULONG ) $6, HB_COMP_PARAM ); } - hb_compSequenceFinish( HB_COMP_PARAM, ( ULONG ) $2, ( ULONG ) $6, ( ULONG ) $9, + hb_compSequenceFinish( HB_COMP_PARAM, ( HB_ULONG ) $2, ( HB_ULONG ) $6, ( HB_ULONG ) $9, $5 != 0, $7 != 0, $4 == lLoopCount ); } EndSeqID /* 10 */ @@ -1918,7 +1918,7 @@ WithObject : WITHOBJECT Expression Crlf else { hb_compNOOPfill( HB_COMP_PARAM->functions.pLast, - ( ULONG ) $4, 1, HB_FALSE, HB_TRUE ); + ( HB_ULONG ) $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 diff --git a/harbour/src/compiler/harbour.yyc b/harbour/src/compiler/harbour.yyc index b17a1b9e5a..986dc536ac 100644 --- a/harbour/src/compiler/harbour.yyc +++ b/harbour/src/compiler/harbour.yyc @@ -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 diff --git a/harbour/src/compiler/hbcmplib.c b/harbour/src/compiler/hbcmplib.c index aae790c0e0..e78e0b3b4b 100644 --- a/harbour/src/compiler/hbcmplib.c +++ b/harbour/src/compiler/hbcmplib.c @@ -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 ) diff --git a/harbour/src/compiler/hbdbginf.c b/harbour/src/compiler/hbdbginf.c index 958cb849f7..2938de436c 100644 --- a/harbour/src/compiler/hbdbginf.c +++ b/harbour/src/compiler/hbdbginf.c @@ -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; diff --git a/harbour/src/compiler/hbdead.c b/harbour/src/compiler/hbdead.c index 5e098d2c11..69fbd79b8e 100644 --- a/harbour/src/compiler/hbdead.c +++ b/harbour/src/compiler/hbdead.c @@ -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 diff --git a/harbour/src/compiler/hbident.c b/harbour/src/compiler/hbident.c index ad7dcce897..810ccfd2a4 100644 --- a/harbour/src/compiler/hbident.c +++ b/harbour/src/compiler/hbident.c @@ -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 */ diff --git a/harbour/src/compiler/hblbl.c b/harbour/src/compiler/hblbl.c index 4972febcbd..710022d571 100644 --- a/harbour/src/compiler/hblbl.c +++ b/harbour/src/compiler/hblbl.c @@ -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 ) ); diff --git a/harbour/src/compiler/hbmain.c b/harbour/src/compiler/hbmain.c index 97e967e396..3786c238cd 100644 --- a/harbour/src/compiler/hbmain.c +++ b/harbour/src/compiler/hbmain.c @@ -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 ); diff --git a/harbour/src/compiler/hbopt.c b/harbour/src/compiler/hbopt.c index 22625b7701..0c5c08a669 100644 --- a/harbour/src/compiler/hbopt.c +++ b/harbour/src/compiler/hbopt.c @@ -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 ) { diff --git a/harbour/src/compiler/hbpcode.c b/harbour/src/compiler/hbpcode.c index 3196853ae8..a0fc58d619 100644 --- a/harbour/src/compiler/hbpcode.c +++ b/harbour/src/compiler/hbpcode.c @@ -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 */ diff --git a/harbour/src/compiler/ppcomp.c b/harbour/src/compiler/ppcomp.c index 19052a4b77..93e802807a 100644 --- a/harbour/src/compiler/ppcomp.c +++ b/harbour/src/compiler/ppcomp.c @@ -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; diff --git a/harbour/src/debug/dbgentry.c b/harbour/src/debug/dbgentry.c index 252d9be48c..d2761a6a64 100644 --- a/harbour/src/debug/dbgentry.c +++ b/harbour/src/debug/dbgentry.c @@ -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; diff --git a/harbour/src/macro/macrolex.c b/harbour/src/macro/macrolex.c index ccc62faaaa..72b271af7a 100644 --- a/harbour/src/macro/macrolex.c +++ b/harbour/src/macro/macrolex.c @@ -61,8 +61,8 @@ typedef struct _HB_MACRO_LEX { char * pString; char * pDst; - ULONG ulLen; - ULONG ulSrc; + HB_SIZE ulLen; + HB_SIZE ulSrc; HB_BOOL quote; char pBuffer[ 2 ]; } @@ -209,7 +209,7 @@ static int hb_lexStringCopy( YYSTYPE *yylval_ptr, HB_MACRO_PTR pMacro, static int hb_lexStringExtCopy( YYSTYPE *yylval_ptr, HB_MACRO_PTR pMacro, PHB_MACRO_LEX pLex ) { - ULONG ulLen; + HB_SIZE ulLen; pLex->quote = HB_FALSE; yylval_ptr->valChar.string = pLex->pDst; while( pLex->ulSrc < pLex->ulLen ) @@ -241,7 +241,7 @@ static int hb_lexStringExtCopy( YYSTYPE *yylval_ptr, HB_MACRO_PTR pMacro, return LITERAL; } -static int hb_lexNumConv( YYSTYPE *yylval_ptr, PHB_MACRO_LEX pLex, ULONG ulLen ) +static int hb_lexNumConv( YYSTYPE *yylval_ptr, PHB_MACRO_LEX pLex, HB_SIZE ulLen ) { HB_MAXINT lNumber; double dNumber; @@ -441,7 +441,7 @@ int hb_macrolex( YYSTYPE *yylval_ptr, HB_MACRO_PTR pMacro ) if( pLex->ulSrc < pLex->ulLen && HB_ISDIGIT( pLex->pString[ pLex->ulSrc ] ) ) { - ULONG ul = pLex->ulSrc; + HB_SIZE ul = pLex->ulSrc; while( ++ul < pLex->ulLen && HB_ISDIGIT( pLex->pString[ ul ] ) ) {}; ul -= --pLex->ulSrc; @@ -566,7 +566,7 @@ int hb_macrolex( YYSTYPE *yylval_ptr, HB_MACRO_PTR pMacro ) default: if( HB_ISDIGIT( ch ) ) { - ULONG ul = pLex->ulSrc; + HB_SIZE ul = pLex->ulSrc; pLex->quote = HB_FALSE; if( ch == '0' && ul < pLex->ulLen ) @@ -636,7 +636,7 @@ int hb_macrolex( YYSTYPE *yylval_ptr, HB_MACRO_PTR pMacro ) } else if( HB_ISFIRSTIDCHAR( ch ) ) { - ULONG ulLen; + HB_SIZE ulLen; pLex->quote = HB_FALSE; yylval_ptr->string = pLex->pDst; *pLex->pDst++ = ch - ( ( ch >= 'a' && ch <= 'z' ) ? 'a' - 'A' : 0 ); @@ -746,7 +746,7 @@ int hb_macrolex( YYSTYPE *yylval_ptr, HB_MACRO_PTR pMacro ) if( pLex->ulSrc < pLex->ulLen && pLex->pString[ pLex->ulSrc ] == '(' ) { - ULONG ul = pLex->ulSrc; + HB_SIZE ul = pLex->ulSrc; while( ++ul < pLex->ulLen ) { if( pLex->pString[ ul ] == ')' ) diff --git a/harbour/src/nortl/nortl.c b/harbour/src/nortl/nortl.c index ed3935fc23..4c5737ec20 100644 --- a/harbour/src/nortl/nortl.c +++ b/harbour/src/nortl/nortl.c @@ -80,8 +80,8 @@ typedef struct _HB_MEMINFO { struct _HB_MEMINFO * pPrevBlock; struct _HB_MEMINFO * pNextBlock; - ULONG ulSize; - HB_U32 Signature; + HB_SIZE ulSize; + HB_U32 Signature; } HB_MEMINFO, * PHB_MEMINFO; #ifdef HB_ALLOC_ALIGNMENT @@ -99,7 +99,7 @@ static long s_ulMemoryConsumed = 0; /* memory max size consumed */ #endif /* HB_FM_STATISTICS */ -void * hb_xgrab( ULONG ulSize ) /* allocates fixed memory, exits on failure */ +void * hb_xgrab( HB_SIZE ulSize ) /* allocates fixed memory, exits on failure */ { void * pMem; @@ -137,11 +137,11 @@ void * hb_xgrab( ULONG ulSize ) /* allocates fixed memory, exits on failu return pMem; } -void * hb_xrealloc( void * pMem, ULONG ulSize ) /* reallocates memory */ +void * hb_xrealloc( void * pMem, HB_SIZE ulSize ) /* reallocates memory */ { #ifdef HB_FM_STATISTICS PHB_MEMINFO pMemBlock; - ULONG ulMemSize; + HB_SIZE ulMemSize; void * pResult; if( ulSize == 0 ) @@ -226,9 +226,9 @@ void hb_xfree( void * pMem ) /* frees fixed memory */ hb_errInternal( HB_EI_XFREENULL, "hb_xfree called with a NULL pointer", NULL, NULL ); } -ULONG hb_xquery( int iMode ) +HB_ULONG hb_xquery( int iMode ) { - ULONG ulResult = 0; + HB_ULONG ulResult = 0; #ifdef HB_FM_STATISTICS switch( iMode ) @@ -248,7 +248,7 @@ ULONG hb_xquery( int iMode ) } #ifdef HB_FM_STATISTICS -static char * hb_memToStr( char * szBuffer, void * pMem, ULONG ulSize ) +static char * hb_memToStr( char * szBuffer, void * pMem, HB_SIZE ulSize ) { unsigned char * byMem = ( HB_BYTE * ) pMem; char * pDest = szBuffer; @@ -349,7 +349,7 @@ void hb_errInternal( HB_ERRCODE errCode, const char * szText, const char * szPar } /* console */ -void hb_conOutErr( const char * pStr, ULONG ulLen ) +void hb_conOutErr( const char * pStr, HB_SIZE ulLen ) { if( ulLen == 0 ) ulLen = strlen( pStr ); @@ -372,14 +372,14 @@ int hb_charLower( int iChar ) return HB_TOLOWER( iChar ); } -const char * hb_osEncodeCP( const char * szName, char ** pszFree, ULONG * pulSize ) +const char * hb_osEncodeCP( const char * szName, char ** pszFree, HB_SIZE * pulSize ) { HB_SYMBOL_UNUSED( pulSize ); HB_SYMBOL_UNUSED( pszFree ); return szName; } -const char * hb_osDecodeCP( const char * szName, char ** pszFree, ULONG * pulSize ) +const char * hb_osDecodeCP( const char * szName, char ** pszFree, HB_SIZE * pulSize ) { HB_SYMBOL_UNUSED( pulSize ); HB_SYMBOL_UNUSED( pszFree ); @@ -429,7 +429,7 @@ const char * hb_fsNameConv( const char * szFileName, char ** pszFree ) s_iFileCase != HB_SET_CASE_MIXED || s_iDirCase != HB_SET_CASE_MIXED ) { PHB_FNAME pFileName; - ULONG ulLen; + HB_SIZE ulLen; if( pszFree ) { diff --git a/harbour/src/pp/hbpp.c b/harbour/src/pp/hbpp.c index cc4dd96061..05c0d841d6 100644 --- a/harbour/src/pp/hbpp.c +++ b/harbour/src/pp/hbpp.c @@ -129,7 +129,7 @@ static void hb_pp_writeTokenList( FILE * fout, PHB_PP_TOKEN pTokenLst, const cha static int hb_pp_writeRules( FILE * fout, PHB_PP_RULE pFirst, const char * szName ) { char szMatch[ 16 ], szResult[ 16 ]; - ULONG ulRepeatBits, ulBit; + HB_ULONG ulRepeatBits, ulBit; PHB_PP_RULE pRule; int iRule; HB_USHORT u; @@ -265,7 +265,7 @@ static void hb_pp_undefCompilerRules( PHB_PP_STATE pState ) static int hb_pp_preprocesfile( PHB_PP_STATE pState, const char * szRuleFile ) { int iResult = 0; - ULONG ulLen; + HB_SIZE ulLen; while( hb_pp_nextLine( pState, &ulLen ) != NULL && ulLen ) {}; diff --git a/harbour/src/pp/ppcore.c b/harbour/src/pp/ppcore.c index e8edbafa35..8b2f11ce04 100644 --- a/harbour/src/pp/ppcore.c +++ b/harbour/src/pp/ppcore.c @@ -264,7 +264,7 @@ static void hb_pp_operatorsFree( PHB_PP_OPERATOR pOperators, int iOperators ) } static const HB_PP_OPERATOR * hb_pp_operatorFind( PHB_PP_STATE pState, - char * buffer, ULONG ulLen ) + char * buffer, HB_SIZE ulLen ) { const HB_PP_OPERATOR * pOperator = pState->pOperators; int i = pState->iOperators; @@ -319,14 +319,14 @@ static void hb_membufFlush( PHB_MEM_BUFFER pBuffer ) } #ifdef HB_PP_MULTILINE_STRING -static void hb_membufRemove( PHB_MEM_BUFFER pBuffer, ULONG ulLeft ) +static void hb_membufRemove( PHB_MEM_BUFFER pBuffer, HB_SIZE ulLeft ) { if( ulLeft < pBuffer->ulLen ) pBuffer->ulLen = ulLeft; } #endif -static ULONG hb_membufLen( const PHB_MEM_BUFFER pBuffer ) +static HB_SIZE hb_membufLen( const PHB_MEM_BUFFER pBuffer ) { return pBuffer->ulLen; } @@ -346,7 +346,7 @@ static void hb_membufAddCh( PHB_MEM_BUFFER pBuffer, char ch ) pBuffer->pBufPtr[ pBuffer->ulLen++ ] = ch; } -static void hb_membufAddData( PHB_MEM_BUFFER pBuffer, const char * data, ULONG ulLen ) +static void hb_membufAddData( PHB_MEM_BUFFER pBuffer, const char * data, HB_SIZE ulLen ) { if( pBuffer->ulLen + ulLen > pBuffer->ulAllocated ) { @@ -458,7 +458,7 @@ static PHB_PP_TOKEN hb_pp_tokenResultEnd( PHB_PP_TOKEN * pTokenPtr, HB_BOOL fDir return pNext; } -static PHB_PP_TOKEN hb_pp_tokenNew( const char * value, ULONG ulLen, +static PHB_PP_TOKEN hb_pp_tokenNew( const char * value, HB_SIZE ulLen, int iSpaces, HB_USHORT type ) { PHB_PP_TOKEN pToken = ( PHB_PP_TOKEN ) hb_xgrab( sizeof( HB_PP_TOKEN ) ); @@ -492,7 +492,7 @@ static PHB_PP_TOKEN hb_pp_tokenNew( const char * value, ULONG ulLen, } static void hb_pp_tokenSetValue( PHB_PP_TOKEN pToken, - const char * value, ULONG ulLen ) + const char * value, HB_SIZE ulLen ) { if( HB_PP_TOKEN_ALLOC( pToken->type ) ) hb_xfree( ( void * ) pToken->value ); @@ -527,7 +527,7 @@ static PHB_PP_TOKEN hb_pp_tokenClone( PHB_PP_TOKEN pSource ) } static void hb_pp_tokenAdd( PHB_PP_TOKEN ** pTokenPtr, - const char * value, ULONG ulLen, + const char * value, HB_SIZE ulLen, int iSpaces, HB_USHORT type ) { PHB_PP_TOKEN pToken = hb_pp_tokenNew( value, ulLen, iSpaces, type ); @@ -549,7 +549,7 @@ static void hb_pp_tokenAddCmdSep( PHB_PP_STATE pState ) } } -static void hb_pp_tokenAddNext( PHB_PP_STATE pState, const char * value, ULONG ulLen, +static void hb_pp_tokenAddNext( PHB_PP_STATE pState, const char * value, HB_SIZE ulLen, HB_USHORT type ) { if( pState->fCanNextLine ) @@ -631,7 +631,7 @@ static void hb_pp_tokenAddNext( PHB_PP_STATE pState, const char * value, ULONG u } static void hb_pp_tokenAddStreamFunc( PHB_PP_STATE pState, PHB_PP_TOKEN pToken, - const char * value, ULONG ulLen ) + const char * value, HB_SIZE ulLen ) { while( pToken ) { @@ -714,8 +714,8 @@ static void hb_pp_readLine( PHB_PP_STATE pState ) } } -static HB_BOOL hb_pp_canQuote( HB_BOOL fQuote, char * pBuffer, ULONG ulLen, - ULONG ul, ULONG * pulAt ) +static HB_BOOL hb_pp_canQuote( HB_BOOL fQuote, char * pBuffer, HB_SIZE ulLen, + HB_SIZE ul, HB_SIZE * pulAt ) { char cQuote = 0; @@ -729,7 +729,7 @@ static HB_BOOL hb_pp_canQuote( HB_BOOL fQuote, char * pBuffer, ULONG ulLen, { if( cQuote && !fQuote ) { - ULONG u = ul + 1; + HB_SIZE u = ul + 1; cQuote = 0; while( u < ulLen ) { @@ -769,9 +769,9 @@ static HB_BOOL hb_pp_canQuote( HB_BOOL fQuote, char * pBuffer, ULONG ulLen, return HB_FALSE; } -static HB_BOOL hb_pp_hasCommand( char * pBuffer, ULONG ulLen, ULONG * pulAt, int iCmds, ... ) +static HB_BOOL hb_pp_hasCommand( char * pBuffer, HB_SIZE ulLen, HB_SIZE * pulAt, int iCmds, ... ) { - ULONG ul = 0, u; + HB_SIZE ul = 0, u; char * cmd; va_list va; int i; @@ -837,7 +837,7 @@ static void hb_pp_dumpEnd( PHB_PP_STATE pState ) { int iLines = 0; char * pBuffer; - ULONG ulLen; + HB_SIZE ulLen; if( pState->pFile->fGenLineInfo ) { @@ -877,7 +877,7 @@ static void hb_pp_getLine( PHB_PP_STATE pState ) { PHB_PP_TOKEN * pInLinePtr; char * pBuffer, ch; - ULONG ulLen, ul; + HB_SIZE ulLen, ul; HB_BOOL fDump = HB_FALSE; int iLines = 0; @@ -1101,7 +1101,7 @@ static void hb_pp_getLine( PHB_PP_STATE pState ) else if( ( ( ch == 'e' || ch == 'E' ) && ulLen > 1 && pBuffer[ 1 ] == '"' ) || ( ch == '"' && pState->fEscStr ) ) { - ULONG ulStrip, u; + HB_SIZE ulStrip, u; if( ch != '"' ) ++ul; @@ -1148,7 +1148,7 @@ static void hb_pp_getLine( PHB_PP_STATE pState ) HB_PP_TOKEN_STRING ); if( ul == ulLen ) { - ULONG ulSkip = pBuffer - hb_membufPtr( pState->pBuffer ); + HB_SIZE ulSkip = pBuffer - hb_membufPtr( pState->pBuffer ); hb_membufAddCh( pState->pBuffer, '\0' ); pBuffer = hb_membufPtr( pState->pBuffer ) + ulSkip; hb_pp_error( pState, 'E', HB_PP_ERR_STRING_TERMINATOR, pBuffer + u - 1 ); @@ -1164,7 +1164,7 @@ static void hb_pp_getLine( PHB_PP_STATE pState ) HB_PP_TOKEN_TIMESTAMP ); if( ul == ulLen ) { - ULONG ulSkip = pBuffer - hb_membufPtr( pState->pBuffer ) + 1; + HB_SIZE ulSkip = pBuffer - hb_membufPtr( pState->pBuffer ) + 1; hb_membufAddCh( pState->pBuffer, '\0' ); pBuffer = hb_membufPtr( pState->pBuffer ) + ulSkip; hb_pp_error( pState, 'E', HB_PP_ERR_STRING_TERMINATOR, pBuffer ); @@ -1180,7 +1180,7 @@ static void hb_pp_getLine( PHB_PP_STATE pState ) HB_PP_TOKEN_DATE ); if( ul == ulLen ) { - ULONG ulSkip = pBuffer - hb_membufPtr( pState->pBuffer ) + 1; + HB_SIZE ulSkip = pBuffer - hb_membufPtr( pState->pBuffer ) + 1; hb_membufAddCh( pState->pBuffer, '\0' ); pBuffer = hb_membufPtr( pState->pBuffer ) + ulSkip; hb_pp_error( pState, 'E', HB_PP_ERR_STRING_TERMINATOR, pBuffer ); @@ -1197,7 +1197,7 @@ static void hb_pp_getLine( PHB_PP_STATE pState ) #ifdef HB_PP_MULTILINE_STRING while( ul == ulLen ) { - ULONG u = 1; + HB_SIZE u = 1; while( ul > u && pBuffer[ ul - u ] == ' ' ) ++u; if( ul >= u && pBuffer[ ul - u ] == ';' ) { @@ -1222,7 +1222,7 @@ static void hb_pp_getLine( PHB_PP_STATE pState ) HB_PP_TOKEN_STRING ); if( ul == ulLen ) { - ULONG ulSkip = pBuffer - hb_membufPtr( pState->pBuffer ) + 1; + HB_SIZE ulSkip = pBuffer - hb_membufPtr( pState->pBuffer ) + 1; hb_membufAddCh( pState->pBuffer, '\0' ); pBuffer = hb_membufPtr( pState->pBuffer ) + ulSkip; hb_pp_error( pState, 'E', HB_PP_ERR_STRING_TERMINATOR, pBuffer ); @@ -1955,7 +1955,7 @@ static PHB_PP_FILE hb_pp_FileNew( PHB_PP_STATE pState, const char * szFileName, return pFile; } -static PHB_PP_FILE hb_pp_FileBufNew( const char * pLineBuf, ULONG ulLineBufLen ) +static PHB_PP_FILE hb_pp_FileBufNew( const char * pLineBuf, HB_SIZE ulLineBufLen ) { PHB_PP_FILE pFile; @@ -2139,7 +2139,7 @@ static void hb_pp_pragmaStreamFile( PHB_PP_STATE pState, const char * szFileName if( pFile ) { char * pBuffer = ( char * ) hb_xgrab( MAX_STREAM_SIZE + 1 ); - ULONG ulSize; + HB_SIZE ulSize; if( ! pState->pStreamBuffer ) pState->pStreamBuffer = hb_membufNew(); @@ -2188,7 +2188,7 @@ static HB_BOOL hb_pp_pragmaOperatorNew( PHB_PP_STATE pState, PHB_PP_TOKEN pToken if( !HB_PP_TOKEN_ISEOC( pToken ) && HB_PP_TOKEN_CANJOIN( pToken->type ) ) { - ULONG ulLen; + HB_SIZE ulLen; hb_membufFlush( pState->pBuffer ); do @@ -2211,7 +2211,7 @@ static HB_BOOL hb_pp_pragmaOperatorNew( PHB_PP_STATE pState, PHB_PP_TOKEN pToken { PHB_PP_OPERATOR pOperator; char * pBuffer = hb_membufPtr( pState->pBuffer ), * pDstBuffer; - ULONG ulDstLen = hb_membufLen( pState->pBuffer ) - ulLen; + HB_SIZE ulDstLen = hb_membufLen( pState->pBuffer ) - ulLen; if( ulDstLen ) pDstBuffer = pBuffer + ulLen; @@ -4310,7 +4310,7 @@ static void hb_pp_processCondDefined( PHB_PP_STATE pState, PHB_PP_TOKEN pToken ) if( szValue ) { - hb_pp_tokenSetValue( pToken, szValue, ( ULONG ) strlen( szValue ) ); + hb_pp_tokenSetValue( pToken, szValue, ( HB_SIZE ) strlen( szValue ) ); HB_PP_TOKEN_SETTYPE( pToken, HB_PP_TOKEN_NUMBER ); pToken->pNext = pNext->pNext->pNext->pNext; pNext->pNext->pNext->pNext = NULL; @@ -5257,7 +5257,7 @@ void hb_pp_initRules( PHB_PP_RULE * pRulesPtr, int * piRules, if( pDefRule->markers > 0 ) { HB_USHORT marker; - ULONG ulBit; + HB_ULONG ulBit; pMarkers = ( PHB_PP_MARKER ) hb_xgrab( pDefRule->markers * sizeof( HB_PP_MARKER ) ); memset( pMarkers, '\0', pDefRule->markers * sizeof( HB_PP_MARKER ) ); @@ -5575,7 +5575,7 @@ void hb_pp_readRules( PHB_PP_STATE pState, const char * szRulesFile ) /* * close all open input files and set the given buffer as input stream */ -HB_BOOL hb_pp_inBuffer( PHB_PP_STATE pState, const char * pBuffer, ULONG ulLen ) +HB_BOOL hb_pp_inBuffer( PHB_PP_STATE pState, const char * pBuffer, HB_SIZE ulLen ) { hb_pp_InFileFree( pState ); @@ -5838,7 +5838,7 @@ void hb_pp_setStream( PHB_PP_STATE pState, int iMode ) /* * return next preprocessed line */ -char * hb_pp_nextLine( PHB_PP_STATE pState, ULONG * pulLen ) +char * hb_pp_nextLine( PHB_PP_STATE pState, HB_SIZE * pulLen ) { if( pState->pFile ) { @@ -5881,13 +5881,13 @@ char * hb_pp_nextLine( PHB_PP_STATE pState, ULONG * pulLen ) /* * preprocess given buffer */ -char * hb_pp_parseLine( PHB_PP_STATE pState, const char * pLine, ULONG * pulLen ) +char * hb_pp_parseLine( PHB_PP_STATE pState, const char * pLine, HB_SIZE * pulLen ) { PHB_PP_TOKEN pToken; PHB_PP_FILE pFile; HB_BOOL fError = HB_FALSE; HB_USHORT ltype; - ULONG ulLen; + HB_SIZE ulLen; if( !pState->pOutputBuffer ) pState->pOutputBuffer = hb_membufNew(); @@ -5937,7 +5937,7 @@ char * hb_pp_parseLine( PHB_PP_STATE pState, const char * pLine, ULONG * pulLen /* * create new PP context for macro compiler */ -PHB_PP_STATE hb_pp_lexNew( const char * pMacroString, ULONG ulLen ) +PHB_PP_STATE hb_pp_lexNew( const char * pMacroString, HB_SIZE ulLen ) { PHB_PP_STATE pState = hb_pp_new(); diff --git a/harbour/src/rdd/dbcmd.c b/harbour/src/rdd/dbcmd.c index aa14fa24e0..be58dc4142 100644 --- a/harbour/src/rdd/dbcmd.c +++ b/harbour/src/rdd/dbcmd.c @@ -338,7 +338,7 @@ HB_FUNC( DBCREATE ) HB_USHORT uiSize, uiLen; PHB_ITEM pStruct, pFieldDesc, pDelim; HB_BOOL fKeepOpen, fCurrArea; - ULONG ulConnection; + HB_ULONG ulConnection; /* * NOTE: 4-th, 5-th and 6-th parameters are undocumented Clipper ones @@ -406,7 +406,7 @@ HB_FUNC( HB_DBCREATETEMP ) const char * szAlias, * szDriver, * szCpId; HB_USHORT uiSize, uiLen; PHB_ITEM pStruct, pFieldDesc; - ULONG ulConnection; + HB_ULONG ulConnection; szAlias = hb_parc( 1 ); pStruct = hb_param( 2, HB_IT_ARRAY ); @@ -465,7 +465,7 @@ HB_FUNC( __DBOPENSDF ) HB_USHORT uiSize, uiLen; PHB_ITEM pStruct, pFieldDesc, pDelim; HB_BOOL fKeepOpen, fCurrArea; - ULONG ulConnection; + HB_ULONG ulConnection; HB_ERRCODE errCode; /* @@ -1071,7 +1071,7 @@ HB_FUNC( INDEXORD ) /* Same as RECCOUNT() */ HB_FUNC( LASTREC ) { - ULONG ulRecCount = 0; + HB_ULONG ulRecCount = 0; AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer(); if( pArea ) @@ -1822,7 +1822,7 @@ HB_FUNC( __DBARRANGE ) if( pArea ) { HB_USHORT uiNewArea, uiCount, uiDest; - ULONG ulSize; + HB_SIZE ulSize; char * szFieldLine, * szPos; PHB_ITEM pStruct, pFields; DBSORTINFO dbSortInfo; @@ -1889,7 +1889,7 @@ HB_FUNC( __DBARRANGE ) ulSize = 0; for( uiCount = 1; uiCount <= dbSortInfo.uiItemCount; ++uiCount ) { - ULONG ulLine = hb_arrayGetCLen( pFields, uiCount ); + HB_SIZE ulLine = hb_arrayGetCLen( pFields, uiCount ); if( ulLine > ulSize ) ulSize = ulLine; } @@ -2070,15 +2070,14 @@ HB_FUNC( HB_RDDINFO ) { LPRDDNODE pRDDNode; HB_USHORT uiRddID; - ULONG ulConnection; + HB_ULONG ulConnection; PHB_ITEM pIndex, pParam; const char * szDriver; szDriver = hb_parc( 3 ); if( !szDriver ) /* no VIA RDD parameter, use default */ - { szDriver = hb_rddDefaultDrv( NULL ); - } + ulConnection = hb_parnl( 4 ); pRDDNode = hb_rddFindNode( szDriver, &uiRddID ); /* find the RDDNODE */ @@ -2092,16 +2091,14 @@ HB_FUNC( HB_RDDINFO ) hb_itemReturnRelease( pInfo ); } else - { hb_errRT_DBCMD( EG_ARG, EDBCMD_EVAL_BADPARAMETER, NULL, HB_ERR_FUNCNAME ); - } } HB_FUNC( HB_DBDROP ) { LPRDDNODE pRDDNode; HB_USHORT uiRddID; - ULONG ulConnection; + HB_ULONG ulConnection; const char * szDriver; PHB_ITEM pName; @@ -2126,15 +2123,14 @@ HB_FUNC( HB_DBEXISTS ) { LPRDDNODE pRDDNode; HB_USHORT uiRddID; - ULONG ulConnection; + HB_ULONG ulConnection; const char * szDriver; PHB_ITEM pName; szDriver = hb_parc( 3 ); if( !szDriver ) /* no VIA RDD parameter, use default */ - { szDriver = hb_rddDefaultDrv( NULL ); - } + ulConnection = hb_parnl( 4 ); pRDDNode = hb_rddFindNode( szDriver, &uiRddID ); /* find the RDD */ @@ -2151,15 +2147,14 @@ HB_FUNC( HB_DBRENAME ) { LPRDDNODE pRDDNode; HB_USHORT uiRddID; - ULONG ulConnection; + HB_ULONG ulConnection; const char * szDriver; PHB_ITEM pTable, pIndex, pNewName; szDriver = hb_parc( 4 ); if( !szDriver ) /* no VIA RDD parameter, use default */ - { szDriver = hb_rddDefaultDrv( NULL ); - } + ulConnection = hb_parnl( 5 ); pRDDNode = hb_rddFindNode( szDriver, &uiRddID ); /* find the RDDNODE */ diff --git a/harbour/src/rdd/dbcmdx.c b/harbour/src/rdd/dbcmdx.c index 0da4cf8ccd..382c422e3f 100644 --- a/harbour/src/rdd/dbcmdx.c +++ b/harbour/src/rdd/dbcmdx.c @@ -134,7 +134,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 ) { diff --git a/harbour/src/rdd/dbf1.c b/harbour/src/rdd/dbf1.c index e62af8e8f5..4b1d06cd21 100644 --- a/harbour/src/rdd/dbf1.c +++ b/harbour/src/rdd/dbf1.c @@ -207,7 +207,7 @@ static void hb_dbfUpdateStampFields( DBFAREAP pArea ) static void hb_dbfSetBlankRecord( DBFAREAP pArea, int iType ) { HB_BYTE * pPtr = pArea->pRecord, bFill = ' ', bNext; - ULONG ulSize = 1; /* 1 byte ' ' for DELETE flag */ + HB_SIZE ulSize = 1; /* 1 byte ' ' for DELETE flag */ HB_USHORT uiCount; LPFIELD pField; @@ -341,8 +341,8 @@ static void hb_dbfSetBlankRecord( DBFAREAP pArea, int iType ) memset( pPtr, bFill, ulSize ); ulSize += pPtr - pArea->pRecord; - if( ulSize < ( ULONG ) pArea->uiRecordLen ) - memset( pArea->pRecord + ulSize, '\0', ( ULONG ) pArea->uiRecordLen - ulSize ); + if( ulSize < ( HB_SIZE ) pArea->uiRecordLen ) + memset( pArea->pRecord + ulSize, '\0', ( HB_SIZE ) pArea->uiRecordLen - ulSize ); /* set varlength and nullable bits in _NullFlags */ if( pArea->uiNullCount ) @@ -358,7 +358,7 @@ static void hb_dbfAllocNullFlag( DBFAREAP pArea, HB_USHORT uiField, HB_BOOL fLen { if( !pArea->pFieldBits ) { - ULONG ulSize = sizeof( HB_DBFFIELDBITS ) * pArea->area.uiFieldExtent; + HB_SIZE ulSize = sizeof( HB_DBFFIELDBITS ) * pArea->area.uiFieldExtent; pArea->pFieldBits = ( PHB_DBFFIELDBITS ) memset( hb_xgrab( ulSize ), 0, ulSize ); } if( fLength ) @@ -447,15 +447,15 @@ static void hb_dbfTriggerSet( DBFAREAP pArea, PHB_ITEM pTrigger ) /* * Return the total number of records. */ -static ULONG hb_dbfCalcRecCount( DBFAREAP pArea ) +static HB_ULONG hb_dbfCalcRecCount( DBFAREAP pArea ) { HB_TRACE(HB_TR_DEBUG, ("hb_dbfCalcRecCount(%p)", pArea)); if( ! pArea->pDataFile ) return 0; else - return ( ULONG ) ( ( hb_fileSize( pArea->pDataFile ) - - pArea->uiHeaderLen ) / pArea->uiRecordLen ); + return ( HB_ULONG ) ( ( hb_fileSize( pArea->pDataFile ) - + pArea->uiHeaderLen ) / pArea->uiRecordLen ); } /* @@ -489,7 +489,7 @@ static HB_BOOL hb_dbfReadRecord( DBFAREAP pArea ) ( HB_FOFFSET ) pArea->uiHeaderLen + ( HB_FOFFSET ) ( pArea->ulRecNo - 1 ) * ( HB_FOFFSET ) pArea->uiRecordLen ) != - ( ULONG ) pArea->uiRecordLen ) + ( HB_SIZE ) pArea->uiRecordLen ) { hb_dbfErrorRT( pArea, EG_READ, EDBF_READ, pArea->szDataFileName, hb_fsError(), 0, NULL ); @@ -526,7 +526,7 @@ static HB_BOOL hb_dbfWriteRecord( DBFAREAP pArea ) static HB_BOOL hb_dbfPasswordSet( DBFAREAP pArea, PHB_ITEM pPasswd, HB_BOOL fRaw ) { char pKeyBuffer[ 8 ]; - ULONG ulLen; + HB_SIZE ulLen; HB_BOOL fKeySet = HB_FALSE, fSet; HB_TRACE(HB_TR_DEBUG, ("hb_dbfPasswordSet(%p,%p,%d)", pArea, pPasswd, fRaw)); @@ -600,7 +600,7 @@ static void hb_dbfTableCrypt( DBFAREAP pArea, PHB_ITEM pPasswd, HB_BOOL fEncrypt fEncrypt ? !pArea->fTableEncrypted && !pArea->fHasMemo : pArea->fTableEncrypted ) { - ULONG ulRecords, ulRecNo; + HB_ULONG ulRecords, ulRecNo; if( SELF_RECCOUNT( ( AREAP ) pArea, &ulRecords ) == HB_SUCCESS ) { @@ -669,7 +669,7 @@ static HB_ERRCODE hb_dbfUnlockAllRecords( DBFAREAP pArea ) if( pArea->pLocksPos ) { - ULONG ulCount; + HB_ULONG ulCount; errCode = SELF_GOCOLD( ( AREAP ) pArea ); for( ulCount = 0; ulCount < pArea->ulNumLocksPos; ulCount++ ) @@ -684,10 +684,10 @@ static HB_ERRCODE hb_dbfUnlockAllRecords( DBFAREAP pArea ) /* * Unlock a records. */ -static HB_ERRCODE hb_dbfUnlockRecord( DBFAREAP pArea, ULONG ulRecNo ) +static HB_ERRCODE hb_dbfUnlockRecord( DBFAREAP pArea, HB_ULONG ulRecNo ) { HB_ERRCODE errCode = HB_SUCCESS; - ULONG ulCount, * pList; + HB_ULONG ulCount, * pList; HB_TRACE(HB_TR_DEBUG, ("hb_dbfUnlockRecord(%p, %lu)", pArea, ulRecNo)); @@ -709,10 +709,10 @@ static HB_ERRCODE hb_dbfUnlockRecord( DBFAREAP pArea, ULONG ulRecNo ) { pList = pArea->pLocksPos + ulCount; memmove( pList, pList + 1, ( pArea->ulNumLocksPos - ulCount - 1 ) * - sizeof( ULONG ) ); - pArea->pLocksPos = ( ULONG * ) hb_xrealloc( pArea->pLocksPos, - ( pArea->ulNumLocksPos - 1 ) * - sizeof( ULONG ) ); + sizeof( HB_ULONG ) ); + pArea->pLocksPos = ( HB_ULONG * ) hb_xrealloc( pArea->pLocksPos, + ( pArea->ulNumLocksPos - 1 ) * + sizeof( HB_ULONG ) ); pArea->ulNumLocksPos --; } } @@ -722,7 +722,7 @@ static HB_ERRCODE hb_dbfUnlockRecord( DBFAREAP pArea, ULONG ulRecNo ) /* * Lock a record. */ -static HB_ERRCODE hb_dbfLockRecord( DBFAREAP pArea, ULONG ulRecNo, HB_USHORT * pResult, +static HB_ERRCODE hb_dbfLockRecord( DBFAREAP pArea, HB_ULONG ulRecNo, HB_USHORT * pResult, HB_BOOL bExclusive ) { HB_TRACE(HB_TR_DEBUG, ("hb_dbfLockRecord(%p, %lu, %p, %i)", pArea, ulRecNo, @@ -749,7 +749,7 @@ static HB_ERRCODE hb_dbfLockRecord( DBFAREAP pArea, ULONG ulRecNo, HB_USHORT * p } else if( pArea->ulNumLocksPos > 0 ) { - ULONG ul; + HB_ULONG ul; for( ul = 0; ul < pArea->ulNumLocksPos; ul++ ) { if( pArea->pLocksPos[ ul ] == ulRecNo ) @@ -764,13 +764,13 @@ static HB_ERRCODE hb_dbfLockRecord( DBFAREAP pArea, ULONG ulRecNo, HB_USHORT * p { if( pArea->ulNumLocksPos == 0 ) /* Create the list */ { - pArea->pLocksPos = ( ULONG * ) hb_xgrab( sizeof( ULONG ) ); + pArea->pLocksPos = ( HB_ULONG * ) hb_xgrab( sizeof( HB_ULONG ) ); } else /* Resize the list */ { - pArea->pLocksPos = ( ULONG * ) hb_xrealloc( pArea->pLocksPos, - ( pArea->ulNumLocksPos + 1 ) * - sizeof( ULONG ) ); + pArea->pLocksPos = ( HB_ULONG * ) hb_xrealloc( pArea->pLocksPos, + ( pArea->ulNumLocksPos + 1 ) * + sizeof( HB_ULONG ) ); } pArea->pLocksPos[ pArea->ulNumLocksPos++ ] = ulRecNo; * pResult = HB_TRUE; @@ -850,9 +850,9 @@ static HB_ERRCODE hb_dbfUnlockFile( DBFAREAP pArea ) /* * Test if a record is locked. */ -static HB_BOOL hb_dbfIsLocked( DBFAREAP pArea, ULONG ulRecNo ) +static HB_BOOL hb_dbfIsLocked( DBFAREAP pArea, HB_ULONG ulRecNo ) { - ULONG ulCount; + HB_ULONG ulCount; HB_TRACE(HB_TR_DEBUG, ("hb_dbfIsLocked(%p)", pArea)); @@ -872,7 +872,7 @@ static HB_BOOL hb_dbfIsLocked( DBFAREAP pArea, ULONG ulRecNo ) */ static void hb_dbfGetLockArray( DBFAREAP pArea, PHB_ITEM pItem ) { - ULONG ulCount; + HB_ULONG ulCount; HB_TRACE(HB_TR_DEBUG, ("hb_dbfGetLockArray(%p, %p)", pArea, pItem)); @@ -947,9 +947,9 @@ HB_ERRCODE hb_dbfGetEGcode( HB_ERRCODE errCode ) * This function is common for different MEMO implementation * so I left it in DBF. */ -ULONG hb_dbfGetMemoBlock( DBFAREAP pArea, HB_USHORT uiIndex ) +HB_ULONG hb_dbfGetMemoBlock( DBFAREAP pArea, HB_USHORT uiIndex ) { - ULONG ulBlock= 0; + HB_ULONG ulBlock= 0; HB_TRACE(HB_TR_DEBUG, ("hb_dbfGetMemoBlock(%p, %hu)", pArea, uiIndex)); @@ -980,7 +980,7 @@ ULONG hb_dbfGetMemoBlock( DBFAREAP pArea, HB_USHORT uiIndex ) * This function is common for different MEMO implementation * so I left it in DBF. */ -void hb_dbfPutMemoBlock( DBFAREAP pArea, HB_USHORT uiIndex, ULONG ulBlock ) +void hb_dbfPutMemoBlock( DBFAREAP pArea, HB_USHORT uiIndex, HB_ULONG ulBlock ) { HB_TRACE(HB_TR_DEBUG, ("hb_dbfPutMemoBlock(%p, %hu, %lu)", pArea, uiIndex, ulBlock)); @@ -1013,8 +1013,8 @@ void hb_dbfPutMemoBlock( DBFAREAP pArea, HB_USHORT uiIndex, ULONG ulBlock ) * so I left it in DBF. */ HB_ERRCODE hb_dbfGetMemoData( DBFAREAP pArea, HB_USHORT uiIndex, - ULONG * pulBlock, ULONG * pulSize, - ULONG * pulType ) + HB_ULONG * pulBlock, HB_ULONG * pulSize, + HB_ULONG * pulType ) { HB_TRACE(HB_TR_DEBUG, ("hb_dbfGetMemoData(%p, %hu, %p, %p, %p)", pArea, uiIndex, pulBlock, pulSize, pulType)); @@ -1034,7 +1034,7 @@ HB_ERRCODE hb_dbfGetMemoData( DBFAREAP pArea, HB_USHORT uiIndex, } else if( pArea->area.lpFields[ uiIndex ].uiLen == 10 ) { - ULONG ulValue; + HB_ULONG ulValue; if( pArea->bMemoType == DB_MEMO_SMT ) { @@ -1083,7 +1083,7 @@ HB_ERRCODE hb_dbfGetMemoData( DBFAREAP pArea, HB_USHORT uiIndex, * so I left it in DBF. */ HB_ERRCODE hb_dbfSetMemoData( DBFAREAP pArea, HB_USHORT uiIndex, - ULONG ulBlock, ULONG ulSize, ULONG ulType ) + HB_ULONG ulBlock, HB_ULONG ulSize, HB_ULONG ulType ) { HB_TRACE(HB_TR_DEBUG, ("hb_dbfSetMemoData(%p, %hu, %lu, %lu, %lu)", pArea, uiIndex, ulBlock, ulSize, ulType)); @@ -1378,7 +1378,7 @@ static HB_ERRCODE hb_dbfGoBottom( DBFAREAP pArea ) /* * Position cursor at a specific physical record. */ -static HB_ERRCODE hb_dbfGoTo( DBFAREAP pArea, ULONG ulRecNo ) +static HB_ERRCODE hb_dbfGoTo( DBFAREAP pArea, HB_ULONG ulRecNo ) { HB_TRACE(HB_TR_DEBUG, ("hb_dbfGoTo(%p, %lu)", pArea, ulRecNo)); @@ -1531,7 +1531,7 @@ static HB_ERRCODE hb_dbfSkipRaw( DBFAREAP 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; @@ -1569,7 +1569,7 @@ static HB_ERRCODE hb_dbfAddField( DBFAREAP pArea, LPDBFIELDINFO pFieldInfo ) */ static HB_ERRCODE hb_dbfAppend( DBFAREAP pArea, HB_BOOL bUnLockAll ) { - ULONG ulNewRecord; + HB_ULONG ulNewRecord; HB_USHORT fLocked; HB_ERRCODE errCode; @@ -1788,7 +1788,7 @@ static HB_ERRCODE hb_dbfGetValue( DBFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI PHB_ITEM pError; HB_BOOL fError; char * pszVal; - ULONG ulLen;; + HB_SIZE ulLen; HB_TRACE(HB_TR_DEBUG, ("hb_dbfGetValue(%p, %hu, %p)", pArea, uiIndex, pItem)); @@ -1828,7 +1828,7 @@ static HB_ERRCODE hb_dbfGetValue( DBFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI { ulLen = ( HB_UCHAR ) pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] + ulLen - 1 ]; /* protection against corrupted files */ - if( ulLen > ( ULONG ) pField->uiLen ) + if( ulLen > ( HB_SIZE ) pField->uiLen ) ulLen = pField->uiLen; } if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) @@ -2034,7 +2034,7 @@ static HB_ERRCODE hb_dbfGetValue( DBFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI /* * Obtain the length of a field value. */ -static HB_ERRCODE hb_dbfGetVarLen( DBFAREAP pArea, HB_USHORT uiIndex, ULONG * pLength ) +static HB_ERRCODE hb_dbfGetVarLen( DBFAREAP pArea, HB_USHORT uiIndex, HB_SIZE * pLength ) { HB_TRACE(HB_TR_DEBUG, ("hb_dbfGetVarLen(%p, %hu, %p)", pArea, uiIndex, pLength)); @@ -2198,7 +2198,7 @@ static HB_ERRCODE hb_dbfPutValue( DBFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI */ char szBuffer[ 256 ]; const char * pszPtr; - ULONG ulSize, ulLen; + HB_SIZE ulSize, ulLen; HB_BYTE * ptr; PHB_ITEM pError; HB_ERRCODE errCode; @@ -2259,7 +2259,7 @@ static HB_ERRCODE hb_dbfPutValue( DBFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], hb_itemGetCPtr( pItem ), ulLen ); } - if( ulLen < ( ULONG ) pField->uiLen ) + if( ulLen < ( HB_SIZE ) pField->uiLen ) memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + ulLen, ' ', pField->uiLen - ulLen ); } @@ -2267,7 +2267,7 @@ static HB_ERRCODE hb_dbfPutValue( DBFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI { if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) { - if( ulLen > ( ULONG ) sizeof( szBuffer ) ) + if( ulLen > ( HB_SIZE ) sizeof( szBuffer ) ) ulLen = sizeof( szBuffer ); pszPtr = hb_cdpnDup2( pszPtr, ulSize, szBuffer, &ulLen, hb_vmCDP(), pArea->area.cdPage ); @@ -2279,7 +2279,7 @@ static HB_ERRCODE hb_dbfPutValue( DBFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI } memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], pszPtr, ulLen ); - if( ulLen < ( ULONG ) pField->uiLen ) + if( ulLen < ( HB_SIZE ) pField->uiLen ) { pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] + pField->uiLen - 1 ] = ( HB_BYTE ) ulLen; hb_dbfSetNullFlag( pArea->pRecord, pArea->uiNullOffset, pArea->pFieldBits[ uiIndex ].uiLengthBit ); @@ -2532,7 +2532,7 @@ static HB_ERRCODE hb_dbfRecall( DBFAREAP pArea ) /* * Obtain number of records in WorkArea. */ -static HB_ERRCODE hb_dbfRecCount( DBFAREAP pArea, ULONG * pRecCount ) +static HB_ERRCODE hb_dbfRecCount( DBFAREAP pArea, HB_ULONG * pRecCount ) { HB_TRACE(HB_TR_DEBUG, ("hb_dbfRecCount(%p, %p)", pArea, pRecCount)); @@ -2547,7 +2547,7 @@ static HB_ERRCODE hb_dbfRecCount( DBFAREAP pArea, ULONG * pRecCount ) /* * Obtain physical row number at current WorkArea cursor position. */ -static HB_ERRCODE hb_dbfRecNo( DBFAREAP pArea, ULONG * pulRecNo ) +static HB_ERRCODE hb_dbfRecNo( DBFAREAP pArea, HB_ULONG * pulRecNo ) { HB_TRACE(HB_TR_DEBUG, ("hb_dbfRecNo(%p, %p)", pArea, pulRecNo)); @@ -2567,7 +2567,7 @@ static HB_ERRCODE hb_dbfRecNo( DBFAREAP pArea, ULONG * pulRecNo ) static HB_ERRCODE hb_dbfRecId( DBFAREAP pArea, PHB_ITEM pRecNo ) { HB_ERRCODE errCode; - ULONG ulRecNo = 0; + HB_ULONG ulRecNo = 0; HB_TRACE(HB_TR_DEBUG, ("hb_dbfRecId(%p, %p)", pArea, pRecNo)); @@ -2726,7 +2726,7 @@ static HB_ERRCODE hb_dbfClose( DBFAREAP pArea ) static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo ) { HB_ERRCODE errCode = HB_SUCCESS; - ULONG ulSize; + HB_SIZE ulSize; HB_USHORT uiCount; HB_BOOL fError, fRawBlob; DBFFIELD * pThisField; @@ -2843,7 +2843,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo ) pArea->szDataFileName = hb_strdup( szFileName ); - ulSize = ( ULONG ) pArea->area.uiFieldCount * sizeof( DBFFIELD ) + + ulSize = ( HB_SIZE ) pArea->area.uiFieldCount * sizeof( DBFFIELD ) + ( pArea->bTableType == DB_DBF_VFP ? 1 : 2 ); pBuffer = ( HB_BYTE * ) hb_xgrab( ulSize + sizeof( DBFFIELD ) + 1 ); memset( pBuffer, 0, ulSize + sizeof( DBFFIELD ) + 1 ); @@ -3440,7 +3440,7 @@ static HB_ERRCODE hb_dbfFieldInfo( DBFAREAP pArea, HB_USHORT uiIndex, HB_USHORT */ static HB_ERRCODE hb_dbfRecInfo( DBFAREAP pArea, PHB_ITEM pRecID, HB_USHORT uiInfoType, PHB_ITEM pInfo ) { - ULONG ulRecNo = hb_itemGetNL( pRecID ), ulPrevRec = 0; + HB_ULONG ulRecNo = hb_itemGetNL( pRecID ), ulPrevRec = 0; HB_ERRCODE errResult = HB_SUCCESS; HB_BOOL bDeleted; @@ -3518,7 +3518,7 @@ static HB_ERRCODE hb_dbfRecInfo( DBFAREAP pArea, PHB_ITEM pRecID, HB_USHORT uiIn { HB_USHORT uiFields; HB_BYTE * pResult; - ULONG ulLength, ulLen; + HB_SIZE ulLength, ulLen; if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) ) { @@ -3604,7 +3604,7 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo ) { HB_ERRCODE errCode, errOsCode; HB_USHORT uiFlags, uiFields, uiCount, uiSkip; - ULONG ulSize; + HB_SIZE ulSize; HB_BOOL fRawBlob; PHB_ITEM pError, pItem; PHB_FNAME pFileName; @@ -3771,7 +3771,7 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo ) /* Add fields */ uiSkip = 0; uiFields = ( pArea->uiHeaderLen - sizeof( DBFHEADER ) ) / sizeof( DBFFIELD ); - ulSize = ( ULONG ) uiFields * sizeof( DBFFIELD ); + ulSize = ( HB_SIZE ) uiFields * sizeof( DBFFIELD ); pBuffer = uiFields ? ( HB_BYTE * ) hb_xgrab( ulSize ) : NULL; /* Read fields and exit if error */ @@ -4142,7 +4142,7 @@ static HB_ERRCODE hb_dbfStructSize( DBFAREAP pArea, HB_USHORT * uiSize ) /* * Pack helper function called for each packed record */ -static HB_ERRCODE hb_dbfPackRec( DBFAREAP pArea, ULONG ulRecNo, HB_BOOL *fWritten ) +static HB_ERRCODE hb_dbfPackRec( DBFAREAP pArea, HB_ULONG ulRecNo, HB_BOOL *fWritten ) { HB_TRACE(HB_TR_DEBUG, ("hb_dbfPackRec(%p, %lu, %p)", pArea, ulRecNo, fWritten)); @@ -4158,7 +4158,7 @@ static HB_ERRCODE hb_dbfPackRec( DBFAREAP pArea, ULONG ulRecNo, HB_BOOL *fWritte */ static HB_ERRCODE hb_dbfPack( DBFAREAP pArea ) { - ULONG ulRecIn, ulRecOut, ulEvery, ulUserEvery; + HB_ULONG ulRecIn, ulRecOut, ulEvery, ulUserEvery; PHB_ITEM pBlock; HB_BOOL fWritten; @@ -4289,7 +4289,7 @@ static HB_ERRCODE hb_dbfPack( DBFAREAP pArea ) void hb_dbfTranslateRec( DBFAREAP pArea, HB_BYTE * pBuffer, PHB_CODEPAGE cdp_src, PHB_CODEPAGE cdp_dest ) { char * pTmpBuf = NULL; - ULONG ulLen; + HB_SIZE ulLen; LPFIELD pField; HB_USHORT uiIndex; @@ -4306,13 +4306,13 @@ void hb_dbfTranslateRec( DBFAREAP pArea, HB_BYTE * pBuffer, PHB_CODEPAGE cdp_src memcpy( pBuffer + pArea->pFieldOffset[ uiIndex ], pTmpBuf, ulLen ); if( pField->uiType == HB_FT_STRING ) { - if( ulLen < ( ULONG ) pField->uiLen ) + if( ulLen < ( HB_SIZE ) pField->uiLen ) memset( pBuffer + pArea->pFieldOffset[ uiIndex ] + ulLen, ' ', pField->uiLen - ulLen ); } else { - if( ulLen < ( ULONG ) pField->uiLen ) + if( ulLen < ( HB_SIZE ) pField->uiLen ) { pBuffer[ pArea->pFieldOffset[ uiIndex ] + pField->uiLen - 1 ] = ( HB_BYTE ) ulLen; hb_dbfSetNullFlag( pBuffer, pArea->uiNullOffset, pArea->pFieldBits[ uiIndex ].uiLengthBit ); @@ -4331,7 +4331,7 @@ void hb_dbfTranslateRec( DBFAREAP pArea, HB_BYTE * pBuffer, PHB_CODEPAGE cdp_src */ static HB_ERRCODE hb_dbfSort( DBFAREAP pArea, LPDBSORTINFO pSortInfo ) { - ULONG ulRecNo; + HB_ULONG ulRecNo; HB_USHORT uiCount; HB_BOOL bMoreRecords, bLimited, bValidRecord; HB_ERRCODE errCode; @@ -4679,7 +4679,7 @@ static HB_ERRCODE hb_dbfSetFilter( DBFAREAP pArea, LPDBFILTERINFO pFilterInfo ) /* * Perform a network lowlevel lock in the specified WorkArea. */ -static HB_ERRCODE hb_dbfRawLock( DBFAREAP pArea, HB_USHORT uiAction, ULONG ulRecNo ) +static HB_ERRCODE hb_dbfRawLock( DBFAREAP pArea, HB_USHORT uiAction, HB_ULONG ulRecNo ) { HB_ERRCODE errCode = HB_SUCCESS; HB_FOFFSET ulPos, ulFlSize, ulRlSize; @@ -4830,7 +4830,7 @@ static HB_ERRCODE hb_dbfUnLock( DBFAREAP pArea, PHB_ITEM pRecNo ) { if( pArea->ulNumLocksPos > 0 ) { - ULONG ulRecNo = hb_itemGetNL( pRecNo ); + HB_ULONG ulRecNo = hb_itemGetNL( pRecNo ); /* Unlock all records? */ if( ulRecNo == 0 ) errCode = hb_dbfUnlockAllRecords( pArea ); @@ -4902,7 +4902,7 @@ static HB_ERRCODE hb_dbfGetValueFile( DBFAREAP pArea, HB_USHORT uiIndex, const c { if( hb_fileWriteAt( pFile, pArea->pRecord + pArea->pFieldOffset[ uiIndex ], pField->uiLen, hb_fileSize( pFile ) ) != - ( ULONG ) pField->uiLen ) + ( HB_SIZE ) pField->uiLen ) { errCode = EDBF_WRITE; } @@ -5211,7 +5211,7 @@ static HB_ERRCODE hb_dbfWriteDBHeader( DBFAREAP pArea ) return errCode; } -static HB_ERRCODE hb_dbfDrop( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, ULONG ulConnect ) +static HB_ERRCODE hb_dbfDrop( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, HB_ULONG ulConnect ) { char szFileName[ HB_PATH_MAX ]; const char * szFile, * szExt; @@ -5293,7 +5293,7 @@ static HB_ERRCODE hb_dbfDrop( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pIte return fResult ? HB_SUCCESS : HB_FAILURE; } -static HB_ERRCODE hb_dbfExists( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, ULONG ulConnect ) +static HB_ERRCODE hb_dbfExists( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, HB_ULONG ulConnect ) { char szFileName[ HB_PATH_MAX ]; const char * szFile; @@ -5329,7 +5329,7 @@ static HB_ERRCODE hb_dbfExists( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pI return hb_fileExists( szFileName, NULL ) ? HB_SUCCESS : HB_FAILURE; } -static HB_ERRCODE hb_dbfRename( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, PHB_ITEM pItemNew, ULONG ulConnect ) +static HB_ERRCODE hb_dbfRename( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pItemIndex, PHB_ITEM pItemNew, HB_ULONG ulConnect ) { char szFileName[ HB_PATH_MAX ]; char szFileNew[ HB_PATH_MAX ]; @@ -5493,7 +5493,7 @@ static HB_ERRCODE hb_dbfExit( LPRDDNODE pRDD ) return HB_SUCCESS; } -static HB_ERRCODE hb_dbfRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem ) +static HB_ERRCODE hb_dbfRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem ) { LPDBFDATA pData; diff --git a/harbour/src/rdd/dbfcdx/dbfcdx1.c b/harbour/src/rdd/dbfcdx/dbfcdx1.c index 1f7785aec2..2866735554 100644 --- a/harbour/src/rdd/dbfcdx/dbfcdx1.c +++ b/harbour/src/rdd/dbfcdx/dbfcdx1.c @@ -164,8 +164,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 @@ -326,7 +326,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(); @@ -355,7 +355,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; @@ -411,8 +411,8 @@ static int hb_cdxValCompare( LPCDXTAG pTag, HB_BYTE * val1, HB_BYTE len1, } else if( pTag->pIndex->pArea->fSortCDP ) { - iResult = hb_cdpcmp( ( const char * ) val1, ( ULONG ) iLimit, - ( const char * ) val2, ( ULONG ) iLimit, + iResult = hb_cdpcmp( ( const char * ) val1, ( HB_ULONG ) iLimit, + ( const char * ) val2, ( HB_ULONG ) iLimit, pTag->pIndex->pArea->dbfarea.area.cdPage, 0 ); } else if( iLimit > 0 ) @@ -495,10 +495,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]; @@ -512,9 +512,9 @@ static LPCDXKEY hb_cdxKeyPutItem( LPCDXKEY pKey, PHB_ITEM pItem, ULONG ulRec, LP if( pTag->IgnoreCase ) { char tmp[CDX_MAXKEY]; - ULONG ul = hb_itemGetCLen( pItem ); - if( ul > ( ULONG ) sizeof( tmp ) ) - ul = ( ULONG ) sizeof( tmp ); + HB_ULONG ul = hb_itemGetCLen( pItem ); + if( ul > ( HB_ULONG ) sizeof( tmp ) ) + ul = ( HB_ULONG ) sizeof( tmp ); memcpy( tmp, hb_itemGetCPtr( pItem ), ul ); hb_strUpper( tmp, ul ); hb_cdpnDup2( tmp, ul, ( char * ) ptr, &ulLen, @@ -524,7 +524,7 @@ static LPCDXKEY hb_cdxKeyPutItem( LPCDXKEY pKey, PHB_ITEM pItem, ULONG ulRec, LP hb_cdpnDup2( hb_itemGetCPtr( pItem ), hb_itemGetCLen( pItem ), ( char * ) ptr, &ulLen, hb_vmCDP(), pTag->pIndex->pArea->dbfarea.area.cdPage ); - if( iMode == CDX_CMP_EXACT && ulLen < ( ULONG ) pTag->uiLen ) + if( iMode == CDX_CMP_EXACT && ulLen < ( HB_ULONG ) pTag->uiLen ) { memset( ptr + ulLen, pTag->bTrail, pTag->uiLen - ulLen ); ulLen = pTag->uiLen; @@ -533,16 +533,16 @@ static LPCDXKEY hb_cdxKeyPutItem( LPCDXKEY pKey, PHB_ITEM pItem, ULONG ulRec, LP else { ulLen = hb_itemGetCLen( pItem ); - if( ulLen > ( ULONG ) pTag->uiLen ) + if( ulLen > ( HB_ULONG ) pTag->uiLen ) ulLen = pTag->uiLen; if( pTag->IgnoreCase || - ( iMode == CDX_CMP_EXACT && ulLen < ( ULONG ) pTag->uiLen ) ) + ( iMode == CDX_CMP_EXACT && ulLen < ( HB_ULONG ) pTag->uiLen ) ) { memcpy( ptr, hb_itemGetCPtr( pItem ), ulLen ); if( pTag->IgnoreCase ) hb_strUpper( ( char * ) ptr, ulLen ); - if( iMode == CDX_CMP_EXACT && ulLen < ( ULONG ) pTag->uiLen ) + if( iMode == CDX_CMP_EXACT && ulLen < ( HB_ULONG ) pTag->uiLen ) { memset( ptr + ulLen, pTag->bTrail, pTag->uiLen - ulLen ); ulLen = pTag->uiLen; @@ -614,7 +614,7 @@ static PHB_ITEM hb_cdxKeyGetItem( LPCDXKEY pKey, PHB_ITEM pItem, LPCDXTAG pTag, case 'C': if( fTrans ) { - ULONG ulLen = pKey->len; + HB_ULONG ulLen = pKey->len; char * pszVal = hb_cdpnDup( ( const char * ) pKey->val, &ulLen, pTag->pIndex->pArea->dbfarea.area.cdPage, hb_vmCDP() ); pItem = hb_itemPutCLPtr( pItem, pszVal, ulLen ); @@ -855,7 +855,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 ) { @@ -997,11 +997,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 ) { @@ -1039,7 +1039,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: ### */ @@ -1064,7 +1064,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 ) { @@ -1096,7 +1096,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 ) @@ -1145,7 +1145,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 ) @@ -1153,7 +1153,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 @@ -1164,13 +1164,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++; @@ -1183,7 +1183,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 ) { @@ -1537,7 +1537,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 ) @@ -1555,7 +1555,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 ) @@ -1607,7 +1607,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 ) @@ -1689,8 +1689,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 ), @@ -1730,7 +1730,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; @@ -1831,7 +1831,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 ) @@ -1916,7 +1916,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; @@ -1987,7 +1987,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 @@ -2179,7 +2179,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 ); @@ -2228,7 +2228,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 @@ -2350,7 +2350,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; @@ -2486,7 +2486,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 ) @@ -2519,7 +2519,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 @@ -2685,7 +2685,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++ ) @@ -2723,7 +2723,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 ) @@ -2857,7 +2857,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; @@ -2873,7 +2873,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 ) { @@ -2945,7 +2945,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; @@ -3132,7 +3132,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 ) @@ -3302,7 +3302,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 ); /* @@ -3456,7 +3456,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 ) ); @@ -3632,7 +3632,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 ]; @@ -3770,7 +3770,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; @@ -3799,7 +3799,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 ) @@ -3844,7 +3844,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 ) @@ -3875,7 +3875,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; @@ -3889,7 +3889,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(); @@ -4240,10 +4240,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 ); @@ -4271,10 +4271,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 ) { @@ -4358,7 +4358,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 ); @@ -4391,7 +4391,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 ); @@ -4427,7 +4427,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 ) { @@ -4470,7 +4470,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 ) { @@ -5374,7 +5374,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 ) ) { @@ -5397,7 +5397,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 ) ) { @@ -5508,7 +5508,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 ); @@ -5538,7 +5538,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 ); @@ -5580,7 +5580,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() ) @@ -5638,7 +5638,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 ) ) @@ -5659,7 +5659,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 ) ) @@ -5694,9 +5694,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; @@ -5744,13 +5744,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 ); @@ -5791,7 +5791,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 ) @@ -5823,7 +5823,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 ) { @@ -5849,7 +5849,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 ) @@ -5860,7 +5860,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 ); @@ -5907,7 +5907,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 ) @@ -5924,7 +5924,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 ) @@ -5956,7 +5956,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 ) { @@ -5982,10 +5982,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 ) @@ -6023,7 +6023,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 ) @@ -6031,7 +6031,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 ) { @@ -6040,7 +6040,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 ); @@ -6120,7 +6120,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 */ @@ -6223,9 +6223,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 ); @@ -6360,7 +6360,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; @@ -6534,7 +6534,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 ); @@ -6602,7 +6602,7 @@ static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pKeyIt 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)); @@ -7417,7 +7417,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; @@ -8661,7 +8661,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; @@ -8790,7 +8790,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 @@ -8803,7 +8803,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; @@ -8917,7 +8917,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 ); @@ -8941,15 +8941,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 ) @@ -8969,11 +8969,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 ) @@ -9003,11 +9003,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 ]; @@ -9015,7 +9015,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. @@ -9069,10 +9069,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++ ) @@ -9114,7 +9114,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; @@ -9141,19 +9141,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; @@ -9249,7 +9249,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; @@ -9366,7 +9366,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 ); @@ -9409,7 +9409,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; @@ -9479,11 +9479,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 + diff --git a/harbour/src/rdd/dbffpt/dbffpt1.c b/harbour/src/rdd/dbffpt/dbffpt1.c index bcd7ac8fc0..03f357b67a 100644 --- a/harbour/src/rdd/dbffpt/dbffpt1.c +++ b/harbour/src/rdd/dbffpt/dbffpt1.c @@ -260,7 +260,7 @@ static HB_BOOL hb_fptRootBlockUnLock( FPTAREAP pArea ) /* * Read root block pointer. */ -static HB_ERRCODE hb_fptGetRootBlock( FPTAREAP pArea, ULONG * pulBlock ) +static HB_ERRCODE hb_fptGetRootBlock( FPTAREAP pArea, HB_ULONG * pulBlock ) { *pulBlock = 0; @@ -282,7 +282,7 @@ static HB_ERRCODE hb_fptGetRootBlock( FPTAREAP pArea, ULONG * pulBlock ) /* * Write root block pointer. */ -static HB_ERRCODE hb_fptPutRootBlock( FPTAREAP pArea, ULONG ulBlock ) +static HB_ERRCODE hb_fptPutRootBlock( FPTAREAP pArea, HB_ULONG ulBlock ) { if( hb_fptHasDirectAccess( pArea ) ) { @@ -372,7 +372,7 @@ static HB_ERRCODE hb_fptPutRootBlock( FPTAREAP pArea, ULONG ulBlock ) */ static void hb_fptSortGCitems( LPMEMOGCTABLE pGCtable ) { - ULONG ulOffset, ulSize; + HB_ULONG ulOffset, ulSize; HB_BOOL fChanged, fMoved = HB_TRUE; int i, j, l; @@ -410,7 +410,7 @@ static void hb_fptSortGCitems( LPMEMOGCTABLE pGCtable ) */ static void hb_fptPackGCitems( LPMEMOGCTABLE pGCtable ) { - ULONG ulEnd; + HB_ULONG ulEnd; int i, j; /* TODO: better alogrithm this primitve one can be too slow for big @@ -524,10 +524,10 @@ static HB_ERRCODE hb_fptWriteGCitems( FPTAREAP pArea, LPMEMOGCTABLE pGCtable, HB * Add new block to GC free memo blocks list. */ static HB_ERRCODE hb_fptGCfreeBlock( FPTAREAP pArea, LPMEMOGCTABLE pGCtable, - ULONG ulOffset, ULONG ulByteSize, HB_BOOL fRaw ) + HB_ULONG ulOffset, HB_ULONG ulByteSize, HB_BOOL fRaw ) { HB_ERRCODE errCode = HB_SUCCESS; - ULONG ulSize; + HB_ULONG ulSize; if( pArea->bMemoType == DB_MEMO_DBT ) { @@ -632,11 +632,11 @@ static HB_ERRCODE hb_fptGCfreeBlock( FPTAREAP pArea, LPMEMOGCTABLE pGCtable, * Get free memo block from GC free memo blocks list or allocate new one. */ static HB_ERRCODE hb_fptGCgetFreeBlock( FPTAREAP pArea, LPMEMOGCTABLE pGCtable, - ULONG * ulOffset, ULONG ulByteSize, + HB_ULONG * ulOffset, HB_ULONG ulByteSize, HB_BOOL fRaw ) { HB_BOOL fAlloc = HB_FALSE; - ULONG ulSize; + HB_ULONG ulSize; int i; @@ -822,7 +822,7 @@ static HB_ERRCODE hb_fptReadGCdata( FPTAREAP pArea, LPMEMOGCTABLE pGCtable ) static HB_ERRCODE hb_fptWriteGCdata( FPTAREAP pArea, LPMEMOGCTABLE pGCtable ) { HB_ERRCODE errCode = HB_SUCCESS; - ULONG ulHdrSize = 512; + HB_ULONG ulHdrSize = 512; int i, j; if( pGCtable->bChanged > 0 ) @@ -847,9 +847,9 @@ static HB_ERRCODE hb_fptWriteGCdata( FPTAREAP pArea, LPMEMOGCTABLE pGCtable ) pGCtable->ulCounter++; if( pGCtable->usItems == 0 && pGCtable->ulDirPage ) { - ULONG ulOffset = pGCtable->ulDirPage; - ULONG ulSize = ( pGCtable->ulSize + pArea->ulMemoBlockSize - 1 ) / - pArea->ulMemoBlockSize; + HB_ULONG ulOffset = pGCtable->ulDirPage; + HB_ULONG ulSize = ( pGCtable->ulSize + pArea->ulMemoBlockSize - 1 ) / + pArea->ulMemoBlockSize; if( pGCtable->ulRevPage ) { ulSize <<= 1; @@ -963,9 +963,9 @@ static HB_ERRCODE hb_fptWriteGCdata( FPTAREAP pArea, LPMEMOGCTABLE pGCtable ) /* * Return the size of memo. */ -static ULONG hb_fptGetMemoLen( FPTAREAP pArea, HB_USHORT uiIndex ) +static HB_ULONG hb_fptGetMemoLen( FPTAREAP pArea, HB_USHORT uiIndex ) { - ULONG ulBlock, ulSize, ulType; + HB_ULONG ulBlock, ulSize, ulType; FPTBLOCK fptBlock; HB_TRACE(HB_TR_DEBUG, ("hb_fptGetMemoLen(%p, %hu)", pArea, uiIndex)); @@ -982,7 +982,7 @@ static ULONG hb_fptGetMemoLen( FPTAREAP pArea, HB_USHORT uiIndex ) if( pArea->bMemoType == DB_MEMO_DBT ) { HB_BYTE pBlock[ DBT_DEFBLOCKSIZE ]; - ULONG ulLen, u; + HB_ULONG ulLen, u; do { @@ -1012,7 +1012,7 @@ static ULONG hb_fptGetMemoLen( FPTAREAP pArea, HB_USHORT uiIndex ) */ static const char * hb_fptGetMemoType( FPTAREAP pArea, HB_USHORT uiIndex ) { - ULONG ulBlock, ulSize, ulType; + HB_ULONG ulBlock, ulSize, ulType; FPTBLOCK fptBlock; HB_TRACE(HB_TR_DEBUG, ("hb_fptGetMemoType(%p, %hu)", pArea, uiIndex)); @@ -1114,10 +1114,10 @@ static const char * hb_fptGetMemoType( FPTAREAP pArea, HB_USHORT uiIndex ) /* * Calculate the size of SMT memo item */ -static ULONG hb_fptCountSMTItemLength( FPTAREAP pArea, PHB_ITEM pItem, - ULONG * pulArrayCount, HB_BOOL fTrans ) +static HB_ULONG hb_fptCountSMTItemLength( FPTAREAP pArea, PHB_ITEM pItem, + HB_ULONG * pulArrayCount, HB_BOOL fTrans ) { - ULONG ulLen, u, ulSize; + HB_ULONG ulLen, u, ulSize; switch( hb_itemType( pItem ) ) { @@ -1235,9 +1235,9 @@ static HB_ERRCODE hb_fptCountSMTDataLength( FPTAREAP pArea, HB_FOFFSET * pfOffse /* * Write VM item as SMT memos. */ -static ULONG hb_fptStoreSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBufPtr, HB_BOOL fTrans ) +static HB_ULONG hb_fptStoreSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBufPtr, HB_BOOL fTrans ) { - ULONG ulLen, u, ulSize = 0; + HB_ULONG ulLen, u, ulSize = 0; HB_MAXINT iVal; HB_LONG lVal; double dVal; @@ -1332,7 +1332,7 @@ static ULONG hb_fptStoreSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBuf */ static HB_ERRCODE hb_fptReadRawSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_FOFFSET *pfOffset, HB_BOOL fTrans ) { - ULONG ulLen, u; + HB_ULONG ulLen, u; HB_BYTE buffer[ 10 ]; char *pBuffer; int iWidth, iDec; @@ -1373,7 +1373,7 @@ static HB_ERRCODE hb_fptReadRawSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_FOFFS *pfOffset += ulLen; if( fTrans && ulLen > 0 ) { - ULONG ulSize = ulLen + 1; + HB_ULONG ulSize = ulLen + 1; hb_cdpnDup3( pBuffer, ulLen, pBuffer, &ulLen, &pBuffer, &ulSize, pArea->area.cdPage, hb_vmCDP() ); } @@ -1429,7 +1429,7 @@ static HB_ERRCODE hb_fptReadRawSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_FOFFS */ static HB_ERRCODE hb_fptReadSMTItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BYTE * bBufEnd, PHB_ITEM pItem, HB_BOOL fTrans ) { - ULONG ulLen, u; + HB_ULONG ulLen, u; HB_ERRCODE errCode = HB_SUCCESS; int iWidth, iDec; @@ -1550,10 +1550,10 @@ static HB_ERRCODE hb_fptReadSMTItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BY /* * Calculate the size of SIX memo item */ -static ULONG hb_fptCountSixItemLength( FPTAREAP pArea, PHB_ITEM pItem, - ULONG * pulArrayCount, HB_BOOL fTrans ) +static HB_ULONG hb_fptCountSixItemLength( FPTAREAP pArea, PHB_ITEM pItem, + HB_ULONG * pulArrayCount, HB_BOOL fTrans ) { - ULONG ulLen, u, ulSize; + HB_ULONG ulLen, u, ulSize; switch ( hb_itemType( pItem ) ) { @@ -1604,9 +1604,9 @@ static ULONG hb_fptCountSixItemLength( FPTAREAP pArea, PHB_ITEM pItem, /* * Write fpt vartype as SIX memos. */ -static ULONG hb_fptStoreSixItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBufPtr, HB_BOOL fTrans ) +static HB_ULONG hb_fptStoreSixItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBufPtr, HB_BOOL fTrans ) { - ULONG ulLen, u, ulSize; + HB_ULONG ulLen, u, ulSize; HB_MAXINT iVal; HB_LONG lVal; double dVal; @@ -1717,7 +1717,7 @@ static ULONG hb_fptStoreSixItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBuf static HB_ERRCODE hb_fptReadSixItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BYTE * bBufEnd, PHB_ITEM pItem, HB_BOOL fTrans ) { HB_USHORT usType; - ULONG ulLen, u; + HB_ULONG ulLen, u; HB_ERRCODE errCode = HB_SUCCESS; ulLen = SIX_ITEM_BUFSIZE; @@ -1756,7 +1756,7 @@ static HB_ERRCODE hb_fptReadSixItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BY char * pszStr = ( char * ) ( *pbMemoBuf ); if( fTrans && ulLen > 0 ) { - ULONG ulSize = ulLen; + HB_ULONG ulSize = ulLen; pszStr = hb_cdpnDup( pszStr, &ulSize, pArea->area.cdPage, hb_vmCDP() ); hb_itemPutCLPtr( pItem, pszStr, ulSize ); } @@ -1815,10 +1815,10 @@ static HB_ERRCODE hb_fptReadSixItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BY /* * Calculate the size of FLEX memo item */ -static ULONG hb_fptCountFlexItemLength( FPTAREAP pArea, PHB_ITEM pItem, - ULONG * pulArrayCount, HB_BOOL fTrans ) +static HB_ULONG hb_fptCountFlexItemLength( FPTAREAP pArea, PHB_ITEM pItem, + HB_ULONG * pulArrayCount, HB_BOOL fTrans ) { - ULONG ulLen, u, ulSize = 1; + HB_ULONG ulLen, u, ulSize = 1; HB_MAXINT iVal; switch ( hb_itemType( pItem ) ) @@ -1871,7 +1871,7 @@ static ULONG hb_fptCountFlexItemLength( FPTAREAP pArea, PHB_ITEM pItem, */ static void hb_fptStoreFlexItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBufPtr, HB_BOOL fTrans ) { - ULONG ulLen, u; + HB_ULONG ulLen, u; HB_MAXINT iVal; HB_LONG lVal; double dVal; @@ -1984,7 +1984,7 @@ static void hb_fptStoreFlexItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBuf static HB_ERRCODE hb_fptReadFlexItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BYTE * bBufEnd, PHB_ITEM pItem, HB_BOOL bRoot, HB_BOOL fTrans ) { HB_BYTE usType; - ULONG ulLen, i; + HB_ULONG ulLen, i; HB_ERRCODE errCode = HB_SUCCESS; if( bRoot ) @@ -2250,11 +2250,11 @@ static HB_ERRCODE hb_fptReadFlexItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_B if( iDec ) { iLen -= iDec + 1; - hb_itemPutNDLen( pItem, ( ULONG ) HB_GET_LE_UINT32( *pbMemoBuf ), iLen, iDec ); + hb_itemPutNDLen( pItem, ( HB_ULONG ) HB_GET_LE_UINT32( *pbMemoBuf ), iLen, iDec ); } else { - hb_itemPutNIntLen( pItem, ( ULONG ) HB_GET_LE_UINT32( *pbMemoBuf ), iLen ); + hb_itemPutNIntLen( pItem, ( HB_ULONG ) HB_GET_LE_UINT32( *pbMemoBuf ), iLen ); } *pbMemoBuf += 6; } @@ -2378,15 +2378,15 @@ static HB_ERRCODE hb_fptCopyToRawFile( PHB_FILE pSrc, HB_FOFFSET from, if( size ) { HB_FOFFSET written = 0; - ULONG ulBufSize, ulRead; + HB_ULONG ulBufSize, ulRead; HB_BYTE * pBuffer; - ulBufSize = ( ULONG ) HB_MIN( 0x10000, size ); + ulBufSize = ( HB_ULONG ) HB_MIN( 0x10000, size ); pBuffer = ( HB_BYTE * ) hb_xgrab( ulBufSize ); do { - ulRead = hb_fileReadAt( pSrc, pBuffer, ( ULONG ) + ulRead = hb_fileReadAt( pSrc, pBuffer, ( HB_ULONG ) HB_MIN( ( HB_FOFFSET ) ulBufSize, size - written ), from + written ); if( ulRead == 0 ) @@ -2412,15 +2412,15 @@ static HB_ERRCODE hb_fptCopyToFile( PHB_FILE pSrc, HB_FOFFSET from, if( size ) { HB_FOFFSET written = 0; - ULONG ulBufSize, ulRead; + HB_ULONG ulBufSize, ulRead; HB_BYTE * pBuffer; - ulBufSize = ( ULONG ) HB_MIN( 0x10000, size ); + ulBufSize = ( HB_ULONG ) HB_MIN( 0x10000, size ); pBuffer = ( HB_BYTE * ) hb_xgrab( ulBufSize ); do { - ulRead = hb_fileReadAt( pSrc, pBuffer, ( ULONG ) + ulRead = hb_fileReadAt( pSrc, pBuffer, ( HB_ULONG ) HB_MIN( ( HB_FOFFSET ) ulBufSize, size - written ), from + written ); if( ulRead == 0 ) @@ -2440,7 +2440,7 @@ static HB_ERRCODE hb_fptCopyToFile( PHB_FILE pSrc, HB_FOFFSET from, } static HB_ERRCODE hb_fptReadRawBlock( FPTAREAP pArea, HB_BYTE * bBuffer, HB_FHANDLE hFile, - ULONG ulBlock, ULONG ulSize ) + HB_ULONG ulBlock, HB_ULONG ulSize ) { HB_ERRCODE errCode = HB_SUCCESS; @@ -2463,10 +2463,10 @@ static HB_ERRCODE hb_fptReadRawBlock( FPTAREAP pArea, HB_BYTE * bBuffer, HB_FHAN } static HB_ERRCODE hb_fptReadBlobBlock( FPTAREAP pArea, PHB_ITEM pItem, - HB_FHANDLE hFile, ULONG ulBlock, + HB_FHANDLE hFile, HB_ULONG ulBlock, HB_USHORT uiMode ) { - ULONG ulSize; + HB_ULONG ulSize; HB_BYTE buffer[ 4 ]; if( ulBlock == 0 ) @@ -2506,7 +2506,7 @@ static HB_ERRCODE hb_fptReadBlobBlock( FPTAREAP pArea, PHB_ITEM pItem, } static HB_ERRCODE hb_fptReadSMTBlock( FPTAREAP pArea, PHB_ITEM pItem, - ULONG ulBlock, ULONG ulSize, HB_BOOL fTrans ) + HB_ULONG ulBlock, HB_ULONG ulSize, HB_BOOL fTrans ) { if( ulBlock == 0 ) return EDBF_CORRUPT; @@ -2546,11 +2546,11 @@ static HB_ERRCODE hb_fptReadSMTBlock( FPTAREAP pArea, PHB_ITEM pItem, * Read fpt vartype memos. */ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem, - HB_FHANDLE hFile, ULONG ulBlock, ULONG ulStart, - ULONG ulCount, HB_BOOL fTrans ) + HB_FHANDLE hFile, HB_ULONG ulBlock, HB_ULONG ulStart, + HB_ULONG ulCount, HB_BOOL fTrans ) { HB_ERRCODE errCode; - ULONG ulSize = 0, ulType = 0; + HB_ULONG ulSize = 0, ulType = 0; char * pBuffer; HB_BYTE * bMemoBuf; FPTBLOCK fptBlock; @@ -2651,7 +2651,7 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt { if( fTrans && ulSize != 0 ) { - ULONG ulBufSize = ulSize + 1; + HB_ULONG ulBufSize = ulSize + 1; hb_cdpnDup3( pBuffer, ulSize, pBuffer, &ulSize, &pBuffer, &ulBufSize, pArea->area.cdPage, hb_vmCDP() ); @@ -2666,7 +2666,7 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt { if( fTrans && ulSize != 0 ) { - ULONG ulBufSize = ulSize + 1; + HB_ULONG ulBufSize = ulSize + 1; hb_cdpnDup3( pBuffer, ulSize, pBuffer, &ulSize, &pBuffer, &ulBufSize, pArea->area.cdPage, hb_vmCDP() ); @@ -2749,7 +2749,7 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt case FPTIT_TEXT: if( fTrans && ulSize != 0 ) { - ULONG ulBufSize = ulSize + 1; + HB_ULONG ulBufSize = ulSize + 1; hb_cdpnDup3( pBuffer, ulSize, pBuffer, &ulSize, &pBuffer, &ulBufSize, pArea->area.cdPage, hb_vmCDP() ); @@ -2781,9 +2781,9 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt /* * Write memo data. */ -static HB_ERRCODE hb_fptWriteMemo( FPTAREAP pArea, ULONG ulBlock, ULONG ulSize, +static HB_ERRCODE hb_fptWriteMemo( FPTAREAP pArea, HB_ULONG ulBlock, HB_ULONG ulSize, const HB_BYTE *bBufPtr, HB_FHANDLE hFile, - ULONG ulType, ULONG ulLen, ULONG * pulStoredBlock ) + HB_ULONG ulType, HB_ULONG ulLen, HB_ULONG * pulStoredBlock ) { MEMOGCTABLE fptGCtable; HB_ERRCODE errCode; @@ -2851,7 +2851,7 @@ static HB_ERRCODE hb_fptWriteMemo( FPTAREAP pArea, ULONG ulBlock, ULONG ulSize, /* TODO: uiMode => BLOB_IMPORT_COMPRESS, BLOB_IMPORT_ENCRYPT */ if( hFile != FS_ERROR ) { - ULONG ulWritten = 0, ulRead, ulBufSize = HB_MIN( ( 1 << 16 ), ulLen ); + HB_ULONG ulWritten = 0, ulRead, ulBufSize = HB_MIN( ( 1 << 16 ), ulLen ); HB_BYTE * bBuffer = ( HB_BYTE * ) hb_xgrab( ulBufSize ); do @@ -2893,8 +2893,8 @@ static HB_ERRCODE hb_fptWriteMemo( FPTAREAP pArea, ULONG ulBlock, ULONG ulSize, else if( pArea->uiMemoVersion == DB_MEMOVER_FLEX && ( ulLen + sizeof( FPTBLOCK ) ) % pArea->ulMemoBlockSize != 0 ) { - ULONG ulBlocks = ( ulLen + sizeof( FPTBLOCK ) + pArea->ulMemoBlockSize - 1 ) / - pArea->ulMemoBlockSize; + HB_ULONG ulBlocks = ( ulLen + sizeof( FPTBLOCK ) + pArea->ulMemoBlockSize - 1 ) / + pArea->ulMemoBlockSize; hb_fileWriteAt( pArea->pMemoFile, "\xAF", 1, FPT_BLOCK_OFFSET( *pulStoredBlock + ulBlocks ) - 1 ); } @@ -2919,10 +2919,10 @@ static HB_ERRCODE hb_fptWriteMemo( FPTAREAP pArea, ULONG ulBlock, ULONG ulSize, * Assign a value to the specified memo field. */ static HB_ERRCODE hb_fptPutMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem, - ULONG * pulBlock, HB_BOOL fTrans ) + HB_ULONG * pulBlock, HB_BOOL fTrans ) { - ULONG ulBlock = 0, ulSize, ulType, ulOldSize = 0, ulOldType = 0, ulArrayCount = 0; - HB_BYTE itmBuffer[FLEX_ITEM_BUFSIZE]; + HB_ULONG ulBlock = 0, ulSize, ulType, ulOldSize = 0, ulOldType = 0, ulArrayCount = 0; + HB_BYTE itmBuffer[ FLEX_ITEM_BUFSIZE ]; HB_BYTE *bBufPtr = NULL, *bBufAlloc = NULL; HB_ERRCODE errCode; HB_MAXINT iVal; @@ -2934,7 +2934,7 @@ static HB_ERRCODE hb_fptPutMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt { ulType = FPTIT_TEXT; ulSize = hb_itemGetCLen( pItem ); - bBufPtr = ( HB_BYTE *) hb_itemGetCPtr( pItem ); + bBufPtr = ( HB_BYTE * ) hb_itemGetCPtr( pItem ); if( ulSize > 0 && fTrans ) { bBufPtr = bBufAlloc = ( HB_BYTE * ) @@ -2957,7 +2957,7 @@ static HB_ERRCODE hb_fptPutMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt return EDBF_DATATYPE; bBufPtr = bBufAlloc = ( HB_BYTE * ) hb_xgrab( ulSize ); hb_fptStoreSMTItem( pArea, pItem, &bBufPtr, fTrans ); - ulType = ( ULONG ) bBufAlloc[ 0 ]; + ulType = ( HB_ULONG ) bBufAlloc[ 0 ]; bBufPtr = bBufAlloc; } else if( pArea->uiMemoVersion == DB_MEMOVER_SIX ) @@ -2974,7 +2974,7 @@ static HB_ERRCODE hb_fptPutMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt { bBufPtr = bBufAlloc = ( HB_BYTE * ) hb_xgrab( ulSize ); hb_fptStoreSixItem( pArea, pItem, &bBufPtr, fTrans ); - ulType = ( ULONG ) HB_GET_LE_UINT16( bBufAlloc ); + ulType = ( HB_ULONG ) HB_GET_LE_UINT16( bBufAlloc ); bBufPtr = bBufAlloc; } else @@ -3246,13 +3246,13 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM hb_itemPutNILen( pItem, ( signed char ) pFieldBuf[ 0 ], 4 ); else if( pField->uiLen >= 6 ) { - ULONG ulBlock = HB_GET_LE_UINT32( pFieldBuf + pField->uiLen - 6 ); + HB_ULONG ulBlock = HB_GET_LE_UINT32( pFieldBuf + pField->uiLen - 6 ); if( uiType <= HB_VF_CHAR ) /* 64000 max string size */ { const char * pString; char * pAlloc = NULL, *pPtr; - ULONG ulLen = uiType; + HB_ULONG ulLen = uiType; if( uiType <= pField->uiLen - 2 ) { @@ -3267,7 +3267,7 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM } else { - ULONG ulSize = ulLen; + HB_ULONG ulSize = ulLen; pString = pPtr = pAlloc = ( char * ) hb_xgrab( ulLen + 1 ); if( pField->uiLen > 6 ) @@ -3392,7 +3392,7 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM return errCode; } -static HB_ERRCODE hb_fptGetVarFile( FPTAREAP pArea, ULONG ulBlock, const char * szFile, HB_USHORT uiMode, HB_BOOL fTrans ) +static HB_ERRCODE hb_fptGetVarFile( FPTAREAP pArea, HB_ULONG ulBlock, const char * szFile, HB_USHORT uiMode, HB_BOOL fTrans ) { HB_ERRCODE errCode; HB_FHANDLE hFile; @@ -3431,7 +3431,7 @@ static HB_ERRCODE hb_fptGetVarFile( FPTAREAP pArea, ULONG ulBlock, const char * return HB_SUCCESS; } -static ULONG hb_fptPutVarFile( FPTAREAP pArea, ULONG ulBlock, const char * szFile ) +static HB_ULONG hb_fptPutVarFile( FPTAREAP pArea, HB_ULONG ulBlock, const char * szFile ) { HB_ERRCODE errCode; HB_FHANDLE hFile; @@ -3446,13 +3446,13 @@ static ULONG hb_fptPutVarFile( FPTAREAP pArea, ULONG ulBlock, const char * szFil } else { - ULONG ulSize; + HB_ULONG ulSize; HB_FOFFSET size = hb_fsSeekLarge( hFile, 0, FS_END ); hb_fsSeek( hFile, 0, FS_SET ); if( ( HB_FOFFSET ) ( size & 0xFFFFFFFFUL ) == size ) - ulSize = HB_MIN( ( ULONG ) size, 0xFFFFFFFFUL - sizeof( FPTBLOCK ) ); + ulSize = HB_MIN( ( HB_ULONG ) size, 0xFFFFFFFFUL - sizeof( FPTBLOCK ) ); else - ulSize = ( ULONG ) HB_MIN( size, ( HB_FOFFSET ) ( 0xFFFFFFFFUL - sizeof( FPTBLOCK ) ) ); + ulSize = ( HB_ULONG ) HB_MIN( size, ( HB_FOFFSET ) ( 0xFFFFFFFFUL - sizeof( FPTBLOCK ) ) ); if( hb_fptFileLockEx( pArea, HB_TRUE ) ) { @@ -3558,7 +3558,7 @@ static HB_ERRCODE hb_fptPutVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM else { HB_BYTE buffer[ 11 ], *pBlock = NULL, *pAlloc = NULL; - ULONG ulOldBlock = 0, ulOldSize = 0, ulNewSize = 0; + HB_ULONG ulOldBlock = 0, ulOldSize = 0, ulNewSize = 0; HB_USHORT uiType = HB_GET_LE_UINT16( pFieldBuf + pField->uiLen - 2 ); if( ( uiType <= HB_VF_CHAR && uiType > pField->uiLen - 2 ) || @@ -3632,7 +3632,7 @@ static HB_ERRCODE hb_fptPutVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM } else if( HB_IS_STRING( pItem ) ) { - ULONG ulLen = hb_itemGetCLen( pItem ); + HB_ULONG ulLen = hb_itemGetCLen( pItem ); pBlock = ( HB_BYTE * ) hb_itemGetCPtr( pItem ); if( ulLen > HB_VF_CHAR ) @@ -3664,9 +3664,9 @@ static HB_ERRCODE hb_fptPutVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM } else if( HB_IS_ARRAY( pItem ) ) { - ULONG ulArrayCount = 0; + HB_ULONG ulArrayCount = 0; HB_BOOL fTrans = ( pField->uiFlags & HB_FF_BINARY ) == 0 && - hb_vmCDP() != pArea->area.cdPage; + hb_vmCDP() != pArea->area.cdPage; ulNewSize = hb_fptCountSMTItemLength( pArea, pItem, &ulArrayCount, fTrans ); pBlock = pAlloc = ( HB_BYTE * ) hb_xgrab( ulNewSize ); hb_fptStoreSMTItem( pArea, pItem, &pBlock, fTrans ); @@ -3738,7 +3738,7 @@ static HB_ERRCODE hb_fptStructSize( FPTAREAP pArea, HB_USHORT * uiSize ) * Obtain the length of a field value. * ( DBENTRYP_SVL ) hb_fptGetVarLen */ -static HB_ERRCODE hb_fptGetVarLen( FPTAREAP pArea, HB_USHORT uiIndex, ULONG * pLength ) +static HB_ERRCODE hb_fptGetVarLen( FPTAREAP pArea, HB_USHORT uiIndex, HB_ULONG * pLength ) { HB_TRACE(HB_TR_DEBUG, ("hb_fptGetVarLen(%p, %hu, %p)", pArea, uiIndex, pLength)); @@ -3823,7 +3823,7 @@ static HB_ERRCODE hb_fptPutValue( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI static HB_ERRCODE hb_fptCreateMemFile( FPTAREAP pArea, LPDBOPENINFO pCreateInfo ) { FPTHEADER fptHeader; - ULONG ulNextBlock, ulSize, ulLen; + HB_ULONG ulNextBlock, ulSize, ulLen; HB_TRACE(HB_TR_DEBUG, ("hb_fptCreateMemFile(%p, %p)", pArea, pCreateInfo)); @@ -3989,7 +3989,7 @@ static HB_ERRCODE hb_fptCreateMemFile( FPTAREAP pArea, LPDBOPENINFO pCreateInfo memset( &fptHeader, 0, sizeof( FPTHEADER ) ); do { - ULONG ulWrite = HB_MIN( ulLen - ulSize, sizeof( FPTHEADER ) ); + HB_ULONG ulWrite = HB_MIN( ulLen - ulSize, sizeof( FPTHEADER ) ); if( hb_fileWriteAt( pArea->pMemoFile, &fptHeader, ulWrite, ulSize ) != ulWrite ) return HB_FAILURE; @@ -4247,10 +4247,10 @@ static HB_ERRCODE hb_fptPutValueFile( FPTAREAP pArea, HB_USHORT uiIndex, const c else if( pField->uiType == HB_FT_ANY ) { HB_BYTE * pAlloc; - ULONG ulSize; + HB_ULONG ulSize; HB_FOFFSET size = hb_fsSeekLarge( hFile, 0, FS_END ); - ulSize = ( ULONG ) HB_MIN( size, HB_VF_CHAR ); + ulSize = ( HB_ULONG ) HB_MIN( size, HB_VF_CHAR ); pAlloc = ( HB_BYTE * ) hb_xgrab( ulSize + 1 ); hb_fsSeek( hFile, 0, FS_SET ); if( hb_fsRead( hFile, pAlloc, ( HB_USHORT ) ulSize ) != ( HB_USHORT ) ulSize ) @@ -4277,17 +4277,17 @@ static HB_ERRCODE hb_fptPutValueFile( FPTAREAP pArea, HB_USHORT uiIndex, const c } else { - ULONG ulSize, ulBlock, ulType, ulOldSize, ulOldType; + HB_ULONG ulSize, ulBlock, ulType, ulOldSize, ulOldType; HB_FOFFSET size = hb_fsSeekLarge( hFile, 0, FS_END ); hb_fsSeek( hFile, 0, FS_SET ); if( ( HB_FOFFSET ) ( size & 0xFFFFFFFFUL ) == size ) { - ulSize = HB_MIN( ( ULONG ) size, 0xFFFFFFFFUL - sizeof( FPTBLOCK ) ); + ulSize = HB_MIN( ( HB_ULONG ) size, 0xFFFFFFFFUL - sizeof( FPTBLOCK ) ); } else { - ulSize = ( ULONG ) HB_MIN( size, ( HB_FOFFSET ) ( 0xFFFFFFFFUL - sizeof( FPTBLOCK ) ) ); + ulSize = ( HB_ULONG ) HB_MIN( size, ( HB_FOFFSET ) ( 0xFFFFFFFFUL - sizeof( FPTBLOCK ) ) ); } if( pArea->bMemoType == DB_MEMO_SMT ) @@ -4330,7 +4330,7 @@ static HB_ERRCODE hb_fptPutValueFile( FPTAREAP pArea, HB_USHORT uiIndex, const c static HB_ERRCODE hb_fptDoPackRec( FPTAREAP pArea ) { HB_ERRCODE errCode = HB_SUCCESS; - ULONG ulBlock, ulSize, ulType; + HB_ULONG ulBlock, ulSize, ulType; HB_USHORT uiField; HB_FOFFSET pos, from; @@ -4374,7 +4374,7 @@ static HB_ERRCODE hb_fptDoPackRec( FPTAREAP pArea ) { from = FPT_BLOCK_OFFSET( ulBlock ); pos = hb_fileSize( pArea->pMemoTmpFile ); - ulBlock = ( ULONG ) ( ( pos + pArea->ulNewBlockSize - 1 ) / + ulBlock = ( HB_ULONG ) ( ( pos + pArea->ulNewBlockSize - 1 ) / pArea->ulNewBlockSize ); pos = ( HB_FOFFSET ) ulBlock * ( HB_FOFFSET ) pArea->ulNewBlockSize; @@ -4432,7 +4432,7 @@ static HB_ERRCODE hb_fptDoPackRec( FPTAREAP pArea ) { from = FPT_BLOCK_OFFSET( ulBlock ); pos = hb_fileSize( pArea->pMemoTmpFile ); - ulBlock = ( ULONG ) ( ( pos + pArea->ulNewBlockSize - 1 ) / + ulBlock = ( HB_ULONG ) ( ( pos + pArea->ulNewBlockSize - 1 ) / pArea->ulNewBlockSize ); pos = ( HB_FOFFSET ) ulBlock * ( HB_FOFFSET ) pArea->ulNewBlockSize; @@ -4464,7 +4464,7 @@ static HB_ERRCODE hb_fptDoPack( FPTAREAP pArea, HB_USHORT uiBlockSize, else if( pArea->fHasMemo && pArea->pMemoFile && pArea->pDataFile ) { char szFile[ HB_PATH_MAX ]; - ULONG ulRecNo, ulRecords; + HB_ULONG ulRecNo, ulRecords; HB_LONG lStep = lEvalStep; if( pEvalBlock && !HB_IS_BLOCK( pEvalBlock ) ) @@ -4533,10 +4533,10 @@ static HB_ERRCODE hb_fptDoPack( FPTAREAP pArea, HB_USHORT uiBlockSize, if( errCode == HB_SUCCESS ) { HB_FOFFSET size = hb_fileSize( pArea->pMemoTmpFile ); - ULONG ulNextBlock; + HB_ULONG ulNextBlock; HB_BYTE buffer[4]; - ulNextBlock = ( ULONG ) ( ( size + pArea->ulNewBlockSize - 1 ) / + ulNextBlock = ( HB_ULONG ) ( ( size + pArea->ulNewBlockSize - 1 ) / pArea->ulNewBlockSize ); if( pArea->bMemoType == DB_MEMO_SMT || pArea->bMemoType == DB_MEMO_DBT ) @@ -4574,7 +4574,7 @@ static HB_ERRCODE hb_fptDoPack( FPTAREAP pArea, HB_USHORT uiBlockSize, * Pack helper function called for each packed record * ( DBENTRYP_LSP ) hb_fptPackRec, */ -static HB_ERRCODE hb_fptPackRec( FPTAREAP pArea, ULONG ulRecNo, HB_BOOL *pfWritten ) +static HB_ERRCODE hb_fptPackRec( FPTAREAP pArea, HB_ULONG ulRecNo, HB_BOOL *pfWritten ) { HB_TRACE(HB_TR_DEBUG, ("hb_fptPackRec(%p, %lu, %p)", pArea, ulRecNo, pfWritten)); @@ -4632,10 +4632,10 @@ static HB_ERRCODE hb_fptPack( FPTAREAP pArea ) if( errCode == HB_SUCCESS ) { HB_FOFFSET size = hb_fileSize( pArea->pMemoTmpFile ); - ULONG ulNextBlock; + HB_ULONG ulNextBlock; HB_BYTE buffer[4]; - ulNextBlock = ( ULONG ) ( ( size + pArea->ulNewBlockSize - 1 ) / + ulNextBlock = ( HB_ULONG ) ( ( size + pArea->ulNewBlockSize - 1 ) / pArea->ulNewBlockSize ); if( pArea->bMemoType == DB_MEMO_SMT || pArea->bMemoType == DB_MEMO_DBT ) @@ -4756,7 +4756,7 @@ static HB_ERRCODE hb_fptInfo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem if( HB_IS_ARRAY( pItem ) ) { - ULONG ulBlock = hb_arrayGetNL( pItem, 1 ); + HB_ULONG ulBlock = hb_arrayGetNL( pItem, 1 ); const char * szFile = hb_arrayGetCPtr( pItem, 2 ); if( ulBlock && szFile && *szFile ) @@ -4770,7 +4770,7 @@ static HB_ERRCODE hb_fptInfo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem case DBI_BLOB_DIRECT_GET: /* BLOBDirectGet() { , , } */ { /* pItem := { , , } */ - ULONG ulBlock, ulStart, ulCount; + HB_ULONG ulBlock, ulStart, ulCount; HB_ERRCODE errCode; if( HB_IS_ARRAY( pItem ) ) @@ -4807,7 +4807,7 @@ static HB_ERRCODE hb_fptInfo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem { /* pItem := { , } */ HB_ERRCODE errCode = EDBF_UNSUPPORTED; - ULONG ulBlock = 0; + HB_ULONG ulBlock = 0; if( HB_IS_ARRAY( pItem ) ) { @@ -4835,7 +4835,7 @@ static HB_ERRCODE hb_fptInfo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem } case DBI_BLOB_ROOT_GET: /* BLOBRootGet() */ { - ULONG ulBlock; + HB_ULONG ulBlock; HB_ERRCODE errCode; errCode = hb_fptGetRootBlock( pArea, &ulBlock ); @@ -4854,7 +4854,7 @@ static HB_ERRCODE hb_fptInfo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem } case DBI_BLOB_ROOT_PUT: /* BLOBRootPut( ) */ { - ULONG ulBlock; + HB_ULONG ulBlock; HB_ERRCODE errCode; errCode = hb_fptGetRootBlock( pArea, &ulBlock ); @@ -4920,7 +4920,7 @@ static HB_ERRCODE hb_fptFieldInfo( FPTAREAP pArea, HB_USHORT uiIndex, HB_USHORT pArea->area.lpFields[ uiIndex - 1 ].uiType == HB_FT_BLOB || pArea->area.lpFields[ uiIndex - 1 ].uiType == HB_FT_OLE ) ) { - ULONG ulBlock, ulSize, ulType; + HB_ULONG ulBlock, ulSize, ulType; HB_BOOL bDeleted; SELF_DELETED( ( AREAP ) pArea, &bDeleted ); @@ -4929,7 +4929,7 @@ static HB_ERRCODE hb_fptFieldInfo( FPTAREAP pArea, HB_USHORT uiIndex, HB_USHORT case DBS_BLOB_GET: /* BLOBGet() { , } */ { /* pItem := { , } */ - ULONG ulStart, ulCount; + HB_ULONG ulStart, ulCount; HB_ERRCODE errCode; HB_BOOL fTrans = FPT_DIRECT_TRANS( pArea ); @@ -4986,7 +4986,7 @@ static HB_ERRCODE hb_fptFieldInfo( FPTAREAP pArea, HB_USHORT uiIndex, HB_USHORT * Retrieve (set) information about RDD * ( DBENTRYP_RSLV ) hb_fptRddInfo */ -static HB_ERRCODE hb_fptRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem ) +static HB_ERRCODE hb_fptRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem ) { LPDBFDATA pData; diff --git a/harbour/src/rdd/dbfnsx/dbfnsx1.c b/harbour/src/rdd/dbfnsx/dbfnsx1.c index b2cddce0b9..f31f88e415 100644 --- a/harbour/src/rdd/dbfnsx/dbfnsx1.c +++ b/harbour/src/rdd/dbfnsx/dbfnsx1.c @@ -136,37 +136,37 @@ static void hb_nsxSetKeyCount( LPPAGEINFO pPage, HB_USHORT uiKeys ) HB_PUT_LE_UINT16( ptr, uiKeys ); } -static ULONG hb_nsxGetLowerPage( LPPAGEINFO pPage ) +static HB_ULONG hb_nsxGetLowerPage( LPPAGEINFO pPage ) { HB_UCHAR * ptr = hb_nsxPageBuffer( pPage ) + 4; return HB_GET_LE_UINT32( ptr ); } -static void hb_nsxSetLowerPage( LPPAGEINFO pPage, ULONG ulPage ) +static void hb_nsxSetLowerPage( LPPAGEINFO pPage, HB_ULONG ulPage ) { HB_UCHAR * ptr = hb_nsxPageBuffer( pPage ) + 4; HB_PUT_LE_UINT32( ptr, ulPage ); } -static ULONG hb_nsxGetKeyPage( LPPAGEINFO pPage, HB_USHORT uiLen, HB_USHORT uiKey ) +static HB_ULONG hb_nsxGetKeyPage( LPPAGEINFO pPage, HB_USHORT uiLen, HB_USHORT uiKey ) { HB_UCHAR * ptr = hb_nsxGetBranchKeyPtr( pPage, uiLen, uiKey ); return HB_GET_LE_UINT32( ptr ); } -static void hb_nsxSetKeyPage( LPPAGEINFO pPage, HB_USHORT uiLen, HB_USHORT uiKey, ULONG ulPage ) +static void hb_nsxSetKeyPage( LPPAGEINFO pPage, HB_USHORT uiLen, HB_USHORT uiKey, HB_ULONG ulPage ) { HB_UCHAR * ptr = hb_nsxGetBranchKeyPtr( pPage, uiLen, uiKey ); HB_PUT_LE_UINT32( ptr, ulPage ); } -static ULONG hb_nsxGetKeyRec( LPPAGEINFO pPage, HB_USHORT uiLen, HB_USHORT uiKey ) +static HB_ULONG hb_nsxGetKeyRec( LPPAGEINFO pPage, HB_USHORT uiLen, HB_USHORT uiKey ) { HB_UCHAR * ptr = hb_nsxGetBranchKeyPtr( pPage, uiLen, uiKey ) + 4; return HB_GET_LE_UINT32( ptr ); } -static void hb_nsxSetKeyRec( LPPAGEINFO pPage, HB_USHORT uiLen, HB_USHORT uiKey, ULONG ulRec ) +static void hb_nsxSetKeyRec( LPPAGEINFO pPage, HB_USHORT uiLen, HB_USHORT uiKey, HB_ULONG ulRec ) { HB_UCHAR * ptr = hb_nsxGetBranchKeyPtr( pPage, uiLen, uiKey ) + 4; HB_PUT_LE_UINT32( ptr, ulRec ); @@ -177,23 +177,23 @@ static HB_UCHAR * hb_nsxGetKeyVal( LPPAGEINFO pPage, HB_USHORT uiLen, HB_USHORT return hb_nsxGetBranchKeyPtr( pPage, uiLen, uiKey ) + 8; } -static void hb_nsxBranchKeySetPage( HB_UCHAR * ptr, ULONG ulPage ) +static void hb_nsxBranchKeySetPage( HB_UCHAR * ptr, HB_ULONG ulPage ) { HB_PUT_LE_UINT32( ptr, ulPage ); } -static void hb_nsxBranchKeySetRec( HB_UCHAR * ptr, ULONG ulRec ) +static void hb_nsxBranchKeySetRec( HB_UCHAR * ptr, HB_ULONG ulRec ) { ptr += 4; HB_PUT_LE_UINT32( ptr, ulRec ); } -static ULONG hb_nsxBranchKeyPage( HB_UCHAR * ptr ) +static HB_ULONG hb_nsxBranchKeyPage( HB_UCHAR * ptr ) { return HB_GET_LE_UINT32( ptr ); } -static ULONG hb_nsxBranchKeyRec( HB_UCHAR * ptr ) +static HB_ULONG hb_nsxBranchKeyRec( HB_UCHAR * ptr ) { ptr += 4; return HB_GET_LE_UINT32( ptr ); @@ -216,7 +216,7 @@ static void hb_nsxLeafSetFreeOffset( LPPAGEINFO pPage, HB_USHORT uiOffset ) /* #define HB_NSX_NO_CORRUPT_PROTECT */ static HB_USHORT hb_nsxLeafGetKey( LPTAGINFO pTag, LPPAGEINFO pPage, HB_USHORT uiOffset, - HB_UCHAR * bPrevValue, ULONG * pulRecNo ) + HB_UCHAR * bPrevValue, HB_ULONG * pulRecNo ) { HB_UCHAR * ptr = ( HB_UCHAR * ) hb_nsxPageBuffer( pPage ); HB_UCHAR ucRecLen = hb_nsxGetKeyRecSizePtr( ptr ), ucSize, ucDupCount; @@ -329,7 +329,7 @@ static HB_USHORT hb_nsxLeafGetKey( LPTAGINFO pTag, LPPAGEINFO pPage, HB_USHORT u } static HB_USHORT hb_nsxLeafPutKey( LPTAGINFO pTag, LPPAGEINFO pPage, HB_USHORT uiOffset, - HB_UCHAR * bPrevValue, HB_UCHAR *pKeyValue, ULONG ulRecNo ) + HB_UCHAR * bPrevValue, HB_UCHAR *pKeyValue, HB_ULONG ulRecNo ) { HB_UCHAR *ptr = ( HB_UCHAR * ) hb_nsxPageBuffer( pPage ) + uiOffset, *pDst, *pSrc, *pEnd; @@ -639,11 +639,11 @@ static HB_USHORT hb_nsxKeyTypeRaw( HB_UCHAR ucType ) * probably not here or we will have to add parameter * for scope key evaluation */ -static LPKEYINFO hb_nsxKeyPutItem( LPKEYINFO pKey, PHB_ITEM pItem, ULONG ulRecNo, +static LPKEYINFO hb_nsxKeyPutItem( LPKEYINFO pKey, PHB_ITEM pItem, HB_ULONG ulRecNo, LPTAGINFO pTag, HB_BOOL fTrans, HB_USHORT *puiLen ) { double d; - ULONG len; + HB_ULONG len; if( !pKey ) pKey = hb_nsxKeyNew( pTag->KeyLength ); @@ -669,11 +669,11 @@ static LPKEYINFO hb_nsxKeyPutItem( LPKEYINFO pKey, PHB_ITEM pItem, ULONG ulRecNo else { len = hb_itemGetCLen( pItem ); - if( len > ( ULONG ) pTag->KeyLength ) + if( len > ( HB_ULONG ) pTag->KeyLength ) len = pTag->KeyLength; memcpy( pKey->val, hb_itemGetCPtr( pItem ), len ); } - if( len < ( ULONG ) pTag->KeyLength ) + if( len < ( HB_ULONG ) pTag->KeyLength ) { memset( pKey->val + len, pTag->TrailChar, pTag->KeyLength - len ); if( puiLen ) @@ -724,7 +724,7 @@ static PHB_ITEM hb_nsxKeyGetItem( PHB_ITEM pItem, LPKEYINFO pKey, case 'C': if( fTrans ) { - ULONG ulLen = pTag->KeyLength; + HB_ULONG ulLen = pTag->KeyLength; char * pszVal = hb_cdpnDup( ( const char * ) pKey->val, &ulLen, pTag->pIndex->pArea->dbfarea.area.cdPage, hb_vmCDP() ); pItem = hb_itemPutCLPtr( pItem, pszVal, ulLen ); @@ -860,8 +860,8 @@ static int hb_nsxValCompare( LPTAGINFO pTag, HB_UCHAR * val1, int len1, if( iLimit > 0 ) { if( pTag->pIndex->pArea->dbfarea.area.cdPage->sort ) - iResult = hb_cdpcmp( ( const char * ) val1, ( ULONG ) iLimit, - ( const char * ) val2, ( ULONG ) iLimit, + iResult = hb_cdpcmp( ( const char * ) val1, ( HB_ULONG ) iLimit, + ( const char * ) val2, ( HB_ULONG ) iLimit, pTag->pIndex->pArea->dbfarea.area.cdPage, 0 ); else iResult = memcmp( val1, val2, iLimit ); @@ -1069,7 +1069,7 @@ static void hb_nsxTagRefreshScope( LPTAGINFO pTag ) /* * an interface for fast check record number in record filter */ -static HB_BOOL hb_nsxCheckRecordScope( NSXAREAP pArea, ULONG ulRec ) +static HB_BOOL hb_nsxCheckRecordScope( NSXAREAP pArea, HB_ULONG ulRec ) { HB_LONG lRecNo = ( HB_LONG ) ulRec; @@ -1084,7 +1084,7 @@ static HB_BOOL hb_nsxCheckRecordScope( NSXAREAP pArea, ULONG ulRec ) static void hb_nsxTagCheckBuffers( LPTAGINFO pTag ) { LPPAGEINFO pPage; - ULONG i; + HB_ULONG i; if( ( pTag->HdrChanged || pTag->pIndex->Changed ) && !pTag->pIndex->lockWrite ) hb_errInternal( 9999, "hb_nsxTagCheckBuffers: tag modified in unlocked index", NULL, NULL ); @@ -1102,7 +1102,7 @@ static void hb_nsxTagCheckBuffers( LPTAGINFO pTag ) static void hb_nsxPageCheckKeys( LPPAGEINFO pPage, LPTAGINFO pTag, int iPos, int iType ) { HB_UCHAR pKeyVal[ NSX_MAXKEYLEN ], pKeyPrev[ NSX_MAXKEYLEN ]; - ULONG ulRecNo = 0, ulPrevRec; + HB_ULONG ulRecNo = 0, ulPrevRec; HB_USHORT uiOffset = NSX_LEAFKEYOFFSET, u; int i; @@ -1175,13 +1175,13 @@ static void hb_nsxPageCheckKeys( LPPAGEINFO pPage, LPTAGINFO pTag, int iPos, int /* * read a given block from index file */ -static HB_BOOL hb_nsxBlockRead( LPNSXINDEX pIndex, ULONG ulBlock, HB_BYTE *buffer, int iSize ) +static HB_BOOL hb_nsxBlockRead( LPNSXINDEX pIndex, HB_ULONG ulBlock, HB_BYTE *buffer, int iSize ) { if( !pIndex->lockRead && !pIndex->lockWrite ) hb_errInternal( 9103, "hb_nsxBlockRead on not locked index file.", NULL, NULL ); if( hb_fileReadAt( pIndex->pFile, buffer, iSize, - hb_nsxFileOffset( pIndex, ulBlock ) ) != ( ULONG ) iSize ) + hb_nsxFileOffset( pIndex, ulBlock ) ) != ( HB_ULONG ) iSize ) { hb_nsxErrorRT( pIndex->pArea, EG_READ, EDBF_READ, pIndex->IndexName, hb_fsError(), 0, NULL ); @@ -1193,13 +1193,13 @@ static HB_BOOL hb_nsxBlockRead( LPNSXINDEX pIndex, ULONG ulBlock, HB_BYTE *buffe /* * write a given block into index file */ -static HB_BOOL hb_nsxBlockWrite( LPNSXINDEX pIndex, ULONG ulBlock, HB_BYTE *buffer, int iSize ) +static HB_BOOL hb_nsxBlockWrite( LPNSXINDEX pIndex, HB_ULONG ulBlock, HB_BYTE *buffer, int iSize ) { if( !pIndex->lockWrite ) hb_errInternal( 9102, "hb_nsxBlockWrite on not locked index file.", NULL, NULL ); if( hb_fileWriteAt( pIndex->pFile, buffer, iSize, - hb_nsxFileOffset( pIndex, ulBlock ) ) != ( ULONG ) iSize ) + hb_nsxFileOffset( pIndex, ulBlock ) ) != ( HB_ULONG ) iSize ) { hb_nsxErrorRT( pIndex->pArea, EG_WRITE, EDBF_WRITE, pIndex->IndexName, hb_fsError(), 0, NULL ); @@ -1286,7 +1286,7 @@ static HB_BOOL hb_nsxTagHeaderCheck( LPTAGINFO pTag ) return pTag->RootBlock != 0; } -static ULONG hb_nsxTagRootBlock( LPTAGINFO pTag ) +static HB_ULONG hb_nsxTagRootBlock( LPTAGINFO pTag ) { if( !pTag->RootBlock ) { @@ -1305,7 +1305,7 @@ static ULONG hb_nsxTagRootBlock( LPTAGINFO pTag ) */ static void hb_nsxFreePageBuffer( LPNSXINDEX pIndex ) { - ULONG ul, ulMax = pIndex->ulPagesDepth; + HB_ULONG ul, ulMax = pIndex->ulPagesDepth; LPPAGEINFO * pPagePtr = pIndex->pages; if( ulMax ) @@ -1347,10 +1347,10 @@ static void hb_nsxIndexTrunc( LPNSXINDEX pIndex ) /* * try to find given tag page in the buffer */ -static LPPAGEINFO hb_nsxPageFind( LPTAGINFO pTag, ULONG ulPage ) +static LPPAGEINFO hb_nsxPageFind( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO * pPagePtr = pTag->pIndex->pages; - ULONG u; + HB_ULONG u; for( u = pTag->pIndex->ulPages; u; u--, pPagePtr++ ) { @@ -1363,7 +1363,7 @@ static LPPAGEINFO hb_nsxPageFind( LPTAGINFO pTag, ULONG ulPage ) /* * try to find free space in buffer */ -static LPPAGEINFO hb_nsxPageGetBuffer( LPTAGINFO pTag, ULONG ulPage ) +static LPPAGEINFO hb_nsxPageGetBuffer( LPTAGINFO pTag, HB_ULONG ulPage ) { LPNSXINDEX pIndex = pTag->pIndex; LPPAGEINFO * pPagePtr; @@ -1403,7 +1403,7 @@ static LPPAGEINFO hb_nsxPageGetBuffer( LPTAGINFO pTag, ULONG ulPage ) } else { - ULONG ul = pIndex->ulPageLast; + HB_ULONG ul = pIndex->ulPageLast; for( ; ; ) { if( ++ul >= pIndex->ulPagesDepth ) @@ -1491,7 +1491,7 @@ static void hb_nsxPageRelease( LPTAGINFO pTag, LPPAGEINFO pPage ) /* * load page from index file or the buffer */ -static LPPAGEINFO hb_nsxPageLoad( LPTAGINFO pTag, ULONG ulPage ) +static LPPAGEINFO hb_nsxPageLoad( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO pPage; @@ -1577,7 +1577,7 @@ static void hb_nsxPageFree( LPTAGINFO pTag, LPPAGEINFO pPage ) /* * add given page to list of free pages */ -static void hb_nsxPageAddFree( LPTAGINFO pTag, ULONG ulPage ) +static void hb_nsxPageAddFree( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO pPage = hb_nsxPageGetBuffer( pTag, ulPage ); pPage->Changed = HB_TRUE; @@ -1590,14 +1590,14 @@ static void hb_nsxPageAddFree( LPTAGINFO pTag, ULONG ulPage ) /* * allocate new page address */ -static ULONG hb_nsxPageAlloc( LPNSXINDEX pIndex ) +static HB_ULONG hb_nsxPageAlloc( LPNSXINDEX pIndex ) { - ULONG ulPage; + HB_ULONG ulPage; if( !pIndex->FileSize ) { HB_FOFFSET fOffset; fOffset = hb_fileSize( pIndex->pFile ); - pIndex->FileSize = ( ULONG ) + pIndex->FileSize = ( HB_ULONG ) ( fOffset >> ( pIndex->LargeFile ? NSX_PAGELEN_BITS : 0 ) ); } ulPage = pIndex->FileSize; @@ -1636,10 +1636,10 @@ static LPPAGEINFO hb_nsxPageNew( LPTAGINFO pTag, HB_BOOL fNull ) /* * get free page in index file */ -static ULONG hb_nsxPageGetFree( LPTAGINFO pTag ) +static HB_ULONG hb_nsxPageGetFree( LPTAGINFO pTag ) { LPPAGEINFO pPage = hb_nsxPageNew( pTag, HB_FALSE ); - ULONG ulPage = 0; + HB_ULONG ulPage = 0; if( pPage ) { @@ -1771,7 +1771,7 @@ static HB_ERRCODE hb_nsxTagAdd( LPNSXINDEX pIndex, LPTAGINFO pTag ) /* * create new tag and load it from index file */ -static LPTAGINFO hb_nsxTagLoad( LPNSXINDEX pIndex, ULONG ulBlock, +static LPTAGINFO hb_nsxTagLoad( LPNSXINDEX pIndex, HB_ULONG ulBlock, const char * szTagName, LPNSXTAGHEADER lpNSX ) { LPTAGINFO pTag; @@ -1867,7 +1867,7 @@ static void hb_nsxIndexTagDel( LPNSXINDEX pIndex, const char * szTagName ) /* * find tag header block in NSX header */ -static ULONG hb_nsxIndexTagFind( LPNSXROOTHEADER lpNSX, const char * szTagName ) +static HB_ULONG hb_nsxIndexTagFind( LPNSXROOTHEADER lpNSX, const char * szTagName ) { int iTags = HB_GET_LE_UINT16( lpNSX->TagCount ), i; LPNSXTAGITEM pTagItem = lpNSX->TagList; @@ -2036,7 +2036,7 @@ static HB_ERRCODE hb_nsxIndexLoad( LPNSXINDEX pIndex ) NSXTAGHEADER tagbuffer; int iTags = HB_GET_LE_UINT16( pIndex->HeaderBuff.TagCount ); LPNSXTAGITEM pTagItem = pIndex->HeaderBuff.TagList; - ULONG ulBlock; + HB_ULONG ulBlock; if( iTags > NSX_MAXTAGS ) return HB_FAILURE; @@ -2081,7 +2081,7 @@ static HB_ERRCODE hb_nsxIndexHeaderRead( LPNSXINDEX pIndex ) } else { - ULONG ulVersion, ulNext, ulFileSize; + HB_ULONG ulVersion, ulNext, ulFileSize; ulVersion = HB_GET_LE_UINT16( pIndex->HeaderBuff.Version ); ulNext = HB_GET_LE_UINT32( pIndex->HeaderBuff.FreePage ); @@ -2364,7 +2364,7 @@ static HB_BOOL hb_nsxTagGetPrevKey( LPTAGINFO pTag, HB_UCHAR * pKeyVal, int iLev * decode key from leaf page into given buffer */ static HB_BOOL hb_nsxPageGetLeafKey( LPTAGINFO pTag, LPPAGEINFO pPage, HB_USHORT uiKey, - HB_UCHAR * pKeyVal, ULONG * pulRecNo ) + HB_UCHAR * pKeyVal, HB_ULONG * pulRecNo ) { HB_USHORT uiOffset = NSX_LEAFKEYOFFSET; @@ -2477,7 +2477,7 @@ static void hb_nsxTagSetPageStack( LPTAGINFO pTag, LPPAGEINFO pPage, HB_USHORT u /* * go down from the given index page to the first key */ -static LPPAGEINFO hb_nsxPageTopMove( LPTAGINFO pTag, ULONG ulPage ) +static LPPAGEINFO hb_nsxPageTopMove( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO pPage; @@ -2507,7 +2507,7 @@ static LPPAGEINFO hb_nsxPageTopMove( LPTAGINFO pTag, ULONG ulPage ) /* * go down from the given index page to the last key */ -static LPPAGEINFO hb_nsxPageBottomMove( LPTAGINFO pTag, ULONG ulPage ) +static LPPAGEINFO hb_nsxPageBottomMove( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO pPage; @@ -2580,7 +2580,7 @@ static HB_BOOL hb_nsxTagNextKey( LPTAGINFO pTag ) { int iLevel = pTag->stackLevel - 1; LPPAGEINFO pPage; - ULONG ulPage; + HB_ULONG ulPage; HB_BOOL fFound; if( iLevel >= 0 ) @@ -2638,7 +2638,7 @@ static HB_BOOL hb_nsxTagPrevKey( LPTAGINFO pTag ) { int iLevel = pTag->stackLevel - 1; LPPAGEINFO pPage; - ULONG ulPage; + HB_ULONG ulPage; HB_BOOL fFound; if( iLevel >= 0 ) @@ -2697,10 +2697,10 @@ static HB_BOOL hb_nsxTagPrevKey( LPTAGINFO pTag ) */ static int hb_nsxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage, HB_UCHAR * key, HB_SHORT keylen, int mode, - HB_BOOL fLast, ULONG ulRecNo, HB_BOOL *fStop ) + HB_BOOL fLast, HB_ULONG ulRecNo, HB_BOOL *fStop ) { int iBegin, iEnd, iLast, k, i; - ULONG ulRec; + HB_ULONG ulRec; *fStop = HB_FALSE; @@ -2798,7 +2798,7 @@ static int hb_nsxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage, static HB_BOOL hb_nsxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, HB_USHORT uiLen ) { LPPAGEINFO pPage; - ULONG ulPage, ulRecNo = 0; + HB_ULONG ulPage, ulRecNo = 0; int iKey; HB_BOOL fStop = HB_FALSE, fLast = HB_FALSE, fOut; @@ -2989,7 +2989,7 @@ static HB_BOOL hb_nsxTagInsertKey( LPTAGINFO pTag, LPPAGEINFO pPage, uiKey = pTag->stack[ pTag->stackLevel - 1 ].ikey, uiKeys = pPage->uiKeys, uiHalfOffset = 0, uiHalfKeys = 0, u; int iLen = pTag->KeyLength; - ULONG ulRecNo; + HB_ULONG ulRecNo; HB_UCHAR pKeyVal[ NSX_MAXKEYLEN ], * pKeyBuff, * ptr, ucRecSize; LPKEYINFO pNewKey = NULL; @@ -3175,12 +3175,12 @@ static HB_BOOL hb_nsxTagInsertKey( LPTAGINFO pTag, LPPAGEINFO pPage, static HB_BOOL hb_nsxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey ) { LPPAGEINFO pPage; - ULONG ulPage; + HB_ULONG ulPage; HB_BOOL fFound, fBottom = HB_FALSE; if( pTag->UniqueKey ) { - ULONG ulRecNo = pKey->rec; + HB_ULONG ulRecNo = pKey->rec; pKey->rec = NSX_IGNORE_REC_NUM; fFound = hb_nsxTagKeyFind( pTag, pKey, pTag->KeyLength ); @@ -3230,7 +3230,7 @@ static HB_BOOL hb_nsxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey ) static void hb_nsxPageLeafKeyDel( LPTAGINFO pTag, LPPAGEINFO pPage, HB_USHORT uiKey ) { HB_UCHAR pKeyVal[ NSX_MAXKEYLEN ], pKeyVal2[ NSX_MAXKEYLEN ], * pPrevVal = NULL; - ULONG ulRecNo; + HB_ULONG ulRecNo; HB_USHORT uiOffset = NSX_LEAFKEYOFFSET, u; HB_BOOL fPrev; @@ -3282,7 +3282,7 @@ static HB_BOOL hb_nsxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey ) { int iLevel, iKey, iBaseLevel, iBaseKey; LPPAGEINFO pBasePage, pPage; - ULONG ulPage, ulRecNo; + HB_ULONG ulPage, ulRecNo; HB_BOOL fResult = HB_TRUE; pKey->page = 0; @@ -3596,10 +3596,10 @@ static void hb_nsxTagSkipPrev( LPTAGINFO pTag ) /* * count keys in the given page and all subpages */ -static ULONG hb_nsxPageCountKeys( LPTAGINFO pTag, ULONG ulPage ) +static HB_ULONG hb_nsxPageCountKeys( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO pPage = hb_nsxPageLoad( pTag, ulPage ); - ULONG ulKeys; + HB_ULONG ulKeys; if( ! pPage ) return 0; @@ -3655,7 +3655,7 @@ static double hb_nsxTagCountRelKeyPos( LPTAGINFO pTag ) static void hb_nsxTagGoToRelKeyPos( LPTAGINFO pTag, double dPos ) { LPPAGEINFO pPage; - ULONG ulPage; + HB_ULONG ulPage; int iKey, iKeys; if( pTag->fUsrDescend ) @@ -3712,7 +3712,7 @@ static void hb_nsxTagGoToRelKeyPos( LPTAGINFO pTag, double dPos ) /* * free pages allocated by tag */ -static HB_BOOL hb_nsxTagPagesFree( LPTAGINFO pTag, ULONG ulPage ) +static HB_BOOL hb_nsxTagPagesFree( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO pPage = hb_nsxPageLoad( pTag, ulPage ); HB_BOOL fOK = pPage != NULL; @@ -4010,9 +4010,9 @@ static int hb_nsxTagCount( NSXAREAP pArea ) /* * count number of keys in given tag */ -static ULONG hb_nsxOrdKeyCount( LPTAGINFO pTag ) +static HB_ULONG hb_nsxOrdKeyCount( LPTAGINFO pTag ) { - ULONG ulKeyCount = 0; + HB_ULONG ulKeyCount = 0; if( !pTag->pIndex->fShared && pTag->keyCount && !pTag->pIndex->pArea->dbfarea.area.dbfi.fFilter ) @@ -4047,9 +4047,9 @@ static ULONG hb_nsxOrdKeyCount( LPTAGINFO pTag ) /* * get the logical key position in the given tag */ -static ULONG hb_nsxOrdKeyNo( LPTAGINFO pTag ) +static HB_ULONG hb_nsxOrdKeyNo( LPTAGINFO pTag ) { - ULONG ulKeyNo = 0; + HB_ULONG ulKeyNo = 0; if( hb_nsxTagLockRead( pTag ) ) { @@ -4125,7 +4125,7 @@ static ULONG hb_nsxOrdKeyNo( LPTAGINFO pTag ) /* * set logical key position in given tag */ -static HB_BOOL hb_nsxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo ) +static HB_BOOL hb_nsxOrdKeyGoto( LPTAGINFO pTag, HB_ULONG ulKeyNo ) { NSXAREAP pArea = pTag->pIndex->pArea; @@ -4145,7 +4145,7 @@ static HB_BOOL hb_nsxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo ) int iLevel = pTag->stackLevel - 1, iKey; HB_BOOL fBack = pTag->fUsrDescend, fFirst = HB_TRUE; LPPAGEINFO pPage; - ULONG ulPage; + HB_ULONG ulPage; --ulKeyNo; while( ulKeyNo != 0 && iLevel >= 0 ) @@ -4158,7 +4158,7 @@ static HB_BOOL hb_nsxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo ) { if( hb_nsxIsLeaf( pPage ) ) { - if( ( ULONG ) iKey < ulKeyNo ) + if( ( HB_ULONG ) iKey < ulKeyNo ) { --iLevel; ulKeyNo -= iKey; @@ -4214,7 +4214,7 @@ static HB_BOOL hb_nsxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo ) else { iKey = pPage->uiKeys - iKey - 1; - if( ( ULONG ) iKey < ulKeyNo ) + if( ( HB_ULONG ) iKey < ulKeyNo ) { --iLevel; ulKeyNo -= iKey; @@ -4531,7 +4531,7 @@ static HB_BOOL hb_nsxOrdSkipEval( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pEv break; if( hb_nsxEvalSeekCond( pTag, pEval ) ) { - ULONG ulRecNo = pArea->dbfarea.ulRecNo; + HB_ULONG ulRecNo = pArea->dbfarea.ulRecNo; if( SELF_SKIPFILTER( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS || pArea->dbfarea.ulRecNo == ulRecNo || hb_nsxEvalSeekCond( pTag, pEval ) ) { @@ -4645,7 +4645,7 @@ static HB_BOOL hb_nsxOrdSkipWild( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pWi { if( hb_strMatchWild( ( const char * ) pTag->CurKeyInfo->val, szPattern ) ) { - ULONG ulRecNo = pTag->CurKeyInfo->rec; + HB_ULONG ulRecNo = pTag->CurKeyInfo->rec; if( SELF_GOTO( ( AREAP ) pArea, ulRecNo ) != HB_SUCCESS ) break; if( SELF_SKIPFILTER( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS || @@ -4695,7 +4695,7 @@ static HB_BOOL hb_nsxOrdSkipWild( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pWi static HB_BOOL hb_nsxRegexMatch( LPTAGINFO pTag, PHB_REGEX pRegEx, const char * szKey ) { - ULONG ulLen = pTag->KeyLength; + HB_ULONG ulLen = pTag->KeyLength; char szBuff[ NSX_MAXKEYLEN + 1 ]; if( pTag->pIndex->pArea->dbfarea.area.cdPage != hb_vmCDP() ) @@ -4752,7 +4752,7 @@ static HB_BOOL hb_nsxOrdSkipRegEx( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pR if( hb_nsxRegexMatch( pTag, pRegEx, ( const char * ) pTag->CurKeyInfo->val ) ) { - ULONG ulRecNo = pArea->dbfarea.ulRecNo; + HB_ULONG ulRecNo = pArea->dbfarea.ulRecNo; if( SELF_SKIPFILTER( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS || pArea->dbfarea.ulRecNo == ulRecNo || hb_nsxRegexMatch( pTag, pRegEx, ( const char * ) pTag->CurKeyInfo->val ) ) @@ -4886,7 +4886,7 @@ static HB_BOOL hb_nsxOrdKeyDel( LPTAGINFO pTag, PHB_ITEM pItem ) * custom indexes when the same record can be stored more then once * or when the used index key is unknown */ -static HB_BOOL hb_nsxOrdFindRec( LPTAGINFO pTag, ULONG ulRecNo, HB_BOOL fCont ) +static HB_BOOL hb_nsxOrdFindRec( LPTAGINFO pTag, HB_ULONG ulRecNo, HB_BOOL fCont ) { NSXAREAP pArea = pTag->pIndex->pArea; HB_BOOL fFound = HB_FALSE; @@ -4932,11 +4932,11 @@ static HB_BOOL hb_nsxOrdFindRec( LPTAGINFO pTag, ULONG ulRecNo, HB_BOOL fCont ) /* * evaluate given C function in given scope */ -static ULONG hb_nsxOrdScopeEval( LPTAGINFO pTag, - HB_EVALSCOPE_FUNC pFunc, void *pParam, - PHB_ITEM pItemLo, PHB_ITEM pItemHi ) +static HB_ULONG hb_nsxOrdScopeEval( LPTAGINFO pTag, + HB_EVALSCOPE_FUNC pFunc, void *pParam, + PHB_ITEM pItemLo, PHB_ITEM pItemHi ) { - ULONG ulCount = 0, ulLen = ( ULONG ) pTag->KeyLength; + HB_ULONG ulCount = 0, ulLen = ( HB_ULONG ) pTag->KeyLength; PHB_ITEM pItemTop = hb_itemNew( NULL ), pItemBottom = hb_itemNew( NULL ); HB_BOOL fDescend = pTag->fUsrDescend; @@ -5045,7 +5045,7 @@ static HB_BOOL hb_nsxQSort( LPNSXSORTINFO pSort, HB_UCHAR * pSrc, HB_UCHAR * pBu static void hb_nsxSortSortPage( LPNSXSORTINFO pSort ) { - ULONG ulSize = pSort->ulKeys * ( pSort->keyLen + 4 ); + HB_ULONG ulSize = pSort->ulKeys * ( pSort->keyLen + 4 ); if( !hb_nsxQSort( pSort, pSort->pKeyPool, &pSort->pKeyPool[ ulSize ], pSort->ulKeys ) ) { pSort->pStartKey = &pSort->pKeyPool[ ulSize ]; @@ -5058,7 +5058,7 @@ static void hb_nsxSortSortPage( LPNSXSORTINFO pSort ) static void hb_nsxSortBufferFlush( LPNSXSORTINFO pSort ) { - ULONG ulSize; + HB_ULONG ulSize; if( pSort->ulPagesIO ) { LPNSXINDEX pIndex = pSort->pTag->pIndex; @@ -5108,10 +5108,10 @@ static void hb_nsxSortStorePage( LPNSXSORTINFO pSort, LPPAGEINFO pPage ) hb_nsxPageSave( pIndex, pPage ); } -static void hb_nsxSortAddNodeKey( LPNSXSORTINFO pSort, HB_UCHAR *pKeyVal, ULONG ulRec ) +static void hb_nsxSortAddNodeKey( LPNSXSORTINFO pSort, HB_UCHAR *pKeyVal, HB_ULONG ulRec ) { LPPAGEINFO pPage; - ULONG ulPage = 0; + HB_ULONG ulPage = 0; int iLevel = 0; for( ;; ) @@ -5191,7 +5191,7 @@ static void hb_nsxSortAddNodeKey( LPNSXSORTINFO pSort, HB_UCHAR *pKeyVal, ULONG static void hb_nsxSortWritePage( LPNSXSORTINFO pSort ) { - ULONG ulSize = pSort->ulKeys * ( pSort->keyLen + 4 ); + HB_ULONG ulSize = pSort->ulKeys * ( pSort->keyLen + 4 ); hb_nsxSortSortPage( pSort ); @@ -5220,15 +5220,15 @@ static void hb_nsxSortWritePage( LPNSXSORTINFO pSort ) pSort->ulCurPage++; } -static void hb_nsxSortGetPageKey( LPNSXSORTINFO pSort, ULONG ulPage, - HB_UCHAR ** pKeyVal, ULONG *pulRec ) +static void hb_nsxSortGetPageKey( LPNSXSORTINFO pSort, HB_ULONG ulPage, + HB_UCHAR ** 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( pSort->hTempFile != FS_ERROR && ( hb_fsSeekLarge( pSort->hTempFile, pSort->pSwapPage[ ulPage ].nOffset, FS_SET ) != pSort->pSwapPage[ ulPage ].nOffset || @@ -5249,11 +5249,11 @@ static void hb_nsxSortOrderPages( LPNSXSORTINFO pSort ) { int iLen = pSort->keyLen, i; HB_LONG l, r, m; - ULONG n, ulPage, ulRec; + HB_ULONG n, ulPage, ulRec; HB_UCHAR *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 ) @@ -5283,11 +5283,11 @@ static void hb_nsxSortOrderPages( LPNSXSORTINFO pSort ) } } -static HB_BOOL hb_nsxSortKeyGet( LPNSXSORTINFO pSort, HB_UCHAR ** pKeyVal, ULONG *pulRec ) +static HB_BOOL hb_nsxSortKeyGet( LPNSXSORTINFO pSort, HB_UCHAR ** pKeyVal, HB_ULONG *pulRec ) { int iLen = pSort->keyLen, i; HB_LONG l, r, m; - ULONG ulPage; + HB_ULONG ulPage; ulPage = pSort->pSortedPages[ pSort->ulFirst ]; @@ -5295,7 +5295,7 @@ static HB_BOOL hb_nsxSortKeyGet( LPNSXSORTINFO pSort, HB_UCHAR ** pKeyVal, ULONG if( pSort->pSwapPage[ ulPage ].ulKeys > 0 ) { HB_UCHAR *pKey, *pTmp; - ULONG ulRec, ulPg; + HB_ULONG ulRec, ulPg; /* * last key was taken from this page - we have to resort it. @@ -5350,7 +5350,7 @@ static HB_BOOL hb_nsxSortKeyGet( LPNSXSORTINFO pSort, HB_UCHAR ** pKeyVal, ULONG return HB_FALSE; } -static void hb_nsxSortKeyAdd( LPNSXSORTINFO pSort, ULONG ulRec, const char * pKeyVal, int iKeyLen ) +static void hb_nsxSortKeyAdd( LPNSXSORTINFO pSort, HB_ULONG ulRec, const char * pKeyVal, int iKeyLen ) { int iLen = pSort->keyLen; HB_UCHAR *pDst; @@ -5375,12 +5375,12 @@ static void hb_nsxSortKeyAdd( LPNSXSORTINFO pSort, ULONG ulRec, const char * pKe pSort->ulTotKeys++; } -static LPNSXSORTINFO hb_nsxSortNew( LPTAGINFO pTag, ULONG ulRecCount ) +static LPNSXSORTINFO hb_nsxSortNew( LPTAGINFO pTag, HB_ULONG ulRecCount ) { LPNSXSORTINFO pSort; HB_UCHAR * pBuf; int iLen = pTag->KeyLength; - ULONG ulSize, ulMax, ulMin; + HB_ULONG ulSize, ulMax, ulMin; if( ulRecCount == 0 ) ulRecCount = 1; @@ -5388,8 +5388,8 @@ static LPNSXSORTINFO hb_nsxSortNew( LPTAGINFO pTag, ULONG ulRecCount ) pSort = ( LPNSXSORTINFO ) hb_xgrab( sizeof( NSXSORTINFO ) ); memset( pSort, 0, sizeof( NSXSORTINFO ) ); - ulMin = ( ULONG ) ceil( sqrt( ( double ) ulRecCount ) ); - ulMax = ( ( ULONG ) ceil( sqrt( ( double ) ulRecCount / ( iLen + 4 ) ) ) ) << 7; + ulMin = ( HB_ULONG ) ceil( sqrt( ( double ) ulRecCount ) ); + ulMax = ( ( HB_ULONG ) ceil( sqrt( ( double ) ulRecCount / ( iLen + 4 ) ) ) ) << 7; /* * this effectively increase allocated memory buffer for very large files * moving the maximum to: 267'443'712 for 4'294'967'295 records and 250 @@ -5505,7 +5505,7 @@ static void hb_nsxSortOut( LPNSXSORTINFO pSort ) { HB_BOOL fUnique = pSort->fUnique, fNext; LPTAGINFO pTag = pSort->pTag; - ULONG ulLastPage = 0, ulPage, ulRec, ulKey; + HB_ULONG ulLastPage = 0, ulPage, ulRec, ulKey; HB_UCHAR * pKeyVal = NULL; int iLen = pSort->keyLen, iLevel; @@ -5734,7 +5734,7 @@ static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO pTag, HB_BOOL fReindex ) { LPNSXAREA pArea = pTag->pIndex->pArea; PHB_ITEM pForItem, pWhileItem = NULL, pEvalItem = NULL, pItem = NULL; - ULONG ulRecCount, ulRecNo = pArea->dbfarea.ulRecNo; + HB_ULONG ulRecCount, ulRecNo = pArea->dbfarea.ulRecNo; LPNSXSORTINFO pSort; HB_LONG lStep = 0; HB_ERRCODE errCode = HB_SUCCESS; @@ -5788,7 +5788,7 @@ static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO pTag, HB_BOOL fReindex ) else { LPTAGINFO pSaveTag = pArea->lpCurTag; - ULONG ulStartRec = 0, ulNextCount = 0; + HB_ULONG ulStartRec = 0, ulNextCount = 0; HB_BOOL fDirectRead, fUseFilter = HB_FALSE; HB_BYTE * pSaveRecBuff = pArea->dbfarea.pRecord; char szBuffer[ NSX_MAXKEYLEN ]; @@ -5869,11 +5869,11 @@ static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO 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->pBuffIO, pArea->dbfarea.uiRecordLen * iRec, ( HB_FOFFSET ) pArea->dbfarea.uiHeaderLen + @@ -6130,7 +6130,7 @@ static HB_ERRCODE hb_nsxSeek( NSXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pItem, HB_ERRCODE retval = HB_SUCCESS; HB_BOOL fEOF = HB_FALSE, fLast; HB_USHORT uiLen; - ULONG ulRec; + HB_ULONG ulRec; if( pArea->dbfarea.lpdbPendingRel && pArea->dbfarea.lpdbPendingRel->isScoped ) SELF_FORCEREL( ( AREAP ) pArea ); @@ -6613,7 +6613,7 @@ static HB_ERRCODE hb_nsxOrderCreate( NSXAREAP pArea, LPDBORDERCREATEINFO pOrderI LPNSXINDEX pIndex, * pIndexPtr; LPTAGINFO pTag = NULL; HB_ERRCODE errCode; - ULONG ulRecNo; + HB_ULONG ulRecNo; HB_BOOL fNewFile, fProd, fLocked = HB_FALSE, fAscend = HB_TRUE, fCustom = HB_FALSE, fTemporary = HB_FALSE, fExclusive = HB_FALSE; HB_BYTE bType, bTrail; @@ -7585,7 +7585,7 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, HB_USHORT uiIndex, LPDBORDERI case DBOI_KEYCOUNT: case DBOI_KEYCOUNTRAW: { - ULONG ulRecCount = 0; + HB_ULONG ulRecCount = 0; SELF_RECCOUNT( ( AREAP ) pArea, &ulRecCount ); hb_itemPutNInt( pInfo->itmResult, ulRecCount ); break; @@ -7615,9 +7615,9 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, HB_USHORT uiIndex, LPDBORDERI } 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; if( SELF_GOTO( ( AREAP ) pArea, ulRecNo ) == HB_SUCCESS && @@ -7629,7 +7629,7 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, HB_USHORT uiIndex, LPDBORDERI } else { - ULONG ulRecNo = 0, ulRecCount = 0; + HB_ULONG ulRecNo = 0, ulRecCount = 0; double dPos = 0.0; /* resolve any pending relations */ if( SELF_RECNO( ( AREAP ) pArea, &ulRecNo ) == HB_SUCCESS ) @@ -7962,7 +7962,7 @@ static HB_ERRCODE hb_nsxOrderListRebuild( NSXAREAP pArea ) return errCode; } -static HB_ERRCODE hb_nsxRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem ) +static HB_ERRCODE hb_nsxRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem ) { LPDBFDATA pData; diff --git a/harbour/src/rdd/dbfntx/dbfntx1.c b/harbour/src/rdd/dbfntx/dbfntx1.c index c4eca2ffb7..d705690276 100644 --- a/harbour/src/rdd/dbfntx/dbfntx1.c +++ b/harbour/src/rdd/dbfntx/dbfntx1.c @@ -148,8 +148,8 @@ #include "hbapicdp.h" #ifdef HB_NTX_DEBUG_DISP - static ULONG s_rdNO = 0; - static ULONG s_wrNO = 0; + static HB_ULONG s_rdNO = 0; + static HB_ULONG s_wrNO = 0; #endif static RDDFUNCS ntxSuper; @@ -214,13 +214,13 @@ static char * hb_ntxGetKeyPtr( LPPAGEINFO pPage, HB_SHORT iKey ) return hb_ntxPageBuffer( pPage ) + hb_ntxGetKeyOffset( pPage, iKey ); } -static ULONG hb_ntxGetKeyPage( LPPAGEINFO pPage, HB_SHORT iKey ) +static HB_ULONG hb_ntxGetKeyPage( LPPAGEINFO pPage, HB_SHORT iKey ) { char * ptr = hb_ntxGetKeyPtr( pPage, iKey ); return HB_GET_LE_UINT32( ptr ); } -static void hb_ntxSetKeyPage( LPPAGEINFO pPage, HB_SHORT iKey, ULONG ulPage ) +static void hb_ntxSetKeyPage( LPPAGEINFO pPage, HB_SHORT iKey, HB_ULONG ulPage ) { char * ptr = hb_ntxGetKeyPtr( pPage, iKey ); HB_PUT_LE_UINT32( ptr, ulPage ); @@ -231,13 +231,13 @@ static char * hb_ntxGetKeyVal( LPPAGEINFO pPage, HB_SHORT iKey ) return hb_ntxGetKeyPtr( pPage, iKey ) + 8; } -static void hb_ntxSetKeyRec( LPPAGEINFO pPage, HB_SHORT iKey, ULONG ulRec ) +static void hb_ntxSetKeyRec( LPPAGEINFO pPage, HB_SHORT iKey, HB_ULONG ulRec ) { char * ptr = hb_ntxGetKeyPtr( pPage, iKey ) + 4; HB_PUT_LE_UINT32( ptr, ulRec ); } -static ULONG hb_ntxGetKeyRec( LPPAGEINFO pPage, HB_SHORT iKey ) +static HB_ULONG hb_ntxGetKeyRec( LPPAGEINFO pPage, HB_SHORT iKey ) { char * ptr = hb_ntxGetKeyPtr( pPage, iKey ) + 4; return HB_GET_LE_UINT32( ptr ); @@ -424,10 +424,10 @@ static HB_BYTE hb_ntxItemTypeCmp( HB_BYTE bType ) * probably not here or we will have to add parameter * for scope key evaluation */ -static LPKEYINFO hb_ntxKeyPutItem( LPKEYINFO pKey, PHB_ITEM pItem, ULONG ulRecNo, +static LPKEYINFO hb_ntxKeyPutItem( LPKEYINFO pKey, PHB_ITEM pItem, HB_ULONG ulRecNo, LPTAGINFO pTag, HB_BOOL fTrans, HB_USHORT *puiLen ) { - ULONG len; + HB_ULONG len; if( !pKey ) pKey = hb_ntxKeyNew( NULL, pTag->KeyLength ); @@ -448,11 +448,11 @@ static LPKEYINFO hb_ntxKeyPutItem( LPKEYINFO pKey, PHB_ITEM pItem, ULONG ulRecNo else { len = hb_itemGetCLen( pItem ); - if( len > ( ULONG ) pTag->KeyLength ) + if( len > ( HB_ULONG ) pTag->KeyLength ) len = pTag->KeyLength; memcpy( pKey->key, hb_itemGetCPtr( pItem ), len ); } - if( len < ( ULONG ) pTag->KeyLength ) + if( len < ( HB_ULONG ) pTag->KeyLength ) { memset( pKey->key + len, ' ', pTag->KeyLength - len ); if( puiLen ) @@ -516,7 +516,7 @@ static PHB_ITEM hb_ntxKeyGetItem( PHB_ITEM pItem, LPKEYINFO pKey, case 'C': if( fTrans ) { - ULONG ulLen = pTag->KeyLength; + HB_ULONG ulLen = pTag->KeyLength; char * pszVal = hb_cdpnDup( pKey->key, &ulLen, pTag->Owner->Owner->dbfarea.area.cdPage, hb_vmCDP() ); pItem = hb_itemPutCLPtr( pItem, pszVal, ulLen ); @@ -680,7 +680,7 @@ static int hb_ntxValCompare( LPTAGINFO pTag, const char* val1, int len1, if( iLimit > 0 ) { if( pTag->Owner->Owner->dbfarea.area.cdPage->sort ) - iResult = hb_cdpcmp( val1, ( ULONG ) iLimit, val2, ( ULONG ) iLimit, pTag->Owner->Owner->dbfarea.area.cdPage, 0 ); + iResult = hb_cdpcmp( val1, ( HB_ULONG ) iLimit, val2, ( HB_ULONG ) iLimit, pTag->Owner->Owner->dbfarea.area.cdPage, 0 ); else iResult = memcmp( val1, val2, iLimit ); } @@ -874,7 +874,7 @@ static void hb_ntxTagRefreshScope( LPTAGINFO pTag ) /* * an interface for fast check record number in record filter */ -static HB_BOOL hb_ntxCheckRecordScope( NTXAREAP pArea, ULONG ulRec ) +static HB_BOOL hb_ntxCheckRecordScope( NTXAREAP pArea, HB_ULONG ulRec ) { HB_LONG lRecNo = ( HB_LONG ) ulRec; @@ -889,7 +889,7 @@ static HB_BOOL hb_ntxCheckRecordScope( NTXAREAP pArea, ULONG ulRec ) static void hb_ntxTagCheckBuffers( LPTAGINFO pTag ) { LPPAGEINFO pPage; - ULONG i; + HB_ULONG i; if( ( pTag->HdrChanged || pTag->Owner->Changed ) && !pTag->Owner->lockWrite ) hb_errInternal( 9301, "hb_ntxTagCheckBuffers: tag modified in unlocked index", NULL, NULL ); @@ -931,7 +931,7 @@ static void hb_ntxPageCheckKeys( LPPAGEINFO pPage, LPTAGINFO pTag, int iPos, int /* * read a given block from index file */ -static HB_BOOL hb_ntxBlockRead( LPNTXINDEX pIndex, ULONG ulBlock, HB_BYTE *buffer, int iSize ) +static HB_BOOL hb_ntxBlockRead( LPNTXINDEX pIndex, HB_ULONG ulBlock, HB_BYTE *buffer, int iSize ) { if( !pIndex->lockRead && !pIndex->lockWrite ) hb_errInternal( 9103, "hb_ntxBlockRead on not locked index file.", NULL, NULL ); @@ -940,7 +940,7 @@ static HB_BOOL hb_ntxBlockRead( LPNTXINDEX pIndex, ULONG ulBlock, HB_BYTE *buffe s_rdNO++; #endif if( hb_fileReadAt( pIndex->DiskFile, buffer, iSize, - hb_ntxFileOffset( pIndex, ulBlock ) ) != ( ULONG ) iSize ) + hb_ntxFileOffset( pIndex, ulBlock ) ) != ( HB_ULONG ) iSize ) { hb_ntxErrorRT( pIndex->Owner, EG_READ, EDBF_READ, pIndex->IndexName, hb_fsError(), 0, NULL ); @@ -952,7 +952,7 @@ static HB_BOOL hb_ntxBlockRead( LPNTXINDEX pIndex, ULONG ulBlock, HB_BYTE *buffe /* * write a given block into index file */ -static HB_BOOL hb_ntxBlockWrite( LPNTXINDEX pIndex, ULONG ulBlock, HB_BYTE *buffer, int iSize ) +static HB_BOOL hb_ntxBlockWrite( LPNTXINDEX pIndex, HB_ULONG ulBlock, HB_BYTE *buffer, int iSize ) { if( !pIndex->lockWrite ) hb_errInternal( 9102, "hb_ntxBlockWrite on not locked index file.", NULL, NULL ); @@ -961,7 +961,7 @@ static HB_BOOL hb_ntxBlockWrite( LPNTXINDEX pIndex, ULONG ulBlock, HB_BYTE *buff s_wrNO++; #endif if( hb_fileWriteAt( pIndex->DiskFile, buffer, iSize, - hb_ntxFileOffset( pIndex, ulBlock ) ) != ( ULONG ) iSize ) + hb_ntxFileOffset( pIndex, ulBlock ) ) != ( HB_ULONG ) iSize ) { hb_ntxErrorRT( pIndex->Owner, EG_WRITE, EDBF_WRITE, pIndex->IndexName, hb_fsError(), 0, NULL ); @@ -1057,7 +1057,7 @@ static HB_BOOL hb_ntxTagHeaderCheck( LPTAGINFO pTag ) */ static void hb_ntxFreePageBuffer( LPNTXINDEX pIndex ) { - ULONG ul, ulMax = pIndex->ulPagesDepth; + HB_ULONG ul, ulMax = pIndex->ulPagesDepth; LPPAGEINFO * pPagePtr = pIndex->pages; if( ulMax ) @@ -1098,10 +1098,10 @@ static void hb_ntxIndexTrunc( LPNTXINDEX pIndex ) /* * try to find given tag page in the buffer */ -static LPPAGEINFO hb_ntxPageFind( LPTAGINFO pTag, ULONG ulPage ) +static LPPAGEINFO hb_ntxPageFind( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO * pPagePtr = pTag->Owner->pages; - ULONG u; + HB_ULONG u; for( u = pTag->Owner->ulPages; u; u--, pPagePtr++ ) { @@ -1114,7 +1114,7 @@ static LPPAGEINFO hb_ntxPageFind( LPTAGINFO pTag, ULONG ulPage ) /* * try to find free space in buffer */ -static LPPAGEINFO hb_ntxPageGetBuffer( LPTAGINFO pTag, ULONG ulPage ) +static LPPAGEINFO hb_ntxPageGetBuffer( LPTAGINFO pTag, HB_ULONG ulPage ) { LPNTXINDEX pIndex = pTag->Owner; LPPAGEINFO * pPagePtr; @@ -1154,7 +1154,7 @@ static LPPAGEINFO hb_ntxPageGetBuffer( LPTAGINFO pTag, ULONG ulPage ) } else { - ULONG ul = pIndex->ulPageLast; + HB_ULONG ul = pIndex->ulPageLast; for( ;; ) { if( ++ul >= pIndex->ulPagesDepth ) @@ -1247,7 +1247,7 @@ static void hb_ntxPageRelease( LPTAGINFO pTag, LPPAGEINFO pPage ) /* * load page from index file or the buffer */ -static LPPAGEINFO hb_ntxPageLoad( LPTAGINFO pTag, ULONG ulPage ) +static LPPAGEINFO hb_ntxPageLoad( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO pPage; @@ -1312,14 +1312,14 @@ static void hb_ntxPageInit( LPTAGINFO pTag, LPPAGEINFO pPage ) /* * allocate new page address */ -static ULONG hb_ntxPageAlloc( LPNTXINDEX pIndex ) +static HB_ULONG hb_ntxPageAlloc( LPNTXINDEX pIndex ) { - ULONG ulPage; + HB_ULONG ulPage; if( !pIndex->TagBlock ) { HB_FOFFSET fOffset; fOffset = hb_fileSize( pIndex->DiskFile ); - pIndex->TagBlock = ( ULONG ) + pIndex->TagBlock = ( HB_ULONG ) ( fOffset >> ( pIndex->LargeFile ? NTXBLOCKBITS : 0 ) ); } ulPage = pIndex->TagBlock; @@ -1383,7 +1383,7 @@ static LPPAGEINFO hb_ntxPageNew( LPTAGINFO pTag, HB_BOOL fNull ) /* * add given page to list of free pages */ -static void hb_ntxPageAddFree( LPTAGINFO pTag, ULONG ulPage ) +static void hb_ntxPageAddFree( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO pPage = hb_ntxPageGetBuffer( pTag, ulPage ); pPage->Changed = HB_TRUE; @@ -1396,10 +1396,10 @@ static void hb_ntxPageAddFree( LPTAGINFO pTag, ULONG ulPage ) /* * get free page in index file */ -static ULONG hb_ntxPageGetFree( LPTAGINFO pTag ) +static HB_ULONG hb_ntxPageGetFree( LPTAGINFO pTag ) { LPPAGEINFO pPage = hb_ntxPageNew( pTag, HB_FALSE ); - ULONG ulPage = 0; + HB_ULONG ulPage = 0; if( pPage ) { @@ -1539,7 +1539,7 @@ static HB_ERRCODE hb_ntxTagAdd( LPNTXINDEX pIndex, LPTAGINFO pTag ) /* * create new tag and load it from index file */ -static LPTAGINFO hb_ntxTagLoad( LPNTXINDEX pIndex, ULONG ulBlock, +static LPTAGINFO hb_ntxTagLoad( LPNTXINDEX pIndex, HB_ULONG ulBlock, char * szTagName, HB_BYTE * buffer ) { LPNTXHEADER lpNTX = ( LPNTXHEADER ) buffer; @@ -1670,7 +1670,7 @@ static void hb_ntxIndexTagDel( LPNTXINDEX pIndex, char * szTagName ) /* * find tag header block in CTX header */ -static ULONG hb_ntxIndexTagFind( LPCTXHEADER lpCTX, char * szTagName ) +static HB_ULONG hb_ntxIndexTagFind( LPCTXHEADER lpCTX, char * szTagName ) { int iTags = HB_GET_LE_UINT16( lpCTX->ntags ), i; LPCTXTAGITEM pTagItem = ( LPCTXTAGITEM ) lpCTX->tags; @@ -1691,7 +1691,7 @@ static HB_ERRCODE hb_ntxTagHeaderSave( LPTAGINFO pTag ) LPNTXINDEX pIndex = pTag->Owner; NTXHEADER Header; int iSize = NTX_ROOTHEAD_HEADSIZE, type, version = 0, iLen; - ULONG next = 0; + HB_ULONG next = 0; if( pIndex->Compound ) { @@ -1873,7 +1873,7 @@ static HB_ERRCODE hb_ntxIndexLoad( LPNTXINDEX pIndex, char * szTagName ) HB_BYTE tagbuffer[ NTXBLOCKSIZE ]; LPCTXHEADER lpCTX = ( LPCTXHEADER ) pIndex->HeaderBuff; LPCTXTAGITEM pTagItem = ( LPCTXTAGITEM ) lpCTX->tags; - ULONG ulBlock; + HB_ULONG ulBlock; int iTags; iTags = HB_GET_LE_UINT16( lpCTX->ntags ); @@ -1931,7 +1931,7 @@ static HB_ERRCODE hb_ntxIndexHeaderRead( LPNTXINDEX pIndex ) return HB_FAILURE; #else LPCTXHEADER lpCTX = ( LPCTXHEADER ) pIndex->HeaderBuff; - ULONG ulVersion, ulNext; + HB_ULONG ulVersion, ulNext; /* HB_USHORT usTags = HB_GET_LE_UINT16( lpCTX->ntags ); */ ulVersion = HB_GET_LE_UINT32( lpCTX->version ); @@ -1959,7 +1959,7 @@ static HB_ERRCODE hb_ntxIndexHeaderRead( LPNTXINDEX pIndex ) else { LPNTXHEADER lpNTX = ( LPNTXHEADER ) pIndex->HeaderBuff; - ULONG ulRootPage, ulVersion; + HB_ULONG ulRootPage, ulVersion; LPTAGINFO pTag; if( pIndex->Compound ) @@ -2257,7 +2257,7 @@ static void hb_ntxPageGetKey( LPPAGEINFO pPage, HB_USHORT uiKey, LPKEYINFO pKey, /* * set next page and key in page path */ -static void hb_ntxTagSetPageStack( LPTAGINFO pTag, ULONG ulPage, HB_USHORT uiKey ) +static void hb_ntxTagSetPageStack( LPTAGINFO pTag, HB_ULONG ulPage, HB_USHORT uiKey ) { if( pTag->stackLevel == pTag->stackSize ) { @@ -2280,7 +2280,7 @@ static void hb_ntxTagSetPageStack( LPTAGINFO pTag, ULONG ulPage, HB_USHORT uiKey /* * go down from the given index page to the first key */ -static LPPAGEINFO hb_ntxPageTopMove( LPTAGINFO pTag, ULONG ulPage ) +static LPPAGEINFO hb_ntxPageTopMove( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO pPage = NULL; @@ -2306,7 +2306,7 @@ static LPPAGEINFO hb_ntxPageTopMove( LPTAGINFO pTag, ULONG ulPage ) /* * go down from the given index page to the last key */ -static LPPAGEINFO hb_ntxPageBottomMove( LPTAGINFO pTag, ULONG ulPage ) +static LPPAGEINFO hb_ntxPageBottomMove( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO pPage = NULL; @@ -2374,7 +2374,7 @@ static HB_BOOL hb_ntxTagNextKey( LPTAGINFO pTag ) { int iLevel = pTag->stackLevel - 1; LPPAGEINFO pPage; - ULONG ulPage = 0; + HB_ULONG ulPage = 0; if( iLevel >= 0 ) { @@ -2427,7 +2427,7 @@ static HB_BOOL hb_ntxTagPrevKey( LPTAGINFO pTag ) { int iLevel = pTag->stackLevel - 1; LPPAGEINFO pPage; - ULONG ulPage; + HB_ULONG ulPage; if( iLevel >= 0 ) { @@ -2480,7 +2480,7 @@ static HB_BOOL hb_ntxTagPrevKey( LPTAGINFO pTag ) */ static int hb_ntxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage, char* key, HB_SHORT keylen, HB_BOOL fNext, - ULONG ulRecNo, HB_BOOL *fStop ) + HB_ULONG ulRecNo, HB_BOOL *fStop ) { HB_SHORT iLast = -1, iBegin = 0, iEnd = pPage->uiKeys - 1, k, i; @@ -2494,7 +2494,7 @@ static int hb_ntxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage, { if( ulRecNo != 0 && pTag->fSortRec ) { - ULONG ulRec = hb_ntxGetKeyRec( pPage, i ); + HB_ULONG ulRec = hb_ntxGetKeyRec( pPage, i ); if( ulRecNo < ulRec ) k = -1; else if( ulRecNo > ulRec ) @@ -2524,7 +2524,7 @@ static int hb_ntxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage, /* * find a record in page starting from given key */ -static HB_BOOL hb_ntxPageFindRecNo( LPPAGEINFO pPage, int * iStart, ULONG ulRecno ) +static HB_BOOL hb_ntxPageFindRecNo( LPPAGEINFO pPage, int * iStart, HB_ULONG ulRecno ) { int iKey = *iStart; while( iKey < pPage->uiKeys ) @@ -2545,7 +2545,7 @@ static HB_BOOL hb_ntxPageFindRecNo( LPPAGEINFO pPage, int * iStart, ULONG ulRecn static HB_BOOL hb_ntxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, HB_USHORT uiLen ) { LPPAGEINFO pPage = NULL; - ULONG ulPage = 0, ulRecNo = 0; + HB_ULONG ulPage = 0, ulRecNo = 0; int iKey; HB_BOOL fStop = HB_FALSE, fNext = HB_FALSE, fPrev = HB_FALSE, fOut = HB_FALSE; @@ -2644,7 +2644,7 @@ static HB_BOOL hb_ntxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, HB_USHORT uiLen * set key in the given tag page */ static void hb_ntxPageKeySet( LPTAGINFO pTag, LPPAGEINFO pPage, HB_USHORT uiPos, - ULONG ulPage, ULONG ulRec, char * keyVal ) + HB_ULONG ulPage, HB_ULONG ulRec, char * keyVal ) { hb_ntxSetKeyPage( pPage, uiPos, ulPage ); hb_ntxSetKeyRec( pPage, uiPos, ulRec ); @@ -2656,7 +2656,7 @@ static void hb_ntxPageKeySet( LPTAGINFO pTag, LPPAGEINFO pPage, HB_USHORT uiPos, * add key to tag page */ static void hb_ntxPageKeyAdd( LPTAGINFO pTag, LPPAGEINFO pPage, HB_USHORT uiPos, - ULONG ulPage, ULONG ulRec, char * keyVal ) + HB_ULONG ulPage, HB_ULONG ulRec, char * keyVal ) { HB_USHORT u, ntmp = hb_ntxGetKeyOffset( pPage, pPage->uiKeys + 1 ); @@ -2700,7 +2700,7 @@ static LPKEYINFO hb_ntxPageSplit( LPTAGINFO pTag, LPPAGEINFO pPage, LPKEYINFO pKeyNew; HB_USHORT uiKeys = pPage->uiKeys + 1, uiLen = pTag->KeyLength + 8, i, j, u, uiHalf; - ULONG ulPage; + HB_ULONG ulPage; if( ! pNewPage ) return NULL; @@ -2897,12 +2897,12 @@ static HB_BOOL hb_ntxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey ) int iLevel, iKey; LPPAGEINFO pPage = NULL; LPKEYINFO pNewKey = NULL; - ULONG ulPage; + HB_ULONG ulPage; HB_BOOL fFound, fBottom = HB_FALSE; if( pTag->UniqueKey ) { - ULONG ulRecNo = pKey->Xtra; + HB_ULONG ulRecNo = pKey->Xtra; pKey->Xtra = NTX_IGNORE_REC_NUM; fFound = hb_ntxTagKeyFind( pTag, pKey, pTag->KeyLength ); @@ -3068,7 +3068,7 @@ static HB_BOOL hb_ntxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey ) { int iLevel, iBaseKey, iKey; LPPAGEINFO pBasePage, pPage; - ULONG ulPage; + HB_ULONG ulPage; pKey->Tag = 0; if( pTag->stackLevel == 0 || pTag->CurKeyInfo->Xtra != pKey->Xtra || @@ -3377,10 +3377,10 @@ static void hb_ntxTagSkipPrev( LPTAGINFO pTag ) /* * count keys in the given page and all subpages */ -static ULONG hb_ntxPageCountKeys( LPTAGINFO pTag, ULONG ulPage ) +static HB_ULONG hb_ntxPageCountKeys( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO pPage = hb_ntxPageLoad( pTag, ulPage ); - ULONG ulKeys; + HB_ULONG ulKeys; HB_USHORT u; if( ! pPage ) @@ -3428,7 +3428,7 @@ static double hb_ntxTagCountRelKeyPos( LPTAGINFO pTag ) static void hb_ntxTagGoToRelKeyPos( LPTAGINFO pTag, double dPos ) { LPPAGEINFO pPage = NULL; - ULONG ulPage = 0; + HB_ULONG ulPage = 0; int iKey, iKeys; if( pTag->fUsrDescend == pTag->AscendKey ) @@ -3477,7 +3477,7 @@ static void hb_ntxTagGoToRelKeyPos( LPTAGINFO pTag, double dPos ) /* * free pages allocated by tag */ -static HB_BOOL hb_ntxTagPagesFree( LPTAGINFO pTag, ULONG ulPage ) +static HB_BOOL hb_ntxTagPagesFree( LPTAGINFO pTag, HB_ULONG ulPage ) { LPPAGEINFO pPage = hb_ntxPageLoad( pTag, ulPage ); HB_BOOL fOK = pPage != NULL; @@ -3753,9 +3753,9 @@ static int hb_ntxFindTagNum( NTXAREAP pArea, LPTAGINFO pTag ) /* * count number of keys in given tag */ -static ULONG hb_ntxOrdKeyCount( LPTAGINFO pTag ) +static HB_ULONG hb_ntxOrdKeyCount( LPTAGINFO pTag ) { - ULONG ulKeyCount = 0; + HB_ULONG ulKeyCount = 0; if( !pTag->Owner->fShared && pTag->keyCount && !pTag->Owner->Owner->dbfarea.area.dbfi.fFilter ) @@ -3789,9 +3789,9 @@ static ULONG hb_ntxOrdKeyCount( LPTAGINFO pTag ) /* * get the logical key position in the given tag */ -static ULONG hb_ntxOrdKeyNo( LPTAGINFO pTag ) +static HB_ULONG hb_ntxOrdKeyNo( LPTAGINFO pTag ) { - ULONG ulKeyNo = 0; + HB_ULONG ulKeyNo = 0; if( hb_ntxTagLockRead( pTag ) ) { @@ -3816,7 +3816,7 @@ static ULONG hb_ntxOrdKeyNo( LPTAGINFO pTag ) int iLevel = pTag->stackLevel, iKey, iFirst = 1; HB_BOOL fBack = pTag->fUsrDescend == pTag->AscendKey; LPPAGEINFO pPage; - ULONG ulPage; + HB_ULONG ulPage; while( --iLevel >= 0 ) { @@ -3857,7 +3857,7 @@ static ULONG hb_ntxOrdKeyNo( LPTAGINFO pTag ) /* * set logical key position in given tag */ -static HB_BOOL hb_ntxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo ) +static HB_BOOL hb_ntxOrdKeyGoto( LPTAGINFO pTag, HB_ULONG ulKeyNo ) { NTXAREAP pArea = pTag->Owner->Owner; @@ -4164,7 +4164,7 @@ static HB_BOOL hb_ntxOrdSkipEval( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pEv break; if( hb_ntxEvalSeekCond( pTag, pEval ) ) { - ULONG ulRecNo = pArea->dbfarea.ulRecNo; + HB_ULONG ulRecNo = pArea->dbfarea.ulRecNo; if( SELF_SKIPFILTER( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS || pArea->dbfarea.ulRecNo == ulRecNo || hb_ntxEvalSeekCond( pTag, pEval ) ) { @@ -4278,7 +4278,7 @@ static HB_BOOL hb_ntxOrdSkipWild( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pWi { if( hb_strMatchWild( pTag->CurKeyInfo->key, szPattern ) ) { - ULONG ulRecNo = pTag->CurKeyInfo->Xtra; + HB_ULONG ulRecNo = pTag->CurKeyInfo->Xtra; if( SELF_GOTO( ( AREAP ) pArea, ulRecNo ) != HB_SUCCESS ) break; if( SELF_SKIPFILTER( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS || @@ -4328,7 +4328,7 @@ static HB_BOOL hb_ntxOrdSkipWild( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pWi static HB_BOOL hb_ntxRegexMatch( LPTAGINFO pTag, PHB_REGEX pRegEx, char * szKey ) { - ULONG ulLen = pTag->KeyLength; + HB_ULONG ulLen = pTag->KeyLength; char szBuff[ NTX_MAX_KEY + 1 ]; if( pTag->Owner->Owner->dbfarea.area.cdPage != hb_vmCDP() ) @@ -4386,7 +4386,7 @@ static HB_BOOL hb_ntxOrdSkipRegEx( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pR if( hb_ntxRegexMatch( pTag, pRegEx, ( char * ) pTag->CurKeyInfo->key ) ) { - ULONG ulRecNo = pArea->dbfarea.ulRecNo; + HB_ULONG ulRecNo = pArea->dbfarea.ulRecNo; if( SELF_SKIPFILTER( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS || pArea->dbfarea.ulRecNo == ulRecNo || hb_ntxRegexMatch( pTag, pRegEx, ( char * ) pTag->CurKeyInfo->key ) ) @@ -4520,7 +4520,7 @@ static HB_BOOL hb_ntxOrdKeyDel( LPTAGINFO pTag, PHB_ITEM pItem ) * custom indexes when the same record can be stored more then once * or when the used index key is unknown */ -static HB_BOOL hb_ntxOrdFindRec( LPTAGINFO pTag, ULONG ulRecNo, HB_BOOL fCont ) +static HB_BOOL hb_ntxOrdFindRec( LPTAGINFO pTag, HB_ULONG ulRecNo, HB_BOOL fCont ) { NTXAREAP pArea = pTag->Owner->Owner; HB_BOOL fFound = HB_FALSE; @@ -4566,11 +4566,11 @@ static HB_BOOL hb_ntxOrdFindRec( LPTAGINFO pTag, ULONG ulRecNo, HB_BOOL fCont ) /* * evaluate given C function in given scope */ -static ULONG hb_ntxOrdScopeEval( LPTAGINFO pTag, - HB_EVALSCOPE_FUNC pFunc, void *pParam, - PHB_ITEM pItemLo, PHB_ITEM pItemHi ) +static HB_ULONG hb_ntxOrdScopeEval( LPTAGINFO pTag, + HB_EVALSCOPE_FUNC pFunc, void *pParam, + PHB_ITEM pItemLo, PHB_ITEM pItemHi ) { - ULONG ulCount = 0, ulLen = ( ULONG ) pTag->KeyLength; + HB_ULONG ulCount = 0, ulLen = ( HB_ULONG ) pTag->KeyLength; PHB_ITEM pItemTop = hb_itemNew( NULL ), pItemBottom = hb_itemNew( NULL ); hb_ntxTagGetScope( pTag, 0, pItemTop ); @@ -4680,7 +4680,7 @@ static HB_BOOL hb_ntxQSort( LPNTXSORTINFO pSort, HB_BYTE * pSrc, HB_BYTE * pBuf, static void hb_ntxSortSortPage( LPNTXSORTINFO pSort ) { - ULONG ulSize = pSort->ulKeys * ( pSort->keyLen + 4 ); + HB_ULONG ulSize = pSort->ulKeys * ( pSort->keyLen + 4 ); if( !hb_ntxQSort( pSort, pSort->pKeyPool, &pSort->pKeyPool[ ulSize ], pSort->ulKeys ) ) { pSort->pStartKey = &pSort->pKeyPool[ ulSize ]; @@ -4693,7 +4693,7 @@ static void hb_ntxSortSortPage( LPNTXSORTINFO pSort ) static void hb_ntxSortBufferFlush( LPNTXSORTINFO pSort ) { - ULONG ulSize; + HB_ULONG ulSize; if( pSort->ulPagesIO ) { LPNTXINDEX pIndex = pSort->pTag->Owner; @@ -4740,10 +4740,10 @@ static void hb_ntxSortStorePage( LPNTXSORTINFO pSort, LPPAGEINFO pPage ) hb_ntxPageSave( pIndex, pPage ); } -static void hb_ntxSortAddNodeKey( LPNTXSORTINFO pSort, HB_BYTE *pKeyVal, ULONG ulRec ) +static void hb_ntxSortAddNodeKey( LPNTXSORTINFO pSort, HB_BYTE *pKeyVal, HB_ULONG ulRec ) { LPPAGEINFO pPage; - ULONG ulPage = 0; + HB_ULONG ulPage = 0; int iLevel = 0; for( ;; ) @@ -4774,7 +4774,7 @@ static void hb_ntxSortAddNodeKey( LPNTXSORTINFO pSort, HB_BYTE *pKeyVal, ULONG u static void hb_ntxSortWritePage( LPNTXSORTINFO pSort ) { - ULONG ulSize = pSort->ulKeys * ( pSort->keyLen + 4 ); + HB_ULONG ulSize = pSort->ulKeys * ( pSort->keyLen + 4 ); hb_ntxSortSortPage( pSort ); @@ -4803,15 +4803,15 @@ static void hb_ntxSortWritePage( LPNTXSORTINFO pSort ) pSort->ulCurPage++; } -static void hb_ntxSortGetPageKey( LPNTXSORTINFO pSort, ULONG ulPage, - HB_BYTE ** pKeyVal, ULONG *pulRec ) +static void hb_ntxSortGetPageKey( LPNTXSORTINFO 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( pSort->hTempFile != FS_ERROR && ( hb_fsSeekLarge( pSort->hTempFile, pSort->pSwapPage[ ulPage ].nOffset, FS_SET ) != pSort->pSwapPage[ ulPage ].nOffset || @@ -4832,11 +4832,11 @@ static void hb_ntxSortOrderPages( LPNTXSORTINFO 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 ) @@ -4871,11 +4871,11 @@ static void hb_ntxSortOrderPages( LPNTXSORTINFO pSort ) } } -static HB_BOOL hb_ntxSortKeyGet( LPNTXSORTINFO pSort, HB_BYTE ** pKeyVal, ULONG *pulRec ) +static HB_BOOL hb_ntxSortKeyGet( LPNTXSORTINFO 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 ]; @@ -4883,7 +4883,7 @@ static HB_BOOL hb_ntxSortKeyGet( LPNTXSORTINFO pSort, HB_BYTE ** pKeyVal, ULONG if( pSort->pSwapPage[ ulPage ].ulKeys > 0 ) { HB_BYTE *pKey, *pTmp; - ULONG ulRec, ulPg; + HB_ULONG ulRec, ulPg; /* * last key was taken from this page - we have to resort it. @@ -4945,7 +4945,7 @@ static HB_BOOL hb_ntxSortKeyGet( LPNTXSORTINFO pSort, HB_BYTE ** pKeyVal, ULONG return HB_FALSE; } -static void hb_ntxSortKeyAdd( LPNTXSORTINFO pSort, ULONG ulRec, const char * pKeyVal, int iKeyLen ) +static void hb_ntxSortKeyAdd( LPNTXSORTINFO pSort, HB_ULONG ulRec, const char * pKeyVal, int iKeyLen ) { int iLen = pSort->keyLen; HB_BYTE *pDst; @@ -4970,12 +4970,12 @@ static void hb_ntxSortKeyAdd( LPNTXSORTINFO pSort, ULONG ulRec, const char * pKe pSort->ulTotKeys++; } -static LPNTXSORTINFO hb_ntxSortNew( LPTAGINFO pTag, ULONG ulRecCount ) +static LPNTXSORTINFO hb_ntxSortNew( LPTAGINFO pTag, HB_ULONG ulRecCount ) { LPNTXSORTINFO pSort; HB_BYTE * pBuf; int iLen = pTag->KeyLength; - ULONG ulSize, ulMax, ulMin; + HB_ULONG ulSize, ulMax, ulMin; if( ulRecCount == 0 ) ulRecCount = 1; @@ -4983,8 +4983,8 @@ static LPNTXSORTINFO hb_ntxSortNew( LPTAGINFO pTag, ULONG ulRecCount ) pSort = ( LPNTXSORTINFO ) hb_xgrab( sizeof( NTXSORTINFO ) ); memset( pSort, 0, sizeof( NTXSORTINFO ) ); - ulMin = ( ULONG ) ceil( sqrt( ( double ) ulRecCount ) ); - ulMax = ( ( ULONG ) ceil( sqrt( ( double ) ulRecCount / ( iLen + 4 ) ) ) ) << 7; + ulMin = ( HB_ULONG ) ceil( sqrt( ( double ) ulRecCount ) ); + ulMax = ( ( HB_ULONG ) ceil( sqrt( ( double ) ulRecCount / ( iLen + 4 ) ) ) ) << 7; /* * this effectively increase allocated memory buffer for very large files * moving the maximum to: 270'566'400 for 4'294'967'295 records and 256 @@ -5098,7 +5098,7 @@ static void hb_ntxSortOut( LPNTXSORTINFO pSort ) { HB_BOOL fUnique = pSort->fUnique, fBalance, fNext; LPTAGINFO pTag = pSort->pTag; - ULONG ulPage, ulRec, ulKey; + HB_ULONG ulPage, ulRec, ulKey; HB_USHORT uiHalf; HB_BYTE * pKeyVal; int iLen = pSort->keyLen, iLevel; @@ -5267,7 +5267,7 @@ static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO pTag, HB_BOOL fReindex ) { LPNTXAREA pArea = pTag->Owner->Owner; PHB_ITEM pForItem, pWhileItem = NULL, pEvalItem = NULL, pItem = NULL; - ULONG ulRecCount, ulRecNo = pArea->dbfarea.ulRecNo; + HB_ULONG ulRecCount, ulRecNo = pArea->dbfarea.ulRecNo; LPNTXSORTINFO pSort; HB_LONG lStep = 0; HB_ERRCODE errCode = HB_SUCCESS; @@ -5309,7 +5309,7 @@ static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO pTag, HB_BOOL fReindex ) else { LPTAGINFO pSaveTag = pArea->lpCurTag; - ULONG ulStartRec = 0, ulNextCount = 0; + HB_ULONG ulStartRec = 0, ulNextCount = 0; HB_BOOL fDirectRead, fUseFilter = HB_FALSE; HB_BYTE * pSaveRecBuff = pArea->dbfarea.pRecord; char szBuffer[ NTX_MAX_KEY ]; @@ -5389,11 +5389,11 @@ static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO 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->pBuffIO, pArea->dbfarea.uiRecordLen * iRec, ( HB_FOFFSET ) pArea->dbfarea.uiHeaderLen + @@ -5658,7 +5658,7 @@ static HB_ERRCODE hb_ntxSeek( NTXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pItem, HB_ERRCODE retval = HB_SUCCESS; HB_BOOL fEOF = HB_FALSE, fLast; HB_USHORT uiLen; - ULONG ulRec; + HB_ULONG ulRec; if( pArea->dbfarea.lpdbPendingRel && pArea->dbfarea.lpdbPendingRel->isScoped ) SELF_FORCEREL( ( AREAP ) pArea ); @@ -6188,7 +6188,7 @@ static HB_ERRCODE hb_ntxOrderCreate( NTXAREAP pArea, LPDBORDERCREATEINFO pOrderI LPTAGINFO pTag = NULL; LPDBFDATA pData; HB_ERRCODE errCode; - ULONG ulRecNo; + HB_ULONG ulRecNo; HB_BOOL fCompound, fTagName, fBagName, fProd, fLocked = HB_FALSE, fAscend = HB_TRUE, fCustom = HB_FALSE, fTemporary = HB_FALSE, fExclusive = HB_FALSE; HB_BYTE bType; @@ -7213,7 +7213,7 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, HB_USHORT uiIndex, LPDBORDERI case DBOI_KEYCOUNT: case DBOI_KEYCOUNTRAW: { - ULONG ulRecCount = 0; + HB_ULONG ulRecCount = 0; SELF_RECCOUNT( ( AREAP ) pArea, &ulRecCount ); hb_itemPutNInt( pInfo->itmResult, ulRecCount ); break; @@ -7243,9 +7243,9 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, HB_USHORT uiIndex, LPDBORDERI } 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; if( SELF_GOTO( ( AREAP ) pArea, ulRecNo ) == HB_SUCCESS && @@ -7257,7 +7257,7 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, HB_USHORT uiIndex, LPDBORDERI } else { - ULONG ulRecNo = 0, ulRecCount = 0; + HB_ULONG ulRecNo = 0, ulRecCount = 0; double dPos = 0.0; /* resolve any pending relations */ if( SELF_RECNO( ( AREAP ) pArea, &ulRecNo ) == HB_SUCCESS ) @@ -7646,7 +7646,7 @@ static HB_ERRCODE hb_ntxInit( LPRDDNODE pRDD ) #define hb_ntxExists NULL #define hb_ntxRename NULL -static HB_ERRCODE hb_ntxRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem ) +static HB_ERRCODE hb_ntxRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem ) { LPDBFDATA pData; diff --git a/harbour/src/rdd/dbsql.c b/harbour/src/rdd/dbsql.c index 332042950d..284e72a575 100644 --- a/harbour/src/rdd/dbsql.c +++ b/harbour/src/rdd/dbsql.c @@ -235,14 +235,14 @@ static HB_BOOL hb_exportBufSqlVar( PHB_FILEBUF pFileBuf, PHB_ITEM pValue, } /* Export DBF content to a SQL script file */ -static ULONG hb_db2Sql( AREAP pArea, PHB_ITEM pFields, HB_MAXINT llNext, - PHB_ITEM pWhile, PHB_ITEM pFor, - const char * szDelim, const char * szSep, - const char * szEsc, const char * szTable, - HB_FHANDLE hFile, HB_BOOL fInsert, HB_BOOL fRecno ) +static HB_ULONG hb_db2Sql( AREAP pArea, PHB_ITEM pFields, HB_MAXINT llNext, + PHB_ITEM pWhile, PHB_ITEM pFor, + const char * szDelim, const char * szSep, + const char * szEsc, const char * szTable, + HB_FHANDLE hFile, HB_BOOL fInsert, HB_BOOL fRecno ) { PHB_FILEBUF pFileBuf; - ULONG ulRecords = 0; + HB_ULONG ulRecords = 0; HB_USHORT uiFields = 0, ui; PHB_ITEM pTmp; HB_BOOL fWriteSep = HB_FALSE; @@ -286,7 +286,7 @@ static ULONG hb_db2Sql( AREAP pArea, PHB_ITEM pFields, HB_MAXINT llNext, if( fRecno ) { - ULONG ulRec = ulRecords; + HB_ULONG ulRec = ulRecords; char szRecno[ 13 ], * szVal; szVal = szRecno + sizeof( szRecno ); diff --git a/harbour/src/rdd/delim1.c b/harbour/src/rdd/delim1.c index 825a0456c2..5eea018a21 100644 --- a/harbour/src/rdd/delim1.c +++ b/harbour/src/rdd/delim1.c @@ -101,9 +101,9 @@ static void hb_delimClearRecordBuffer( DELIMAREAP pArea ) memset( pArea->pRecord, ' ', pArea->uiRecordLen ); } -static ULONG hb_delimEncodeBuffer( DELIMAREAP pArea ) +static HB_SIZE hb_delimEncodeBuffer( DELIMAREAP pArea ) { - ULONG ulSize; + HB_SIZE ulSize; HB_USHORT uiField, uiLen; LPFIELD pField; HB_BYTE * pBuffer, * pFieldBuf; @@ -199,7 +199,7 @@ static int hb_delimNextChar( DELIMAREAP pArea ) ( pArea->ulBufferRead == 0 || pArea->ulBufferRead >= pArea->ulBufferSize - 1 ) ) { - ULONG ulLeft = pArea->ulBufferRead - pArea->ulBufferIndex; + HB_SIZE ulLeft = pArea->ulBufferRead - pArea->ulBufferIndex; if( ulLeft ) memcpy( pArea->pBuffer, @@ -250,7 +250,7 @@ static HB_ERRCODE hb_delimReadRecord( DELIMAREAP pArea ) if( pArea->ulBufferStart <= pArea->ulRecordOffset && pArea->ulBufferStart + ( HB_FOFFSET ) pArea->ulBufferRead > pArea->ulRecordOffset ) { - pArea->ulBufferIndex = ( ULONG ) ( pArea->ulRecordOffset - pArea->ulBufferStart ); + pArea->ulBufferIndex = ( HB_SIZE ) ( pArea->ulRecordOffset - pArea->ulBufferStart ); } else { @@ -449,7 +449,7 @@ static HB_ERRCODE hb_delimDeleted( DELIMAREAP pArea, HB_BOOL * pDeleted ) /* * Obtain number of records in WorkArea. */ -static HB_ERRCODE hb_delimRecCount( DELIMAREAP pArea, ULONG * pRecCount ) +static HB_ERRCODE hb_delimRecCount( DELIMAREAP pArea, HB_ULONG * pRecCount ) { HB_TRACE(HB_TR_DEBUG, ("hb_delimRecCount(%p,%p)", pArea, pRecCount)); @@ -461,7 +461,7 @@ static HB_ERRCODE hb_delimRecCount( DELIMAREAP pArea, ULONG * pRecCount ) /* * Obtain physical row number at current WorkArea cursor position. */ -static HB_ERRCODE hb_delimRecNo( DELIMAREAP pArea, ULONG * pulRecNo ) +static HB_ERRCODE hb_delimRecNo( DELIMAREAP pArea, HB_ULONG * pulRecNo ) { HB_TRACE(HB_TR_DEBUG, ("hb_delimRecNo(%p,%p)", pArea, pulRecNo)); @@ -476,7 +476,7 @@ static HB_ERRCODE hb_delimRecNo( DELIMAREAP pArea, ULONG * pulRecNo ) static HB_ERRCODE hb_delimRecId( DELIMAREAP pArea, PHB_ITEM pRecNo ) { HB_ERRCODE errCode; - ULONG ulRecNo; + HB_ULONG ulRecNo; HB_TRACE(HB_TR_DEBUG, ("hb_delimRecId(%p,%p)", pArea, pRecNo)); @@ -557,7 +557,7 @@ static HB_ERRCODE hb_delimGetValue( DELIMAREAP pArea, HB_USHORT uiIndex, PHB_ITE case HB_FT_STRING: if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) { - ULONG ulLen = pField->uiLen; + HB_SIZE ulLen = pField->uiLen; char * pszVal = hb_cdpnDup( ( const char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], &ulLen, pArea->area.cdPage, hb_vmCDP() ); hb_itemPutCLPtr( pItem, pszVal, ulLen ); @@ -641,7 +641,7 @@ static HB_ERRCODE hb_delimPutValue( DELIMAREAP pArea, HB_USHORT uiIndex, PHB_ITE char szBuffer[ 256 ]; HB_ERRCODE errCode; LPFIELD pField; - ULONG ulSize; + HB_SIZE ulSize; HB_TRACE(HB_TR_DEBUG, ("hb_delimPutValue(%p,%hu,%p)", pArea, uiIndex, pItem)); @@ -670,12 +670,12 @@ static HB_ERRCODE hb_delimPutValue( DELIMAREAP pArea, HB_USHORT uiIndex, PHB_ITE else { ulSize = hb_itemGetCLen( pItem ); - if( ulSize > ( ULONG ) pField->uiLen ) + if( ulSize > ( HB_SIZE ) pField->uiLen ) ulSize = pField->uiLen; memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], hb_itemGetCPtr( pItem ), ulSize ); } - if( ulSize < ( ULONG ) pField->uiLen ) + if( ulSize < ( HB_SIZE ) pField->uiLen ) memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + ulSize, ' ', pField->uiLen - ulSize ); } @@ -822,7 +822,7 @@ static HB_ERRCODE hb_delimGoCold( DELIMAREAP pArea ) if( pArea->fRecordChanged ) { - ULONG ulSize = hb_delimEncodeBuffer( pArea ); + HB_SIZE ulSize = hb_delimEncodeBuffer( pArea ); if( hb_fileWriteAt( pArea->pFile, pArea->pBuffer, ulSize, pArea->ulRecordOffset ) != ulSize ) @@ -1432,7 +1432,7 @@ static HB_ERRCODE hb_delimOpen( DELIMAREAP pArea, LPDBOPENINFO pOpenInfo ) /* * Retrieve information about the current driver. */ -static HB_ERRCODE hb_delimRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem ) +static HB_ERRCODE hb_delimRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem ) { HB_TRACE(HB_TR_DEBUG, ("hb_delimRddInfo(%p,%hu,%lu,%p)", pRDD, uiIndex, ulConnect, pItem)); diff --git a/harbour/src/rdd/hbdbsort.c b/harbour/src/rdd/hbdbsort.c index 5537a9a0c3..a5d544b7b3 100644 --- a/harbour/src/rdd/hbdbsort.c +++ b/harbour/src/rdd/hbdbsort.c @@ -96,7 +96,7 @@ HB_BOOL hb_dbQSortAdvance( LPDBQUICKSORT pQuickSort, HB_USHORT uiCount ) return ( hb_fsWrite( pQuickSort->hFile, pQuickSort->pBuffer, uiSize ) == uiSize ); } -static HB_BOOL hb_dbQSortIsLess( LPDBQUICKSORT pQuickSort, ULONG ulRecNo1, ULONG ulRecNo2 ) +static HB_BOOL hb_dbQSortIsLess( LPDBQUICKSORT pQuickSort, HB_ULONG ulRecNo1, HB_ULONG ulRecNo2 ) { HB_USHORT uiCount, uiField; DBFAREAP pArea; @@ -168,7 +168,7 @@ static HB_BOOL hb_dbQSortIsLess( LPDBQUICKSORT pQuickSort, ULONG ulRecNo1, ULONG return HB_FALSE; } -static void hb_dbQSortSwap( LPDBQUICKSORT pQuickSort, ULONG ulRecNo1, ULONG ulRecNo2 ) +static void hb_dbQSortSwap( LPDBQUICKSORT pQuickSort, HB_ULONG ulRecNo1, HB_ULONG ulRecNo2 ) { /* Swap records */ hb_fsSeek( pQuickSort->hFile, ( ulRecNo1 - 1 ) * pQuickSort->uiRecordLen, FS_SET ); @@ -181,9 +181,9 @@ static void hb_dbQSortSwap( LPDBQUICKSORT pQuickSort, ULONG ulRecNo1, ULONG ulRe hb_fsWrite( pQuickSort->hFile, pQuickSort->pSwapBufferA, pQuickSort->uiRecordLen ); } -static void hb_dbQSortDo( LPDBQUICKSORT pQuickSort, ULONG ulFirst, ULONG ulLast ) +static void hb_dbQSortDo( LPDBQUICKSORT pQuickSort, HB_ULONG ulFirst, HB_ULONG ulLast ) { - ULONG ulPivot, ulLeft, ulRight; + HB_ULONG ulPivot, ulLeft, ulRight; /* Select pivot */ if( hb_dbQSortIsLess( pQuickSort, ulFirst, ulLast ) ) @@ -223,7 +223,7 @@ static void hb_dbQSortDo( LPDBQUICKSORT pQuickSort, ULONG ulFirst, ULONG ulLast void hb_dbQSortComplete( LPDBQUICKSORT pQuickSort ) { - ULONG ulRecCount; + HB_ULONG ulRecCount; AREAP pArea; ulRecCount = hb_fsSeek( pQuickSort->hFile, 0, FS_END ) / pQuickSort->uiRecordLen; diff --git a/harbour/src/rdd/hbsix/sxcrypt.c b/harbour/src/rdd/hbsix/sxcrypt.c index e253f178df..66ba95737c 100644 --- a/harbour/src/rdd/hbsix/sxcrypt.c +++ b/harbour/src/rdd/hbsix/sxcrypt.c @@ -137,7 +137,7 @@ static HB_BOOL _hb_sxGetKey( PHB_ITEM pKeyItem, char * pKeyVal ) { HB_BOOL fResult = HB_FALSE; PHB_ITEM pItem = NULL; - ULONG ulKey; + HB_SIZE ulKey; if( ! ( hb_itemType( pKeyItem ) & HB_IT_STRING ) ) { diff --git a/harbour/src/rdd/hbsix/sxfname.c b/harbour/src/rdd/hbsix/sxfname.c index e6254febbf..d31d2cce37 100644 --- a/harbour/src/rdd/hbsix/sxfname.c +++ b/harbour/src/rdd/hbsix/sxfname.c @@ -63,7 +63,7 @@ HB_FUNC( SX_FNAMEPARSER ) { char szPathBuf[ HB_PATH_MAX ]; PHB_FNAME pFileName; - ULONG ulLen; + HB_SIZE ulLen; char * pszFree; szFileName = hb_fsNameConv( szFileName, &pszFree ); diff --git a/harbour/src/rdd/hbsix/sxord.c b/harbour/src/rdd/hbsix/sxord.c index 7c70db1013..8806f8ef73 100644 --- a/harbour/src/rdd/hbsix/sxord.c +++ b/harbour/src/rdd/hbsix/sxord.c @@ -366,7 +366,7 @@ HB_FUNC( SX_STEP ) HB_FUNC( SX_KEYSINCLUDED ) { AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer(); - ULONG ulKeys = 0; + HB_ULONG ulKeys = 0; if( pArea ) { @@ -571,7 +571,7 @@ HB_FUNC( SX_KEYSKIP ) HB_FUNC( SX_KEYCOUNT ) { AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer(); - ULONG ulKeys = 0; + HB_ULONG ulKeys = 0; if( pArea ) { @@ -591,7 +591,7 @@ HB_FUNC( SX_KEYCOUNT ) HB_FUNC( SX_KEYNO ) { AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer(); - ULONG ulKeyNo = 0; + HB_ULONG ulKeyNo = 0; if( pArea ) { diff --git a/harbour/src/rdd/hbsix/sxtable.c b/harbour/src/rdd/hbsix/sxtable.c index 8fbc17f20b..b9186f4c3a 100644 --- a/harbour/src/rdd/hbsix/sxtable.c +++ b/harbour/src/rdd/hbsix/sxtable.c @@ -236,7 +236,7 @@ HB_FUNC( SX_RLOCK ) pRecords = hb_param( 1, HB_IT_ARRAY ); if( pRecords ) { - ULONG ul, ulLen = hb_arrayLen( pRecords ); + HB_SIZE ul, ulLen = hb_arrayLen( pRecords ); pResult = hb_itemArrayNew( ulLen ); for( ul = 1; ul <= ulLen; ++ul ) { @@ -268,7 +268,7 @@ HB_FUNC( SX_UNLOCK ) PHB_ITEM pRecords = hb_param( 1, HB_IT_ARRAY ); if( pRecords ) { - ULONG ul, ulLen = hb_arrayLen( pRecords ); + HB_SIZE ul, ulLen = hb_arrayLen( pRecords ); for( ul = 1; ul <= ulLen; ++ul ) { SELF_UNLOCK( pArea, hb_arrayGetItemPtr( pRecords, ul ) ); diff --git a/harbour/src/rdd/hbsix/sxutil.c b/harbour/src/rdd/hbsix/sxutil.c index 3c82b0e9d2..1e7b209959 100644 --- a/harbour/src/rdd/hbsix/sxutil.c +++ b/harbour/src/rdd/hbsix/sxutil.c @@ -63,7 +63,7 @@ HB_FUNC( SX_SLIMFAST ) if( szExp && *szExp ) { char * szDst, cQuote = 0, c; - ULONG ulDst; + HB_SIZE ulDst; szDst = ( char * ) hb_xgrab( hb_parclen( 1 ) + 1 ); ulDst = 0; diff --git a/harbour/src/rdd/hsx/hsx.c b/harbour/src/rdd/hsx/hsx.c index c82d05e98a..ddfee7066c 100644 --- a/harbour/src/rdd/hsx/hsx.c +++ b/harbour/src/rdd/hsx/hsx.c @@ -307,7 +307,7 @@ typedef HSXHEADER * LPHSXHEADER; typedef struct _HSXINFO { int iHandle; /* HSX handle */ - ULONG ulRecCount; /* number of records */ + HB_ULONG ulRecCount; /* number of records */ HB_USHORT uiRecordSize; /* record size in bytes */ HB_BOOL fIgnoreCase; /* ignore case */ int iFilterType; /* character filter */ @@ -317,18 +317,18 @@ typedef struct _HSXINFO char * szFileName; /* file name */ HB_BOOL fShared; /* Shared file */ HB_BOOL fReadonly; /* Read only file */ - ULONG ulBufSize; /* size of buffer in records */ - ULONG ulBufRec; /* number of record in buffer */ - ULONG ulFirstRec; /* first record in the buffer */ + HB_SIZE ulBufSize; /* size of buffer in records */ + HB_ULONG ulBufRec; /* number of record in buffer */ + HB_ULONG ulFirstRec; /* first record in the buffer */ HB_BYTE * pBuffer; /* the buffer pointer */ HB_BOOL fChanged; /* the buffer is changed and should be written to index file */ HB_BOOL fHdrChanged; /* new records, header file has to be updated */ HB_BOOL fWrLocked; /* the index is locked for writing */ char * pSearchVal; /* current search value for HS_NEXT */ - ULONG ulSearch; /* the length of search value */ + HB_SIZE ulSearch; /* the length of search value */ HB_BYTE * pSearchKey; /* current search key val for HS_NEXT */ - ULONG ulCurrRec; /* current record for HS_NEXT */ + HB_ULONG ulCurrRec; /* current record for HS_NEXT */ /* xHarbour extension */ int iArea; /* work area number if bound with WA or 0 */ @@ -459,7 +459,7 @@ static int hb_hsxHashVal( int c1, int c2, int iKeyBits, return iBitNum; } -static void hb_hsxHashStr( const char * pStr, ULONG ulLen, HB_BYTE * pKey, int iKeySize, +static void hb_hsxHashStr( const char * pStr, HB_SIZE ulLen, HB_BYTE * pKey, int iKeySize, HB_BOOL fNoCase, int iFilter, HB_BOOL fUseHash ) { int c1, c2, iBitNum, iKeyBits = iKeySize << 3; @@ -491,12 +491,12 @@ static void hb_hsxHashStr( const char * pStr, ULONG ulLen, HB_BYTE * pKey, int i } } -static int hb_hsxStrCmp( const char * pSub, ULONG ulSub, const char * pStr, ULONG ulLen, +static int hb_hsxStrCmp( const char * pSub, HB_SIZE ulSub, const char * pStr, HB_SIZE ulLen, HB_BOOL fNoCase, int iFilter ) { HB_BOOL fResult = HB_FALSE; HB_UCHAR c1, c2; - ULONG ul; + HB_SIZE ul; if( ulSub == 0 ) return HSX_SUCCESSFALSE; @@ -586,7 +586,7 @@ static int hb_hsxEval( int iHandle, PHB_ITEM pExpr, HB_BYTE *pKey, HB_BOOL *fDel LPHSXINFO pHSX = hb_hsxGetPointer( iHandle ); int iResult = HSX_SUCCESS; const char * pStr; - ULONG ulLen; + HB_SIZE ulLen; if( ! pHSX ) return HSX_BADHANDLE; @@ -643,8 +643,8 @@ static int hb_hsxEval( int iHandle, PHB_ITEM pExpr, HB_BYTE *pKey, HB_BOOL *fDel static void hb_hsxGetRecCount( LPHSXINFO pHSX ) { - pHSX->ulRecCount = ( ULONG ) ( ( hb_fileSize( pHSX->pFile ) - - HSXHEADER_LEN ) / pHSX->uiRecordSize ); + pHSX->ulRecCount = ( HB_ULONG ) ( ( hb_fileSize( pHSX->pFile ) - + HSXHEADER_LEN ) / pHSX->uiRecordSize ); } static int hb_hsxHdrFlush( int iHandle ) @@ -693,7 +693,7 @@ static int hb_hsxFlush( int iHandle ) if( pHSX->fChanged ) { HB_FOFFSET fOffset; - ULONG ulSize; + HB_SIZE ulSize; fOffset = ( HB_FOFFSET ) HSXHEADER_LEN + ( HB_FOFFSET ) ( pHSX->ulFirstRec - 1 ) * @@ -752,7 +752,7 @@ static int hb_hsxHdrRead( int iHandle ) return iResult; } -static int hb_hsxRead( int iHandle, ULONG ulRecord, HB_BYTE ** pRecPtr ) +static int hb_hsxRead( int iHandle, HB_ULONG ulRecord, HB_BYTE ** pRecPtr ) { LPHSXINFO pHSX = hb_hsxGetPointer( iHandle ); HB_BOOL fCount = pHSX->fShared; @@ -773,7 +773,8 @@ static int hb_hsxRead( int iHandle, ULONG ulRecord, HB_BYTE ** pRecPtr ) ulRecord >= pHSX->ulFirstRec + pHSX->ulBufRec ) { HB_FOFFSET fOffset; - ULONG ulSize, ulFirst; + HB_SIZE ulSize; + HB_ULONG ulFirst; int iRetVal; if( ( iRetVal = hb_hsxFlush( iHandle ) ) != HSX_SUCCESS ) @@ -809,7 +810,7 @@ static int hb_hsxRead( int iHandle, ULONG ulRecord, HB_BYTE ** pRecPtr ) return HSX_SUCCESS; } -static int hb_hsxAppend( int iHandle, ULONG * pulRecNo, HB_BYTE **pRecPtr ) +static int hb_hsxAppend( int iHandle, HB_ULONG * pulRecNo, HB_BYTE **pRecPtr ) { LPHSXINFO pHSX = hb_hsxGetPointer( iHandle ); @@ -838,7 +839,7 @@ static int hb_hsxAppend( int iHandle, ULONG * pulRecNo, HB_BYTE **pRecPtr ) return HSX_SUCCESS; } -static int hb_hsxUpdate( int iHandle, ULONG ulRecord, HB_BYTE **pRecPtr ) +static int hb_hsxUpdate( int iHandle, HB_ULONG ulRecord, HB_BYTE **pRecPtr ) { LPHSXINFO pHSX = hb_hsxGetPointer( iHandle ); @@ -876,7 +877,7 @@ static int hb_hsxUpdate( int iHandle, ULONG ulRecord, HB_BYTE **pRecPtr ) return HSX_SUCCESS; } -static int hb_hsxLock( int iHandle, int iAction, ULONG ulRecord ) +static int hb_hsxLock( int iHandle, int iAction, HB_ULONG ulRecord ) { LPHSXINFO pHSX = hb_hsxGetPointer( iHandle ); int iRetVal = HSX_SUCCESS, iRet; @@ -983,7 +984,7 @@ static int hb_hsxLock( int iHandle, int iAction, ULONG ulRecord ) return iRetVal; } -static int hb_hsxIfDel( int iHandle, ULONG ulRecord ) +static int hb_hsxIfDel( int iHandle, HB_ULONG ulRecord ) { HB_BYTE *pRecPtr; int iRetVal, iRet; @@ -1002,7 +1003,7 @@ static int hb_hsxIfDel( int iHandle, ULONG ulRecord ) return iRetVal; } -static int hb_hsxDelete( int iHandle, ULONG ulRecord ) +static int hb_hsxDelete( int iHandle, HB_ULONG ulRecord ) { LPHSXINFO pHSX = hb_hsxGetPointer( iHandle ); int iRetVal, iRet; @@ -1034,7 +1035,7 @@ static int hb_hsxDelete( int iHandle, ULONG ulRecord ) return iRetVal; } -static int hb_hsxUnDelete( int iHandle, ULONG ulRecord ) +static int hb_hsxUnDelete( int iHandle, HB_ULONG ulRecord ) { LPHSXINFO pHSX = hb_hsxGetPointer( iHandle ); int iRetVal, iRet; @@ -1066,7 +1067,7 @@ static int hb_hsxUnDelete( int iHandle, ULONG ulRecord ) return iRetVal; } -static int hb_hsxReplace( int iHandle, ULONG ulRecord, PHB_ITEM pExpr, HB_BOOL fDeleted ) +static int hb_hsxReplace( int iHandle, HB_ULONG ulRecord, PHB_ITEM pExpr, HB_BOOL fDeleted ) { LPHSXINFO pHSX = hb_hsxGetPointer( iHandle ); int iRetVal, iRet; @@ -1097,7 +1098,7 @@ static int hb_hsxReplace( int iHandle, ULONG ulRecord, PHB_ITEM pExpr, HB_BOOL f return iRetVal; } -static int hb_hsxAdd( int iHandle, ULONG *pulRecNo, PHB_ITEM pExpr, HB_BOOL fDeleted ) +static int hb_hsxAdd( int iHandle, HB_ULONG *pulRecNo, PHB_ITEM pExpr, HB_BOOL fDeleted ) { LPHSXINFO pHSX = hb_hsxGetPointer( iHandle ); int iRetVal, iRet; @@ -1112,7 +1113,7 @@ static int hb_hsxAdd( int iHandle, ULONG *pulRecNo, PHB_ITEM pExpr, HB_BOOL fDel if( iRetVal == HSX_SUCCESS ) { HB_BYTE * pRecPtr; - ULONG ulRecNo; + HB_ULONG ulRecNo; iRetVal = hb_hsxAppend( iHandle, &ulRecNo, &pRecPtr ); if( iRetVal == HSX_SUCCESS ) @@ -1135,7 +1136,7 @@ static int hb_hsxAdd( int iHandle, ULONG *pulRecNo, PHB_ITEM pExpr, HB_BOOL fDel return iRetVal; } -static int hb_hsxSeekSet( int iHandle, const char * pStr, ULONG ulLen ) +static int hb_hsxSeekSet( int iHandle, const char * pStr, HB_SIZE ulLen ) { LPHSXINFO pHSX = hb_hsxGetPointer( iHandle ); int iRetVal; @@ -1167,7 +1168,7 @@ static int hb_hsxSeekSet( int iHandle, const char * pStr, ULONG ulLen ) return iRetVal; } -static int hb_hsxNext( int iHandle, ULONG * pulRecNo ) +static int hb_hsxNext( int iHandle, HB_ULONG * pulRecNo ) { LPHSXINFO pHSX = hb_hsxGetPointer( iHandle ); int iRetVal, iRet; @@ -1259,8 +1260,8 @@ static void hb_hsxExpDestroy( PHB_ITEM pItem ) hb_itemRelease( pItem ); } -static int hb_hsxVerify( int iHandle, const char * szText, ULONG ulLen, - const char * szSub, ULONG ulSub, int iType ) +static int hb_hsxVerify( int iHandle, const char * szText, HB_SIZE ulLen, + const char * szSub, HB_SIZE ulSub, int iType ) { LPHSXINFO pHSX = hb_hsxGetPointer( iHandle ); int iResult; @@ -1279,7 +1280,7 @@ static int hb_hsxVerify( int iHandle, const char * szText, ULONG ulLen, iResult = HSX_SUCCESSFALSE; else { - ULONG ul, ull; + HB_SIZE ul, ull; switch( iType ) { @@ -1382,7 +1383,7 @@ static int hb_hsxCreate( const char * szFile, int iBufSize, int iKeySize, char szFileName[ HB_PATH_MAX ]; const char * szExpr = NULL; PHB_ITEM pKeyExpr = NULL; - ULONG ulBufSize; + HB_SIZE ulBufSize; HB_USHORT uiRecordSize; LPHSXINFO pHSX; PHB_FILE pFile; @@ -1471,7 +1472,7 @@ static int hb_hsxOpen( const char * szFile, int iBufSize, int iMode ) char szFileName[ HB_PATH_MAX ]; HB_BOOL fShared, fReadonly; PHB_FILE pFile; - ULONG ulBufSize; + HB_SIZE ulBufSize; HB_USHORT uiFlags; LPHSXINFO pHSX; int iRetVal, iRet; @@ -1544,7 +1545,7 @@ static int hb_hsxIndex( const char * szFile, PHB_ITEM pExpr, int iKeySize, int iMode, int iBufSize, HB_BOOL fIgnoreCase, int iFilter ) { int iRetVal = HSX_SUCCESS, iHandle; - ULONG ulRecNo = 0, ulRecCount = 0, ulNewRec, ulRec; + HB_ULONG ulRecNo = 0, ulRecCount = 0, ulNewRec, ulRec; HB_ERRCODE errCode; AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer(); @@ -1596,7 +1597,7 @@ static int hb_hsxIndex( const char * szFile, PHB_ITEM pExpr, int iKeySize, return hb_hsxOpen( szFile, iBufSize, iMode ); } -static int hb_hsxFilter( int iHandle, const char * pSeek, ULONG ulSeek, +static int hb_hsxFilter( int iHandle, const char * pSeek, HB_ULONG ulSeek, PHB_ITEM pVerify, int iVerifyType ) { AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer(); @@ -1604,7 +1605,7 @@ static int hb_hsxFilter( int iHandle, const char * pSeek, ULONG ulSeek, HB_BOOL fDestroyExpr = HB_FALSE, fValid; int iResult = HSX_SUCCESS; HB_ERRCODE errCode; - ULONG ulRecNo = 0, ulRec; + HB_ULONG ulRecNo = 0, ulRec; PHB_ITEM pItem; if( !pHSX ) @@ -1732,7 +1733,7 @@ HB_FUNC( HS_ADD ) { if( hb_param( 1, HB_IT_NUMERIC ) ) { - ULONG ulRecNo; + HB_ULONG ulRecNo; int iRetVal; iRetVal = hb_hsxAdd( hb_parni( 1 ), &ulRecNo, @@ -1830,7 +1831,8 @@ HB_FUNC( HS_FILTER ) { const char * szText = hb_parc( 2 ); char * pBuff = NULL; - ULONG ulLen = hb_parclen( 2 ), ulRecords = 0, ull, ul; + HB_SIZE ulLen = hb_parclen( 2 ), ull, ul; + HB_ULONG ulRecords = 0; int iHandle = -1, iResult = HSX_BADPARMS; HB_BOOL fNew = HB_FALSE, fToken = HB_TRUE; @@ -1933,7 +1935,7 @@ HB_FUNC( HS_FILTER ) Searches a HiPer-SEEK index file for first/next match */ HB_FUNC( HS_NEXT ) { - ULONG ulRecNo = 0; + HB_ULONG ulRecNo = 0; int iRetVal = HSX_BADPARMS; if( hb_param( 1, HB_IT_NUMERIC ) ) @@ -1956,7 +1958,7 @@ HB_FUNC( HS_VERIFY ) int iHandle = hb_parni( 1 ); PHB_ITEM pExpr = hb_param( 2, HB_IT_BLOCK ); const char * szText = NULL; - ULONG ulLen = 0; + HB_SIZE ulLen = 0; LPHSXINFO pHSX; pHSX = hb_hsxGetPointer( iHandle ); @@ -1987,7 +1989,7 @@ HB_FUNC( HS_VERIFY ) { PHB_ITEM pExpr = hb_param( 1, HB_IT_BLOCK ); const char * szSub = hb_parc( 2 ), * szText = NULL; - ULONG ulSub = hb_parclen( 2 ), ulLen = 0; + HB_SIZE ulSub = hb_parclen( 2 ), ulLen = 0; HB_BOOL fIgnoreCase = hb_parl( 3 ); if( ulSub ) diff --git a/harbour/src/rdd/sdf1.c b/harbour/src/rdd/sdf1.c index ff0a6ecfc4..fdd0a74640 100644 --- a/harbour/src/rdd/sdf1.c +++ b/harbour/src/rdd/sdf1.c @@ -274,7 +274,7 @@ static HB_ERRCODE hb_sdfDeleted( SDFAREAP pArea, HB_BOOL * pDeleted ) /* * Obtain number of records in WorkArea. */ -static HB_ERRCODE hb_sdfRecCount( SDFAREAP pArea, ULONG * pRecCount ) +static HB_ERRCODE hb_sdfRecCount( SDFAREAP pArea, HB_ULONG * pRecCount ) { HB_TRACE(HB_TR_DEBUG, ("hb_sdfRecCount(%p,%p)", pArea, pRecCount)); @@ -285,7 +285,7 @@ static HB_ERRCODE hb_sdfRecCount( SDFAREAP pArea, ULONG * pRecCount ) /* * Obtain physical row number at current WorkArea cursor position. */ -static HB_ERRCODE hb_sdfRecNo( SDFAREAP pArea, ULONG * pulRecNo ) +static HB_ERRCODE hb_sdfRecNo( SDFAREAP pArea, HB_ULONG * pulRecNo ) { HB_TRACE(HB_TR_DEBUG, ("hb_sdfRecNo(%p,%p)", pArea, pulRecNo)); @@ -299,7 +299,7 @@ static HB_ERRCODE hb_sdfRecNo( SDFAREAP pArea, ULONG * pulRecNo ) static HB_ERRCODE hb_sdfRecId( SDFAREAP pArea, PHB_ITEM pRecNo ) { HB_ERRCODE errCode; - ULONG ulRecNo; + HB_ULONG ulRecNo; HB_TRACE(HB_TR_DEBUG, ("hb_sdfRecId(%p,%p)", pArea, pRecNo)); @@ -380,7 +380,7 @@ static HB_ERRCODE hb_sdfGetValue( SDFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI case HB_FT_STRING: if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) { - ULONG ulLen = pField->uiLen; + HB_SIZE ulLen = pField->uiLen; char * pszVal = hb_cdpnDup( ( const char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], &ulLen, pArea->area.cdPage, hb_vmCDP() ); hb_itemPutCLPtr( pItem, pszVal, ulLen ); @@ -470,7 +470,7 @@ static HB_ERRCODE hb_sdfPutValue( SDFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI char szBuffer[ 256 ]; HB_ERRCODE errCode; LPFIELD pField; - ULONG ulSize; + HB_SIZE ulSize; HB_TRACE(HB_TR_DEBUG, ("hb_sdfPutValue(%p,%hu,%p)", pArea, uiIndex, pItem)); @@ -499,12 +499,12 @@ static HB_ERRCODE hb_sdfPutValue( SDFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI else { ulSize = hb_itemGetCLen( pItem ); - if( ulSize > ( ULONG ) pField->uiLen ) + if( ulSize > ( HB_SIZE ) pField->uiLen ) ulSize = pField->uiLen; memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], hb_itemGetCPtr( pItem ), ulSize ); } - if( ulSize < ( ULONG ) pField->uiLen ) + if( ulSize < ( HB_SIZE ) pField->uiLen ) memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + ulSize, ' ', pField->uiLen - ulSize ); } @@ -651,7 +651,7 @@ static HB_ERRCODE hb_sdfGoCold( SDFAREAP pArea ) if( pArea->fRecordChanged ) { - ULONG ulWrite = pArea->uiRecordLen + pArea->uiEolLen; + HB_SIZE ulWrite = pArea->uiRecordLen + pArea->uiEolLen; if( hb_fileWriteAt( pArea->pFile, pArea->pRecord, ulWrite, pArea->ulRecordOffset ) != ulWrite ) @@ -1173,7 +1173,7 @@ static HB_ERRCODE hb_sdfOpen( SDFAREAP pArea, LPDBOPENINFO pOpenInfo ) /* * Retrieve information about the current driver. */ -static HB_ERRCODE hb_sdfRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulConnect, PHB_ITEM pItem ) +static HB_ERRCODE hb_sdfRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem ) { HB_TRACE(HB_TR_DEBUG, ("hb_sdfRddInfo(%p,%hu,%lu,%p)", pRDD, uiIndex, ulConnect, pItem)); diff --git a/harbour/src/rdd/usrrdd/usrrdd.c b/harbour/src/rdd/usrrdd/usrrdd.c index 3b77c359c3..800c256e95 100644 --- a/harbour/src/rdd/usrrdd/usrrdd.c +++ b/harbour/src/rdd/usrrdd/usrrdd.c @@ -170,7 +170,7 @@ static AREAP hb_usrGetAreaPointer( int iArea ) * RDD structures conversions */ -static PHB_ITEM hb_usrArrayGet( PHB_ITEM pArray, ULONG ulPos, HB_TYPE uiType ) +static PHB_ITEM hb_usrArrayGet( PHB_ITEM pArray, HB_SIZE ulPos, HB_TYPE uiType ) { PHB_ITEM pItem = hb_arrayGetItemPtr( pArray, ulPos ); @@ -180,7 +180,7 @@ static PHB_ITEM hb_usrArrayGet( PHB_ITEM pArray, ULONG ulPos, HB_TYPE uiType ) return NULL; } -static const char * hb_usrArrayGetC( PHB_ITEM pArray, ULONG ulPos ) +static const char * hb_usrArrayGetC( PHB_ITEM pArray, HB_SIZE ulPos ) { PHB_ITEM pItem = hb_arrayGetItemPtr( pArray, ulPos ); @@ -463,7 +463,7 @@ static HB_BOOL hb_usrItemToTransInfo( PHB_ITEM pItem, LPDBTRANSINFO pTransInfo ) HB_USHORT uiItemCount = hb_arrayGetNI( pItem, UR_TI_ITEMCOUNT ), uiCount; PHB_ITEM pItems = hb_arrayGetItemPtr( pItem, UR_TI_ITEMS ), pItm; - if( hb_arrayLen( pItems ) == ( ULONG ) uiItemCount && + if( hb_arrayLen( pItems ) == ( HB_SIZE ) uiItemCount && hb_usrItemToScopeInfo( hb_arrayGetItemPtr( pItem, UR_TI_SCOPE ), &pTransInfo->dbsci ) ) { @@ -536,7 +536,7 @@ static HB_BOOL hb_usrItemToSortInfo( PHB_ITEM pItem, LPDBSORTINFO pSortInfo ) HB_USHORT uiItemCount = hb_arrayGetNI( pItem, UR_SRI_ITEMCOUNT ), uiCount; PHB_ITEM pItems = hb_arrayGetItemPtr( pItem, UR_SRI_ITEMS ), pItm; - if( hb_arrayLen( pItems ) == ( ULONG ) uiItemCount && + if( hb_arrayLen( pItems ) == ( HB_SIZE ) uiItemCount && hb_usrItemToTransInfo( hb_arrayGetItemPtr( pItem, UR_SRI_TRANSINFO ), &pSortInfo->dbtri ) ) { @@ -797,7 +797,7 @@ static HB_ERRCODE hb_usrInit( LPRDDNODE pRDD ) if( pRDD->rddID >= s_uiUsrNodes ) { - ULONG ulSize = ( pRDD->rddID + 1 ) * sizeof( LPUSRRDDNODE ); + HB_SIZE ulSize = ( pRDD->rddID + 1 ) * sizeof( LPUSRRDDNODE ); if( s_uiUsrNodes ) s_pUsrRddNodes = ( LPUSRRDDNODE * ) hb_xrealloc( s_pUsrRddNodes, ulSize ); else @@ -1058,7 +1058,7 @@ static HB_ERRCODE hb_usrGoTop( AREAP pArea ) return hb_usrReturn(); } -static HB_ERRCODE hb_usrGoTo( AREAP pArea, ULONG ulRecNo ) +static HB_ERRCODE hb_usrGoTo( AREAP pArea, HB_ULONG ulRecNo ) { HB_TRACE(HB_TR_DEBUG, ("hb_usrGoTo(%p,%lu)", pArea, ulRecNo)); @@ -1415,7 +1415,7 @@ static HB_ERRCODE hb_usrPutValue( AREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem return hb_usrReturn(); } -static HB_ERRCODE hb_usrGetVarLen( AREAP pArea, HB_USHORT uiIndex, ULONG * pulLength ) +static HB_ERRCODE hb_usrGetVarLen( AREAP pArea, HB_USHORT uiIndex, HB_ULONG * pulLength ) { HB_LONG lOffset; @@ -1440,7 +1440,7 @@ static HB_ERRCODE hb_usrGetVarLen( AREAP pArea, HB_USHORT uiIndex, ULONG * pulLe return hb_usrReturn(); } -static HB_ERRCODE hb_usrRecCount( AREAP pArea, ULONG * pulRecCount ) +static HB_ERRCODE hb_usrRecCount( AREAP pArea, HB_ULONG * pulRecCount ) { HB_LONG lOffset; @@ -1480,7 +1480,7 @@ static HB_ERRCODE hb_usrRecInfo( AREAP pArea, PHB_ITEM pRecID, HB_USHORT uiInfoT return hb_usrReturn(); } -static HB_ERRCODE hb_usrRecNo( AREAP pArea, ULONG * pulRecNo ) +static HB_ERRCODE hb_usrRecNo( AREAP pArea, HB_ULONG * pulRecNo ) { HB_LONG lOffset; @@ -1690,7 +1690,7 @@ static HB_ERRCODE hb_usrPack( AREAP pArea ) return hb_usrReturn(); } -static HB_ERRCODE hb_usrPackRec( AREAP pArea, ULONG ulRecNo, HB_BOOL * pWritten ) +static HB_ERRCODE hb_usrPackRec( AREAP pArea, HB_ULONG ulRecNo, HB_BOOL * pWritten ) { HB_LONG lOffset; @@ -2351,7 +2351,7 @@ static HB_ERRCODE hb_usrEvalBlock( AREAP pArea, PHB_ITEM pBlock ) * Network operations */ -static HB_ERRCODE hb_usrRawLock( AREAP pArea, HB_USHORT uiAction, ULONG ulRecNo ) +static HB_ERRCODE hb_usrRawLock( AREAP pArea, HB_USHORT uiAction, HB_ULONG ulRecNo ) { HB_TRACE(HB_TR_DEBUG, ("hb_usrRawLock(%p,%hu,%lu)", pArea, uiAction, ulRecNo)); @@ -2528,7 +2528,7 @@ static HB_ERRCODE hb_usrWriteDBHeader( AREAP pArea ) * non WorkArea functions */ -static HB_ERRCODE hb_usrDrop( LPRDDNODE pRDD, PHB_ITEM pTable, PHB_ITEM pIndex, ULONG ulConnection ) +static HB_ERRCODE hb_usrDrop( LPRDDNODE pRDD, PHB_ITEM pTable, PHB_ITEM pIndex, HB_ULONG ulConnection ) { HB_TRACE(HB_TR_DEBUG, ("hb_usrDrop(%p,%p,%p,%lu)", pRDD, pTable, pIndex, ulConnection)); @@ -2544,7 +2544,7 @@ static HB_ERRCODE hb_usrDrop( LPRDDNODE pRDD, PHB_ITEM pTable, PHB_ITEM pIndex, return hb_usrReturn(); } -static HB_ERRCODE hb_usrExists( LPRDDNODE pRDD, PHB_ITEM pTable, PHB_ITEM pIndex, ULONG ulConnection ) +static HB_ERRCODE hb_usrExists( LPRDDNODE pRDD, PHB_ITEM pTable, PHB_ITEM pIndex, HB_ULONG ulConnection ) { HB_TRACE(HB_TR_DEBUG, ("hb_usrExists(%p,%p,%p,%lu)", pRDD, pTable, pIndex, ulConnection)); @@ -2560,7 +2560,7 @@ static HB_ERRCODE hb_usrExists( LPRDDNODE pRDD, PHB_ITEM pTable, PHB_ITEM pIndex return hb_usrReturn(); } -static HB_ERRCODE hb_usrRename( LPRDDNODE pRDD, PHB_ITEM pTable, PHB_ITEM pIndex, PHB_ITEM pNewName, ULONG ulConnection ) +static HB_ERRCODE hb_usrRename( LPRDDNODE pRDD, PHB_ITEM pTable, PHB_ITEM pIndex, PHB_ITEM pNewName, HB_ULONG ulConnection ) { HB_TRACE(HB_TR_DEBUG, ("hb_usrRename(%p,%p,%p,%p,%lu)", pRDD, pTable, pIndex, pNewName, ulConnection)); @@ -2577,7 +2577,7 @@ static HB_ERRCODE hb_usrRename( LPRDDNODE pRDD, PHB_ITEM pTable, PHB_ITEM pIndex return hb_usrReturn(); } -static HB_ERRCODE hb_usrRddInfo( LPRDDNODE pRDD, HB_USHORT uiInfoType, ULONG ulConnection, PHB_ITEM pInfo ) +static HB_ERRCODE hb_usrRddInfo( LPRDDNODE pRDD, HB_USHORT uiInfoType, HB_ULONG ulConnection, PHB_ITEM pInfo ) { HB_TRACE(HB_TR_DEBUG, ("hb_usrRddInfo(%p,%hu,%lu,%p)", pRDD, uiInfoType, ulConnection, pInfo)); @@ -3416,7 +3416,7 @@ HB_FUNC_UR_SUPER( GETVARLEN ) if( pArea ) { - ULONG ulLength; + HB_ULONG ulLength; hb_retni( SUPER_GETVARLEN( pArea, hb_parni( 2 ), &ulLength ) ); hb_stornl( ulLength, 3 ); @@ -3429,7 +3429,7 @@ HB_FUNC_UR_SUPER( RECCOUNT ) if( pArea ) { - ULONG ulRecCount; + HB_ULONG ulRecCount; hb_retni( SUPER_RECCOUNT( pArea, &ulRecCount ) ); hb_stornl( ulRecCount, 2 ); @@ -3451,7 +3451,7 @@ HB_FUNC_UR_SUPER( RECNO ) if( pArea ) { - ULONG ulRecNo; + HB_ULONG ulRecNo; hb_retni( SUPER_RECNO( pArea, &ulRecNo ) ); hb_stornl( ulRecNo, 2 ); diff --git a/harbour/src/rdd/wacore.c b/harbour/src/rdd/wacore.c index 52f85f1703..3fd4c2136d 100644 --- a/harbour/src/rdd/wacore.c +++ b/harbour/src/rdd/wacore.c @@ -514,7 +514,7 @@ HB_ERRCODE hb_rddDetachArea( AREAP pArea, PHB_ITEM pCargo ) { AREAP * pHolder; PHB_ITEM pDetachedArea; - ULONG ulPos; + HB_SIZE ulPos; int iArea; HB_TRACE(HB_TR_DEBUG, ("hb_rddDetachArea(%p,%p)", pArea, pCargo)); @@ -617,7 +617,7 @@ AREAP hb_rddRequestArea( const char * szAlias, PHB_ITEM pCargo, { if( s_pDetachedAreas ) { - ULONG ulLen = hb_arrayLen( s_pDetachedAreas ), ulPos = 1; + HB_SIZE ulLen = hb_arrayLen( s_pDetachedAreas ), ulPos = 1; if( pSymAlias ) { for( ulPos = 1; ulPos <= ulLen; ++ulPos ) diff --git a/harbour/src/rdd/wafunc.c b/harbour/src/rdd/wafunc.c index c336e67036..f3593c5cab 100644 --- a/harbour/src/rdd/wafunc.c +++ b/harbour/src/rdd/wafunc.c @@ -586,7 +586,7 @@ HB_ERRCODE hb_rddPutFieldValue( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol ) 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 ) { char szDriverBuffer[ HB_RDD_MAX_DRIVERNAME_LEN + 1 ]; @@ -674,7 +674,7 @@ HB_ERRCODE hb_rddOpenTable( const char * szFileName, const char * szDriver, 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 ) { char szDriverBuffer[ HB_RDD_MAX_DRIVERNAME_LEN + 1 ]; @@ -746,7 +746,7 @@ HB_ERRCODE hb_rddCreateTable( const char * szFileName, const char * szDriver, HB_ERRCODE hb_rddCreateTableTemp( const char * szDriver, const char * szAlias, - const char * szCpId, ULONG ulConnection, + const char * szCpId, HB_ULONG ulConnection, PHB_ITEM pStruct ) { char szDriverBuffer[ HB_RDD_MAX_DRIVERNAME_LEN + 1 ]; @@ -1071,7 +1071,7 @@ HB_ERRCODE hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest, 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, diff --git a/harbour/src/rdd/workarea.c b/harbour/src/rdd/workarea.c index 1bb8ee7f50..40889618b0 100644 --- a/harbour/src/rdd/workarea.c +++ b/harbour/src/rdd/workarea.c @@ -789,7 +789,7 @@ static HB_ERRCODE hb_waInfo( AREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem ) } case DBI_POSITIONED: { - ULONG ulRecCount, ulRecNo; + HB_ULONG ulRecCount, ulRecNo; if( SELF_RECNO( pArea, &ulRecNo ) != HB_SUCCESS ) return HB_FAILURE; if( ulRecNo == 0 ) @@ -1720,7 +1720,7 @@ static HB_ERRCODE hb_waEvalBlock( AREAP pArea, PHB_ITEM pBlock ) /* * RDD info */ -static HB_ERRCODE hb_waRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, ULONG ulConnection, PHB_ITEM pItem ) +static HB_ERRCODE hb_waRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnection, PHB_ITEM pItem ) { HB_BOOL fResult; int iResult; diff --git a/harbour/src/rtl/errapi.c b/harbour/src/rtl/errapi.c index 85e2c4b1f2..b8fa4f366c 100644 --- a/harbour/src/rtl/errapi.c +++ b/harbour/src/rtl/errapi.c @@ -904,10 +904,10 @@ PHB_ITEM hb_errPutFlags( PHB_ITEM pError, HB_USHORT uiFlags ) return pError; } -PHB_ITEM hb_errPutArgs( PHB_ITEM pError, ULONG ulArgCount, ... ) +PHB_ITEM hb_errPutArgs( PHB_ITEM pError, HB_ULONG ulArgCount, ... ) { PHB_ITEM pArray; - ULONG ulArgPos; + HB_ULONG ulArgPos; va_list va; HB_TRACE(HB_TR_DEBUG, ("hb_errPutArgs(%p, %lu, ...)", pError, ulArgCount)); @@ -1047,14 +1047,14 @@ HB_FUNC( __ERRRT_SBASE ) hb_param( 6, HB_IT_ANY ) ); } -HB_USHORT hb_errRT_BASE( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, ULONG ulArgCount, ... ) +HB_USHORT hb_errRT_BASE( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ULONG ulArgCount, ... ) { HB_USHORT uiAction; PHB_ITEM pError; PHB_ITEM pArray; va_list va; - ULONG ulArgPos; + HB_ULONG ulArgPos; /* I replaced EF_CANRETRY with EF_NONE for Clipper compatibility * If it's wrong and I missed sth please fix me, Druzus. @@ -1108,14 +1108,14 @@ HB_USHORT hb_errRT_BASE( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const cha return uiAction; } -HB_USHORT hb_errRT_BASE_Ext1( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ERRCODE errOsCode, HB_USHORT uiFlags, ULONG ulArgCount, ... ) +HB_USHORT hb_errRT_BASE_Ext1( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, 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; pError = hb_errRT_New( ES_ERROR, HB_ERR_SS_BASE, errGenCode, errSubCode, szDescription, szOperation, errOsCode, uiFlags ); @@ -1165,14 +1165,14 @@ HB_USHORT hb_errRT_BASE_Ext1( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, cons return uiAction; } -PHB_ITEM hb_errRT_BASE_Subst( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, ULONG ulArgCount, ... ) +PHB_ITEM hb_errRT_BASE_Subst( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ULONG ulArgCount, ... ) { PHB_ITEM pRetVal; PHB_ITEM pError; PHB_ITEM pArray; va_list va; - ULONG ulArgPos; + HB_ULONG ulArgPos; pError = hb_errRT_New_Subst( ES_ERROR, HB_ERR_SS_BASE, errGenCode, errSubCode, szDescription, szOperation, 0, EF_NONE ); @@ -1222,13 +1222,13 @@ PHB_ITEM hb_errRT_BASE_Subst( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, cons return pRetVal; } -void hb_errRT_BASE_SubstR( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, ULONG ulArgCount, ... ) +void hb_errRT_BASE_SubstR( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ULONG ulArgCount, ... ) { PHB_ITEM pError; PHB_ITEM pArray; va_list va; - ULONG ulArgPos; + HB_ULONG ulArgPos; pError = hb_errRT_New_Subst( ES_ERROR, HB_ERR_SS_BASE, errGenCode, errSubCode, szDescription, szOperation, 0, EF_NONE ); diff --git a/harbour/src/rtl/filebuf.c b/harbour/src/rtl/filebuf.c index b471942e3c..2a69a55af5 100644 --- a/harbour/src/rtl/filebuf.c +++ b/harbour/src/rtl/filebuf.c @@ -78,8 +78,8 @@ HB_FLOCK, * PHB_FLOCK; typedef struct _HB_FILE { const HB_FILE_FUNCS * pFuncs; - ULONG device; - ULONG inode; + HB_ULONG device; + HB_ULONG inode; int used; HB_BOOL shared; HB_BOOL readonly; @@ -115,7 +115,7 @@ void hb_fileDsp( PHB_FILE pFile, const char * szMsg ) } */ -static PHB_FILE hb_fileFind( ULONG device, ULONG inode ) +static PHB_FILE hb_fileFind( HB_ULONG device, HB_ULONG inode ) { if( s_openFiles && ( device || inode ) ) { @@ -132,7 +132,7 @@ static PHB_FILE hb_fileFind( ULONG device, ULONG inode ) } static PHB_FILE hb_fileNew( HB_FHANDLE hFile, HB_BOOL fShared, HB_BOOL fReadonly, - ULONG device, ULONG inode, HB_BOOL fBind ) + HB_ULONG device, HB_ULONG inode, HB_BOOL fBind ) { PHB_FILE pFile = hb_fileFind( device, inode ); @@ -378,13 +378,13 @@ static PHB_FILE s_fileExtOpen( const char * pFilename, const char * pDefExt, hFile = hb_fsExtOpen( pFilename, pDefExt, uiExFlags, pPaths, pError ); if( hFile != FS_ERROR ) { - ULONG device = 0, inode = 0; + HB_ULONG device = 0, inode = 0; #if defined( HB_OS_UNIX ) hb_vmUnlock(); if( fstat( hFile, &statbuf ) == 0 ) { - device = ( ULONG ) statbuf.st_dev; - inode = ( ULONG ) statbuf.st_ino; + device = ( HB_ULONG ) statbuf.st_dev; + inode = ( HB_ULONG ) statbuf.st_ino; } hb_vmLock(); #endif diff --git a/harbour/src/rtl/gtcgi/gtcgi.c b/harbour/src/rtl/gtcgi/gtcgi.c index ca21f15199..a81eb2d556 100644 --- a/harbour/src/rtl/gtcgi/gtcgi.c +++ b/harbour/src/rtl/gtcgi/gtcgi.c @@ -92,7 +92,7 @@ typedef struct _HB_GTCGI int iLineBufSize; char * sLineBuf; char * szCrLf; - ULONG ulCrLf; + HB_SIZE ulCrLf; HB_BOOL fDispTrans; PHB_CODEPAGE cdpTerm; PHB_CODEPAGE cdpHost; diff --git a/harbour/src/rtl/gtpca/gtpca.c b/harbour/src/rtl/gtpca/gtpca.c index 6c2200d079..8094c7acf0 100644 --- a/harbour/src/rtl/gtpca/gtpca.c +++ b/harbour/src/rtl/gtpca/gtpca.c @@ -103,10 +103,10 @@ static int s_iRow; static int s_iCol; static int s_iLineBufSize = 0; static char * s_sLineBuf; -static ULONG s_ulTransBufSize = 0; +static HB_SIZE s_ulTransBufSize = 0; static char * s_sTransBuf; static const char * s_szCrLf; -static ULONG s_ulCrLf; +static HB_SIZE s_ulCrLf; static int s_iCurrentSGR, s_iFgColor, s_iBgColor, s_iBold, s_iBlink, s_iAM; static int s_iCursorStyle; static HB_BOOL s_bStdinConsole; diff --git a/harbour/src/rtl/gtstd/gtstd.c b/harbour/src/rtl/gtstd/gtstd.c index 4050d4bef9..0e8258a84a 100644 --- a/harbour/src/rtl/gtstd/gtstd.c +++ b/harbour/src/rtl/gtstd/gtstd.c @@ -104,11 +104,11 @@ typedef struct _HB_GTSTD int iLineBufSize; char * sLineBuf; - ULONG ulTransBufSize; + HB_SIZE ulTransBufSize; char * sTransBuf; HB_BOOL fFullRedraw; char * szCrLf; - ULONG ulCrLf; + HB_SIZE ulCrLf; HB_BOOL fDispTrans; PHB_CODEPAGE cdpTerm; diff --git a/harbour/src/rtl/gtxwc/gtxwc.c b/harbour/src/rtl/gtxwc/gtxwc.c index 594de0261c..52990e4724 100644 --- a/harbour/src/rtl/gtxwc/gtxwc.c +++ b/harbour/src/rtl/gtxwc/gtxwc.c @@ -365,8 +365,8 @@ typedef struct tag_x_wnddef int lastCursorType; HB_BOOL cursorState; - ULONG cursorBlinkRate; - ULONG cursorStateTime; + HB_ULONG cursorBlinkRate; + HB_ULONG cursorStateTime; /* Mouse informations */ int mouseCol; @@ -375,15 +375,15 @@ typedef struct tag_x_wnddef int mouseGotoRow; int mouseNumButtons; int mouseButtonsState; - unsigned char mouseButtonsMap[XWC_MAX_BUTTONS]; - Time mouseButtonsTime[XWC_MAX_BUTTONS]; + unsigned char mouseButtonsMap[ XWC_MAX_BUTTONS ]; + Time mouseButtonsTime[ XWC_MAX_BUTTONS ]; /* current screen contents (attr<<24)|(color<<16)|char */ - ULONG *pCurrScr; + HB_ULONG * pCurrScr; /* character translation table, it changes characters in screen buffer into UNICODE or graphs primitives */ - XWC_CharTrans charTrans[256]; - XWC_CharTrans boxTrans[256]; + XWC_CharTrans charTrans[ 256 ]; + XWC_CharTrans boxTrans[ 256 ]; HB_BOOL fInvalidChr; XWC_RECT rInvalidChr; @@ -399,7 +399,7 @@ typedef struct tag_x_wnddef /* Clipboard buffer */ unsigned char * ClipboardData; - ULONG ClipboardSize; + HB_SIZE ClipboardSize; Atom ClipboardRequest; Time ClipboardTime; HB_BOOL ClipboardOwner; @@ -1854,7 +1854,7 @@ static void hb_gt_xwc_ProcessKey( PXWND_DEF wnd, XKeyEvent *evt) if( n > 0 ) { unsigned char keystr[ 32 ]; - ULONG u = sizeof( keystr ); + HB_ULONG u = sizeof( keystr ); #ifndef HB_XWC_USE_LOCALE hb_cdpnDup2( ( const char * ) buf, n, ( char * ) keystr, &u, @@ -2236,7 +2236,7 @@ static void hb_gt_xwc_WndProc( PXWND_DEF wnd, XEvent *evt ) /* TODO: for s_atomString convert data to ISO-8859-1 */ if( wnd->inCDP && wnd->hostCDP && wnd->inCDP != wnd->hostCDP ) { - ULONG ulLen = wnd->ClipboardSize; + HB_SIZE ulLen = wnd->ClipboardSize; unsigned char * pBuffer = ( unsigned char * ) hb_cdpnDup( ( const char * ) wnd->ClipboardData, &ulLen, wnd->hostCDP, wnd->inCDP ); @@ -2255,7 +2255,7 @@ static void hb_gt_xwc_WndProc( PXWND_DEF wnd, XEvent *evt ) } else if( req->target == s_atomUTF8String ) { - ULONG ulLen = wnd->ClipboardSize; + HB_SIZE ulLen = wnd->ClipboardSize; unsigned char * pBuffer = ( unsigned char * ) hb_cdpnDup( ( const char * ) wnd->ClipboardData, &ulLen, wnd->hostCDP, wnd->utf8CDP ); @@ -2491,9 +2491,9 @@ static void hb_gt_xwc_DrawString( PXWND_DEF wnd, int col, int row, HB_BYTE color /* *********************************************************************** */ -static ULONG hb_gt_xwc_HashCurrChar( HB_BYTE attr, HB_BYTE color, HB_USHORT chr ) +static HB_ULONG hb_gt_xwc_HashCurrChar( HB_BYTE attr, HB_BYTE color, HB_USHORT chr ) { - return ( ( ULONG ) attr << 24 ) | ( ( ULONG ) color << 16 ) | ( ULONG ) chr; + return ( ( HB_ULONG ) attr << 24 ) | ( ( HB_ULONG ) color << 16 ) | ( HB_ULONG ) chr; } /* *********************************************************************** */ @@ -2503,7 +2503,7 @@ static void hb_gt_xwc_RepaintChar( PXWND_DEF wnd, int colStart, int rowStart, in HB_USHORT irow, icol, index, startCol = 0, len, basex, basey, nsize; HB_BYTE oldColor = 0, color, attr; HB_USHORT usCh16, usChBuf[ XWC_MAX_COLS ]; - ULONG ulCurr = 0xFFFFFFFFL; + HB_ULONG ulCurr = 0xFFFFFFFFL; int i, iColor; XWC_CharTrans * chTrans; @@ -2891,7 +2891,7 @@ static void hb_gt_xwc_UpdateSize( PXWND_DEF wnd ) /* *********************************************************************** */ -static ULONG hb_gt_xwc_CurrentTime( void ) +static HB_ULONG hb_gt_xwc_CurrentTime( void ) { struct timeval tv; gettimeofday( &tv, NULL ); @@ -2910,7 +2910,7 @@ static void hb_gt_xwc_ProcessMessages( PXWND_DEF wnd ) } else { - ULONG ulCurrentTime = hb_gt_xwc_CurrentTime(); + HB_ULONG ulCurrentTime = hb_gt_xwc_CurrentTime(); if( ulCurrentTime - wnd->cursorStateTime > wnd->cursorBlinkRate ) { @@ -2996,11 +2996,11 @@ static void hb_gt_xwc_SetScrBuff( PXWND_DEF wnd, HB_USHORT cols, HB_USHORT rows wnd->rows = rows; if( wnd->pCurrScr == NULL ) - wnd->pCurrScr = ( ULONG* ) hb_xgrab( iSize * sizeof( ULONG ) ); + wnd->pCurrScr = ( HB_ULONG * ) hb_xgrab( iSize * sizeof( HB_ULONG ) ); else - wnd->pCurrScr = ( ULONG* ) hb_xrealloc( wnd->pCurrScr, iSize * sizeof( ULONG ) ); + wnd->pCurrScr = ( HB_ULONG * ) hb_xrealloc( wnd->pCurrScr, iSize * sizeof( HB_ULONG ) ); - memset( wnd->pCurrScr, 0xFFFFFFFFL, iSize * sizeof( ULONG ) ); + memset( wnd->pCurrScr, 0xFFFFFFFFL, iSize * sizeof( HB_ULONG ) ); hb_gt_xwc_InvalidateChar( wnd, 0, 0, wnd->cols - 1, wnd->rows - 1 ); HB_GTSELF_RESIZE( wnd->pGT, wnd->rows, wnd->cols ); } @@ -3092,7 +3092,7 @@ static void hb_gt_xwc_ClearSelection( PXWND_DEF wnd ) /* *********************************************************************** */ -static void hb_gt_xwc_SetSelection( PXWND_DEF wnd, const char *szData, ULONG ulSize ) +static void hb_gt_xwc_SetSelection( PXWND_DEF wnd, const char * szData, HB_SIZE ulSize ) { HB_XWC_XLIB_LOCK @@ -3134,7 +3134,7 @@ static void hb_gt_xwc_RequestSelection( PXWND_DEF wnd ) if( !wnd->ClipboardOwner ) { Atom aRequest; - ULONG ulCurrentTime = hb_gt_xwc_CurrentTime(); + HB_ULONG ulCurrentTime = hb_gt_xwc_CurrentTime(); int iConnFD = ConnectionNumber( wnd->dpy ); wnd->ClipboardRcvd = HB_FALSE; @@ -3175,7 +3175,7 @@ static void hb_gt_xwc_RequestSelection( PXWND_DEF wnd ) hb_gt_xwc_ProcessMessages( wnd ); if( !wnd->ClipboardRcvd && wnd->ClipboardRequest == aRequest ) { - ULONG ulTime = hb_gt_xwc_CurrentTime() - ulCurrentTime; + HB_ULONG ulTime = hb_gt_xwc_CurrentTime() - ulCurrentTime; struct timeval timeout; fd_set readfds; @@ -4101,7 +4101,7 @@ static HB_BOOL hb_gt_xwc_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) wnd->colors[ iVal ].set = HB_FALSE; if( wnd->dpy && hb_gt_xwc_setPalette( wnd ) ) { - memset( wnd->pCurrScr, 0xFFFFFFFFL, wnd->cols * wnd->rows * sizeof( ULONG ) ); + memset( wnd->pCurrScr, 0xFFFFFFFFL, wnd->cols * wnd->rows * sizeof( HB_ULONG ) ); hb_gt_xwc_InvalidateChar( wnd, 0, 0, wnd->cols - 1, wnd->rows - 1 ); } } @@ -4129,7 +4129,7 @@ static HB_BOOL hb_gt_xwc_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) } if( wnd->dpy && hb_gt_xwc_setPalette( wnd ) ) { - memset( wnd->pCurrScr, 0xFFFFFFFFL, wnd->cols * wnd->rows * sizeof( ULONG ) ); + memset( wnd->pCurrScr, 0xFFFFFFFFL, wnd->cols * wnd->rows * sizeof( HB_ULONG ) ); hb_gt_xwc_InvalidateChar( wnd, 0, 0, wnd->cols - 1, wnd->rows - 1 ); } } diff --git a/harbour/src/rtl/hbproces.c b/harbour/src/rtl/hbproces.c index da6dd1d381..ad701722c3 100644 --- a/harbour/src/rtl/hbproces.c +++ b/harbour/src/rtl/hbproces.c @@ -381,10 +381,10 @@ static int hb_fsProcessExec( const char *pszFilename, } #endif -HB_FHANDLE hb_fsProcessOpen( const char *pszFilename, - HB_FHANDLE *phStdin, HB_FHANDLE *phStdout, - HB_FHANDLE *phStderr, - HB_BOOL fDetach, ULONG *pulPID ) +HB_FHANDLE hb_fsProcessOpen( const char * pszFilename, + HB_FHANDLE * phStdin, HB_FHANDLE * phStdout, + HB_FHANDLE * phStderr, + HB_BOOL fDetach, HB_ULONG * pulPID ) { HB_FHANDLE hResult = FS_ERROR; char * pszFree = NULL; diff --git a/harbour/src/rtl/hbprocfn.c b/harbour/src/rtl/hbprocfn.c index 9ddf565319..86fede6c05 100644 --- a/harbour/src/rtl/hbprocfn.c +++ b/harbour/src/rtl/hbprocfn.c @@ -66,7 +66,7 @@ HB_FUNC( HB_PROCESSOPEN ) HB_BOOL fDetach = hb_parl( 5 ); HB_FHANDLE hStdIn, *phStdIn, hStdOut, *phStdOut, hStdErr, *phStdErr; HB_FHANDLE hProcess; - ULONG ulPID; + HB_ULONG ulPID; if( szName && ( pStdIn || HB_ISNIL( 2 ) ) && diff --git a/harbour/src/rtl/hbsocket.c b/harbour/src/rtl/hbsocket.c index b65cb95c5e..d148f93e5e 100644 --- a/harbour/src/rtl/hbsocket.c +++ b/harbour/src/rtl/hbsocket.c @@ -735,7 +735,7 @@ static const char * hb_inet_ntoa( struct in_addr * addr, char * pBuffer ) * in many systems inet_ntoa() returns pointer to * static buffer and is not MT safe. */ - ULONG u = ntohl( addr->s_addr ); + HB_ULONG u = ntohl( addr->s_addr ); hb_snprintf( pBuffer, INET_ADDRSTRLEN, "%hd.%hd.%hd.%hd", HB_UHBYTE( u ), HB_ULBYTE( u ), HB_HIBYTE( u ), HB_LOBYTE( u ) ); return pBuffer; diff --git a/harbour/src/vm/classes.c b/harbour/src/vm/classes.c index cee60e4d7d..4d85887602 100644 --- a/harbour/src/vm/classes.c +++ b/harbour/src/vm/classes.c @@ -174,9 +174,9 @@ typedef struct HB_USHORT uiPrevCls; HB_USHORT uiPrevMth; #ifndef 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 } METHOD, * PMETHOD; @@ -195,7 +195,7 @@ typedef struct PHB_ITEM pInlines; /* Array for inline codeblocks */ PHB_ITEM pMutex; /* Class sync method mutex */ PHB_SYMB * pFriendSyms; /* Friend functions' symbols */ - ULONG ulOpFlags; /* Flags for overloaded operators */ + HB_ULONG ulOpFlags; /* Flags for overloaded operators */ HB_USHORT uiClass; /* This class handle */ HB_USHORT fHasDestructor; /* has the class destructor message? */ HB_USHORT fHasOnError; /* has the class OnError message? */ @@ -224,9 +224,9 @@ typedef struct #define hb_clsBucketPos( p, m ) ( ( (p)->uiSymNum & (m) ) << BUCKETBITS ) #ifdef HB_MSG_POOL -# define hb_clsMthNum(p) ( ( ULONG ) (p)->uiMethodCount ) +# define hb_clsMthNum(p) ( ( HB_ULONG ) (p)->uiMethodCount ) #else -# define hb_clsMthNum(p) ( ( ( ULONG ) (p)->uiHashKey + 1 ) << BUCKETBITS ) +# define hb_clsMthNum(p) ( ( ( HB_ULONG ) (p)->uiHashKey + 1 ) << BUCKETBITS ) #endif #if defined( HB_REAL_BLOCK_SCOPE ) @@ -442,7 +442,7 @@ static HB_USHORT hb_clsBucketPos( PHB_DYNS pMsg, HB_USHORT uiMask ) */ static HB_BOOL hb_clsDictRealloc( PCLASS pClass ) { - ULONG ulNewHashKey, ulLimit, ul; + HB_ULONG ulNewHashKey, ulLimit, ul; #ifdef HB_MSG_POOL HB_USHORT * puiMsgIdx; #else @@ -451,7 +451,7 @@ static HB_BOOL hb_clsDictRealloc( PCLASS pClass ) HB_TRACE(HB_TR_DEBUG, ("hb_clsDictRealloc(%p)", pClass)); - ulNewHashKey = ( ULONG ) pClass->uiHashKey + 1; + ulNewHashKey = ( HB_ULONG ) pClass->uiHashKey + 1; ulLimit = ulNewHashKey << BUCKETBITS; do @@ -542,13 +542,13 @@ static HB_BOOL hb_clsDictRealloc( PCLASS pClass ) static void hb_clsDictInit( PCLASS pClass, HB_USHORT uiHashKey ) { - ULONG ulSize; + HB_ULONG ulSize; HB_TRACE(HB_TR_DEBUG, ("hb_clsDictInit(%p,%hu)", pClass, uiHashKey)); pClass->uiHashKey = uiHashKey; #ifdef HB_MSG_POOL - ulSize = ( ( ( ULONG ) uiHashKey + 1 ) << BUCKETBITS ) * sizeof( HB_USHORT ); + ulSize = ( ( ( HB_ULONG ) uiHashKey + 1 ) << BUCKETBITS ) * sizeof( HB_USHORT ); pClass->puiMsgIdx = ( HB_USHORT * ) hb_xgrab( ulSize ); memset( pClass->puiMsgIdx, 0, ulSize ); @@ -556,7 +556,7 @@ static void hb_clsDictInit( PCLASS pClass, HB_USHORT uiHashKey ) pClass->pMethods = ( PMETHOD ) hb_xgrab( sizeof( METHOD ) ); memset( pClass->pMethods, 0, sizeof( METHOD ) ); #else - ulSize = ( ( ( ULONG ) uiHashKey + 1 ) << BUCKETBITS ) * sizeof( METHOD ); + ulSize = ( ( ( HB_ULONG ) uiHashKey + 1 ) << BUCKETBITS ) * sizeof( METHOD ); pClass->pMethods = ( PMETHOD ) hb_xgrab( ulSize ); memset( pClass->pMethods, 0, ulSize ); #endif @@ -780,7 +780,7 @@ static HB_USHORT hb_clsAddInitValue( PCLASS pClass, PHB_ITEM pItem, if( ui == 0 ) { pClass->pInitData = ( PINITDATA ) hb_xrealloc( pClass->pInitData, - ( ULONG ) ( pClass->uiInitDatas + 1 ) * sizeof( INITDATA ) ); + ( HB_ULONG ) ( pClass->uiInitDatas + 1 ) * sizeof( INITDATA ) ); pInitData = pClass->pInitData + pClass->uiInitDatas++; } } @@ -820,7 +820,7 @@ static HB_USHORT hb_clsFindClassDataOffset( PCLASS pClass, PMETHOD pNewMethod ) uiData = hb_clsFindRealClassDataOffset( pNewMethod ); if( uiData ) { - ULONG ulLimit = hb_clsMthNum( pClass ); + HB_ULONG ulLimit = hb_clsMthNum( pClass ); PMETHOD pMethod = pClass->pMethods; do { @@ -909,7 +909,7 @@ static HB_BOOL hb_clsUpdateHiddenMessages( PMETHOD pSrcMethod, PMETHOD pDstMetho static void hb_clsCopyClass( PCLASS pClsDst, PCLASS pClsSrc ) { PMETHOD pMethod; - ULONG ulLimit; + HB_ULONG ulLimit; HB_TRACE(HB_TR_DEBUG, ("hb_clsCopyClass(%p,%p)", pClsDst, pClsSrc)); @@ -930,7 +930,7 @@ static void hb_clsCopyClass( PCLASS pClsDst, PCLASS pClsSrc ) if( pClsSrc->uiInitDatas ) { - ULONG ulSize = ( ULONG ) pClsSrc->uiInitDatas * sizeof( INITDATA ); + HB_ULONG ulSize = ( HB_ULONG ) pClsSrc->uiInitDatas * sizeof( INITDATA ); HB_USHORT uiData; pClsDst->uiInitDatas = pClsSrc->uiInitDatas; @@ -948,7 +948,7 @@ static void hb_clsCopyClass( PCLASS pClsDst, PCLASS pClsSrc ) ulLimit = hb_clsMthNum( pClsSrc ); #ifdef HB_MSG_POOL memcpy( pClsDst->puiMsgIdx, pClsSrc->puiMsgIdx, - ( ( ( ULONG ) pClsSrc->uiHashKey + 1 ) << BUCKETBITS ) * sizeof( HB_USHORT ) ); + ( ( ( HB_ULONG ) pClsSrc->uiHashKey + 1 ) << BUCKETBITS ) * sizeof( HB_USHORT ) ); pClsDst->uiMethodCount = pClsSrc->uiMethodCount; pClsDst->pMethods = ( PMETHOD ) hb_xrealloc( pClsDst->pMethods, ulLimit * sizeof( METHOD ) ); @@ -1052,7 +1052,7 @@ void hb_clsInit( void ) s_uiClsSize = HB_CLASS_POOL_SIZE; s_uiClasses = 0; - s_pClasses = ( PCLASS * ) hb_xgrab( sizeof( PCLASS ) * ( ( ULONG ) s_uiClsSize + 1 ) ); + s_pClasses = ( PCLASS * ) hb_xgrab( sizeof( PCLASS ) * ( ( HB_ULONG ) s_uiClsSize + 1 ) ); s_pClasses[ 0 ] = NULL; #if defined( HB_MT_VM ) @@ -2085,7 +2085,7 @@ HB_BOOL hb_objGetVarRef( PHB_ITEM pObject, PHB_SYMB pMessage, HB_USHORT uiObjClass = pObject->item.asArray.value->uiClass; PCLASS pClass = s_pClasses[ pStack->uiClass ]; PMETHOD pMethod = pClass->pMethods + pStack->uiMethod; - ULONG ulIndex = pMethod->uiData; + HB_ULONG ulIndex = pMethod->uiData; if( pStack->uiClass != uiObjClass ) ulIndex += hb_clsParentInstanceOffset( s_pClasses[ uiObjClass ], @@ -2152,7 +2152,7 @@ static void hb_objSupperDestructorCall( PHB_ITEM pObject, PCLASS pClass ) { HB_STACK_TLS_PRELOAD PMETHOD pMethod = pClass->pMethods; - ULONG ulLimit = hb_clsMthNum( pClass ); + HB_ULONG ulLimit = hb_clsMthNum( pClass ); char * pcClasses; HB_USHORT uiClass; @@ -2308,7 +2308,7 @@ HB_BOOL hb_objHasMsg( PHB_ITEM pObject, const char *szString ) return HB_FALSE; } -PHB_ITEM hb_objSendMessage( PHB_ITEM pObject, PHB_DYNS pMsgSym, ULONG ulArg, ... ) +PHB_ITEM hb_objSendMessage( PHB_ITEM pObject, PHB_DYNS pMsgSym, HB_ULONG ulArg, ... ) { if( pObject && pMsgSym ) { @@ -2338,7 +2338,7 @@ PHB_ITEM hb_objSendMessage( PHB_ITEM pObject, PHB_DYNS pMsgSym, ULONG ulArg, ... } } -PHB_ITEM hb_objSendMsg( PHB_ITEM pObject, const char *sMsg, ULONG ulArg, ... ) +PHB_ITEM hb_objSendMsg( PHB_ITEM pObject, const char *sMsg, HB_ULONG ulArg, ... ) { hb_vmPushSymbol( hb_dynsymGet( sMsg )->pSymbol ); hb_vmPush( pObject ); @@ -2654,7 +2654,7 @@ static HB_BOOL hb_clsAddMsg( HB_USHORT uiClass, const char * szMessage, HB_USHORT uiOperator, uiSprClass = 0, uiIndex = 0, uiPrevCls, uiPrevMth; PHB_SYMB pOpSym, pFuncSym = NULL; HB_BOOL fOK; - ULONG ulOpFlags = 0; + HB_ULONG ulOpFlags = 0; if( pClass->fLocked ) return HB_FALSE; @@ -2878,13 +2878,13 @@ static HB_BOOL hb_clsAddMsg( HB_USHORT uiClass, const char * szMessage, pNewMeth->pFuncSym = &s___msgScopeErr; else if( pNewMeth->uiScope & HB_OO_CLSTP_SHARED ) { - if( hb_arrayLen( pClass->pSharedDatas ) < ( ULONG ) pNewMeth->uiData ) + if( hb_arrayLen( pClass->pSharedDatas ) < ( HB_ULONG ) pNewMeth->uiData ) hb_arraySize( pClass->pSharedDatas, pNewMeth->uiData ); pNewMeth->pFuncSym = &s___msgSetShrData; } else { - if( hb_arrayLen( pClass->pClassDatas ) < ( ULONG ) pNewMeth->uiData ) + if( hb_arrayLen( pClass->pClassDatas ) < ( HB_ULONG ) pNewMeth->uiData ) hb_arraySize( pClass->pClassDatas, pNewMeth->uiData ); pNewMeth->pFuncSym = &s___msgSetClsData; } @@ -2896,7 +2896,7 @@ static HB_BOOL hb_clsAddMsg( HB_USHORT uiClass, const char * szMessage, pNewMeth->uiData = uiIndex; if( pNewMeth->uiScope & HB_OO_CLSTP_SHARED ) { - if( hb_arrayLen( pClass->pSharedDatas ) < ( ULONG ) pNewMeth->uiData ) + if( hb_arrayLen( pClass->pSharedDatas ) < ( HB_ULONG ) pNewMeth->uiData ) hb_arraySize( pClass->pSharedDatas, pNewMeth->uiData ); if( pInit && ! HB_IS_NIL( pInit ) ) /* Initializer found */ @@ -2913,7 +2913,7 @@ static HB_BOOL hb_clsAddMsg( HB_USHORT uiClass, const char * szMessage, } else { - if( hb_arrayLen( pClass->pClassDatas ) < ( ULONG ) pNewMeth->uiData ) + if( hb_arrayLen( pClass->pClassDatas ) < ( HB_ULONG ) pNewMeth->uiData ) hb_arraySize( pClass->pClassDatas, pNewMeth->uiData ); pNewMeth->uiOffset = hb_clsAddInitValue( pClass, pInit, HB_OO_MSG_CLASSDATA, pNewMeth->uiData, 0, uiClass ); @@ -3142,7 +3142,7 @@ static HB_USHORT hb_clsNew( const char * szClassName, HB_USHORT uiDatas, { s_uiClsSize += HB_CLASS_POOL_RESIZE; s_pClasses = ( PCLASS * ) hb_xrealloc( s_pClasses, sizeof( PCLASS ) * - ( ( ULONG ) s_uiClsSize + 1 ) ); + ( ( HB_ULONG ) s_uiClsSize + 1 ) ); } s_pClasses[ ++s_uiClasses ] = pNewCls; pNewCls->uiClass = s_uiClasses; @@ -3172,7 +3172,7 @@ static HB_USHORT hb_clsNew( const char * szClassName, HB_USHORT uiDatas, } else if( !hb_clsHasParent( pNewCls, pSprCls->pClassSym ) ) { - ULONG ul, ulLimit; + HB_ULONG ul, ulLimit; HB_USHORT nLenClsDatas; /* create class data translation tables */ @@ -4016,9 +4016,9 @@ HB_FUNC( __CLASSSEL ) if( uiClass && uiClass <= s_uiClasses ) { - PCLASS pClass = s_pClasses[ uiClass ]; + PCLASS pClass = s_pClasses[ uiClass ]; PMETHOD pMethod = pClass->pMethods; - ULONG ulLimit = hb_clsMthNum( pClass ), ulPos = 0; + HB_ULONG ulLimit = hb_clsMthNum( pClass ), ulPos = 0; hb_arrayNew( pReturn, pClass->uiMethods ); /* Create a transfer array */ @@ -4030,7 +4030,7 @@ HB_FUNC( __CLASSSEL ) } while( --ulLimit ); - if( ulPos < ( ULONG ) pClass->uiMethods ) + if( ulPos < ( HB_ULONG ) pClass->uiMethods ) hb_arraySize( pReturn, ulPos ); } @@ -4086,7 +4086,7 @@ HB_FUNC( __CLSSYNCWAIT ) #if defined( HB_MT_VM ) HB_STACK_TLS_PRELOAD PHB_ITEM pMutex = NULL; - ULONG ulMilliSec = HB_THREAD_INFINITE_WAIT; + HB_ULONG ulMilliSec = HB_THREAD_INFINITE_WAIT; HB_LONG lOffset = hb_stackBaseProcOffset( 2 ); if( lOffset > 0 ) @@ -4121,7 +4121,7 @@ HB_FUNC( __CLSSYNCWAIT ) { double dTimeOut = hb_parnd( 2 ); if( dTimeOut > 0 ) - ulMilliSec = ( ULONG ) ( dTimeOut * 10 ); + ulMilliSec = ( HB_ULONG ) ( dTimeOut * 10 ); } hb_retl( hb_threadMutexSyncWait( hb_param( 1, HB_IT_ANY ), ulMilliSec, pMutex ) ); @@ -4230,9 +4230,9 @@ HB_FUNC_STATIC( msgClassSel ) if( uiClass && uiClass <= s_uiClasses ) { PHB_ITEM pReturn, pItem; - PCLASS pClass = s_pClasses[ uiClass ]; + PCLASS pClass = s_pClasses[ uiClass ]; PMETHOD pMethod = pClass->pMethods; - ULONG ulLimit = hb_clsMthNum( pClass ), ulPos = 0; + HB_ULONG ulLimit = hb_clsMthNum( pClass ), ulPos = 0; HB_USHORT nParam, nScope; HB_BOOL lFull; @@ -4270,9 +4270,9 @@ HB_FUNC_STATIC( msgClassSel ) } ++pMethod; } - while( --ulLimit && ulPos < ( ULONG ) pClass->uiMethods ); + while( --ulLimit && ulPos < ( HB_ULONG ) pClass->uiMethods ); - if( ulPos < ( ULONG ) pClass->uiMethods ) + if( ulPos < ( HB_ULONG ) pClass->uiMethods ) hb_arraySize( pReturn, ulPos ); hb_itemReturnRelease( pReturn ); } @@ -4695,7 +4695,7 @@ HB_FUNC_STATIC( msgGetData ) PCLASS pClass = s_pClasses[ uiClass ]; PMETHOD pMethod = pClass->pMethods + hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod; - ULONG ulIndex = pMethod->uiData; + HB_ULONG ulIndex = pMethod->uiData; if( uiClass != uiObjClass ) { @@ -4729,7 +4729,7 @@ HB_FUNC_STATIC( msgSetData ) PCLASS pClass = s_pClasses[ uiClass ]; PMETHOD pMethod = pClass->pMethods + hb_stackBaseItem()->item.asSymbol.stackstate->uiMethod; - ULONG ulIndex = pMethod->uiData; + HB_ULONG ulIndex = pMethod->uiData; if( uiClass != uiObjClass ) { @@ -4780,7 +4780,7 @@ HB_FUNC_STATIC( msgNull ) } #ifndef HB_NO_PROFILER -void hb_mthAddTime( ULONG ulClockTicks ) +void hb_mthAddTime( HB_ULONG ulClockTicks ) { PHB_ITEM pObject = hb_stackSelfItem(); PCLASS pClass = s_pClasses[ hb_objGetClassH( pObject ) ]; @@ -4855,9 +4855,9 @@ HB_FUNC( __CLSGETPROPERTIES ) if( uiClass && uiClass <= s_uiClasses ) { - PCLASS pClass = s_pClasses[ uiClass ]; + PCLASS pClass = s_pClasses[ uiClass ]; PMETHOD pMethod; - ULONG ulLimit, ulCount; + HB_ULONG ulLimit, ulCount; HB_USHORT uiScope = HB_OO_CLSTP_PERSIST; if( hb_parl( 2 ) ) @@ -4929,7 +4929,7 @@ HB_FUNC( __CLSPREALLOCATE ) { s_uiClsSize = ( HB_USHORT ) lNewSize; s_pClasses = ( PCLASS * ) hb_xrealloc( s_pClasses, sizeof( PCLASS ) * - ( ( ULONG ) s_uiClsSize + 1 ) ); + ( ( HB_ULONG ) s_uiClsSize + 1 ) ); } HB_CLASS_UNLOCK @@ -5123,7 +5123,7 @@ const char * hb_clsRealMethodName( void ) { PCLASS pClass = s_pClasses[ pStack->uiClass ]; - if( ( ULONG ) pStack->uiMethod < hb_clsMthNum( pClass ) ) + if( ( HB_ULONG ) pStack->uiMethod < hb_clsMthNum( pClass ) ) { PMETHOD pMethod = pClass->pMethods + pStack->uiMethod; diff --git a/harbour/src/vm/cmdarg.c b/harbour/src/vm/cmdarg.c index af28f50cff..bfb50ac225 100644 --- a/harbour/src/vm/cmdarg.c +++ b/harbour/src/vm/cmdarg.c @@ -461,10 +461,10 @@ HB_FUNC( HB_CMDLINE ) } /* Check for command line internal arguments */ -ULONG hb_cmdargProcessVM( int *pCancelKey, int *pCancelKeyEx ) +HB_ULONG hb_cmdargProcessVM( int *pCancelKey, int *pCancelKeyEx ) { char * cFlags; - ULONG ulFlags = HB_VMFLAG_HARBOUR; + HB_ULONG ulFlags = HB_VMFLAG_HARBOUR; if( hb_cmdargCheck( "INFO" ) ) { diff --git a/harbour/src/vm/estack.c b/harbour/src/vm/estack.c index 0fce1c1ee7..9ad945f4ba 100644 --- a/harbour/src/vm/estack.c +++ b/harbour/src/vm/estack.c @@ -285,7 +285,7 @@ void * hb_stackGetTSD( PHB_TSD pTSD ) #else if( pTSD->iHandle == 0 ) { - ULONG ulSize = ( hb_stack.iTSD + 2 ) * sizeof( HB_TSD_HOLDER ); + HB_ULONG ulSize = ( hb_stack.iTSD + 2 ) * sizeof( HB_TSD_HOLDER ); if( hb_stack.iTSD == 0 ) { hb_stack.pTSD = ( PHB_TSD_HOLDER ) hb_xgrab( ulSize ); @@ -578,7 +578,7 @@ void hb_stackDec( void ) } #undef hb_stackDecrease -void hb_stackDecrease( ULONG ulItems ) +void hb_stackDecrease( HB_ULONG ulItems ) { HB_STACK_TLS_PRELOAD @@ -1245,7 +1245,7 @@ static void hb_stackIsMemvarRef( PHB_STACK pStack ) { /* 1. Mark all hidden memvars (PRIVATEs and PUBLICs) */ PHB_PRIVATE_STACK pPrivateStack = &pStack->privates; - ULONG ulCount = pPrivateStack->count; + HB_ULONG ulCount = pPrivateStack->count; while( ulCount ) { diff --git a/harbour/src/vm/eval.c b/harbour/src/vm/eval.c index de5d352816..e5a17e6e88 100644 --- a/harbour/src/vm/eval.c +++ b/harbour/src/vm/eval.c @@ -200,7 +200,7 @@ HB_BOOL hb_evalRelease( PHB_EVALINFO pEvalInfo ) evaluated, you must use '(PHB_ITEM *) 0' as the third parameter. */ -PHB_ITEM hb_itemDo( PHB_ITEM pItem, ULONG ulPCount, ... ) +PHB_ITEM hb_itemDo( PHB_ITEM pItem, HB_ULONG ulPCount, ... ) { PHB_ITEM pResult = NULL; @@ -242,7 +242,7 @@ PHB_ITEM hb_itemDo( PHB_ITEM pItem, ULONG ulPCount, ... ) if( ulPCount ) { - ULONG ulParam; + HB_ULONG ulParam; va_list va; va_start( va, ulPCount ); for( ulParam = 1; ulParam <= ulPCount; ulParam++ ) @@ -270,7 +270,7 @@ PHB_ITEM hb_itemDo( PHB_ITEM pItem, ULONG ulPCount, ... ) being called, you must use '(PHB_ITEM *) 0' as the third parameter. */ -PHB_ITEM hb_itemDoC( const char * szFunc, ULONG ulPCount, ... ) +PHB_ITEM hb_itemDoC( const char * szFunc, HB_ULONG ulPCount, ... ) { PHB_ITEM pResult = NULL; @@ -288,7 +288,7 @@ PHB_ITEM hb_itemDoC( const char * szFunc, ULONG ulPCount, ... ) hb_vmPushNil(); if( ulPCount ) { - ULONG ulParam; + HB_ULONG ulParam; va_list va; va_start( va, ulPCount ); for( ulParam = 1; ulParam <= ulPCount; ulParam++ ) @@ -418,7 +418,7 @@ HB_FUNC( HB_EXECFROMARRAY ) PHB_ITEM pSelf = NULL; PHB_ITEM pArray = NULL; PHB_ITEM pItem; - ULONG ulParamOffset = 0; + HB_ULONG ulParamOffset = 0; int iPCount = hb_pcount(); /* decode parameters */ @@ -507,7 +507,7 @@ HB_BOOL hb_execFromArray( PHB_ITEM pParam ) PHB_SYMB pExecSym = NULL; PHB_ITEM pArray = NULL; PHB_ITEM pSelf = NULL; - ULONG ulParamOffset = 0; + HB_ULONG ulParamOffset = 0; int iPCount = 0; if( pParam && HB_IS_ARRAY( pParam ) && !HB_IS_OBJECT( pParam ) ) diff --git a/harbour/src/vm/extend.c b/harbour/src/vm/extend.c index 183fb44e38..bbf5c187a1 100644 --- a/harbour/src/vm/extend.c +++ b/harbour/src/vm/extend.c @@ -105,7 +105,7 @@ PHB_ITEM hb_param( int iParam, long lMask ) return NULL; } -PHB_ITEM hb_paramError( int iParam ) +PHB_ITEM hb_paramError( int iParam ) { static HB_ITEM s_NIL; @@ -120,14 +120,14 @@ PHB_ITEM hb_paramError( int iParam ) return pParam; } -ULONG hb_parinfo( int iParam ) +HB_ULONG hb_parinfo( int iParam ) { HB_STACK_TLS_PRELOAD HB_TRACE(HB_TR_DEBUG, ("hb_parinfo(%d)", iParam)); if( iParam == 0 ) - return ( ULONG ) hb_pcount(); + return ( HB_ULONG ) hb_pcount(); else { if( iParam >= -1 && iParam <= hb_pcount() ) @@ -138,7 +138,7 @@ ULONG hb_parinfo( int iParam ) if( uiType & HB_IT_BYREF ) uiType |= HB_ITEM_TYPE( hb_itemUnRef( pItem ) ); - return ( ULONG ) uiType; + return ( HB_ULONG ) uiType; } else return 0; diff --git a/harbour/src/vm/fm.c b/harbour/src/vm/fm.c index 26589cc239..8e0fd7d98d 100644 --- a/harbour/src/vm/fm.c +++ b/harbour/src/vm/fm.c @@ -1199,9 +1199,9 @@ void hb_xexit( void ) /* Deinitialize fixed memory subsystem */ #endif -ULONG hb_xquery( int iMode ) +HB_ULONG hb_xquery( int iMode ) { - ULONG ulResult; + HB_ULONG ulResult; HB_TRACE(HB_TR_DEBUG, ("hb_xquery(%d)", iMode)); diff --git a/harbour/src/vm/hvm.c b/harbour/src/vm/hvm.c index 58a2b1ebb2..45bde58e83 100644 --- a/harbour/src/vm/hvm.c +++ b/harbour/src/vm/hvm.c @@ -242,8 +242,8 @@ static HB_CRITICAL_NEW( s_atInitMtx ); #endif /* HB_MT_VM */ #ifndef HB_NO_PROFILER -static ULONG hb_ulOpcodesCalls[ HB_P_LAST_PCODE ]; /* array to profile opcodes calls */ -static ULONG hb_ulOpcodesTime[ HB_P_LAST_PCODE ]; /* array to profile opcodes consumed time */ +static HB_ULONG hb_ulOpcodesCalls[ HB_P_LAST_PCODE ]; /* array to profile opcodes calls */ +static HB_ULONG hb_ulOpcodesTime[ HB_P_LAST_PCODE ]; /* array to profile opcodes consumed time */ static HB_BOOL hb_bProfiler = HB_FALSE; /* profiler status is off */ #endif @@ -266,7 +266,7 @@ static int s_nErrorLevel = 0; /* application exit errorlevel */ static PHB_SYMB s_pSymStart = NULL; /* start symbol of the application. MAIN() is not required */ static PHB_SYMBOLS s_pSymbols = NULL; /* to hold a linked list of all different modules symbol tables */ -static ULONG s_ulFreeSymbols = 0;/* number of free module symbols */ +static HB_ULONG s_ulFreeSymbols = 0;/* number of free module symbols */ static void * s_hDynLibID = NULL; /* unique identifer to mark symbol tables loaded from dynamic libraries */ static HB_BOOL s_fCloneSym = HB_FALSE;/* clone registered symbol tables */ @@ -275,7 +275,7 @@ static void * s_main_thread = NULL; /* Various compatibility flags */ -static ULONG s_VMFlags = HB_VMFLAG_HARBOUR; +static HB_ULONG s_VMFlags = HB_VMFLAG_HARBOUR; #undef hb_vmFlagEnabled #define hb_vmFlagEnabled(flag) (s_VMFlags & (flag)) @@ -948,7 +948,7 @@ void hb_vmInit( HB_BOOL bStartMainProc ) #ifndef HB_NO_PROFILER /* Initialize opcodes profiler support arrays */ { - ULONG ul; + HB_ULONG ul; for( ul = 0; ul < HB_P_LAST_PCODE; ul++ ) { @@ -1169,8 +1169,8 @@ void hb_vmExecute( const HB_BYTE * pCode, PHB_SYMB pSymbols ) HB_BOOL bCanRecover = HB_FALSE; HB_BOOL bDynCode = pSymbols == NULL || ( pSymbols->scope.value & HB_FS_DYNCODE ) != 0; #ifndef HB_NO_PROFILER - ULONG ulLastOpcode = 0; /* opcodes profiler support */ - ULONG ulPastClock = 0; /* opcodes profiler support */ + HB_ULONG ulLastOpcode = 0; /* opcodes profiler support */ + HB_ULONG ulPastClock = 0; /* opcodes profiler support */ #endif #if !defined( HB_GUI ) int * piKeyPolls = hb_stackKeyPolls(); @@ -1180,7 +1180,7 @@ void hb_vmExecute( const HB_BYTE * pCode, PHB_SYMB pSymbols ) #ifndef HB_NO_PROFILER if( hb_bProfiler ) - ulPastClock = ( ULONG ) clock(); + ulPastClock = ( HB_ULONG ) clock(); #endif for( ;; ) @@ -1188,7 +1188,7 @@ void hb_vmExecute( const HB_BYTE * pCode, PHB_SYMB pSymbols ) #ifndef HB_NO_PROFILER if( hb_bProfiler ) { - ULONG ulActualClock = ( ULONG ) clock(); + HB_ULONG ulActualClock = ( HB_ULONG ) clock(); hb_ulOpcodesTime[ ulLastOpcode ] += ( ulActualClock - ulPastClock ); ulPastClock = ulActualClock; @@ -1714,7 +1714,7 @@ void hb_vmExecute( const HB_BYTE * pCode, PHB_SYMB pSymbols ) { HB_USHORT uiCount = HB_PCODE_MKUSHORT( &pCode[ 1 ] ); hb_vmInitThreadStatics( uiCount, &pCode[ 3 ] ); - pCode += 3 + ( ( ULONG ) uiCount << 1 ); + pCode += 3 + ( ( HB_ULONG ) uiCount << 1 ); break; } @@ -5701,7 +5701,7 @@ void hb_vmProc( HB_USHORT uiParams ) HB_STACK_STATE sStackState; PHB_SYMB pSym; #ifndef HB_NO_PROFILER - ULONG ulClock = 0; + HB_ULONG ulClock = 0; HB_BOOL bProfiler = hb_bProfiler; /* because profiler state may change */ #endif @@ -5711,7 +5711,7 @@ void hb_vmProc( HB_USHORT uiParams ) #ifndef HB_NO_PROFILER if( bProfiler ) - ulClock = ( ULONG ) clock(); + ulClock = ( HB_ULONG ) clock(); #endif /* Poll the console keyboard @@ -5761,7 +5761,7 @@ void hb_vmDo( HB_USHORT uiParams ) PHB_SYMB pSym; PHB_ITEM pSelf; #ifndef HB_NO_PROFILER - ULONG ulClock = 0; + HB_ULONG ulClock = 0; HB_BOOL bProfiler = hb_bProfiler; /* because profiler state may change */ #endif @@ -5771,7 +5771,7 @@ void hb_vmDo( HB_USHORT uiParams ) #ifndef HB_NO_PROFILER if( bProfiler ) - ulClock = ( ULONG ) clock(); + ulClock = ( HB_ULONG ) clock(); #endif /* Poll the console keyboard @@ -5850,7 +5850,7 @@ void hb_vmSend( HB_USHORT uiParams ) PHB_SYMB pExecSym; PHB_ITEM pSelf; #ifndef HB_NO_PROFILER - ULONG ulClock = 0; + HB_ULONG ulClock = 0; HB_BOOL bProfiler = hb_bProfiler; /* because profiler state may change */ #endif @@ -5860,7 +5860,7 @@ void hb_vmSend( HB_USHORT uiParams ) #ifndef HB_NO_PROFILER if( bProfiler ) - ulClock = ( ULONG ) clock(); + ulClock = ( HB_ULONG ) clock(); #endif /* Poll the console keyboard @@ -5973,11 +5973,11 @@ HB_ITEM_PTR hb_vmEvalBlock( HB_ITEM_PTR pBlock ) * for example: * retVal = hb_vmEvalBlockV( pBlock, 2, pParam1, pParam2 ); */ -HB_ITEM_PTR hb_vmEvalBlockV( HB_ITEM_PTR pBlock, ULONG ulArgCount, ... ) +HB_ITEM_PTR hb_vmEvalBlockV( HB_ITEM_PTR pBlock, HB_ULONG ulArgCount, ... ) { HB_STACK_TLS_PRELOAD va_list va; - ULONG i; + HB_ULONG i; HB_TRACE(HB_TR_DEBUG, ("hb_vmEvalBlockV(%p, %lu, ...)", pBlock, ulArgCount)); @@ -7376,9 +7376,9 @@ static void hb_vmStaticsRelease( void ) } } -static ULONG hb_vmStaticsCount( void ) +static HB_ULONG hb_vmStaticsCount( void ) { - ULONG ulStatics = 0; + HB_ULONG ulStatics = 0; if( hb_vmLockModuleSymbols() ) { @@ -7436,7 +7436,7 @@ static PHB_ITEM hb_vmStaticsArray( void ) } static PHB_SYMBOLS hb_vmFindFreeModule( PHB_SYMB pSymbols, HB_USHORT uiSymbols, - const char * szModuleName, ULONG ulID ) + const char * szModuleName, HB_ULONG ulID ) { HB_TRACE(HB_TR_DEBUG, ("hb_vmFindFreeModule(%p,%hu,%s,%lu)", pSymbols, uiSymbols, szModuleName, ulID)); @@ -7646,7 +7646,7 @@ void hb_vmExitSymbolGroup( void * hDynLib ) } PHB_SYMBOLS hb_vmRegisterSymbols( PHB_SYMB pModuleSymbols, HB_USHORT uiSymbols, - const char * szModuleName, ULONG ulID, + const char * szModuleName, HB_ULONG ulID, HB_BOOL fDynLib, HB_BOOL fClone ) { PHB_SYMBOLS pNewSymbols; @@ -7670,18 +7670,18 @@ PHB_SYMBOLS hb_vmRegisterSymbols( PHB_SYMB pModuleSymbols, HB_USHORT uiSymbols, if( fClone ) { - ULONG ulSymSize = ( ULONG ) uiSymbols * sizeof( HB_SYMB ), ulSize; + HB_ULONG ulSymSize = ( HB_ULONG ) uiSymbols * sizeof( HB_SYMB ), ulSize; char * buffer; ulSize = ulSymSize; for( ui = 0; ui < uiSymbols; ui++ ) - ulSize += ( ULONG ) strlen( pModuleSymbols[ ui ].szName ) + 1; + ulSize += ( HB_ULONG ) strlen( pModuleSymbols[ ui ].szName ) + 1; buffer = ( char * ) memcpy( hb_xgrab( ulSize ), pModuleSymbols, ulSymSize ); pModuleSymbols = ( PHB_SYMB ) buffer; for( ui = 0; ui < uiSymbols; ui++ ) { buffer += ulSymSize; - ulSymSize = ( ULONG ) strlen( pModuleSymbols[ ui ].szName ) + 1; + ulSymSize = ( HB_ULONG ) strlen( pModuleSymbols[ ui ].szName ) + 1; memcpy( buffer, pModuleSymbols[ ui ].szName, ulSymSize ); pModuleSymbols[ ui ].szName = buffer; } @@ -7827,7 +7827,7 @@ static void hb_vmVerifyPCodeVersion( const char * szModuleName, HB_USHORT uiPCod * module symbols initialization with extended information */ PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, HB_USHORT uiModuleSymbols, - const char * szModuleName, ULONG ulID, + const char * szModuleName, HB_ULONG ulID, HB_USHORT uiPCodeVer ) { HB_TRACE(HB_TR_DEBUG, ("hb_vmProcessSymbols(%p,%hu,%s,%lu,%hu)", pSymbols, uiModuleSymbols, szModuleName, ulID, uiPCodeVer)); @@ -7838,7 +7838,7 @@ PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, HB_USHORT uiModuleSymbols, } PHB_SYMB hb_vmProcessDynLibSymbols( PHB_SYMB pSymbols, HB_USHORT uiModuleSymbols, - const char * szModuleName, ULONG ulID, + const char * szModuleName, HB_ULONG ulID, HB_USHORT uiPCodeVer ) { HB_TRACE(HB_TR_DEBUG, ("hb_vmProcessDynLibSymbols(%p,%hu,%s,%lu,%hu)", pSymbols, uiModuleSymbols, szModuleName, ulID, uiPCodeVer)); @@ -11182,17 +11182,17 @@ void hb_xvmWithObjectMessage( PHB_SYMB pSymbol ) #undef hb_vmFlagEnabled -ULONG hb_vmFlagEnabled( ULONG flags ) +HB_ULONG hb_vmFlagEnabled( HB_ULONG flags ) { return s_VMFlags & flags; } -void hb_vmFlagSet( ULONG flags ) +void hb_vmFlagSet( HB_ULONG flags ) { s_VMFlags |= flags; } -void hb_vmFlagClear( ULONG flags ) +void hb_vmFlagClear( HB_ULONG flags ) { s_VMFlags &= ~flags; } @@ -11251,7 +11251,7 @@ PHB_ITEM hb_dbg_vmVarSGet( PHB_ITEM pStaticsBase, int nOffset ) return NULL; } -ULONG hb_dbg_ProcLevel( void ) +HB_ULONG hb_dbg_ProcLevel( void ) { return hb_stackCallDepth(); } @@ -11325,7 +11325,7 @@ HB_FUNC( __DBGPROCLEVEL ) * compatibility with xHarbour debugger - Harbour does not support * GLOBALs */ -ULONG hb_dbg_vmVarGCount( void ) +HB_ULONG hb_dbg_vmVarGCount( void ) { #if 0 return hb_arrayLen( &s_aGlobals ); @@ -11479,7 +11479,7 @@ HB_FUNC( __OPGETPRF ) /* profiler: It returns an array with an opcode called and { HB_STACK_TLS_PRELOAD #ifndef HB_NO_PROFILER - ULONG ulOpcode = hb_parnl( 1 ); + HB_ULONG ulOpcode = hb_parnl( 1 ); hb_reta( 2 ); if( ulOpcode < HB_P_LAST_PCODE ) diff --git a/harbour/src/vm/itemapi.c b/harbour/src/vm/itemapi.c index e2683950dc..dddcdbdb5e 100644 --- a/harbour/src/vm/itemapi.c +++ b/harbour/src/vm/itemapi.c @@ -638,7 +638,7 @@ long hb_itemGetNL( PHB_ITEM pItem ) else if( HB_IS_DOUBLE( pItem ) ) #if defined( __GNUC__ ) - return ( long ) ( ULONG ) pItem->item.asDouble.value; + return ( long ) ( HB_ULONG ) pItem->item.asDouble.value; #else return ( long ) pItem->item.asDouble.value; #endif diff --git a/harbour/src/vm/macro.c b/harbour/src/vm/macro.c index 2799e80175..c584916b19 100644 --- a/harbour/src/vm/macro.c +++ b/harbour/src/vm/macro.c @@ -74,7 +74,7 @@ static void hb_macroFlagsInit( void * pFlags ) { - * ( ( ULONG * ) pFlags ) = HB_SM_DEFAULT; + * ( ( HB_ULONG * ) pFlags ) = HB_SM_DEFAULT; } static HB_TSD_NEW( s_macroFlags, sizeof( int ), hb_macroFlagsInit, NULL ); @@ -255,7 +255,7 @@ static void hb_macroSyntaxError( HB_MACRO_PTR pMacro ) * PRIVATE &a&b //this will cause syntax error '&' * */ -static char * hb_macroTextSubst( const char * szString, HB_SIZE *pulStringLen ) +static char * hb_macroTextSubst( const char * szString, HB_SIZE * pulStringLen ) { char * szResult; HB_SIZE ulResStrLen; @@ -1111,7 +1111,7 @@ HB_BOOL hb_macroIsValidMacroText( const char * szText, HB_SIZE ulLen ) return HB_FALSE; } -ULONG hb_macroGenJump( HB_LONG lOffset, HB_COMP_DECL ) +HB_ULONG hb_macroGenJump( HB_LONG lOffset, HB_COMP_DECL ) { if( lOffset == 0 ) hb_macroGenPCode4( HB_P_JUMPFAR, 0, 0, 0, HB_COMP_PARAM ); @@ -1127,7 +1127,7 @@ ULONG hb_macroGenJump( HB_LONG lOffset, HB_COMP_DECL ) return HB_PCODE_DATA->lPCodePos - 3; } -ULONG hb_macroGenJumpFalse( HB_LONG lOffset, HB_COMP_DECL ) +HB_ULONG hb_macroGenJumpFalse( HB_LONG lOffset, HB_COMP_DECL ) { if( lOffset == 0 ) hb_macroGenPCode4( HB_P_JUMPFALSEFAR, 0, 0, 0, HB_COMP_PARAM ); @@ -1143,7 +1143,7 @@ ULONG hb_macroGenJumpFalse( HB_LONG lOffset, HB_COMP_DECL ) return HB_PCODE_DATA->lPCodePos - 3; } -ULONG hb_macroGenJumpTrue( HB_LONG lOffset, HB_COMP_DECL ) +HB_ULONG hb_macroGenJumpTrue( HB_LONG lOffset, HB_COMP_DECL ) { if( lOffset == 0 ) hb_macroGenPCode4( HB_P_JUMPTRUEFAR, 0, 0, 0, HB_COMP_PARAM ); @@ -1159,7 +1159,7 @@ ULONG hb_macroGenJumpTrue( HB_LONG lOffset, HB_COMP_DECL ) return HB_PCODE_DATA->lPCodePos - 3; } -void hb_macroGenJumpThere( ULONG ulFrom, ULONG ulTo, HB_COMP_DECL ) +void hb_macroGenJumpThere( HB_ULONG ulFrom, HB_ULONG ulTo, HB_COMP_DECL ) { HB_BYTE * pCode = HB_PCODE_DATA->pCode; HB_LONG lOffset = ulTo - ulFrom + 1; @@ -1170,7 +1170,7 @@ void hb_macroGenJumpThere( ULONG ulFrom, ULONG ulTo, HB_COMP_DECL ) hb_macroError( HB_MACRO_TOO_COMPLEX, HB_COMP_PARAM ); } -void hb_macroGenJumpHere( ULONG ulOffset, HB_COMP_DECL ) +void hb_macroGenJumpHere( HB_ULONG ulOffset, HB_COMP_DECL ) { hb_macroGenJumpThere( ulOffset, HB_PCODE_DATA->lPCodePos, HB_COMP_PARAM ); } @@ -1620,7 +1620,7 @@ void hb_macroGenPCode4( HB_BYTE byte1, HB_BYTE byte2, HB_BYTE byte3, HB_BYTE byt pFunc->pCode[ pFunc->lPCodePos++ ] = byte4; } -void hb_macroGenPCodeN( HB_BYTE * pBuffer, ULONG ulSize, HB_COMP_DECL ) +void hb_macroGenPCodeN( HB_BYTE * pBuffer, HB_ULONG ulSize, HB_COMP_DECL ) { HB_PCODE_INFO_PTR pFunc = HB_PCODE_DATA; @@ -1670,7 +1670,7 @@ void hb_macroCodeBlockStart( HB_COMP_DECL ) void hb_macroCodeBlockEnd( HB_COMP_DECL ) { HB_PCODE_INFO_PTR pCodeblock; /* pointer to the current codeblock */ - ULONG ulSize; + HB_ULONG ulSize; HB_USHORT wParms = 0; /* number of codeblock parameters */ HB_CBVAR_PTR pVar; @@ -1700,7 +1700,7 @@ void hb_macroCodeBlockEnd( HB_COMP_DECL ) * runtime compiled codeblock cannot reference local variables defined in a * function */ - ulSize = ( ULONG ) pCodeblock->lPCodePos + 6; + ulSize = ( HB_ULONG ) pCodeblock->lPCodePos + 6; /*NOTE: HB_P_MPUSHBLOCK differs from HB_P_PUSHBLOCK - the pcode * is stored in dynamic memory pool instead of static memory diff --git a/harbour/src/vm/maindllp.c b/harbour/src/vm/maindllp.c index a01b64e474..223e4de9b9 100644 --- a/harbour/src/vm/maindllp.c +++ b/harbour/src/vm/maindllp.c @@ -163,7 +163,7 @@ HB_EXPORT BOOL WINAPI HB_DLL_ENTRY_POINT( HINSTANCE hInstance, DWORD fdwReason, } /* module symbols initialization with extended information */ -PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, HB_USHORT uiSymbols, const char * szModuleName, ULONG ulID, HB_USHORT uiPcodeVer ) +PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, HB_USHORT uiSymbols, const char * szModuleName, HB_ULONG ulID, HB_USHORT uiPcodeVer ) { static FARPROC s_pProcessSymbols = NULL; @@ -343,7 +343,7 @@ HB_SIZE hb_parinfa( int iParamNum, HB_SIZE uiArrayIndex ) /* retrieve length or return pParinfa ? ( ( HB_PARINFA ) pParinfa )( iParamNum, uiArrayIndex ) : 0; } -ULONG hb_parinfo( int iParam ) /* Determine the param count or data type */ +HB_ULONG hb_parinfo( int iParam ) /* Determine the param count or data type */ { FARPROC pParinfo = hb_getProcAddress( HBTEXT( "_hb_parinfo" ) ); return pParinfo ? ( ( HB_PARINFO ) pParinfo )( iParam ) : 0; @@ -828,13 +828,13 @@ void hb_xexit( void ) /* Deinitialize fixed memory sub pXexit(); } -void * hb_xalloc( ULONG ulSize ) /* allocates memory, returns NULL on failure */ +void * hb_xalloc( HB_ULONG ulSize ) /* allocates memory, returns NULL on failure */ { HB_XALLOC pXalloc = ( HB_XALLOC ) hb_getProcAddress( HBTEXT( "_hb_xalloc" ) ); return pXalloc ? pXalloc( ulSize ) : NULL; } -void * hb_xgrab( ULONG ulSize ) /* allocates memory, exits on failure */ +void * hb_xgrab( HB_ULONG ulSize ) /* allocates memory, exits on failure */ { HB_XGRAB pXgrab = ( HB_XGRAB ) hb_getProcAddress( HBTEXT( "_hb_xgrab" ) ); return pXgrab ? pXgrab( ulSize ) : NULL; @@ -847,13 +847,13 @@ void hb_xfree( void * pMem ) /* frees memory */ pXfree( pMem ); } -void * hb_xrealloc( void * pMem, ULONG ulSize ) /* reallocates memory */ +void * hb_xrealloc( void * pMem, HB_ULONG ulSize ) /* reallocates memory */ { HB_XREALLOC pXrealloc = ( HB_XREALLOC ) hb_getProcAddress( HBTEXT( "_hb_xrealloc" ) ); return pXrealloc ? ( void * ) pXrealloc( pMem, ulSize ) : NULL; } -ULONG hb_xsize( void * pMem ) /* returns the size of an allocated memory block */ +HB_ULONG hb_xsize( void * pMem ) /* returns the size of an allocated memory block */ { HB_XSIZE pXsize = ( HB_XSIZE ) hb_getProcAddress( HBTEXT( "_hb_xsize" ) ); return pXsize ? pXsize( ( void * ) pMem ) : 0; diff --git a/harbour/src/vm/memvars.c b/harbour/src/vm/memvars.c index ca0624716f..c877a218e0 100644 --- a/harbour/src/vm/memvars.c +++ b/harbour/src/vm/memvars.c @@ -96,7 +96,7 @@ struct mv_memvarArray_info { PHB_ITEM pArray; PHB_DYNS * pDyns; - ULONG ulCount; + HB_ULONG ulCount; int iScope; }; @@ -235,7 +235,7 @@ static void hb_memvarAddPrivate( PHB_DYNS pDynSym, PHB_ITEM pValue ) */ if( pMemvar ) { - ULONG ulCount = pPrivateStack->count; + HB_ULONG ulCount = pPrivateStack->count; while( ulCount > pPrivateStack->base ) { if( pDynSym == pPrivateStack->stack[ ulCount - 1 ].pDynSym ) @@ -288,10 +288,10 @@ static void hb_memvarAddPrivate( PHB_DYNS pDynSym, PHB_ITEM pValue ) /* * This function returns current PRIVATE variables stack base */ -ULONG hb_memvarGetPrivatesBase( void ) +HB_ULONG hb_memvarGetPrivatesBase( void ) { HB_STACK_TLS_PRELOAD - ULONG ulBase; + HB_ULONG ulBase; HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetPrivatesBase()")); @@ -303,7 +303,7 @@ ULONG hb_memvarGetPrivatesBase( void ) /* * This function releases PRIVATE variables created after passed base */ -void hb_memvarSetPrivatesBase( ULONG ulBase ) +void hb_memvarSetPrivatesBase( HB_ULONG ulBase ) { HB_STACK_TLS_PRELOAD PHB_PRIVATE_STACK pPrivateStack; @@ -709,7 +709,7 @@ static void hb_memvarRelease( HB_ITEM_PTR pMemvar ) if( pDynSymbol && hb_dynsymGetMemvar( pDynSymbol ) ) { HB_STACK_TLS_PRELOAD - ULONG ulBase = hb_stackGetPrivateStack()->count; + HB_ULONG ulBase = hb_stackGetPrivateStack()->count; /* Find the variable with a requested name that is currently visible * Start from the top of the stack. @@ -746,7 +746,7 @@ static void hb_memvarRelease( HB_ITEM_PTR pMemvar ) static void hb_memvarReleaseWithMask( const char *szMask, HB_BOOL bInclude ) { HB_STACK_TLS_PRELOAD - ULONG ulBase, ulCount; + HB_ULONG ulBase, ulCount; PHB_DYNS pDynVar; PHB_ITEM pMemvar; @@ -781,7 +781,7 @@ static int hb_memvarScopeGet( PHB_DYNS pDynVar ) else { HB_STACK_TLS_PRELOAD - ULONG ulBase = hb_stackGetPrivateStack()->count; /* start from the top of the stack */ + HB_ULONG ulBase = hb_stackGetPrivateStack()->count; /* start from the top of the stack */ while( ulBase ) { @@ -862,7 +862,7 @@ static HB_DYNS_FUNC( hb_memvarCountPublics ) return HB_TRUE; } -static ULONG hb_memvarGetBaseOffset( int iProcLevel ) +static HB_ULONG hb_memvarGetBaseOffset( int iProcLevel ) { HB_STACK_TLS_PRELOAD @@ -961,7 +961,7 @@ static HB_ITEM_PTR hb_memvarDebugVariable( int iScope, int iPos, const char ** p else { HB_STACK_TLS_PRELOAD - if( ( ULONG ) iPos < hb_stackGetPrivateStack()->count ) + if( ( HB_ULONG ) iPos < hb_stackGetPrivateStack()->count ) { HB_DYNS_PTR pDynSym = hb_stackGetPrivateStack()->stack[ iPos ].pDynSym; diff --git a/harbour/src/vm/runner.c b/harbour/src/vm/runner.c index 84e994349b..fdbe881c1d 100644 --- a/harbour/src/vm/runner.c +++ b/harbour/src/vm/runner.c @@ -80,8 +80,8 @@ typedef struct typedef struct { - ULONG ulSymbols; /* Number of symbols */ - ULONG ulFuncs; /* Number of functions */ + HB_ULONG ulSymbols; /* Number of symbols */ + HB_ULONG ulFuncs; /* Number of functions */ HB_BOOL fInit; /* should be INIT functions executed */ HB_BOOL fExit; /* should be EXIT functions executed */ HB_LONG lSymStart; /* Startup Symbol */ @@ -114,7 +114,7 @@ static int hb_hrbReadHead( const char * szBody, HB_SIZE ulBodySize, HB_SIZE * pu return HB_PCODE_MKSHORT( pVersion ); } -static HB_BOOL hb_hrbReadValue( const char * szBody, HB_SIZE ulBodySize, HB_SIZE * pulBodyOffset, ULONG * pulValue ) +static HB_BOOL hb_hrbReadValue( const char * szBody, HB_SIZE ulBodySize, HB_SIZE * pulBodyOffset, HB_ULONG * pulValue ) { HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadValue(%p,%lu,%p,%p)", szBody, ulBodySize, pulBodyOffset, pulValue)); @@ -150,9 +150,9 @@ static char * hb_hrbReadId( const char * szBody, HB_SIZE ulBodySize, HB_SIZE * u return hb_strdup( szIdx ); } -static ULONG hb_hrbFindSymbol( const char * szName, PHB_DYNF pDynFunc, ULONG ulLoaded ) +static HB_ULONG hb_hrbFindSymbol( const char * szName, PHB_DYNF pDynFunc, HB_ULONG ulLoaded ) { - ULONG ulRet; + HB_ULONG ulRet; HB_TRACE(HB_TR_DEBUG, ("hb_hrbFindSymbol(%s, %p, %lu)", szName, pDynFunc, ulLoaded)); @@ -169,7 +169,7 @@ static void hb_hrbInitStatic( PHRB_BODY pHrbBody ) { if( ! pHrbBody->fInit && ! pHrbBody->fExit ) { - ULONG ul; + HB_ULONG ul; pHrbBody->fInit = HB_TRUE; /* Initialize static variables first */ @@ -203,7 +203,7 @@ static void hb_hrbInit( PHRB_BODY pHrbBody, int iPCount, PHB_ITEM * pParams ) { if( hb_vmRequestReenter() ) { - ULONG ul; + HB_ULONG ul; int i; pHrbBody->fInit = HB_FALSE; @@ -234,7 +234,7 @@ static void hb_hrbExit( PHRB_BODY pHrbBody ) { if( hb_vmRequestReenter() ) { - ULONG ul; + HB_ULONG ul; pHrbBody->fExit = HB_FALSE; pHrbBody->fInit = HB_TRUE; @@ -258,7 +258,7 @@ static void hb_hrbExit( PHRB_BODY pHrbBody ) static void hb_hrbUnLoad( PHRB_BODY pHrbBody ) { - ULONG ul; + HB_ULONG ul; hb_hrbExit( pHrbBody ); @@ -308,7 +308,7 @@ static PHRB_BODY hb_hrbLoad( const char * szHrbBody, HB_SIZE ulBodySize, HB_USHO HB_SIZE ulBodyOffset = 0; HB_SIZE ulSize; /* Size of function */ HB_SIZE ulPos; - ULONG ul; + HB_ULONG ul; char * buffer, ch; HB_USHORT usBind = ( usMode & HB_HRB_BIND_MODEMASK ); @@ -827,7 +827,7 @@ HB_FUNC( HB_HRBGETFUNSYM ) if( pHrbBody && szName ) { PHB_SYMB pSym; - ULONG ulPos; + HB_ULONG ulPos; for( ulPos = 0, pSym = pHrbBody->pSymRead; ulPos < pHrbBody->ulSymbols; ++pSym, ++ulPos ) { diff --git a/harbour/src/vm/thread.c b/harbour/src/vm/thread.c index a4b7b65b14..2b0b5cf223 100644 --- a/harbour/src/vm/thread.c +++ b/harbour/src/vm/thread.c @@ -119,7 +119,7 @@ static PHB_ITEM s_pOnceMutex = NULL; static int s_waiting_for_threads = 0; # if defined( HB_PTHREAD_API ) - static void hb_threadTimeInit( struct timespec * ts, ULONG ulMilliSec ) + static void hb_threadTimeInit( struct timespec * ts, HB_ULONG ulMilliSec ) { # if _POSIX_C_SOURCE >= 199309L clock_gettime( CLOCK_REALTIME, ts ); @@ -320,7 +320,7 @@ static PHB_WAIT_LIST _hb_thread_wait_list( void ) static void _hb_thread_wait_add( HB_COND_T * cond, PHB_WAIT_LIST pWaiting ) { #if defined( HB_OS_OS2 ) - ULONG ulPostCount = 0; + HB_ULONG ulPostCount = 0; DosResetEventSem( pWaiting->cond, &ulPostCount ); #elif defined( HB_OS_WIN ) /* It's not necessary because we have workaround for possible race @@ -404,7 +404,7 @@ static HB_BOOL _hb_thread_cond_broadcast( HB_COND_T * cond ) return HB_TRUE; } -static HB_BOOL _hb_thread_cond_wait( HB_COND_T * cond, HB_RAWCRITICAL_T * critical, ULONG ulMillisec ) +static HB_BOOL _hb_thread_cond_wait( HB_COND_T * cond, HB_RAWCRITICAL_T * critical, HB_ULONG ulMillisec ) { PHB_WAIT_LIST pWaiting = _hb_thread_wait_list(); HB_BOOL fResult = HB_FALSE; @@ -693,7 +693,7 @@ HB_BOOL hb_threadCondWait( HB_COND_T * cond, HB_CRITICAL_T * mutex ) #endif } -HB_BOOL hb_threadCondTimedWait( HB_COND_T * cond, HB_CRITICAL_T * mutex, ULONG ulMilliSec ) +HB_BOOL hb_threadCondTimedWait( HB_COND_T * cond, HB_CRITICAL_T * mutex, HB_ULONG ulMilliSec ) { #if !defined( HB_MT_VM ) @@ -922,7 +922,7 @@ static HB_THREAD_STARTFUNC( hb_threadStartVM ) { #if defined( HB_MT_VM ) PHB_ITEM pThItm = ( PHB_ITEM ) Cargo; - ULONG ulPCount, ulParam; + HB_ULONG ulPCount, ulParam; PHB_THREADSTATE pThread; HB_BOOL fSend = HB_FALSE; @@ -1042,7 +1042,7 @@ static PHB_THREADSTATE hb_thParam( int iParam, int iPos ) HB_FUNC( HB_THREADSTART ) { - ULONG ulAttr = 0, ulStart = 1; + HB_ULONG ulAttr = 0, ulStart = 1; const char * szFuncName = NULL; PHB_SYMB pSymbol = NULL; PHB_ITEM pStart; @@ -1050,7 +1050,7 @@ HB_FUNC( HB_THREADSTART ) pStart = hb_param( ulStart, HB_IT_ANY ); while( pStart && HB_IS_NUMERIC( pStart ) ) { - ulAttr |= ( ULONG ) hb_itemGetNL( pStart ); + ulAttr |= ( HB_ULONG ) hb_itemGetNL( pStart ); pStart = hb_param( ++ulStart, HB_IT_ANY ); } @@ -1084,7 +1084,7 @@ HB_FUNC( HB_THREADSTART ) HB_STACK_TLS_PRELOAD PHB_ITEM pReturn; PHB_THREADSTATE pThread; - ULONG ulPCount, ulParam; + HB_ULONG ulPCount, ulParam; pThread = hb_threadStateNew(); pReturn = pThread->pThItm; @@ -1202,7 +1202,7 @@ HB_FUNC( HB_THREADID ) #if defined( HB_MT_VM ) static int hb_threadWait( PHB_THREADSTATE * pThreads, int iThreads, - HB_BOOL fAll, ULONG ulMilliSec ) + HB_BOOL fAll, HB_ULONG ulMilliSec ) { int i, iFinished, iResult = 0; HB_BOOL fExit = ulMilliSec == 0; @@ -1277,7 +1277,7 @@ static int hb_threadWait( PHB_THREADSTATE * pThreads, int iThreads, if( timer <= curr ) fExit = HB_TRUE; else - ulMilliSec = ( ULONG ) ( timer - curr ); + ulMilliSec = ( HB_ULONG ) ( timer - curr ); } #endif @@ -1364,7 +1364,7 @@ HB_FUNC( HB_THREADWAIT ) # define HB_THREAD_WAIT_ALLOC 16 HB_STACK_TLS_PRELOAD HB_BOOL fAll; - ULONG ulMilliSec = HB_THREAD_INFINITE_WAIT; + HB_ULONG ulMilliSec = HB_THREAD_INFINITE_WAIT; PHB_THREADSTATE * pThreads, pAlloc[ HB_THREAD_WAIT_ALLOC ]; int iThreads = -1; @@ -1403,7 +1403,7 @@ HB_FUNC( HB_THREADWAIT ) if( HB_ISNUM( 2 ) ) { double dTimeOut = hb_parnd( 2 ); - ulMilliSec = dTimeOut > 0 ? ( ULONG ) ( dTimeOut * 1000 ) : 0; + ulMilliSec = dTimeOut > 0 ? ( HB_ULONG ) ( dTimeOut * 1000 ) : 0; } fAll = hb_parl( 3 ); @@ -1717,7 +1717,7 @@ void hb_threadMutexSyncSignal( PHB_ITEM pItemMtx ) } else { - ULONG ulLen = hb_arrayLen( pMutex->events ); + HB_ULONG ulLen = hb_arrayLen( pMutex->events ); iCount -= ulLen; if( iCount > 0 ) hb_arraySize( pMutex->events, ulLen + iCount ); @@ -1737,7 +1737,7 @@ void hb_threadMutexSyncSignal( PHB_ITEM pItemMtx ) } } -HB_BOOL hb_threadMutexSyncWait( PHB_ITEM pItemMtx, ULONG ulMilliSec, +HB_BOOL hb_threadMutexSyncWait( PHB_ITEM pItemMtx, HB_ULONG ulMilliSec, PHB_ITEM pItemSync ) { PHB_MUTEX pMutex = hb_mutexPtr( pItemMtx ), pSyncMutex = NULL; @@ -1954,7 +1954,7 @@ HB_BOOL hb_threadMutexLock( PHB_ITEM pItem ) return fResult; } -HB_BOOL hb_threadMutexTimedLock( PHB_ITEM pItem, ULONG ulMilliSec ) +HB_BOOL hb_threadMutexTimedLock( PHB_ITEM pItem, HB_ULONG ulMilliSec ) { PHB_MUTEX pMutex = hb_mutexPtr( pItem ); HB_BOOL fResult = HB_FALSE; @@ -2057,7 +2057,7 @@ void hb_threadMutexNotify( PHB_ITEM pItem, PHB_ITEM pNotifier, HB_BOOL fWaiting else if( pMutex->waiters ) { int iCount = pMutex->waiters; - ULONG ulLen; + HB_ULONG ulLen; if( pMutex->events ) { @@ -2104,7 +2104,7 @@ void hb_threadMutexNotify( PHB_ITEM pItem, PHB_ITEM pNotifier, HB_BOOL fWaiting else if( pMutex->waiters ) { int iCount = pMutex->waiters; - ULONG ulLen; + HB_ULONG ulLen; if( pMutex->events ) { @@ -2238,7 +2238,7 @@ PHB_ITEM hb_threadMutexSubscribe( PHB_ITEM pItem, HB_BOOL fClear ) return pResult; } -PHB_ITEM hb_threadMutexTimedSubscribe( PHB_ITEM pItem, ULONG ulMilliSec, HB_BOOL fClear ) +PHB_ITEM hb_threadMutexTimedSubscribe( PHB_ITEM pItem, HB_ULONG ulMilliSec, HB_BOOL fClear ) { PHB_MUTEX pMutex = hb_mutexPtr( pItem ); PHB_ITEM pResult = NULL; @@ -2370,10 +2370,10 @@ HB_FUNC( HB_MUTEXLOCK ) HB_STACK_TLS_PRELOAD if( HB_ISNUM( 2 ) ) { - ULONG ulMilliSec = 0; + HB_ULONG ulMilliSec = 0; double dTimeOut = hb_parnd( 2 ); if( dTimeOut > 0 ) - ulMilliSec = ( ULONG ) ( dTimeOut * 1000 ); + ulMilliSec = ( HB_ULONG ) ( dTimeOut * 1000 ); hb_retl( hb_threadMutexTimedLock( pItem, ulMilliSec ) ); } else @@ -2419,10 +2419,10 @@ HB_FUNC( HB_MUTEXSUBSCRIBE ) if( HB_ISNUM( 2 ) ) { - ULONG ulMilliSec = 0; + HB_ULONG ulMilliSec = 0; double dTimeOut = hb_parnd( 2 ); if( dTimeOut > 0 ) - ulMilliSec = ( ULONG ) ( dTimeOut * 1000 ); + ulMilliSec = ( HB_ULONG ) ( dTimeOut * 1000 ); pResult = hb_threadMutexTimedSubscribe( pItem, ulMilliSec, HB_FALSE ); } else @@ -2450,10 +2450,10 @@ HB_FUNC( HB_MUTEXSUBSCRIBENOW ) if( HB_ISNUM( 2 ) ) { - ULONG ulMilliSec = 0; + HB_ULONG ulMilliSec = 0; double dTimeOut = hb_parnd( 2 ); if( dTimeOut > 0 ) - ulMilliSec = ( ULONG ) ( dTimeOut * 1000 ); + ulMilliSec = ( HB_ULONG ) ( dTimeOut * 1000 ); pResult = hb_threadMutexTimedSubscribe( pItem, ulMilliSec, HB_TRUE ); } else