From db1fbb5aed2ffd2a594f6b488ebb795743fa497e Mon Sep 17 00:00:00 2001 From: Viktor Szakats Date: Tue, 6 Jul 2010 19:02:19 +0000 Subject: [PATCH] 2010-07-06 21:00 UTC+0200 Viktor Szakats (harbour.01 syenar.hu) * utils/hbrun/hbrun.prg ! Don't search passed program in PATH and hbrun dir, if program name has path component. * contrib/xhb/xhbenum.c * contrib/xhb/xhbqself.c * contrib/xhb/xhbwith.c * contrib/xhb/xhberrc.c ! Fixed msvc64 warnings after HB_SIZE extension in stack API. * contrib/make.hbs + Added logic to protect against case when 'clean install' is used but hbrun or hbmk2 isn't available when launching the make process. In this case 'clean' phase won't be executed for contribs, which is solved by forcing a -rebuild in 'install' phase. * src/vm/strapi.c * src/vm/runner.c * src/vm/itemapi.c * src/vm/asort.c * src/vm/hvm.c * src/vm/arrays.c * src/vm/memvars.c * src/vm/set.c * src/vm/classes.c * src/rtl/lennum.c * src/rtl/strcase.c * src/rtl/replic.c * src/rtl/padr.c * src/rtl/padc.c * src/rtl/strtran.c * src/rtl/strtoexp.c * src/rtl/padl.c * src/rtl/saverest.c * src/rtl/right.c * src/rtl/philes.c * src/rtl/mlcfunc.c * src/rtl/left.c * src/rtl/xsavescr.c * src/rtl/setkey.c * src/rtl/stuff.c * src/rtl/trace.c * src/rtl/samples.c * src/rtl/inkeyapi.c * src/rtl/inkey.c * src/rtl/mtran.c * src/rtl/colorind.c * src/rtl/rat.c * include/hbapi.h * include/hbapistr.h * Renamed HB_SIZE variables to have 'n' prefix. (verified to generate the same objects as before) * src/rtl/philes.c * Changed hb_retnint()/hb_retni() to hb_retns(). * contrib/hbgd/gdwrp.c * Formatting. --- harbour/ChangeLog | 61 ++++ harbour/contrib/hbgd/gdwrp.c | 14 +- harbour/contrib/make.hbs | 47 ++- harbour/contrib/xhb/xhbenum.c | 4 +- harbour/contrib/xhb/xhberrc.c | 2 +- harbour/contrib/xhb/xhbqself.c | 2 +- harbour/contrib/xhb/xhbwith.c | 16 +- harbour/include/hbapi.h | 4 +- harbour/include/hbapistr.h | 64 ++--- harbour/src/rtl/colorind.c | 28 +- harbour/src/rtl/inkey.c | 25 +- harbour/src/rtl/inkeyapi.c | 6 +- harbour/src/rtl/left.c | 10 +- harbour/src/rtl/lennum.c | 8 +- harbour/src/rtl/mlcfunc.c | 356 +++++++++++------------ harbour/src/rtl/mtran.c | 40 +-- harbour/src/rtl/padc.c | 30 +- harbour/src/rtl/padl.c | 24 +- harbour/src/rtl/padr.c | 24 +- harbour/src/rtl/philes.c | 30 +- harbour/src/rtl/rat.c | 54 ++-- harbour/src/rtl/replic.c | 20 +- harbour/src/rtl/right.c | 10 +- harbour/src/rtl/samples.c | 16 +- harbour/src/rtl/saverest.c | 8 +- harbour/src/rtl/setkey.c | 22 +- harbour/src/rtl/strcase.c | 8 +- harbour/src/rtl/strtoexp.c | 32 +-- harbour/src/rtl/strtran.c | 36 +-- harbour/src/rtl/stuff.c | 36 +-- harbour/src/rtl/trace.c | 10 +- harbour/src/rtl/xsavescr.c | 6 +- harbour/src/vm/arrays.c | 506 ++++++++++++++++----------------- harbour/src/vm/asort.c | 10 +- harbour/src/vm/classes.c | 2 +- harbour/src/vm/hvm.c | 18 +- harbour/src/vm/itemapi.c | 266 ++++++++--------- harbour/src/vm/memvars.c | 120 ++++---- harbour/src/vm/runner.c | 128 ++++----- harbour/src/vm/set.c | 42 +-- harbour/src/vm/strapi.c | 466 +++++++++++++++--------------- harbour/utils/hbrun/hbrun.prg | 37 +-- 42 files changed, 1368 insertions(+), 1280 deletions(-) diff --git a/harbour/ChangeLog b/harbour/ChangeLog index ab6c8069e6..e0a3dad108 100644 --- a/harbour/ChangeLog +++ b/harbour/ChangeLog @@ -16,6 +16,67 @@ The license applies to all entries newer than 2009-04-28. */ +2010-07-06 21:00 UTC+0200 Viktor Szakats (harbour.01 syenar.hu) + * utils/hbrun/hbrun.prg + ! Don't search passed program in PATH and hbrun dir, if + program name has path component. + + * contrib/xhb/xhbenum.c + * contrib/xhb/xhbqself.c + * contrib/xhb/xhbwith.c + * contrib/xhb/xhberrc.c + ! Fixed msvc64 warnings after HB_SIZE extension in stack API. + + * contrib/make.hbs + + Added logic to protect against case when 'clean install' + is used but hbrun or hbmk2 isn't available when launching + the make process. In this case 'clean' phase won't be executed + for contribs, which is solved by forcing a -rebuild in + 'install' phase. + + * src/vm/strapi.c + * src/vm/runner.c + * src/vm/itemapi.c + * src/vm/asort.c + * src/vm/hvm.c + * src/vm/arrays.c + * src/vm/memvars.c + * src/vm/set.c + * src/vm/classes.c + * src/rtl/lennum.c + * src/rtl/strcase.c + * src/rtl/replic.c + * src/rtl/padr.c + * src/rtl/padc.c + * src/rtl/strtran.c + * src/rtl/strtoexp.c + * src/rtl/padl.c + * src/rtl/saverest.c + * src/rtl/right.c + * src/rtl/philes.c + * src/rtl/mlcfunc.c + * src/rtl/left.c + * src/rtl/xsavescr.c + * src/rtl/setkey.c + * src/rtl/stuff.c + * src/rtl/trace.c + * src/rtl/samples.c + * src/rtl/inkeyapi.c + * src/rtl/inkey.c + * src/rtl/mtran.c + * src/rtl/colorind.c + * src/rtl/rat.c + * include/hbapi.h + * include/hbapistr.h + * Renamed HB_SIZE variables to have 'n' prefix. + (verified to generate the same objects as before) + + * src/rtl/philes.c + * Changed hb_retnint()/hb_retni() to hb_retns(). + + * contrib/hbgd/gdwrp.c + * Formatting. + 2010-07-06 16:32 UTC+0200 Viktor Szakats (harbour.01 syenar.hu) * contrib/hbwin/hbwapi.h * contrib/hbwin/wapi_winbase.c diff --git a/harbour/contrib/hbgd/gdwrp.c b/harbour/contrib/hbgd/gdwrp.c index 01e5bb3d17..c1c74fa7de 100644 --- a/harbour/contrib/hbgd/gdwrp.c +++ b/harbour/contrib/hbgd/gdwrp.c @@ -57,16 +57,16 @@ /* NOTE: Do some initialization required by the GD headers. */ #if defined( HB_OS_WIN ) - #if !defined( WIN32 ) - #define WIN32 - #endif - #if !defined( BGDWIN32 ) - #define BGDWIN32 - #endif +# if !defined( WIN32 ) +# define WIN32 +#endif +# if !defined( BGDWIN32 ) +# define BGDWIN32 +# endif #endif #ifdef HAVE_CONFIG_H -#include "config.h" +# include "config.h" #endif #include "gd.h" diff --git a/harbour/contrib/make.hbs b/harbour/contrib/make.hbs index 0840881cdb..e293134751 100644 --- a/harbour/contrib/make.hbs +++ b/harbour/contrib/make.hbs @@ -21,6 +21,7 @@ #define F_NAME 1 /* File name */ #define F_ATTR 5 /* File attribute */ +#define _ACT_EXIT 0 #define _ACT_CLEAN 1 #define _ACT_INC 2 #define _ACT_INC_INST 3 @@ -141,6 +142,7 @@ PROCEDURE Main( ... ) LOCAL lFilterNegative LOCAL aParams + LOCAL aGNUMakeParams LOCAL tmp LOCAL nAction @@ -166,15 +168,15 @@ PROCEDURE Main( ... ) /* Workflow translation from GNU Make to hbmk2: - GNU Make parameter HB_MAKECMDGOALS nAction hbmk2 options - -- -------------- ---------- ---------------- -------------- ------------------------- - #1 clean clean clean _ACT_CLEAN -clean - #2 install install install _ACT_INC_INST -inc -instpath= - #3 clean install clean clean install _ACT_CLEAN -clean - install clean install _ACT_INC_INST -inc -instpath= - #4 install clean install install clean _ACT_INC_INST -inc -instpath= - clean install clean _ACT_CLEAN -clean - #5 all _ACT_INC -inc + GNU Make parameter HB_MAKECMDGOALS nAction hbmk2 options + -- -------------- ---------- ---------------- ---------------------- ------------------------- + #1 clean clean clean _ACT_CLEAN -clean + #2 install install install _ACT_INC_INST -inc -instpath= + #3 clean install clean clean install _ACT_CLEAN -clean + install clean install _ACT_INC_REBUILD_INST -inc -instpath= -rebuild + #4 install clean install install clean _ACT_INC_INST -inc -instpath= + clean install clean _ACT_CLEAN -clean + #5 all _ACT_INC -inc */ @@ -183,16 +185,39 @@ PROCEDURE Main( ... ) s_lTest := "test" $ hb_cmdLine() aParams := hb_AParams() + aGNUMakeParams := hb_ATokens( Lower( GetEnv( "HB_MAKECMDGOALS" ) ) ) DO CASE CASE AScan( aParams, "clean" ) > 0 - nAction := _ACT_CLEAN + IF AScan( aGNUMakeParams, "clean" ) > 0 .AND. ; + AScan( aGNUMakeParams, "install" ) > 0 .AND. ; + AScan( aGNUMakeParams, "install" ) > AScan( aGNUMakeParams, "clean" ) + nAction := _ACT_CLEAN + ELSE + nAction := _ACT_CLEAN + ENDIF CASE AScan( aParams, "install" ) > 0 - nAction := _ACT_INC_INST + IF AScan( aGNUMakeParams, "clean" ) > 0 .AND. ; + AScan( aGNUMakeParams, "install" ) > 0 .AND. ; + AScan( aGNUMakeParams, "install" ) > AScan( aGNUMakeParams, "clean" ) + /* Use rebuild mode. This is needed because the clean phase + might not have been called previously by GNU Make, f.e. + because hbrun or hbmk2 wasn't available. -rebuild is + costless, so we do it to make sure to build cleanly. + [vszakats] */ + nAction := _ACT_INC_REBUILD_INST + ELSE + nAction := _ACT_INC_INST + ENDIF OTHERWISE nAction := _ACT_INC ENDCASE + IF nAction == _ACT_EXIT + ErrorLevel( 0 ) + RETURN + ENDIF + /* Check if the requirements are met and if we have anything to do */ IF Empty( GetEnv( "HB_PLATFORM" ) ) .OR. ; diff --git a/harbour/contrib/xhb/xhbenum.c b/harbour/contrib/xhb/xhbenum.c index ef37f009f7..8293cc0f0b 100644 --- a/harbour/contrib/xhb/xhbenum.c +++ b/harbour/contrib/xhb/xhbenum.c @@ -57,7 +57,7 @@ HB_FUNC( HB_ENUMINDEX ) { - HB_LONG lFuncOffset = hb_stackBaseOffset() - 1, lIndex = 0; + HB_ISIZ lFuncOffset = hb_stackBaseOffset() - 1, lIndex = 0; while( --lFuncOffset > 0 ) { PHB_ITEM pItem = hb_stackItem( lFuncOffset ); @@ -67,5 +67,5 @@ HB_FUNC( HB_ENUMINDEX ) break; } } - hb_retnl( lIndex ); + hb_retns( lIndex ); } diff --git a/harbour/contrib/xhb/xhberrc.c b/harbour/contrib/xhb/xhberrc.c index 85a3c9a812..5c5122221c 100644 --- a/harbour/contrib/xhb/xhberrc.c +++ b/harbour/contrib/xhb/xhberrc.c @@ -118,7 +118,7 @@ HB_FUNC( SETUNHANDLEDEXCEPTIONFILTER ) pDefaultHandler = SetUnhandledExceptionFilter( PRGUnhandledExceptionFilter ); - hb_retnl( ( long ) pDefaultHandler ); + hb_retptr( pDefaultHandler ); #endif /* Dummy in Harbour */ hb_retnl( 0 ); diff --git a/harbour/contrib/xhb/xhbqself.c b/harbour/contrib/xhb/xhbqself.c index ae12bb7c65..f55ce8eba9 100644 --- a/harbour/contrib/xhb/xhbqself.c +++ b/harbour/contrib/xhb/xhbqself.c @@ -58,7 +58,7 @@ HB_FUNC( HB_QSELF ) { - HB_LONG lOffset = hb_stackBaseProcOffset( 1 ); + HB_ISIZ lOffset = hb_stackBaseProcOffset( 1 ); if( lOffset > 0 ) { diff --git a/harbour/contrib/xhb/xhbwith.c b/harbour/contrib/xhb/xhbwith.c index bbfdea6008..3f9b274e5c 100644 --- a/harbour/contrib/xhb/xhbwith.c +++ b/harbour/contrib/xhb/xhbwith.c @@ -56,13 +56,13 @@ #include "hbapierr.h" #include "hbstack.h" -static PHB_ITEM hb_vmWithObjectItem( HB_LONG lLevel ) +static PHB_ITEM hb_vmWithObjectItem( HB_ISIZ lLevel ) { - HB_LONG lOffset = hb_stackWithObjectOffset(); + HB_ISIZ lOffset = hb_stackWithObjectOffset(); while( lOffset && lLevel > 0 ) { - HB_LONG * plOffset = ( HB_LONG * ) hb_itemGetPtr( hb_stackItem( lOffset + 1 ) ); + HB_ISIZ * plOffset = ( HB_ISIZ * ) hb_itemGetPtr( hb_stackItem( lOffset + 1 ) ); if( !plOffset ) break; --lLevel; @@ -72,13 +72,13 @@ static PHB_ITEM hb_vmWithObjectItem( HB_LONG lLevel ) return ( lOffset && !lLevel ) ? hb_stackItem( lOffset ) : NULL; } -static HB_LONG hb_vmWithObjectCount( void ) +static HB_ISIZ hb_vmWithObjectCount( void ) { - HB_LONG lOffset = hb_stackWithObjectOffset(), lCount = 0; + HB_ISIZ lOffset = hb_stackWithObjectOffset(), lCount = 0; while( lOffset ) { - HB_LONG * plOffset = ( HB_LONG * ) hb_itemGetPtr( hb_stackItem( lOffset + 1 ) ); + HB_ISIZ * plOffset = ( HB_ISIZ * ) hb_itemGetPtr( hb_stackItem( lOffset + 1 ) ); if( !plOffset ) break; ++lCount; @@ -92,12 +92,12 @@ static HB_LONG hb_vmWithObjectCount( void ) HB_FUNC( HB_QWITH ) { - hb_itemReturn( hb_vmWithObjectItem( hb_parnl( 1 ) ) ); + hb_itemReturn( hb_vmWithObjectItem( hb_parns( 1 ) ) ); } HB_FUNC( HB_WITHOBJECTCOUNTER ) { - hb_retnl( hb_vmWithObjectCount() ); + hb_retns( hb_vmWithObjectCount() ); } HB_FUNC( HB_RESETWITH ) diff --git a/harbour/include/hbapi.h b/harbour/include/hbapi.h index ee2fa36309..8f2b81a1ad 100644 --- a/harbour/include/hbapi.h +++ b/harbour/include/hbapi.h @@ -423,8 +423,8 @@ typedef struct _HB_ITEM typedef struct _HB_BASEARRAY { PHB_ITEM pItems; /* pointer to the array items */ - HB_SIZE ulLen; /* number of items in the array */ - HB_SIZE ulAllocated; /* number of allocated items */ + HB_SIZE nLen; /* number of items in the array */ + HB_SIZE nAllocated; /* number of allocated items */ HB_USHORT uiClass; /* offset to the classes base if it is an object */ HB_USHORT uiPrevCls; /* for fixing after access super */ } HB_BASEARRAY, * PHB_BASEARRAY, * HB_BASEARRAY_PTR; diff --git a/harbour/include/hbapistr.h b/harbour/include/hbapistr.h index 557924eaff..8ed3635369 100644 --- a/harbour/include/hbapistr.h +++ b/harbour/include/hbapistr.h @@ -59,69 +59,69 @@ HB_EXTERN_BEGIN extern HB_EXPORT HB_SIZE hb_wstrlen( const HB_WCHAR * szText ); -extern HB_EXPORT HB_SIZE hb_wstrnlen( const HB_WCHAR * szText, HB_SIZE count ); +extern HB_EXPORT HB_SIZE hb_wstrnlen( const HB_WCHAR * szText, HB_SIZE nCount ); extern HB_EXPORT int hb_wstrcmp( const HB_WCHAR * s1, const HB_WCHAR * s2 ); -extern HB_EXPORT int hb_wstrncmp( const HB_WCHAR * s1, const HB_WCHAR * s2, HB_SIZE count ); +extern HB_EXPORT int hb_wstrncmp( const HB_WCHAR * s1, const HB_WCHAR * s2, HB_SIZE nCount ); extern HB_EXPORT HB_WCHAR * hb_wstrdup( const HB_WCHAR * szText ); -extern HB_EXPORT HB_WCHAR * hb_wstrndup( const HB_WCHAR * szText, HB_SIZE ulLen ); +extern HB_EXPORT HB_WCHAR * hb_wstrndup( const HB_WCHAR * szText, HB_SIZE nLen ); -extern HB_EXPORT char * hb_strunshare( void ** phStr, const char * pStr, HB_SIZE ulLen ); -extern HB_EXPORT HB_WCHAR * hb_wstrunshare( void ** phStr, const HB_WCHAR * pStr, HB_SIZE ulLen ); +extern HB_EXPORT char * hb_strunshare( void ** phStr, const char * pStr, HB_SIZE nLen ); +extern HB_EXPORT HB_WCHAR * hb_wstrunshare( void ** phStr, const HB_WCHAR * pStr, HB_SIZE nLen ); extern HB_EXPORT const char * hb_strnull( const char * str ); extern HB_EXPORT const HB_WCHAR * hb_wstrnull( const HB_WCHAR * str ); extern HB_EXPORT void hb_strfree( void * hString ); -extern HB_EXPORT const char * hb_itemGetStr( PHB_ITEM pItem, void * cdp, void ** phString, HB_SIZE * pulLen ); -extern HB_EXPORT const char * hb_itemGetStrUTF8( PHB_ITEM pItem, void ** phString, HB_SIZE * pulLen ); -extern HB_EXPORT const HB_WCHAR * hb_itemGetStrU16( PHB_ITEM pItem, int iEndian, void ** phString, HB_SIZE * pulLen ); +extern HB_EXPORT const char * hb_itemGetStr( PHB_ITEM pItem, void * cdp, void ** phString, HB_SIZE * pnLen ); +extern HB_EXPORT const char * hb_itemGetStrUTF8( PHB_ITEM pItem, void ** phString, HB_SIZE * pnLen ); +extern HB_EXPORT const HB_WCHAR * hb_itemGetStrU16( PHB_ITEM pItem, int iEndian, void ** phString, HB_SIZE * pnLen ); -extern HB_EXPORT HB_SIZE hb_itemCopyStr( PHB_ITEM pItem, void * cdp, char * pStrBuffer, HB_SIZE ulSize ); -extern HB_EXPORT HB_SIZE hb_itemCopyStrUTF8( PHB_ITEM pItem, char * pStrBuffer, HB_SIZE ulSize ); -extern HB_EXPORT HB_SIZE hb_itemCopyStrU16( PHB_ITEM pItem, int iEndian, HB_WCHAR * pStrBuffer, HB_SIZE ulSize ); +extern HB_EXPORT HB_SIZE hb_itemCopyStr( PHB_ITEM pItem, void * cdp, char * pStrBuffer, HB_SIZE nSize ); +extern HB_EXPORT HB_SIZE hb_itemCopyStrUTF8( PHB_ITEM pItem, char * pStrBuffer, HB_SIZE nSize ); +extern HB_EXPORT HB_SIZE hb_itemCopyStrU16( PHB_ITEM pItem, int iEndian, HB_WCHAR * pStrBuffer, HB_SIZE nSize ); -extern HB_EXPORT PHB_ITEM hb_itemPutStrLen( PHB_ITEM pItem, void * cdp, const char * pStr, HB_SIZE ulLen ); -extern HB_EXPORT PHB_ITEM hb_itemPutStrLenUTF8( PHB_ITEM pItem, const char * pStr, HB_SIZE ulLen ); -extern HB_EXPORT PHB_ITEM hb_itemPutStrLenU16( PHB_ITEM pItem, int iEndian, const HB_WCHAR * pStr, HB_SIZE ulLen ); +extern HB_EXPORT PHB_ITEM hb_itemPutStrLen( PHB_ITEM pItem, void * cdp, const char * pStr, HB_SIZE nLen ); +extern HB_EXPORT PHB_ITEM hb_itemPutStrLenUTF8( PHB_ITEM pItem, const char * pStr, HB_SIZE nLen ); +extern HB_EXPORT PHB_ITEM hb_itemPutStrLenU16( PHB_ITEM pItem, int iEndian, const HB_WCHAR * pStr, HB_SIZE nLen ); extern HB_EXPORT PHB_ITEM hb_itemPutStr( PHB_ITEM pItem, void * cdp, const char * pStr ); extern HB_EXPORT PHB_ITEM hb_itemPutStrUTF8( PHB_ITEM pItem, const char * pStr ); extern HB_EXPORT PHB_ITEM hb_itemPutStrU16( PHB_ITEM pItem, int iEndian, const HB_WCHAR * pStr ); -extern HB_EXPORT const char * hb_arrayGetStr( PHB_ITEM pArray, HB_SIZE ulIndex, void * cdp, void ** phString, HB_SIZE * pulLen ); -extern HB_EXPORT const char * hb_arrayGetStrUTF8( PHB_ITEM pArray, HB_SIZE ulIndex, void ** phString, HB_SIZE * pulLen ); -extern HB_EXPORT const HB_WCHAR * hb_arrayGetStrU16( PHB_ITEM pArray, HB_SIZE ulIndex, int iEndian, void ** phString, HB_SIZE * pulLen ); +extern HB_EXPORT const char * hb_arrayGetStr( PHB_ITEM pArray, HB_SIZE nIndex, void * cdp, void ** phString, HB_SIZE * pnLen ); +extern HB_EXPORT const char * hb_arrayGetStrUTF8( PHB_ITEM pArray, HB_SIZE nIndex, void ** phString, HB_SIZE * pnLen ); +extern HB_EXPORT const HB_WCHAR * hb_arrayGetStrU16( PHB_ITEM pArray, HB_SIZE nIndex, int iEndian, void ** phString, HB_SIZE * pnLen ); -extern HB_EXPORT HB_BOOL hb_arraySetStrLen( PHB_ITEM pArray, HB_SIZE ulIndex, void * cdp, const char * pStr, HB_SIZE ulLen ); -extern HB_EXPORT HB_BOOL hb_arraySetStrLenUTF8( PHB_ITEM pArray, HB_SIZE ulIndex, const char * pStr, HB_SIZE ulLen ); -extern HB_EXPORT HB_BOOL hb_arraySetStrLenU16( PHB_ITEM pArray, HB_SIZE ulIndex, int iEndian, const HB_WCHAR * pStr, HB_SIZE ulLen ); +extern HB_EXPORT HB_BOOL hb_arraySetStrLen( PHB_ITEM pArray, HB_SIZE nIndex, void * cdp, const char * pStr, HB_SIZE nLen ); +extern HB_EXPORT HB_BOOL hb_arraySetStrLenUTF8( PHB_ITEM pArray, HB_SIZE nIndex, const char * pStr, HB_SIZE nLen ); +extern HB_EXPORT HB_BOOL hb_arraySetStrLenU16( PHB_ITEM pArray, HB_SIZE nIndex, int iEndian, const HB_WCHAR * pStr, HB_SIZE nLen ); -extern HB_EXPORT HB_BOOL hb_arraySetStr( PHB_ITEM pArray, HB_SIZE ulIndex, void * cdp, const char * pStr ); -extern HB_EXPORT HB_BOOL hb_arraySetStrUTF8( PHB_ITEM pArray, HB_SIZE ulIndex, const char * pStr ); -extern HB_EXPORT HB_BOOL hb_arraySetStrU16( PHB_ITEM pArray, HB_SIZE ulIndex, int iEndian, const HB_WCHAR * pStr ); +extern HB_EXPORT HB_BOOL hb_arraySetStr( PHB_ITEM pArray, HB_SIZE nIndex, void * cdp, const char * pStr ); +extern HB_EXPORT HB_BOOL hb_arraySetStrUTF8( PHB_ITEM pArray, HB_SIZE nIndex, const char * pStr ); +extern HB_EXPORT HB_BOOL hb_arraySetStrU16( PHB_ITEM pArray, HB_SIZE nIndex, int iEndian, const HB_WCHAR * pStr ); -extern HB_EXPORT const char * hb_parstr( int iParam, void * cdp, void ** phString, HB_SIZE * pulLen ); -extern HB_EXPORT const char * hb_parstr_utf8( int iParam, void ** phString, HB_SIZE * pulLen ); -extern HB_EXPORT const HB_WCHAR * hb_parstr_u16( int iParam, int iEndian, void ** phString, HB_SIZE * pulLen ); +extern HB_EXPORT const char * hb_parstr( int iParam, void * cdp, void ** phString, HB_SIZE * pnLen ); +extern HB_EXPORT const char * hb_parstr_utf8( int iParam, void ** phString, HB_SIZE * pnLen ); +extern HB_EXPORT const HB_WCHAR * hb_parstr_u16( int iParam, int iEndian, void ** phString, HB_SIZE * pnLen ); extern HB_EXPORT void hb_retstr( void * cdp, const char * szText ); extern HB_EXPORT void hb_retstr_utf8( const char * szText ); extern HB_EXPORT void hb_retstr_u16( int iEndian, const HB_WCHAR * szText ); -extern HB_EXPORT void hb_retstrlen( void * cdp, const char * szText, HB_SIZE ulLen ); -extern HB_EXPORT void hb_retstrlen_utf8( const char * szText, HB_SIZE ulLen ); -extern HB_EXPORT void hb_retstrlen_u16( int iEndian, const HB_WCHAR * szText, HB_SIZE ulLen ); +extern HB_EXPORT void hb_retstrlen( void * cdp, const char * szText, HB_SIZE nLen ); +extern HB_EXPORT void hb_retstrlen_utf8( const char * szText, HB_SIZE nLen ); +extern HB_EXPORT void hb_retstrlen_u16( int iEndian, const HB_WCHAR * szText, HB_SIZE nLen ); extern HB_EXPORT int hb_storstr( void * cdp, const char * szText, int iParam ); extern HB_EXPORT int hb_storstr_utf8( const char * szText, int iParam ); extern HB_EXPORT int hb_storstr_u16( int iEndian, const HB_WCHAR * szText, int iParam ); -extern HB_EXPORT int hb_storstrlen( void * cdp, const char * szText, HB_SIZE ulLen, int iParam ); -extern HB_EXPORT int hb_storstrlen_utf8( const char * szText, HB_SIZE ulLen, int iParam ); -extern HB_EXPORT int hb_storstrlen_u16( int iEndian, const HB_WCHAR * szText, HB_SIZE ulLen, int iParam ); +extern HB_EXPORT int hb_storstrlen( void * cdp, const char * szText, HB_SIZE nLen, int iParam ); +extern HB_EXPORT int hb_storstrlen_utf8( const char * szText, HB_SIZE nLen, int iParam ); +extern HB_EXPORT int hb_storstrlen_u16( int iEndian, const HB_WCHAR * szText, HB_SIZE nLen, int iParam ); HB_EXTERN_END diff --git a/harbour/src/rtl/colorind.c b/harbour/src/rtl/colorind.c index 81ac2ad1be..05ec95db04 100644 --- a/harbour/src/rtl/colorind.c +++ b/harbour/src/rtl/colorind.c @@ -57,14 +57,14 @@ HB_FUNC( HB_COLORINDEX ) if( HB_ISCHAR( 1 ) && HB_ISNUM( 2 ) ) { const char * pszColor = hb_parc( 1 ); - HB_SIZE ulColorPos; - HB_SIZE ulColorLen; + HB_SIZE nColorPos; + HB_SIZE nColorLen; int iColorIndex = hb_parni( 2 ); /* Skip the given number of commas */ - for( ulColorPos = 0; pszColor[ ulColorPos ] != '\0' && iColorIndex > 0; ulColorPos++ ) + for( nColorPos = 0; pszColor[ nColorPos ] != '\0' && iColorIndex > 0; nColorPos++ ) { - if( pszColor[ ulColorPos ] == ',' ) + if( pszColor[ nColorPos ] == ',' ) iColorIndex--; } @@ -72,22 +72,22 @@ HB_FUNC( HB_COLORINDEX ) if( iColorIndex == 0 ) { /* Skip the spaces after the comma */ - while( pszColor[ ulColorPos ] == ' ' ) - ulColorPos++; + while( pszColor[ nColorPos ] == ' ' ) + nColorPos++; /* Search for next comma or end of string */ - ulColorLen = 0; - while( pszColor[ ulColorPos + ulColorLen ] != '\0' && - pszColor[ ulColorPos + ulColorLen ] != ',' ) - ulColorLen++; + nColorLen = 0; + while( pszColor[ nColorPos + nColorLen ] != '\0' && + pszColor[ nColorPos + nColorLen ] != ',' ) + nColorLen++; /* Skip the trailing spaces */ - while( ulColorLen > 0 && - pszColor[ ulColorPos + ulColorLen - 1 ] == ' ' ) - ulColorLen--; + while( nColorLen > 0 && + pszColor[ nColorPos + nColorLen - 1 ] == ' ' ) + nColorLen--; /* Return the string */ - hb_retclen( pszColor + ulColorPos, ulColorLen ); + hb_retclen( pszColor + nColorPos, nColorLen ); } else hb_retc_null(); diff --git a/harbour/src/rtl/inkey.c b/harbour/src/rtl/inkey.c index 81ce5a7b4d..2ea509010a 100644 --- a/harbour/src/rtl/inkey.c +++ b/harbour/src/rtl/inkey.c @@ -112,20 +112,20 @@ HB_FUNC( HB_KEYPUT ) else if( HB_ISARRAY( 1 ) ) { PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY ); - HB_SIZE ulIndex; - HB_SIZE ulElements = hb_arrayLen( pArray ); + HB_SIZE nIndex; + HB_SIZE nElements = hb_arrayLen( pArray ); - for( ulIndex = 1; ulIndex <= ulElements; ++ulIndex ) + for( nIndex = 1; nIndex <= nElements; ++nIndex ) { - HB_TYPE type = hb_arrayGetType( pArray, ulIndex ); + HB_TYPE type = hb_arrayGetType( pArray, nIndex ); if( type & HB_IT_NUMERIC ) { - hb_inkeyPut( hb_arrayGetNI( pArray, ulIndex ) ); + hb_inkeyPut( hb_arrayGetNI( pArray, nIndex ) ); } else if( type & HB_IT_STRING ) { - hb_inkeySetText( hb_arrayGetCPtr( pArray, ulIndex ), hb_arrayGetCLen( pArray, ulIndex ) ); + hb_inkeySetText( hb_arrayGetCPtr( pArray, nIndex ), hb_arrayGetCLen( pArray, nIndex ) ); } } } @@ -144,20 +144,20 @@ HB_FUNC( HB_KEYINS ) else if( HB_ISARRAY( 1 ) ) { PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY ); - HB_SIZE ulIndex; - HB_SIZE ulElements = hb_arrayLen( pArray ); + HB_SIZE nIndex; + HB_SIZE nElements = hb_arrayLen( pArray ); - for( ulIndex = 1; ulIndex <= ulElements; ++ulIndex ) + for( nIndex = 1; nIndex <= nElements; ++nIndex ) { - HB_TYPE type = hb_arrayGetType( pArray, ulIndex ); + HB_TYPE type = hb_arrayGetType( pArray, nIndex ); if( type & HB_IT_NUMERIC ) { - hb_inkeyIns( hb_arrayGetNI( pArray, ulIndex ) ); + hb_inkeyIns( hb_arrayGetNI( pArray, nIndex ) ); } else if( type & HB_IT_STRING ) { - hb_inkeySetText( hb_arrayGetCPtr( pArray, ulIndex ), hb_arrayGetCLen( pArray, ulIndex ) ); + hb_inkeySetText( hb_arrayGetCPtr( pArray, nIndex ), hb_arrayGetCLen( pArray, nIndex ) ); } } } @@ -183,4 +183,3 @@ HB_FUNC( HB_SETLASTKEY ) if( HB_ISNUM( 1 ) ) hb_retni( hb_inkeySetLast( hb_parni( 1 ) ) ); } - diff --git a/harbour/src/rtl/inkeyapi.c b/harbour/src/rtl/inkeyapi.c index 505866556b..b3c5f6d58e 100644 --- a/harbour/src/rtl/inkeyapi.c +++ b/harbour/src/rtl/inkeyapi.c @@ -158,16 +158,16 @@ int hb_inkeySetLast( int iKey ) return iLast; } -void hb_inkeySetText( const char * szText, HB_SIZE ulLen ) +void hb_inkeySetText( const char * szText, HB_SIZE nLen ) { PHB_GT pGT; - HB_TRACE(HB_TR_DEBUG, ("hb_inkeySetText(%s,%" HB_PFS "u)", szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_inkeySetText(%s,%" HB_PFS "u)", szText, nLen)); pGT = hb_gt_Base(); if( pGT ) { - HB_GTSELF_INKEYSETTEXT( pGT, szText, ulLen ); + HB_GTSELF_INKEYSETTEXT( pGT, szText, nLen ); hb_gt_BaseFree( pGT ); } } diff --git a/harbour/src/rtl/left.c b/harbour/src/rtl/left.c index edf3e8fd06..4a04c78984 100644 --- a/harbour/src/rtl/left.c +++ b/harbour/src/rtl/left.c @@ -62,16 +62,16 @@ HB_FUNC( LEFT ) if( pText && HB_ISNUM( 2 ) ) { - HB_ISIZ lLen = hb_parns( 2 ); - if( lLen <= 0 ) + HB_ISIZ nLen = hb_parns( 2 ); + if( nLen <= 0 ) hb_retc_null(); else { - HB_SIZE ulText = hb_itemGetCLen( pText ); - if( ( HB_SIZE ) lLen >= ulText ) + HB_SIZE nText = hb_itemGetCLen( pText ); + if( ( HB_SIZE ) nLen >= nText ) hb_itemReturn( pText ); else - hb_retclen( hb_itemGetCPtr( pText ), lLen ); + hb_retclen( hb_itemGetCPtr( pText ), nLen ); } } else diff --git a/harbour/src/rtl/lennum.c b/harbour/src/rtl/lennum.c index eb2774072b..4de539fdb7 100644 --- a/harbour/src/rtl/lennum.c +++ b/harbour/src/rtl/lennum.c @@ -56,7 +56,7 @@ HB_FUNC( LENNUM ) { PHB_ITEM pNumber = hb_param( 1, HB_IT_NUMERIC ); - HB_SIZE ulLen = 0; + HB_SIZE nLen = 0; if( pNumber ) { @@ -64,11 +64,11 @@ HB_FUNC( LENNUM ) if( pszString ) { - ulLen = strlen( pszString ); - hb_strLTrim( pszString, &ulLen ); + nLen = strlen( pszString ); + hb_strLTrim( pszString, &nLen ); hb_xfree( pszString ); } } - hb_retns( ulLen ); + hb_retns( nLen ); } diff --git a/harbour/src/rtl/mlcfunc.c b/harbour/src/rtl/mlcfunc.c index c1542abbd9..d1c0870a45 100644 --- a/harbour/src/rtl/mlcfunc.c +++ b/harbour/src/rtl/mlcfunc.c @@ -57,98 +57,98 @@ typedef struct { const char * szEOL; - HB_SIZE ulLen; + HB_SIZE nLen; } HB_EOL_INFO, * PHB_EOL_INFO; -static int hb_mlEol( const char * pszString, HB_SIZE ulLen, +static int hb_mlEol( const char * pszString, HB_SIZE nLen, PHB_EOL_INFO pEOLs, int iEOLs ) { int i; for( i = 0; i < iEOLs; ++i ) { - if( ulLen >= pEOLs[ i ].ulLen && - memcmp( pszString, pEOLs[ i ].szEOL, pEOLs[ i ].ulLen ) == 0 ) + if( nLen >= pEOLs[ i ].nLen && + memcmp( pszString, pEOLs[ i ].szEOL, pEOLs[ i ].nLen ) == 0 ) return i; } return -1; } -static HB_SIZE hb_mlGetLine( const char * pszString, HB_SIZE ulLen, HB_SIZE ulOffset, - HB_SIZE ulLineLength, HB_SIZE ulTabSize, HB_SIZE ulMaxPos, +static HB_SIZE hb_mlGetLine( const char * pszString, HB_SIZE nLen, HB_SIZE nOffset, + HB_SIZE nLineLength, HB_SIZE nTabSize, HB_SIZE nMaxPos, HB_BOOL fWordWrap, PHB_EOL_INFO pEOLs, int iEOLs, - HB_SIZE * pulLen, HB_SIZE * pulEOL ) + HB_SIZE * pnLen, HB_SIZE * pnEOL ) { - HB_SIZE ulCol = 0, ulBlankCol = 0, ulBlankPos = 0; + HB_SIZE nCol = 0, nBlankCol = 0, nBlankPos = 0; int i; - if( pulEOL ) - * pulEOL = 0; + if( pnEOL ) + * pnEOL = 0; - while( ulOffset < ulLen && ( ulMaxPos == 0 || ulOffset < ulMaxPos ) ) + while( nOffset < nLen && ( nMaxPos == 0 || nOffset < nMaxPos ) ) { - if( pszString[ ulOffset ] == HB_CHAR_SOFT1 && - pszString[ ulOffset + 1 ] == HB_CHAR_SOFT2 ) + if( pszString[ nOffset ] == HB_CHAR_SOFT1 && + pszString[ nOffset + 1 ] == HB_CHAR_SOFT2 ) { - ulOffset += 2; + nOffset += 2; if( !fWordWrap ) break; continue; } - i = hb_mlEol( pszString + ulOffset, ulLen - ulOffset, pEOLs, iEOLs ); + i = hb_mlEol( pszString + nOffset, nLen - nOffset, pEOLs, iEOLs ); if( i >= 0 ) { - if( ulMaxPos ) - ulCol += pEOLs[ i ].ulLen; + if( nMaxPos ) + nCol += pEOLs[ i ].nLen; else - ulOffset += pEOLs[ i ].ulLen; - if( pulEOL ) - * pulEOL = pEOLs[ i ].ulLen; + nOffset += pEOLs[ i ].nLen; + if( pnEOL ) + * pnEOL = pEOLs[ i ].nLen; break; } - if( pszString[ ulOffset ] == ' ' || pszString[ ulOffset ] == HB_CHAR_HT ) + if( pszString[ nOffset ] == ' ' || pszString[ nOffset ] == HB_CHAR_HT ) { - ulBlankCol = ulCol; - ulBlankPos = ulOffset; + nBlankCol = nCol; + nBlankPos = nOffset; } - if( ulCol >= ulLineLength ) + if( nCol >= nLineLength ) { if( fWordWrap ) { - if( ulBlankCol == 0 || pszString[ ulOffset ] == ' ' || - pszString[ ulOffset ] == HB_CHAR_HT ) + if( nBlankCol == 0 || pszString[ nOffset ] == ' ' || + pszString[ nOffset ] == HB_CHAR_HT ) { - ulCol = ulLineLength; - if( pszString[ ulOffset ] == ' ' ) - ++ulOffset; - if( pszString[ ulOffset ] == HB_CHAR_SOFT1 && - pszString[ ulOffset + 1 ] == HB_CHAR_SOFT2 ) - ulOffset += 2; + nCol = nLineLength; + if( pszString[ nOffset ] == ' ' ) + ++nOffset; + if( pszString[ nOffset ] == HB_CHAR_SOFT1 && + pszString[ nOffset + 1 ] == HB_CHAR_SOFT2 ) + nOffset += 2; } else { - ulCol = ulBlankCol; - ulOffset = ulBlankPos + 1; + nCol = nBlankCol; + nOffset = nBlankPos + 1; } } else { - if( ulCol > ulLineLength ) - --ulOffset; - ulCol = ulLineLength; + if( nCol > nLineLength ) + --nOffset; + nCol = nLineLength; } break; } - ulCol += pszString[ ulOffset ] == HB_CHAR_HT ? - ulTabSize - ( ulCol % ulTabSize ) : 1; - ulOffset++; + nCol += pszString[ nOffset ] == HB_CHAR_HT ? + nTabSize - ( nCol % nTabSize ) : 1; + nOffset++; } - * pulLen = ulCol; + * pnLen = nCol; - return ulOffset; + return nOffset; } static PHB_EOL_INFO hb_mlGetEOLs( int iParam, int * piEOLs ) @@ -163,35 +163,35 @@ static PHB_EOL_INFO hb_mlGetEOLs( int iParam, int * piEOLs ) Clipper will ignore these parameters and use CRLF EOL hard coded. [vszakats] */ #ifndef HB_CLP_STRICT /* HB_EXTENSION */ - HB_SIZE ulLen = hb_parclen( iParam ); - if( ulLen ) + HB_SIZE nLen = hb_parclen( iParam ); + if( nLen ) { pEOLs = ( PHB_EOL_INFO ) hb_xgrab( sizeof( HB_EOL_INFO ) ); pEOLs->szEOL = hb_parc( iParam ); - pEOLs->ulLen = ulLen; + pEOLs->nLen = nLen; iEOLs = 1; } else if( HB_ISARRAY( iParam ) ) { PHB_ITEM pArray = hb_param( iParam, HB_IT_ARRAY ); - HB_SIZE ulSize = hb_arrayLen( pArray ), ul; + HB_SIZE nSize = hb_arrayLen( pArray ), n; - for( ul = 1; ul <= ulSize; ++ul ) + for( n = 1; n <= nSize; ++n ) { - if( hb_arrayGetCLen( pArray, ul ) > 0 ) + if( hb_arrayGetCLen( pArray, n ) > 0 ) ++iEOLs; } if( iEOLs ) { pEOLs = ( PHB_EOL_INFO ) hb_xgrab( sizeof( HB_EOL_INFO ) * iEOLs ); iEOLs = 0; - for( ul = 1; ul <= ulSize; ++ul ) + for( n = 1; n <= nSize; ++n ) { - ulLen = hb_arrayGetCLen( pArray, ul ); - if( ulLen > 0 ) + nLen = hb_arrayGetCLen( pArray, n ); + if( nLen > 0 ) { - pEOLs[ iEOLs ].szEOL = hb_arrayGetCPtr( pArray, ul ); - pEOLs[ iEOLs ].ulLen = ulLen; + pEOLs[ iEOLs ].szEOL = hb_arrayGetCPtr( pArray, n ); + pEOLs[ iEOLs ].nLen = nLen; ++iEOLs; } } @@ -207,17 +207,17 @@ static PHB_EOL_INFO hb_mlGetEOLs( int iParam, int * piEOLs ) pEOLs->szEOL = hb_setGetEOL(); if( !pEOLs->szEOL || !pEOLs->szEOL[ 0 ] ) pEOLs->szEOL = hb_conNewLine(); - pEOLs->ulLen = strlen( pEOLs->szEOL ); - iEOLs = pEOLs->ulLen ? 1 : 0; + pEOLs->nLen = strlen( pEOLs->szEOL ); + iEOLs = pEOLs->nLen ? 1 : 0; } * piEOLs = iEOLs; return pEOLs; } -static const char * hb_mlGetParams( int iParAdd, HB_SIZE * pulLen, - HB_SIZE * pulLineLength, - HB_SIZE * pulTabSize, HB_BOOL * pfWordWrap, +static const char * hb_mlGetParams( int iParAdd, HB_SIZE * pnLen, + HB_SIZE * pnLineLength, + HB_SIZE * pnTabSize, HB_BOOL * pfWordWrap, PHB_EOL_INFO * pEOLs, int * piEOLs ) { const char * pszString = hb_parc( 1 ); @@ -227,39 +227,39 @@ static const char * hb_mlGetParams( int iParAdd, HB_SIZE * pulLen, { if( hb_parnd( 2 ) <= 0 ) return NULL; - * pulLineLength = hb_parns( 2 ); + * pnLineLength = hb_parns( 2 ); } else - * pulLineLength = 79; - * pulLen = hb_parclen( 1 ); - * pulTabSize = hb_parnldef( 3 + iParAdd, 4 ); + * pnLineLength = 79; + * pnLen = hb_parclen( 1 ); + * pnTabSize = hb_parnldef( 3 + iParAdd, 4 ); * pfWordWrap = hb_parldef( 4 + iParAdd, 1 ); * pEOLs = hb_mlGetEOLs( 5 + iParAdd, piEOLs ); #ifdef HB_CLP_STRICT - if( * pulLineLength > 254 ) - * pulLineLength = 79; + if( * pnLineLength > 254 ) + * pnLineLength = 79; #endif - if( * pulTabSize >= * pulLineLength ) - * pulTabSize = * pulLineLength - 1; - else if( * pulTabSize == 0 ) - * pulTabSize = 1; + if( * pnTabSize >= * pnLineLength ) + * pnTabSize = * pnLineLength - 1; + else if( * pnTabSize == 0 ) + * pnTabSize = 1; } return pszString; } HB_FUNC( MEMOLINE ) { - HB_SIZE ulLen, ulLineLength, ulTabSize; + HB_SIZE nLen, nLineLength, nTabSize; HB_BOOL fWordWrap; PHB_EOL_INFO pEOLs; int iEOLs; - const char * pszString = hb_mlGetParams( 1, &ulLen, &ulLineLength, - &ulTabSize, &fWordWrap, + const char * pszString = hb_mlGetParams( 1, &nLen, &nLineLength, + &nTabSize, &fWordWrap, &pEOLs, &iEOLs ); char * szLine; - HB_SIZE ulLine = hb_parns( 3 ); - HB_SIZE ulOffset = 0; - HB_SIZE ulCols = 0; + HB_SIZE nLine = hb_parns( 3 ); + HB_SIZE nOffset = 0; + HB_SIZE nCols = 0; if( !pszString ) { @@ -267,42 +267,42 @@ HB_FUNC( MEMOLINE ) return; } - if( ulLine == 0 ) - ulLine = 1; + if( nLine == 0 ) + nLine = 1; - while( --ulLine && ulOffset < ulLen ) + while( --nLine && nOffset < nLen ) { - ulOffset = hb_mlGetLine( pszString, ulLen, ulOffset, - ulLineLength, ulTabSize, 0, fWordWrap, - pEOLs, iEOLs, &ulCols, NULL ); + nOffset = hb_mlGetLine( pszString, nLen, nOffset, + nLineLength, nTabSize, 0, fWordWrap, + pEOLs, iEOLs, &nCols, NULL ); } - if( ulOffset < ulLen ) + if( nOffset < nLen ) { - HB_SIZE ulCol = 0; - hb_mlGetLine( pszString, ulLen, ulOffset, - ulLineLength, ulTabSize, 0, fWordWrap, - pEOLs, iEOLs, &ulCols, NULL ); - szLine = ( char * ) hb_xgrab( ulLineLength + 1 ); - while( ulCol < ulCols ) + HB_SIZE nCol = 0; + hb_mlGetLine( pszString, nLen, nOffset, + nLineLength, nTabSize, 0, fWordWrap, + pEOLs, iEOLs, &nCols, NULL ); + szLine = ( char * ) hb_xgrab( nLineLength + 1 ); + while( nCol < nCols ) { - if( pszString[ ulOffset ] == HB_CHAR_HT ) + if( pszString[ nOffset ] == HB_CHAR_HT ) { - HB_SIZE ul = ulTabSize - ( ulCol % ulTabSize ); + HB_SIZE n = nTabSize - ( nCol % nTabSize ); do - szLine[ ulCol++ ] = ' '; - while( --ul && ulCol < ulCols ); + szLine[ nCol++ ] = ' '; + while( --n && nCol < nCols ); } - else if( pszString[ ulOffset ] == HB_CHAR_SOFT1 && - pszString[ ulOffset + 1 ] == HB_CHAR_SOFT2 ) - ulOffset++; + else if( pszString[ nOffset ] == HB_CHAR_SOFT1 && + pszString[ nOffset + 1 ] == HB_CHAR_SOFT2 ) + nOffset++; else - szLine[ ulCol++ ] = pszString[ ulOffset ]; - ulOffset++; + szLine[ nCol++ ] = pszString[ nOffset ]; + nOffset++; } - if( ulCols < ulLineLength ) - memset( szLine + ulCols, ' ', ulLineLength - ulCols ); - szLine[ ulLineLength ] = 0; - hb_retclen_buffer( szLine, ulLineLength ); + if( nCols < nLineLength ) + memset( szLine + nCols, ' ', nLineLength - nCols ); + szLine[ nLineLength ] = 0; + hb_retclen_buffer( szLine, nLineLength ); } else hb_retc_null(); @@ -311,151 +311,151 @@ HB_FUNC( MEMOLINE ) HB_FUNC( MLCOUNT ) { - HB_SIZE ulLen, ulLineLength, ulTabSize; + HB_SIZE nLen, nLineLength, nTabSize; HB_BOOL fWordWrap; PHB_EOL_INFO pEOLs; int iEOLs; - const char * pszString = hb_mlGetParams( 0, &ulLen, &ulLineLength, - &ulTabSize, &fWordWrap, + const char * pszString = hb_mlGetParams( 0, &nLen, &nLineLength, + &nTabSize, &fWordWrap, &pEOLs, &iEOLs ); - HB_SIZE ulLines = 0; - HB_SIZE ulOffset = 0; - HB_SIZE ulCols = 0; + HB_SIZE nLines = 0; + HB_SIZE nOffset = 0; + HB_SIZE nCols = 0; if( pszString ) { - while( ulOffset < ulLen ) + while( nOffset < nLen ) { - ++ulLines; - ulOffset = hb_mlGetLine( pszString, ulLen, ulOffset, - ulLineLength, ulTabSize, 0, fWordWrap, - pEOLs, iEOLs, &ulCols, NULL ); + ++nLines; + nOffset = hb_mlGetLine( pszString, nLen, nOffset, + nLineLength, nTabSize, 0, fWordWrap, + pEOLs, iEOLs, &nCols, NULL ); } hb_xfree( pEOLs ); } - hb_retns( ulLines ); + hb_retns( nLines ); } HB_FUNC( MLPOS ) { - HB_SIZE ulLen, ulLineLength, ulTabSize; + HB_SIZE nLen, nLineLength, nTabSize; HB_BOOL fWordWrap; PHB_EOL_INFO pEOLs; int iEOLs; - const char * pszString = hb_mlGetParams( 1, &ulLen, &ulLineLength, - &ulTabSize, &fWordWrap, + const char * pszString = hb_mlGetParams( 1, &nLen, &nLineLength, + &nTabSize, &fWordWrap, &pEOLs, &iEOLs ); - HB_SIZE ulLine = hb_parns( 3 ); - HB_SIZE ulOffset = 0; - HB_SIZE ulCols = 0; + HB_SIZE nLine = hb_parns( 3 ); + HB_SIZE nOffset = 0; + HB_SIZE nCols = 0; if( pszString ) { - if( ulLine == 0 ) - ulLine = 1; - while( --ulLine && ulOffset < ulLen ) - ulOffset = hb_mlGetLine( pszString, ulLen, ulOffset, - ulLineLength, ulTabSize, 0, fWordWrap, - pEOLs, iEOLs, &ulCols, NULL ); - if( ulOffset < ulLen ) - ++ulOffset; + if( nLine == 0 ) + nLine = 1; + while( --nLine && nOffset < nLen ) + nOffset = hb_mlGetLine( pszString, nLen, nOffset, + nLineLength, nTabSize, 0, fWordWrap, + pEOLs, iEOLs, &nCols, NULL ); + if( nOffset < nLen ) + ++nOffset; hb_xfree( pEOLs ); } - hb_retns( ulOffset ); + hb_retns( nOffset ); } HB_FUNC( MLCTOPOS ) { - HB_SIZE ulLen, ulLineLength, ulTabSize; + HB_SIZE nLen, nLineLength, nTabSize; HB_BOOL fWordWrap; PHB_EOL_INFO pEOLs; int iEOLs; - const char * pszString = hb_mlGetParams( 2, &ulLen, &ulLineLength, - &ulTabSize, &fWordWrap, + const char * pszString = hb_mlGetParams( 2, &nLen, &nLineLength, + &nTabSize, &fWordWrap, &pEOLs, &iEOLs ); - HB_SIZE ulLine = hb_parns( 3 ); - HB_SIZE ulCol = hb_parns( 4 ); - HB_SIZE ulOffset = 0; - HB_SIZE ulCols = 0; + HB_SIZE nLine = hb_parns( 3 ); + HB_SIZE nCol = hb_parns( 4 ); + HB_SIZE nOffset = 0; + HB_SIZE nCols = 0; if( pszString ) { - if( ulLineLength > 4 && ulLine && HB_ISNUM( 4 ) ) + if( nLineLength > 4 && nLine && HB_ISNUM( 4 ) ) { - while( --ulLine && ulOffset < ulLen ) - ulOffset = hb_mlGetLine( pszString, ulLen, ulOffset, - ulLineLength, ulTabSize, 0, fWordWrap, - pEOLs, iEOLs, &ulCols, NULL ); - if( ulOffset < ulLen && ulCol ) - ulOffset = hb_mlGetLine( pszString, ulLen, ulOffset, - ulCol, ulTabSize, ulLen, HB_FALSE, - pEOLs, iEOLs, &ulCols, NULL ); + while( --nLine && nOffset < nLen ) + nOffset = hb_mlGetLine( pszString, nLen, nOffset, + nLineLength, nTabSize, 0, fWordWrap, + pEOLs, iEOLs, &nCols, NULL ); + if( nOffset < nLen && nCol ) + nOffset = hb_mlGetLine( pszString, nLen, nOffset, + nCol, nTabSize, nLen, HB_FALSE, + pEOLs, iEOLs, &nCols, NULL ); } hb_xfree( pEOLs ); } - ++ulOffset; - hb_retns( ulOffset ); + ++nOffset; + hb_retns( nOffset ); } HB_FUNC( MPOSTOLC ) { - HB_SIZE ulLen, ulLineLength, ulTabSize; + HB_SIZE nLen, nLineLength, nTabSize; HB_BOOL fWordWrap; PHB_EOL_INFO pEOLs; int iEOLs; - const char * pszString = hb_mlGetParams( 1, &ulLen, &ulLineLength, - &ulTabSize, &fWordWrap, + const char * pszString = hb_mlGetParams( 1, &nLen, &nLineLength, + &nTabSize, &fWordWrap, &pEOLs, &iEOLs ); - HB_SIZE ulPos = hb_parns( 3 ); - HB_SIZE ulOffset = 0; - HB_SIZE ulLine = 0; - HB_SIZE ulCol = 0; - HB_SIZE ulEOL = 0; + HB_SIZE nPos = hb_parns( 3 ); + HB_SIZE nOffset = 0; + HB_SIZE nLine = 0; + HB_SIZE nCol = 0; + HB_SIZE nEOL = 0; if( pszString ) { - if( ulPos && ulLen ) + if( nPos && nLen ) { - if( --ulPos ) + if( --nPos ) { do { - ++ulLine; - ulOffset = hb_mlGetLine( pszString, ulLen, ulOffset, - ulLineLength, ulTabSize, ulPos, fWordWrap, - pEOLs, iEOLs, &ulCol, &ulEOL ); - if( ulEOL ) + ++nLine; + nOffset = hb_mlGetLine( pszString, nLen, nOffset, + nLineLength, nTabSize, nPos, fWordWrap, + pEOLs, iEOLs, &nCol, &nEOL ); + if( nEOL ) { - if( ulOffset + ulEOL == ulPos ) + if( nOffset + nEOL == nPos ) { - ulCol = 0; - ++ulLine; + nCol = 0; + ++nLine; break; } - ulOffset += ulEOL; + nOffset += nEOL; } } - while( ulOffset < ulLen && ulOffset < ulPos ); + while( nOffset < nLen && nOffset < nPos ); - if( ulLine && ulCol == ulLineLength && ulPos <= ulLen && - ( hb_mlEol( pszString + ulPos, ulLen - ulPos, pEOLs, iEOLs ) >= 0 || - ( pszString[ ulPos ] == HB_CHAR_SOFT1 && - pszString[ ulPos + 1 ] == HB_CHAR_SOFT2 ) || - ( ulPos > 0 && pszString[ ulPos - 1 ] == HB_CHAR_SOFT1 && - pszString[ ulPos ] == HB_CHAR_SOFT2 ) || - ( ulPos > 1 && pszString[ ulPos - 2 ] == HB_CHAR_SOFT1 && - pszString[ ulPos - 1 ] == HB_CHAR_SOFT2 ) ) ) + if( nLine && nCol == nLineLength && nPos <= nLen && + ( hb_mlEol( pszString + nPos, nLen - nPos, pEOLs, iEOLs ) >= 0 || + ( pszString[ nPos ] == HB_CHAR_SOFT1 && + pszString[ nPos + 1 ] == HB_CHAR_SOFT2 ) || + ( nPos > 0 && pszString[ nPos - 1 ] == HB_CHAR_SOFT1 && + pszString[ nPos ] == HB_CHAR_SOFT2 ) || + ( nPos > 1 && pszString[ nPos - 2 ] == HB_CHAR_SOFT1 && + pszString[ nPos - 1 ] == HB_CHAR_SOFT2 ) ) ) { - ulCol = 0; - ++ulLine; + nCol = 0; + ++nLine; } } else - ++ulLine; + ++nLine; } hb_xfree( pEOLs ); } hb_reta( 2 ); - hb_storvns( ulLine, -1, 1 ); - hb_storvns( ulCol, -1, 2 ); + hb_storvns( nLine, -1, 1 ); + hb_storvns( nCol, -1, 2 ); } diff --git a/harbour/src/rtl/mtran.c b/harbour/src/rtl/mtran.c index cb5a5c7cbd..006b2dfc9d 100644 --- a/harbour/src/rtl/mtran.c +++ b/harbour/src/rtl/mtran.c @@ -53,36 +53,36 @@ #include "hbapi.h" #include "hbapiitm.h" -/* NOTE: pszResult must have an allocated buffer of at least ulStringLen */ +/* NOTE: pszResult must have an allocated buffer of at least nStringLen */ -static char * hb_strMemotran( char * pszResult, HB_SIZE * ulResultLen, const char * pszString, HB_SIZE ulStringLen, char cHardcr, char cSoftcr ) +static char * hb_strMemotran( char * pszResult, HB_SIZE * pnResultLen, const char * pszString, HB_SIZE nStringLen, char cHardcr, char cSoftcr ) { - HB_SIZE ulStringPos = 0; - HB_SIZE ulResultPos = 0; + HB_SIZE nStringPos = 0; + HB_SIZE nResultPos = 0; - HB_TRACE(HB_TR_DEBUG, ("hb_strMemotran(%p, %p, %s, %" HB_PFS "u, %x, %x)", pszResult, ulResultLen, pszString, ulStringLen, cHardcr, cSoftcr)); + HB_TRACE(HB_TR_DEBUG, ("hb_strMemotran(%p, %p, %s, %" HB_PFS "u, %x, %x)", pszResult, pnResultLen, pszString, nStringLen, cHardcr, cSoftcr)); - while( ulStringPos < ulStringLen ) + while( nStringPos < nStringLen ) { - if( pszString[ ulStringPos ] == HB_CHAR_HARD1 && - pszString[ ulStringPos + 1 ] == HB_CHAR_HARD2 ) + if( pszString[ nStringPos ] == HB_CHAR_HARD1 && + pszString[ nStringPos + 1 ] == HB_CHAR_HARD2 ) { - pszResult[ ulResultPos++ ] = cHardcr; - ulStringPos += 2; + pszResult[ nResultPos++ ] = cHardcr; + nStringPos += 2; } - else if( pszString[ ulStringPos ] == HB_CHAR_SOFT1 && - pszString[ ulStringPos + 1 ] == HB_CHAR_SOFT2 ) + else if( pszString[ nStringPos ] == HB_CHAR_SOFT1 && + pszString[ nStringPos + 1 ] == HB_CHAR_SOFT2 ) { - pszResult[ ulResultPos++ ] = cSoftcr; - ulStringPos += 2; + pszResult[ nResultPos++ ] = cSoftcr; + nStringPos += 2; } else - pszResult[ ulResultPos++ ] = pszString[ ulStringPos++ ]; + pszResult[ nResultPos++ ] = pszString[ nStringPos++ ]; } - pszResult[ ulResultPos ] = '\0'; + pszResult[ nResultPos ] = '\0'; - *ulResultLen = ulResultPos; + *pnResultLen = nResultPos; return pszResult; } @@ -96,10 +96,10 @@ HB_FUNC( MEMOTRAN ) char * pszResult = ( char * ) hb_xgrab( hb_itemGetCLen( pString ) + 1 ); char cHardcr = HB_ISCHAR( 2 ) ? *hb_parc( 2 ) : ';'; char cSoftcr = HB_ISCHAR( 3 ) ? *hb_parc( 3 ) : ' '; - HB_SIZE ulResultLen; + HB_SIZE nResultLen; - hb_strMemotran( pszResult, &ulResultLen, hb_itemGetCPtr( pString ), hb_itemGetCLen( pString ), cHardcr, cSoftcr ); - hb_retclen_buffer( pszResult, ulResultLen ); + hb_strMemotran( pszResult, &nResultLen, hb_itemGetCPtr( pString ), hb_itemGetCLen( pString ), cHardcr, cSoftcr ); + hb_retclen_buffer( pszResult, nResultLen ); } else hb_retc_null(); diff --git a/harbour/src/rtl/padc.c b/harbour/src/rtl/padc.c index 5d2967ff6d..6ae139dba5 100644 --- a/harbour/src/rtl/padc.c +++ b/harbour/src/rtl/padc.c @@ -57,46 +57,46 @@ /* centre-pads a date, number, or string with spaces or supplied character */ HB_FUNC( PADC ) { - HB_SIZE ulSize; + HB_SIZE nSize; HB_BOOL bFreeReq; char * szText; - HB_ISIZ lLen = hb_parns( 2 ); + HB_ISIZ nLen = hb_parns( 2 ); - if( lLen > 0 ) + if( nLen > 0 ) { PHB_ITEM pItem = hb_param( 1, HB_IT_ANY ); - if( pItem && HB_IS_STRING( pItem ) && ( HB_SIZE ) lLen == hb_itemGetCLen( pItem ) ) + if( pItem && HB_IS_STRING( pItem ) && ( HB_SIZE ) nLen == hb_itemGetCLen( pItem ) ) { hb_itemReturn( pItem ); } else { - szText = hb_itemPadConv( pItem, &ulSize, &bFreeReq ); + szText = hb_itemPadConv( pItem, &nSize, &bFreeReq ); if( szText ) { - if( ( HB_SIZE ) lLen > ulSize ) + if( ( HB_SIZE ) nLen > nSize ) { - char * szResult = ( char * ) hb_xgrab( lLen + 1 ); + char * szResult = ( char * ) hb_xgrab( nLen + 1 ); char cPad; - HB_ISIZ ulPad = ( ( HB_SIZE ) lLen - ulSize ) >> 1; + HB_ISIZ nPad = ( ( HB_SIZE ) nLen - nSize ) >> 1; cPad = ( HB_ISCHAR( 3 ) ? *( hb_parc( 3 ) ) : ' ' ); - hb_xmemset( szResult, cPad, ulPad ); - hb_xmemcpy( szResult + ulPad, szText, ulSize ); - hb_xmemset( szResult + ulPad + ulSize, cPad, - ( HB_SIZE ) lLen - ulSize - ulPad ); + hb_xmemset( szResult, cPad, nPad ); + hb_xmemcpy( szResult + nPad, szText, nSize ); + hb_xmemset( szResult + nPad + nSize, cPad, + ( HB_SIZE ) nLen - nSize - nPad ); - hb_retclen_buffer( szResult, ( HB_SIZE ) lLen ); + hb_retclen_buffer( szResult, ( HB_SIZE ) nLen ); if( bFreeReq ) hb_xfree( szText ); } else { if( bFreeReq ) - hb_retclen_buffer( szText, ( HB_SIZE ) lLen ); + hb_retclen_buffer( szText, ( HB_SIZE ) nLen ); else - hb_retclen( szText, lLen ); + hb_retclen( szText, nLen ); } } else diff --git a/harbour/src/rtl/padl.c b/harbour/src/rtl/padl.c index e867a546d5..591099fa08 100644 --- a/harbour/src/rtl/padl.c +++ b/harbour/src/rtl/padl.c @@ -57,43 +57,43 @@ /* left-pads a date, number, or string with spaces or supplied character */ HB_FUNC( PADL ) { - HB_SIZE ulSize; + HB_SIZE nSize; HB_BOOL bFreeReq; char * szText; - HB_ISIZ lLen = hb_parns( 2 ); + HB_ISIZ nLen = hb_parns( 2 ); - if( lLen > 0 ) + if( nLen > 0 ) { PHB_ITEM pItem = hb_param( 1, HB_IT_ANY ); - if( pItem && HB_IS_STRING( pItem ) && ( HB_SIZE ) lLen == hb_itemGetCLen( pItem ) ) + if( pItem && HB_IS_STRING( pItem ) && ( HB_SIZE ) nLen == hb_itemGetCLen( pItem ) ) { hb_itemReturn( pItem ); } else { - szText = hb_itemPadConv( pItem, &ulSize, &bFreeReq ); + szText = hb_itemPadConv( pItem, &nSize, &bFreeReq ); if( szText ) { - if( ( HB_SIZE ) lLen > ulSize ) + if( ( HB_SIZE ) nLen > nSize ) { - char * szResult = ( char * ) hb_xgrab( lLen + 1 ); + char * szResult = ( char * ) hb_xgrab( nLen + 1 ); char cPad; cPad = ( HB_ISCHAR( 3 ) ? *( hb_parc( 3 ) ) : ' ' ); - hb_xmemset( szResult, cPad, ( HB_SIZE ) lLen - ulSize ); - hb_xmemcpy( szResult + ( HB_SIZE ) lLen - ulSize, szText, ulSize ); + hb_xmemset( szResult, cPad, ( HB_SIZE ) nLen - nSize ); + hb_xmemcpy( szResult + ( HB_SIZE ) nLen - nSize, szText, nSize ); - hb_retclen_buffer( szResult, ( HB_SIZE ) lLen ); + hb_retclen_buffer( szResult, ( HB_SIZE ) nLen ); if( bFreeReq ) hb_xfree( szText ); } else { if( bFreeReq ) - hb_retclen_buffer( szText, ( HB_SIZE ) lLen ); + hb_retclen_buffer( szText, ( HB_SIZE ) nLen ); else - hb_retclen( szText, lLen ); + hb_retclen( szText, nLen ); } } else diff --git a/harbour/src/rtl/padr.c b/harbour/src/rtl/padr.c index 667d66fdee..ddb2335626 100644 --- a/harbour/src/rtl/padr.c +++ b/harbour/src/rtl/padr.c @@ -57,43 +57,43 @@ /* right-pads a date, number, or string with spaces or supplied character */ HB_FUNC( PADR ) { - HB_SIZE ulSize; + HB_SIZE nSize; HB_BOOL bFreeReq; char * szText; - HB_ISIZ lLen = hb_parns( 2 ); + HB_ISIZ nLen = hb_parns( 2 ); - if( lLen > 0 ) + if( nLen > 0 ) { PHB_ITEM pItem = hb_param( 1, HB_IT_ANY ); - if( pItem && HB_IS_STRING( pItem ) && ( HB_SIZE ) lLen == hb_itemGetCLen( pItem ) ) + if( pItem && HB_IS_STRING( pItem ) && ( HB_SIZE ) nLen == hb_itemGetCLen( pItem ) ) { hb_itemReturn( pItem ); } else { - szText = hb_itemPadConv( pItem, &ulSize, &bFreeReq ); + szText = hb_itemPadConv( pItem, &nSize, &bFreeReq ); if( szText ) { - if( ( HB_SIZE ) lLen > ulSize ) + if( ( HB_SIZE ) nLen > nSize ) { - char * szResult = ( char * ) hb_xgrab( lLen + 1 ); + char * szResult = ( char * ) hb_xgrab( nLen + 1 ); char cPad; cPad = ( HB_ISCHAR( 3 ) ? *( hb_parc( 3 ) ) : ' ' ); - hb_xmemcpy( szResult, szText, ulSize ); - hb_xmemset( szResult + ulSize, cPad, ( HB_SIZE ) lLen - ulSize ); + hb_xmemcpy( szResult, szText, nSize ); + hb_xmemset( szResult + nSize, cPad, ( HB_SIZE ) nLen - nSize ); - hb_retclen_buffer( szResult, ( HB_SIZE ) lLen ); + hb_retclen_buffer( szResult, ( HB_SIZE ) nLen ); if( bFreeReq ) hb_xfree( szText ); } else { if( bFreeReq ) - hb_retclen_buffer( szText, ( HB_SIZE ) lLen ); + hb_retclen_buffer( szText, ( HB_SIZE ) nLen ); else - hb_retclen( szText, lLen ); + hb_retclen( szText, nLen ); } } else diff --git a/harbour/src/rtl/philes.c b/harbour/src/rtl/philes.c index 01e925f77d..6058de9a1b 100644 --- a/harbour/src/rtl/philes.c +++ b/harbour/src/rtl/philes.c @@ -113,31 +113,31 @@ HB_FUNC( FREAD ) { PHB_ITEM pBuffer = hb_param( 2, HB_IT_STRING ); HB_ERRCODE uiError = 0; - HB_SIZE ulRead = 0; + HB_SIZE nRead = 0; if( HB_ISNUM( 1 ) && pBuffer && HB_ISBYREF( 2 ) && HB_ISNUM( 3 ) ) { char * buffer; - HB_SIZE ulSize; + HB_SIZE nSize; - ulRead = hb_parns( 3 ); + nRead = hb_parns( 3 ); /* NOTE: CA-Cl*pper determines the maximum size by calling _parcsiz() instead of _parclen(), this means that the maximum read length will be one more than the length of the passed buffer, because the terminating zero could be used if needed. [vszakats] */ - if( ulRead <= hb_parcsiz( 2 ) && - hb_itemGetWriteCL( pBuffer, &buffer, &ulSize ) ) + if( nRead <= hb_parcsiz( 2 ) && + hb_itemGetWriteCL( pBuffer, &buffer, &nSize ) ) { - ulRead = hb_fsReadLarge( hb_numToHandle( hb_parnint( 1 ) ), buffer, ulRead ); + nRead = hb_fsReadLarge( hb_numToHandle( hb_parnint( 1 ) ), buffer, nRead ); uiError = hb_fsError(); } else - ulRead = 0; + nRead = 0; } - hb_retnint( ulRead ); + hb_retns( nRead ); hb_fsSetFError( uiError ); } @@ -160,7 +160,7 @@ HB_FUNC( FWRITE ) uiError = hb_fsError(); } else - hb_retni( 0 ); + hb_retns( 0 ); hb_fsSetFError( uiError ); } @@ -237,17 +237,17 @@ HB_FUNC( FREADSTR ) if( HB_ISNUM( 1 ) && HB_ISNUM( 2 ) ) { - HB_SIZE ulToRead = hb_parns( 2 ); + HB_SIZE nToRead = hb_parns( 2 ); - if( ulToRead > 0 ) + if( nToRead > 0 ) { HB_FHANDLE fhnd = ( HB_FHANDLE ) hb_parni( 1 ); - char * buffer = ( char * ) hb_xgrab( ulToRead + 1 ); - HB_SIZE ulRead; + char * buffer = ( char * ) hb_xgrab( nToRead + 1 ); + HB_SIZE nRead; - ulRead = hb_fsReadLarge( fhnd, buffer, ulToRead ); + nRead = hb_fsReadLarge( fhnd, buffer, nToRead ); uiError = hb_fsError(); - buffer[ ulRead ] = '\0'; + buffer[ nRead ] = '\0'; /* NOTE: Clipper will not return zero chars from this functions. */ hb_retc_buffer( buffer ); diff --git a/harbour/src/rtl/rat.c b/harbour/src/rtl/rat.c index eb90b83067..66cccebc34 100644 --- a/harbour/src/rtl/rat.c +++ b/harbour/src/rtl/rat.c @@ -54,26 +54,26 @@ HB_FUNC( RAT ) { - HB_SIZE ulSubLen = hb_parclen( 1 ); + HB_SIZE nSubLen = hb_parclen( 1 ); - if( ulSubLen ) + if( nSubLen ) { - HB_ISIZ lPos = hb_parclen( 2 ) - ulSubLen; + HB_ISIZ nPos = hb_parclen( 2 ) - nSubLen; - if( lPos >= 0 ) + if( nPos >= 0 ) { const char * pszSub = hb_parc( 1 ); const char * pszText = hb_parc( 2 ); HB_BOOL bFound = HB_FALSE; - while( lPos >= 0 && !bFound ) + while( nPos >= 0 && !bFound ) { - if( *( pszText + lPos ) == *pszSub ) - bFound = ( memcmp( pszSub, pszText + lPos, ulSubLen ) == 0 ); - lPos--; + if( *( pszText + nPos ) == *pszSub ) + bFound = ( memcmp( pszSub, pszText + nPos, nSubLen ) == 0 ); + nPos--; } - hb_retns( bFound ? lPos + 2 : 0 ); + hb_retns( bFound ? nPos + 2 : 0 ); } else hb_retns( 0 ); @@ -85,46 +85,46 @@ HB_FUNC( RAT ) HB_FUNC( HB_RAT ) { - HB_SIZE ulSubLen = hb_parclen( 1 ); + HB_SIZE nSubLen = hb_parclen( 1 ); - if( ulSubLen ) + if( nSubLen ) { - HB_ISIZ lPos = hb_parclen( 2 ) - ulSubLen; + HB_ISIZ nPos = hb_parclen( 2 ) - nSubLen; - if( lPos >= 0 ) + if( nPos >= 0 ) { const char * pszSub = hb_parc( 1 ); const char * pszText = hb_parc( 2 ); HB_BOOL bFound = HB_FALSE; - HB_ISIZ lStart; + HB_ISIZ nStart; if( HB_ISNUM( 3 ) ) { - lStart = hb_parns( 3 ); - if( lStart >= 1 ) - --lStart; + nStart = hb_parns( 3 ); + if( nStart >= 1 ) + --nStart; else - lStart = 0; + nStart = 0; } else - lStart = 0; + nStart = 0; if( HB_ISNUM( 4 ) ) { - HB_ISIZ lEnd = hb_parns( 4 ) - 1; + HB_ISIZ nEnd = hb_parns( 4 ) - 1; - if( lEnd < lPos ) - lPos = lEnd; + if( nEnd < nPos ) + nPos = nEnd; } - while( lPos >= lStart && !bFound ) + while( nPos >= nStart && !bFound ) { - if( *( pszText + lPos ) == *pszSub ) - bFound = ( memcmp( pszSub, pszText + lPos, ulSubLen ) == 0 ); - lPos--; + if( *( pszText + nPos ) == *pszSub ) + bFound = ( memcmp( pszSub, pszText + nPos, nSubLen ) == 0 ); + nPos--; } - hb_retns( bFound ? lPos + 2 : 0 ); + hb_retns( bFound ? nPos + 2 : 0 ); } else hb_retns( 0 ); diff --git a/harbour/src/rtl/replic.c b/harbour/src/rtl/replic.c index 2ec3a7ae89..6c2a128222 100644 --- a/harbour/src/rtl/replic.c +++ b/harbour/src/rtl/replic.c @@ -60,26 +60,26 @@ HB_FUNC( REPLICATE ) { if( HB_ISCHAR( 1 ) && HB_ISNUM( 2 ) ) { - HB_ISIZ lTimes = hb_parns( 2 ); + HB_ISIZ nTimes = hb_parns( 2 ); - if( lTimes > 0 ) + if( nTimes > 0 ) { - HB_SIZE ulLen = hb_parclen( 1 ); + HB_SIZE nLen = hb_parclen( 1 ); - if( ( double ) ( ( double ) ulLen * ( double ) lTimes ) < ( double ) ULONG_MAX ) + if( ( double ) ( ( double ) nLen * ( double ) nTimes ) < ( double ) ULONG_MAX ) { const char * szText = hb_parc( 1 ); - char * szResult = ( char * ) hb_xgrab( ( ulLen * lTimes ) + 1 ); + char * szResult = ( char * ) hb_xgrab( ( nLen * nTimes ) + 1 ); char * szPtr = szResult; - HB_ISIZ i; + HB_ISIZ n; - for( i = 0; i < lTimes; i++ ) + for( n = 0; n < nTimes; ++n ) { - hb_xmemcpy( szPtr, szText, ulLen ); - szPtr += ulLen; + hb_xmemcpy( szPtr, szText, nLen ); + szPtr += nLen; } - hb_retclen_buffer( szResult, ulLen * lTimes ); + hb_retclen_buffer( szResult, nLen * nTimes ); } else hb_errRT_BASE_SubstR( EG_STROVERFLOW, 1234, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS ); diff --git a/harbour/src/rtl/right.c b/harbour/src/rtl/right.c index d113f54c80..2a2528976e 100644 --- a/harbour/src/rtl/right.c +++ b/harbour/src/rtl/right.c @@ -62,16 +62,16 @@ HB_FUNC( RIGHT ) if( pText && HB_ISNUM( 2 ) ) { - HB_ISIZ lLen = hb_parns( 2 ); - if( lLen <= 0 ) + HB_ISIZ nLen = hb_parns( 2 ); + if( nLen <= 0 ) hb_retc_null(); else { - HB_SIZE ulText = hb_itemGetCLen( pText ); - if( ( HB_SIZE ) lLen >= ulText ) + HB_SIZE nText = hb_itemGetCLen( pText ); + if( ( HB_SIZE ) nLen >= nText ) hb_itemReturn( pText ); else - hb_retclen( hb_itemGetCPtr( pText ) + ulText - lLen, lLen ); + hb_retclen( hb_itemGetCPtr( pText ) + nText - nLen, nLen ); } } else diff --git a/harbour/src/rtl/samples.c b/harbour/src/rtl/samples.c index e901ea4b08..c6362ccc9f 100644 --- a/harbour/src/rtl/samples.c +++ b/harbour/src/rtl/samples.c @@ -78,21 +78,21 @@ static char * hb_SecToTimeStr( char * pszTime, long lTime ) static long hb_TimeStrToSec( const char * pszTime ) { - HB_SIZE ulLen; + HB_SIZE nLen; long lTime = 0; HB_TRACE(HB_TR_DEBUG, ("hb_TimeStrToSec(%s)", pszTime)); - ulLen = strlen( pszTime ); + nLen = strlen( pszTime ); - if( ulLen >= 1 ) - lTime += ( long ) hb_strVal( pszTime, ulLen ) * 3600; + if( nLen >= 1 ) + lTime += ( long ) hb_strVal( pszTime, nLen ) * 3600; - if( ulLen >= 4 ) - lTime += ( long ) hb_strVal( pszTime + 3, ulLen - 3 ) * 60; + if( nLen >= 4 ) + lTime += ( long ) hb_strVal( pszTime + 3, nLen - 3 ) * 60; - if( ulLen >= 7 ) - lTime += ( long ) hb_strVal( pszTime + 6, ulLen - 6 ); + if( nLen >= 7 ) + lTime += ( long ) hb_strVal( pszTime + 6, nLen - 6 ); return lTime; } diff --git a/harbour/src/rtl/saverest.c b/harbour/src/rtl/saverest.c index 60aeb3c528..5e74dd9602 100644 --- a/harbour/src/rtl/saverest.c +++ b/harbour/src/rtl/saverest.c @@ -96,18 +96,18 @@ static void hb_getScreenRange( int * piMin, int * piMax, HB_FUNC( SAVESCREEN ) { int iTop, iLeft, iBottom, iRight; - HB_SIZE ulSize; + HB_SIZE nSize; void * pBuffer; HB_BOOL fNoCheck = HB_FALSE; hb_getScreenRange( &iTop, &iBottom, fNoCheck, HB_TRUE ); hb_getScreenRange( &iLeft, &iRight, fNoCheck, HB_FALSE ); - hb_gtRectSize( iTop, iLeft, iBottom, iRight, &ulSize ); - pBuffer = hb_xgrab( ulSize + 1 ); + hb_gtRectSize( iTop, iLeft, iBottom, iRight, &nSize ); + pBuffer = hb_xgrab( nSize + 1 ); hb_gtSave( iTop, iLeft, iBottom, iRight, pBuffer ); - hb_retclen_buffer( ( char * ) pBuffer, ulSize ); + hb_retclen_buffer( ( char * ) pBuffer, nSize ); } HB_FUNC( RESTSCREEN ) diff --git a/harbour/src/rtl/setkey.c b/harbour/src/rtl/setkey.c index f75aed280c..69345fe6ed 100644 --- a/harbour/src/rtl/setkey.c +++ b/harbour/src/rtl/setkey.c @@ -286,29 +286,29 @@ HB_FUNC( HB_SETKEYSAVE ) PHB_SK_DATA sk_data = ( PHB_SK_DATA ) hb_stackGetTSD( &s_skData ); PHB_ITEM pKeys, pKeyElements, pParam; PHB_SETKEY sk_list_tmp; - HB_SIZE itemcount, nitem; + HB_SIZE nItemCount, nItem; /* build an multi-dimensional array from existing hot-keys, and return it */ /* count the number of items in the list */ - for( itemcount = 0, sk_list_tmp = sk_data->sk_list; + for( nItemCount = 0, sk_list_tmp = sk_data->sk_list; sk_list_tmp; - itemcount++, sk_list_tmp = sk_list_tmp->next ) + nItemCount++, sk_list_tmp = sk_list_tmp->next ) ; - pKeys = hb_itemArrayNew( itemcount ); + pKeys = hb_itemArrayNew( nItemCount ); pKeyElements = hb_itemNew( NULL ); - for( nitem = 1, sk_list_tmp = sk_data->sk_list; - nitem <= itemcount; - nitem++, sk_list_tmp = sk_list_tmp->next ) + for( nItem = 1, sk_list_tmp = sk_data->sk_list; + nItem <= nItemCount; + nItem++, sk_list_tmp = sk_list_tmp->next ) { hb_arrayNew( pKeyElements, 3 ); hb_arraySetNI( pKeyElements, 1, sk_list_tmp->iKeyCode ); hb_arraySet( pKeyElements, 2, sk_list_tmp->pAction ); if( sk_list_tmp->pIsActive ) hb_arraySet( pKeyElements, 3, sk_list_tmp->pIsActive ); - hb_arraySetForward( pKeys, nitem, pKeyElements ); + hb_arraySetForward( pKeys, nItem, pKeyElements ); } hb_itemRelease( pKeyElements ); hb_itemReturnRelease( pKeys ); @@ -320,11 +320,11 @@ HB_FUNC( HB_SETKEYSAVE ) if( HB_IS_ARRAY( pParam ) ) { - itemcount = hb_arrayLen( pParam ); + nItemCount = hb_arrayLen( pParam ); - for( nitem = 1; nitem <= itemcount; nitem++ ) + for( nItem = 1; nItem <= nItemCount; nItem++ ) { - PHB_ITEM itmKeyElements = hb_arrayGetItemPtr( pParam, nitem ); + PHB_ITEM itmKeyElements = hb_arrayGetItemPtr( pParam, nItem ); sk_add( &sk_data->sk_list, HB_FALSE, hb_arrayGetNI( itmKeyElements, 1 ), diff --git a/harbour/src/rtl/strcase.c b/harbour/src/rtl/strcase.c index a8cb8fc1ae..5c0a3894bb 100644 --- a/harbour/src/rtl/strcase.c +++ b/harbour/src/rtl/strcase.c @@ -62,9 +62,9 @@ HB_FUNC( LOWER ) if( pText ) { char * pszBuffer = hb_itemGetC( pText ); - HB_SIZE ulLen = hb_itemGetCLen( pText ); + HB_SIZE nLen = hb_itemGetCLen( pText ); - hb_retclen_buffer( hb_strLower( pszBuffer, ulLen ), ulLen ); + hb_retclen_buffer( hb_strLower( pszBuffer, nLen ), nLen ); } else hb_errRT_BASE_SubstR( EG_ARG, 1103, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS ); @@ -78,9 +78,9 @@ HB_FUNC( UPPER ) if( pText ) { char * pszBuffer = hb_itemGetC( pText ); - HB_SIZE ulLen = hb_itemGetCLen( pText ); + HB_SIZE nLen = hb_itemGetCLen( pText ); - hb_retclen_buffer( hb_strUpper( pszBuffer, ulLen ), ulLen ); + hb_retclen_buffer( hb_strUpper( pszBuffer, nLen ), nLen ); } else hb_errRT_BASE_SubstR( EG_ARG, 1102, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS ); diff --git a/harbour/src/rtl/strtoexp.c b/harbour/src/rtl/strtoexp.c index 22f4c71d8e..09e30e7e0d 100644 --- a/harbour/src/rtl/strtoexp.c +++ b/harbour/src/rtl/strtoexp.c @@ -58,19 +58,19 @@ HB_FUNC( HB_STRTOEXP ) if( pszString ) { - HB_SIZE ulLen = hb_parclen( 1 ), ulRet, ul, uQ = 0; + HB_SIZE nLen = hb_parclen( 1 ), nRet, n, nQ = 0; int iType = 0; char ch, * pDst, * pszResult; - for( ul = 0; ul < ulLen; ++ul ) + for( n = 0; n < nLen; ++n ) { - switch( pszString[ ul ] ) + switch( pszString[ n ] ) { case '\\': - ++uQ; + ++nQ; break; case '"': - ++uQ; + ++nQ; iType |= 1; break; case '\'': @@ -82,23 +82,23 @@ HB_FUNC( HB_STRTOEXP ) case '\r': case '\n': iType |= 7; - ++uQ; + ++nQ; break; case '\0': iType |= 7; - uQ += 3; + nQ += 3; break; } } if( iType == 7 || hb_parl( 2 ) ) { - ulRet = ulLen + 3 + uQ; - pDst = pszResult = ( char * ) hb_xgrab( ulRet + 1 ); + nRet = nLen + 3 + nQ; + pDst = pszResult = ( char * ) hb_xgrab( nRet + 1 ); *pDst++ = 'e'; *pDst++ = '"'; - for( ul = 0; ul < ulLen; ++ul ) + for( n = 0; n < nLen; ++n ) { - ch = pszString[ ul ]; + ch = pszString[ n ]; switch( ch ) { case '\r': @@ -127,8 +127,8 @@ HB_FUNC( HB_STRTOEXP ) } else { - ulRet = ulLen + 2; - pDst = pszResult = ( char * ) hb_xgrab( ulRet + 1 ); + nRet = nLen + 2; + pDst = pszResult = ( char * ) hb_xgrab( nRet + 1 ); if( ( iType & 1 ) == 0 ) *pDst++ = ch = '"'; else if( ( iType & 2 ) == 0 ) @@ -138,11 +138,11 @@ HB_FUNC( HB_STRTOEXP ) *pDst++ = '['; ch = ']'; } - memcpy( pDst, pszString, ulLen ); - pDst += ulLen; + memcpy( pDst, pszString, nLen ); + pDst += nLen; *pDst++ = ch; } *pDst = '\0'; - hb_retclen_buffer( pszResult, ulRet ); + hb_retclen_buffer( pszResult, nRet ); } } diff --git a/harbour/src/rtl/strtran.c b/harbour/src/rtl/strtran.c index ba98b67354..05e1624b86 100644 --- a/harbour/src/rtl/strtran.c +++ b/harbour/src/rtl/strtran.c @@ -116,28 +116,28 @@ HB_FUNC( STRTRAN ) if( bAll || nCount > 0 ) { HB_SIZE nFound = 0; - HB_ISIZ lReplaced = 0; - HB_SIZE i = 0; + HB_ISIZ nReplaced = 0; + HB_SIZE n = 0; HB_SIZE nLength = nText; HB_SIZE nStop = nText - nSeek + 1; - while( i < nStop ) + while( n < nStop ) { - if( ( bAll || lReplaced < ( HB_ISIZ ) nCount ) && - ! memcmp( szText + i, szSeek, nSeek ) ) + if( ( bAll || nReplaced < ( HB_ISIZ ) nCount ) && + ! memcmp( szText + n, szSeek, nSeek ) ) { nFound++; if( nFound >= nStart ) { - lReplaced++; + nReplaced++; nLength = nLength - nSeek + nReplace; - i += nSeek; + n += nSeek; } else - i++; + n++; } else - i++; + n++; } if( nFound ) @@ -146,31 +146,31 @@ HB_FUNC( STRTRAN ) char * szPtr = szResult; nFound = 0; - i = 0; - while( i < nText ) + n = 0; + while( n < nText ) { - if( lReplaced && ! memcmp( szText + i, szSeek, nSeek ) ) + if( nReplaced && ! memcmp( szText + n, szSeek, nSeek ) ) { nFound++; if( nFound >= nStart ) { - lReplaced--; + nReplaced--; memcpy( szPtr, szReplace, nReplace ); szPtr += nReplace; - i += nSeek; + n += nSeek; } else { - *szPtr = szText[ i ]; + *szPtr = szText[ n ]; szPtr++; - i++; + n++; } } else { - *szPtr = szText[ i ]; + *szPtr = szText[ n ]; szPtr++; - i++; + n++; } } hb_retclen_buffer( szResult, nLength ); diff --git a/harbour/src/rtl/stuff.c b/harbour/src/rtl/stuff.c index b3c1741a3b..56ad01f1f5 100644 --- a/harbour/src/rtl/stuff.c +++ b/harbour/src/rtl/stuff.c @@ -58,32 +58,32 @@ HB_FUNC( STUFF ) if( HB_ISCHAR( 1 ) && HB_ISNUM( 2 ) && HB_ISNUM( 3 ) && HB_ISCHAR( 4 ) ) { const char * szText = hb_parc( 1 ); - HB_SIZE ulText = hb_parclen( 1 ); - HB_SIZE ulPos = hb_parns( 2 ); - HB_SIZE ulDel = hb_parns( 3 ); - HB_SIZE ulInsert = hb_parclen( 4 ); + HB_SIZE nText = hb_parclen( 1 ); + HB_SIZE nPos = hb_parns( 2 ); + HB_SIZE nDel = hb_parns( 3 ); + HB_SIZE nInsert = hb_parclen( 4 ); - HB_SIZE ulTotalLen; + HB_SIZE nTotalLen; - if( ulPos > 0 ) - ulPos--; + if( nPos > 0 ) + nPos--; - if( ulPos > ulText ) - ulPos = ulText; + if( nPos > nText ) + nPos = nText; - if( ulDel > ulText - ulPos ) - ulDel = ulText - ulPos; + if( nDel > nText - nPos ) + nDel = nText - nPos; - if( ( ulTotalLen = ulText + ulInsert - ulDel ) > 0 ) + if( ( nTotalLen = nText + nInsert - nDel ) > 0 ) { - char * szResult = ( char * ) hb_xgrab( ulTotalLen + 1 ); + char * szResult = ( char * ) hb_xgrab( nTotalLen + 1 ); - hb_xmemcpy( szResult, szText, ulPos ); - hb_xmemcpy( szResult + ulPos, hb_parc( 4 ), ulInsert ); - hb_xmemcpy( szResult + ulPos + ulInsert, szText + ulPos + ulDel, ulText - ( ulPos + ulDel ) ); + hb_xmemcpy( szResult, szText, nPos ); + hb_xmemcpy( szResult + nPos, hb_parc( 4 ), nInsert ); + hb_xmemcpy( szResult + nPos + nInsert, szText + nPos + nDel, nText - ( nPos + nDel ) ); - szResult[ ulTotalLen ] = '\0'; - hb_retclen_buffer( szResult, ulTotalLen ); + szResult[ nTotalLen ] = '\0'; + hb_retclen_buffer( szResult, nTotalLen ); } else hb_retc_null(); diff --git a/harbour/src/rtl/trace.c b/harbour/src/rtl/trace.c index 6c10dda9aa..79619ba0c1 100644 --- a/harbour/src/rtl/trace.c +++ b/harbour/src/rtl/trace.c @@ -57,13 +57,13 @@ static int s_traceLogLevel = HB_TR_DEFAULT; -static void hb_trace_message( char * buffer, HB_SIZE ulSize, int iParam, int iCount ) +static void hb_trace_message( char * buffer, HB_SIZE nSize, int iParam, int iCount ) { int iFirst = iParam; buffer[ 0 ] = '\0'; - while( iParam <= iCount && ulSize > 1 ) + while( iParam <= iCount && nSize > 1 ) { char * pszString; HB_SIZE nLen; @@ -72,12 +72,12 @@ static void hb_trace_message( char * buffer, HB_SIZE ulSize, int iParam, int iCo if( iParam > iFirst ) { *buffer++ = ' '; - --ulSize; + --nSize; } pszString = hb_itemString( hb_param( iParam, HB_IT_ANY ), &nLen, &fFree ); - hb_strncpy( buffer, pszString, ulSize ); + hb_strncpy( buffer, pszString, nSize ); nLen = strlen( buffer ); - ulSize -= nLen; + nSize -= nLen; buffer += nLen; if( fFree ) hb_xfree( pszString ); diff --git a/harbour/src/rtl/xsavescr.c b/harbour/src/rtl/xsavescr.c index c1461fd0c6..d3a0d128e4 100644 --- a/harbour/src/rtl/xsavescr.c +++ b/harbour/src/rtl/xsavescr.c @@ -87,13 +87,13 @@ static HB_TSD_NEW( s_scrData, sizeof( HB_SCRDATA ), NULL, hb_xSaveRestRelease ); HB_FUNC( __XSAVESCREEN ) { PHB_SCRDATA pScrData = ( PHB_SCRDATA ) hb_stackGetTSD( &s_scrData ); - HB_SIZE ulSize; + HB_SIZE nSize; hb_gtGetPos( &pScrData->row, &pScrData->col ); - hb_gtRectSize( 0, 0, hb_gtMaxRow(), hb_gtMaxCol(), &ulSize ); + hb_gtRectSize( 0, 0, hb_gtMaxRow(), hb_gtMaxCol(), &nSize ); if( pScrData->buffer ) hb_xfree( pScrData->buffer ); - pScrData->buffer = hb_xgrab( ulSize ); + pScrData->buffer = hb_xgrab( nSize ); hb_gtSave( 0, 0, hb_gtMaxRow(), hb_gtMaxCol(), pScrData->buffer ); } diff --git a/harbour/src/vm/arrays.c b/harbour/src/vm/arrays.c index afa3ebd3d0..7154dd7ae3 100644 --- a/harbour/src/vm/arrays.c +++ b/harbour/src/vm/arrays.c @@ -79,10 +79,10 @@ static void hb_arrayReleaseItems( PHB_BASEARRAY pBaseArray ) { - if( pBaseArray->ulLen ) + if( pBaseArray->nLen ) { HB_ITEM_PTR pItems = pBaseArray->pItems; - HB_SIZE ulLen = pBaseArray->ulLen; + HB_SIZE ulLen = pBaseArray->nLen; /* * clear the pBaseArray->pItems to avoid infinite loop in cross @@ -90,7 +90,7 @@ static void hb_arrayReleaseItems( PHB_BASEARRAY pBaseArray ) * object destructor [druzus] */ pBaseArray->pItems = NULL; - pBaseArray->ulLen = 0; + pBaseArray->nLen = 0; while( ulLen-- ) { @@ -159,9 +159,9 @@ static HB_GARBAGE_FUNC( hb_arrayGarbageMark ) { PHB_BASEARRAY pBaseArray = ( PHB_BASEARRAY ) Cargo; - if( pBaseArray->ulLen ) + if( pBaseArray->nLen ) { - HB_SIZE ulLen = pBaseArray->ulLen; + HB_SIZE ulLen = pBaseArray->nLen; HB_ITEM_PTR pItems = pBaseArray->pItems; while( ulLen-- ) @@ -206,10 +206,10 @@ HB_BOOL hb_arrayNew( PHB_ITEM pItem, HB_SIZE ulLen ) /* creates a new array */ pBaseArray = ( PHB_BASEARRAY ) hb_gcAllocRaw( sizeof( HB_BASEARRAY ), &s_gcArrayFuncs ); pBaseArray->pItems = pItems; - pBaseArray->ulLen = ulLen; + pBaseArray->nLen = ulLen; pBaseArray->uiClass = 0; pBaseArray->uiPrevCls = 0; - pBaseArray->ulAllocated= ulLen; + pBaseArray->nAllocated = ulLen; pItem->type = HB_IT_ARRAY; pItem->item.asArray.value = pBaseArray; @@ -224,23 +224,23 @@ HB_BOOL hb_arraySize( PHB_ITEM pArray, HB_SIZE ulLen ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - if( ulLen != pBaseArray->ulLen ) + if( ulLen != pBaseArray->nLen ) { HB_SIZE ulPos; - if( pBaseArray->ulLen == 0 ) + if( pBaseArray->nLen == 0 ) { pBaseArray->pItems = ( PHB_ITEM ) hb_xgrab( ulLen * sizeof( HB_ITEM ) ); - pBaseArray->ulAllocated = ulLen; + pBaseArray->nAllocated = ulLen; for( ulPos = 0; ulPos < ulLen; ulPos++ ) ( pBaseArray->pItems + ulPos )->type = HB_IT_NIL; } else { - if( pBaseArray->ulLen < ulLen ) + if( pBaseArray->nLen < ulLen ) { - if( pBaseArray->ulAllocated < ulLen ) + if( pBaseArray->nAllocated < ulLen ) { /* A common practice is to double allocation buffer size. Thus, making @@ -253,18 +253,18 @@ HB_BOOL hb_arraySize( PHB_ITEM pArray, HB_SIZE ulLen ) size is not doubled, but multiplied by 1.5; - adding of 1, allows reduce reallocation count for small arrays. */ - pBaseArray->ulAllocated = ( pBaseArray->ulAllocated >> 1 ) + 1 + ulLen; - pBaseArray->pItems = ( PHB_ITEM ) hb_xrealloc( pBaseArray->pItems, sizeof( HB_ITEM ) * pBaseArray->ulAllocated ); + pBaseArray->nAllocated = ( pBaseArray->nAllocated >> 1 ) + 1 + ulLen; + pBaseArray->pItems = ( PHB_ITEM ) hb_xrealloc( pBaseArray->pItems, sizeof( HB_ITEM ) * pBaseArray->nAllocated ); } /* set value for new items */ - for( ulPos = pBaseArray->ulLen; ulPos < ulLen; ulPos++ ) + for( ulPos = pBaseArray->nLen; ulPos < ulLen; ulPos++ ) ( pBaseArray->pItems + ulPos )->type = HB_IT_NIL; } - else if( pBaseArray->ulLen > ulLen ) + else if( pBaseArray->nLen > ulLen ) { /* release old items */ - for( ulPos = ulLen; ulPos < pBaseArray->ulLen; ulPos++ ) + for( ulPos = ulLen; ulPos < pBaseArray->nLen; ulPos++ ) { if( HB_IS_COMPLEX( pBaseArray->pItems + ulPos ) ) hb_itemClear( pBaseArray->pItems + ulPos ); @@ -275,15 +275,15 @@ HB_BOOL hb_arraySize( PHB_ITEM pArray, HB_SIZE ulLen ) hb_xfree( pBaseArray->pItems ); pBaseArray->pItems = NULL; } - else if( ulLen < ( pBaseArray->ulAllocated >> 1 ) ) + else if( ulLen < ( pBaseArray->nAllocated >> 1 ) ) { pBaseArray->pItems = ( PHB_ITEM ) hb_xrealloc( pBaseArray->pItems, sizeof( HB_ITEM ) * ulLen ); - pBaseArray->ulAllocated = ulLen; + pBaseArray->nAllocated = ulLen; } } } - pBaseArray->ulLen = ulLen; + pBaseArray->nLen = ulLen; } return HB_TRUE; @@ -297,7 +297,7 @@ HB_SIZE hb_arrayLen( PHB_ITEM pArray ) HB_TRACE(HB_TR_DEBUG, ("hb_arrayLen(%p)", pArray)); if( HB_IS_ARRAY( pArray ) ) - return pArray->item.asArray.value->ulLen; + return pArray->item.asArray.value->nLen; else return 0; } @@ -329,11 +329,11 @@ HB_BOOL hb_arrayAdd( PHB_ITEM pArray, PHB_ITEM pValue ) { PHB_BASEARRAY pBaseArray = ( PHB_BASEARRAY ) pArray->item.asArray.value; - if( pBaseArray->ulLen < HB_SIZE_MAX ) + if( pBaseArray->nLen < HB_SIZE_MAX ) { - hb_arraySize( pArray, pBaseArray->ulLen + 1 ); + hb_arraySize( pArray, pBaseArray->nLen + 1 ); pBaseArray = ( PHB_BASEARRAY ) pArray->item.asArray.value; - hb_itemCopy( pBaseArray->pItems + ( pBaseArray->ulLen - 1 ), pValue ); + hb_itemCopy( pBaseArray->pItems + ( pBaseArray->nLen - 1 ), pValue ); return HB_TRUE; } @@ -350,11 +350,11 @@ HB_BOOL hb_arrayAddForward( PHB_ITEM pArray, PHB_ITEM pValue ) { PHB_BASEARRAY pBaseArray = ( PHB_BASEARRAY ) pArray->item.asArray.value; - if( pBaseArray->ulLen < HB_SIZE_MAX ) + if( pBaseArray->nLen < HB_SIZE_MAX ) { - hb_arraySize( pArray, pBaseArray->ulLen + 1 ); + hb_arraySize( pArray, pBaseArray->nLen + 1 ); pBaseArray = ( PHB_BASEARRAY ) pArray->item.asArray.value; - hb_itemMove( pBaseArray->pItems + ( pBaseArray->ulLen - 1 ), pValue ); + hb_itemMove( pBaseArray->pItems + ( pBaseArray->nLen - 1 ), pValue ); return HB_TRUE; } @@ -363,27 +363,27 @@ HB_BOOL hb_arrayAddForward( PHB_ITEM pArray, PHB_ITEM pValue ) return HB_FALSE; } -HB_BOOL hb_arrayDel( PHB_ITEM pArray, HB_SIZE ulIndex ) +HB_BOOL hb_arrayDel( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayDel(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayDel(%p, %" HB_PFS "u)", pArray, nIndex)); if( HB_IS_ARRAY( pArray ) ) { - HB_SIZE ulLen = pArray->item.asArray.value->ulLen; + HB_SIZE ulLen = pArray->item.asArray.value->nLen; - if( ulIndex > 0 && ulIndex <= ulLen ) + if( nIndex > 0 && nIndex <= ulLen ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - if( ulIndex == ulLen ) + if( nIndex == ulLen ) { - hb_itemSetNil( pBaseArray->pItems + ulIndex - 1 ); + hb_itemSetNil( pBaseArray->pItems + nIndex - 1 ); } else { - for( ; ulIndex < ulLen; ++ulIndex ) /* move items */ - hb_itemMoveRef( pBaseArray->pItems + ulIndex - 1, - pBaseArray->pItems + ulIndex ); + for( ; nIndex < ulLen; ++nIndex ) /* move items */ + hb_itemMoveRef( pBaseArray->pItems + nIndex - 1, + pBaseArray->pItems + nIndex ); } return HB_TRUE; @@ -393,25 +393,25 @@ HB_BOOL hb_arrayDel( PHB_ITEM pArray, HB_SIZE ulIndex ) return HB_FALSE; } -HB_BOOL hb_arrayIns( PHB_ITEM pArray, HB_SIZE ulIndex ) +HB_BOOL hb_arrayIns( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayIns(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayIns(%p, %" HB_PFS "u)", pArray, nIndex)); if( HB_IS_ARRAY( pArray ) ) { - HB_SIZE ulLen = pArray->item.asArray.value->ulLen; + HB_SIZE ulLen = pArray->item.asArray.value->nLen; - if( ulIndex > 0 && ulIndex <= ulLen ) + if( nIndex > 0 && nIndex <= ulLen ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - if( ulIndex == ulLen ) + if( nIndex == ulLen ) { - hb_itemSetNil( pBaseArray->pItems + ulIndex - 1 ); + hb_itemSetNil( pBaseArray->pItems + nIndex - 1 ); } else { - while( --ulLen >= ulIndex ) /* move items */ + while( --ulLen >= nIndex ) /* move items */ hb_itemMoveRef( pBaseArray->pItems + ulLen, pBaseArray->pItems + ulLen - 1 ); } @@ -423,26 +423,26 @@ HB_BOOL hb_arrayIns( PHB_ITEM pArray, HB_SIZE ulIndex ) return HB_FALSE; } -HB_BOOL hb_arraySet( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem ) +HB_BOOL hb_arraySet( PHB_ITEM pArray, HB_SIZE nIndex, PHB_ITEM pItem ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySet(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pItem)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySet(%p, %" HB_PFS "u, %p)", pArray, nIndex, pItem)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemCopy( pArray->item.asArray.value->pItems + ( ulIndex - 1 ), pItem ); + hb_itemCopy( pArray->item.asArray.value->pItems + ( nIndex - 1 ), pItem ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetForward( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem ) +HB_BOOL hb_arraySetForward( PHB_ITEM pArray, HB_SIZE nIndex, PHB_ITEM pItem ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetForward(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pItem)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetForward(%p, %" HB_PFS "u, %p)", pArray, nIndex, pItem)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemMove( pArray->item.asArray.value->pItems + ( ulIndex - 1 ), pItem ); + hb_itemMove( pArray->item.asArray.value->pItems + ( nIndex - 1 ), pItem ); return HB_TRUE; } else @@ -452,13 +452,13 @@ HB_BOOL hb_arraySetForward( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem ) } } -HB_BOOL hb_arrayGet( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem ) +HB_BOOL hb_arrayGet( PHB_ITEM pArray, HB_SIZE nIndex, PHB_ITEM pItem ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGet(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pItem)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGet(%p, %" HB_PFS "u, %p)", pArray, nIndex, pItem)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemCopy( pItem, pArray->item.asArray.value->pItems + ( ulIndex - 1 ) ); + hb_itemCopy( pItem, pArray->item.asArray.value->pItems + ( nIndex - 1 ) ); return HB_TRUE; } else @@ -468,11 +468,11 @@ HB_BOOL hb_arrayGet( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem ) } } -HB_BOOL hb_arrayGetItemRef( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem ) +HB_BOOL hb_arrayGetItemRef( PHB_ITEM pArray, HB_SIZE nIndex, PHB_ITEM pItem ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetItemRef(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pItem)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetItemRef(%p, %" HB_PFS "u, %p)", pArray, nIndex, pItem)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { if( pArray != pItem ) { @@ -482,7 +482,7 @@ HB_BOOL hb_arrayGetItemRef( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem ) } pItem->type = HB_IT_BYREF; pItem->item.asRefer.BasePtr.array = pArray->item.asArray.value; - pItem->item.asRefer.value = ulIndex - 1; + pItem->item.asRefer.value = nIndex - 1; pItem->item.asRefer.offset = 0; return HB_TRUE; } @@ -497,56 +497,56 @@ HB_BOOL hb_arrayGetItemRef( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem ) * This function returns a pointer to an item occupied by the specified * array element - it doesn't return an item's value */ -PHB_ITEM hb_arrayGetItemPtr( PHB_ITEM pArray, HB_SIZE ulIndex ) +PHB_ITEM hb_arrayGetItemPtr( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetItemPtr(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetItemPtr(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return pArray->item.asArray.value->pItems + ulIndex - 1; + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return pArray->item.asArray.value->pItems + nIndex - 1; else return NULL; } -char * hb_arrayGetDS( PHB_ITEM pArray, HB_SIZE ulIndex, char * szDate ) +char * hb_arrayGetDS( PHB_ITEM pArray, HB_SIZE nIndex, char * szDate ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetDS(%p, %" HB_PFS "u, %s)", pArray, ulIndex, szDate)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetDS(%p, %" HB_PFS "u, %s)", pArray, nIndex, szDate)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetDS( pArray->item.asArray.value->pItems + ulIndex - 1, szDate ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetDS( pArray->item.asArray.value->pItems + nIndex - 1, szDate ); else /* NOTE: Intentionally calling it with a bad parameter in order to get the default value from hb_itemGetDS(). [vszakats] */ return hb_itemGetDS( NULL, szDate ); } -long hb_arrayGetDL( PHB_ITEM pArray, HB_SIZE ulIndex ) +long hb_arrayGetDL( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetDL(%p, %" HB_PFS "u)", pArray, ulIndex )); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetDL(%p, %" HB_PFS "u)", pArray, nIndex )); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetDL( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetDL( pArray->item.asArray.value->pItems + nIndex - 1 ); else /* NOTE: Intentionally calling it with a bad parameter in order to get the default value from hb_itemGetDL(). [vszakats] */ return hb_itemGetDL( NULL ); } -double hb_arrayGetTD( PHB_ITEM pArray, HB_SIZE ulIndex ) +double hb_arrayGetTD( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetTD(%p, %" HB_PFS "u)", pArray, ulIndex )); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetTD(%p, %" HB_PFS "u)", pArray, nIndex )); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetTD( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetTD( pArray->item.asArray.value->pItems + nIndex - 1 ); else return 0; } -HB_BOOL hb_arrayGetTDT( PHB_ITEM pArray, HB_SIZE ulIndex, long * plJulian, long * plMilliSec ) +HB_BOOL hb_arrayGetTDT( PHB_ITEM pArray, HB_SIZE nIndex, long * plJulian, long * plMilliSec ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetTDT(%p, %" HB_PFS "u, %p, %p)", pArray, ulIndex, plJulian, plMilliSec)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetTDT(%p, %" HB_PFS "u, %p, %p)", pArray, nIndex, plJulian, plMilliSec)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetTDT( pArray->item.asArray.value->pItems + ulIndex - 1, plJulian, plMilliSec ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetTDT( pArray->item.asArray.value->pItems + nIndex - 1, plJulian, plMilliSec ); else { *plJulian = *plMilliSec = 0; @@ -554,257 +554,257 @@ HB_BOOL hb_arrayGetTDT( PHB_ITEM pArray, HB_SIZE ulIndex, long * plJulian, long } } -HB_BOOL hb_arrayGetL( PHB_ITEM pArray, HB_SIZE ulIndex ) +HB_BOOL hb_arrayGetL( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetL(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetL(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetL( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetL( pArray->item.asArray.value->pItems + nIndex - 1 ); else return HB_FALSE; } -int hb_arrayGetNI( PHB_ITEM pArray, HB_SIZE ulIndex ) +int hb_arrayGetNI( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNI(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNI(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetNI( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetNI( pArray->item.asArray.value->pItems + nIndex - 1 ); else return 0; } -long hb_arrayGetNL( PHB_ITEM pArray, HB_SIZE ulIndex ) +long hb_arrayGetNL( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNL(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNL(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetNL( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetNL( pArray->item.asArray.value->pItems + nIndex - 1 ); else return 0; } -HB_ISIZ hb_arrayGetNS( PHB_ITEM pArray, HB_SIZE ulIndex ) +HB_ISIZ hb_arrayGetNS( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNS(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNS(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetNS( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetNS( pArray->item.asArray.value->pItems + nIndex - 1 ); else return 0; } #ifndef HB_LONG_LONG_OFF -HB_LONGLONG hb_arrayGetNLL( PHB_ITEM pArray, HB_SIZE ulIndex ) +HB_LONGLONG hb_arrayGetNLL( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNLL(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNLL(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetNLL( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetNLL( pArray->item.asArray.value->pItems + nIndex - 1 ); else return 0; } #endif -HB_MAXINT hb_arrayGetNInt( PHB_ITEM pArray, HB_SIZE ulIndex ) +HB_MAXINT hb_arrayGetNInt( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNInt(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNInt(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetNInt( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetNInt( pArray->item.asArray.value->pItems + nIndex - 1 ); else return 0; } -double hb_arrayGetND( PHB_ITEM pArray, HB_SIZE ulIndex ) +double hb_arrayGetND( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetND(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetND(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetND( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetND( pArray->item.asArray.value->pItems + nIndex - 1 ); else return 0; } -HB_SIZE hb_arrayCopyC( PHB_ITEM pArray, HB_SIZE ulIndex, char * szBuffer, HB_SIZE ulLen ) +HB_SIZE hb_arrayCopyC( PHB_ITEM pArray, HB_SIZE nIndex, char * szBuffer, HB_SIZE ulLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayCopyC(%p, %" HB_PFS "u, %s, %" HB_PFS "u)", pArray, ulIndex, szBuffer, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayCopyC(%p, %" HB_PFS "u, %s, %" HB_PFS "u)", pArray, nIndex, szBuffer, ulLen)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemCopyC( pArray->item.asArray.value->pItems + ulIndex - 1, szBuffer, ulLen ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemCopyC( pArray->item.asArray.value->pItems + nIndex - 1, szBuffer, ulLen ); else return 0; } -char * hb_arrayGetC( PHB_ITEM pArray, HB_SIZE ulIndex ) +char * hb_arrayGetC( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetC(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetC(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetC( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetC( pArray->item.asArray.value->pItems + nIndex - 1 ); else return NULL; } -const char * hb_arrayGetCPtr( PHB_ITEM pArray, HB_SIZE ulIndex ) +const char * hb_arrayGetCPtr( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetCPtr(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetCPtr(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetCPtr( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetCPtr( pArray->item.asArray.value->pItems + nIndex - 1 ); else return ""; } -HB_SIZE hb_arrayGetCLen( PHB_ITEM pArray, HB_SIZE ulIndex ) +HB_SIZE hb_arrayGetCLen( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetCLen(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetCLen(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetCLen( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetCLen( pArray->item.asArray.value->pItems + nIndex - 1 ); else return 0; } -void * hb_arrayGetPtr( PHB_ITEM pArray, HB_SIZE ulIndex ) +void * hb_arrayGetPtr( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetPtr(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetPtr(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetPtr( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetPtr( pArray->item.asArray.value->pItems + nIndex - 1 ); else return NULL; } -void * hb_arrayGetPtrGC( PHB_ITEM pArray, HB_SIZE ulIndex, const HB_GC_FUNCS * pFuncs ) +void * hb_arrayGetPtrGC( PHB_ITEM pArray, HB_SIZE nIndex, const HB_GC_FUNCS * pFuncs ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetPtrGC(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pFuncs)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetPtrGC(%p, %" HB_PFS "u, %p)", pArray, nIndex, pFuncs)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetPtrGC( pArray->item.asArray.value->pItems + ulIndex - 1, pFuncs ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetPtrGC( pArray->item.asArray.value->pItems + nIndex - 1, pFuncs ); else return NULL; } -PHB_SYMB hb_arrayGetSymbol( PHB_ITEM pArray, HB_SIZE ulIndex ) +PHB_SYMB hb_arrayGetSymbol( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetSymbol(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetSymbol(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetSymbol( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetSymbol( pArray->item.asArray.value->pItems + nIndex - 1 ); else return NULL; } -HB_TYPE hb_arrayGetType( PHB_ITEM pArray, HB_SIZE ulIndex ) +HB_TYPE hb_arrayGetType( PHB_ITEM pArray, HB_SIZE nIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetType(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetType(%p, %" HB_PFS "u)", pArray, nIndex)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemType( pArray->item.asArray.value->pItems + ulIndex - 1 ); + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemType( pArray->item.asArray.value->pItems + nIndex - 1 ); else return 0; } -HB_BOOL hb_arraySetDS( PHB_ITEM pArray, HB_SIZE ulIndex, const char * szDate ) +HB_BOOL hb_arraySetDS( PHB_ITEM pArray, HB_SIZE nIndex, const char * szDate ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetDS(%p, %" HB_PFS "u, %s)", pArray, ulIndex, szDate)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetDS(%p, %" HB_PFS "u, %s)", pArray, nIndex, szDate)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutDS( pArray->item.asArray.value->pItems + ulIndex - 1, szDate ); + hb_itemPutDS( pArray->item.asArray.value->pItems + nIndex - 1, szDate ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetDL( PHB_ITEM pArray, HB_SIZE ulIndex, long lDate ) +HB_BOOL hb_arraySetDL( PHB_ITEM pArray, HB_SIZE nIndex, long lDate ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetDL(%p, %" HB_PFS "u, %ld)", pArray, ulIndex, lDate)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetDL(%p, %" HB_PFS "u, %ld)", pArray, nIndex, lDate)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutDL( pArray->item.asArray.value->pItems + ulIndex - 1, lDate ); + hb_itemPutDL( pArray->item.asArray.value->pItems + nIndex - 1, lDate ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetTD( PHB_ITEM pArray, HB_SIZE ulIndex, double dTimeStamp ) +HB_BOOL hb_arraySetTD( PHB_ITEM pArray, HB_SIZE nIndex, double dTimeStamp ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetTD(%p, %" HB_PFS "u, %lf)", pArray, ulIndex, dTimeStamp)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetTD(%p, %" HB_PFS "u, %lf)", pArray, nIndex, dTimeStamp)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutTD( pArray->item.asArray.value->pItems + ulIndex - 1, dTimeStamp ); + hb_itemPutTD( pArray->item.asArray.value->pItems + nIndex - 1, dTimeStamp ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetTDT( PHB_ITEM pArray, HB_SIZE ulIndex, long lJulian, long lMilliSec ) +HB_BOOL hb_arraySetTDT( PHB_ITEM pArray, HB_SIZE nIndex, long lJulian, long lMilliSec ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetTDT(%p, %" HB_PFS "u, %lu, %lu)", pArray, ulIndex, lJulian, lMilliSec)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetTDT(%p, %" HB_PFS "u, %lu, %lu)", pArray, nIndex, lJulian, lMilliSec)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutTDT( pArray->item.asArray.value->pItems + ulIndex - 1, lJulian, lMilliSec ); + hb_itemPutTDT( pArray->item.asArray.value->pItems + nIndex - 1, lJulian, lMilliSec ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetL( PHB_ITEM pArray, HB_SIZE ulIndex, HB_BOOL fValue ) +HB_BOOL hb_arraySetL( PHB_ITEM pArray, HB_SIZE nIndex, HB_BOOL fValue ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetL(%p, %" HB_PFS "u, %d)", pArray, ulIndex, fValue)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetL(%p, %" HB_PFS "u, %d)", pArray, nIndex, fValue)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutL( pArray->item.asArray.value->pItems + ulIndex - 1, fValue ); + hb_itemPutL( pArray->item.asArray.value->pItems + nIndex - 1, fValue ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetNI( PHB_ITEM pArray, HB_SIZE ulIndex, int iNumber ) +HB_BOOL hb_arraySetNI( PHB_ITEM pArray, HB_SIZE nIndex, int iNumber ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNI(%p, %" HB_PFS "u, %d)", pArray, ulIndex, iNumber)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNI(%p, %" HB_PFS "u, %d)", pArray, nIndex, iNumber)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutNI( pArray->item.asArray.value->pItems + ulIndex - 1, iNumber ); + hb_itemPutNI( pArray->item.asArray.value->pItems + nIndex - 1, iNumber ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetNL( PHB_ITEM pArray, HB_SIZE ulIndex, long lNumber ) +HB_BOOL hb_arraySetNL( PHB_ITEM pArray, HB_SIZE nIndex, long lNumber ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNL(%p, %" HB_PFS "u, %lu)", pArray, ulIndex, lNumber)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNL(%p, %" HB_PFS "u, %lu)", pArray, nIndex, lNumber)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutNL( pArray->item.asArray.value->pItems + ulIndex - 1, lNumber ); + hb_itemPutNL( pArray->item.asArray.value->pItems + nIndex - 1, lNumber ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetNS( PHB_ITEM pArray, HB_SIZE ulIndex, HB_ISIZ nNumber ) +HB_BOOL hb_arraySetNS( PHB_ITEM pArray, HB_SIZE nIndex, HB_ISIZ nNumber ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNS(%p, %" HB_PFS "u, %" HB_PFS "d)", pArray, ulIndex, nNumber)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNS(%p, %" HB_PFS "u, %" HB_PFS "d)", pArray, nIndex, nNumber)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutNS( pArray->item.asArray.value->pItems + ulIndex - 1, nNumber ); + hb_itemPutNS( pArray->item.asArray.value->pItems + nIndex - 1, nNumber ); return HB_TRUE; } else @@ -812,13 +812,13 @@ HB_BOOL hb_arraySetNS( PHB_ITEM pArray, HB_SIZE ulIndex, HB_ISIZ nNumber ) } #ifndef HB_LONG_LONG_OFF -HB_BOOL hb_arraySetNLL( PHB_ITEM pArray, HB_SIZE ulIndex, HB_LONGLONG llNumber ) +HB_BOOL hb_arraySetNLL( PHB_ITEM pArray, HB_SIZE nIndex, HB_LONGLONG llNumber ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNLL(%p, %" HB_PFS "u, %" PFLL "d)", pArray, ulIndex, llNumber)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNLL(%p, %" HB_PFS "u, %" PFLL "d)", pArray, nIndex, llNumber)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutNLL( pArray->item.asArray.value->pItems + ulIndex - 1, llNumber ); + hb_itemPutNLL( pArray->item.asArray.value->pItems + nIndex - 1, llNumber ); return HB_TRUE; } else @@ -826,104 +826,104 @@ HB_BOOL hb_arraySetNLL( PHB_ITEM pArray, HB_SIZE ulIndex, HB_LONGLONG llNumber ) } #endif -HB_BOOL hb_arraySetNInt( PHB_ITEM pArray, HB_SIZE ulIndex, HB_MAXINT lNumber ) +HB_BOOL hb_arraySetNInt( PHB_ITEM pArray, HB_SIZE nIndex, HB_MAXINT lNumber ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNInt(%p, %" HB_PFS "u, %" PFHL "d)", pArray, ulIndex, lNumber)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNInt(%p, %" HB_PFS "u, %" PFHL "d)", pArray, nIndex, lNumber)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutNInt( pArray->item.asArray.value->pItems + ulIndex - 1, lNumber ); + hb_itemPutNInt( pArray->item.asArray.value->pItems + nIndex - 1, lNumber ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetND( PHB_ITEM pArray, HB_SIZE ulIndex, double dNumber ) +HB_BOOL hb_arraySetND( PHB_ITEM pArray, HB_SIZE nIndex, double dNumber ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetND(%p, %" HB_PFS "u, %lf)", pArray, ulIndex, dNumber)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetND(%p, %" HB_PFS "u, %lf)", pArray, nIndex, dNumber)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutND( pArray->item.asArray.value->pItems + ulIndex - 1, dNumber ); + hb_itemPutND( pArray->item.asArray.value->pItems + nIndex - 1, dNumber ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetC( PHB_ITEM pArray, HB_SIZE ulIndex, const char * szText ) +HB_BOOL hb_arraySetC( PHB_ITEM pArray, HB_SIZE nIndex, const char * szText ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetC(%p, %" HB_PFS "u, %p)", pArray, ulIndex, szText)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetC(%p, %" HB_PFS "u, %p)", pArray, nIndex, szText)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutC( pArray->item.asArray.value->pItems + ulIndex - 1, szText ); + hb_itemPutC( pArray->item.asArray.value->pItems + nIndex - 1, szText ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetCL( PHB_ITEM pArray, HB_SIZE ulIndex, const char * szText, HB_SIZE ulLen ) +HB_BOOL hb_arraySetCL( PHB_ITEM pArray, HB_SIZE nIndex, const char * szText, HB_SIZE ulLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetC(%p, %" HB_PFS "u, %p, %" HB_PFS "u)", pArray, ulIndex, szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetC(%p, %" HB_PFS "u, %p, %" HB_PFS "u)", pArray, nIndex, szText, ulLen)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutCL( pArray->item.asArray.value->pItems + ulIndex - 1, szText, ulLen ); + hb_itemPutCL( pArray->item.asArray.value->pItems + nIndex - 1, szText, ulLen ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetCLPtr( PHB_ITEM pArray, HB_SIZE ulIndex, char * szText, HB_SIZE ulLen ) +HB_BOOL hb_arraySetCLPtr( PHB_ITEM pArray, HB_SIZE nIndex, char * szText, HB_SIZE ulLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetCLPtr(%p, %" HB_PFS "u, %p, %" HB_PFS "u)", pArray, ulIndex, szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetCLPtr(%p, %" HB_PFS "u, %p, %" HB_PFS "u)", pArray, nIndex, szText, ulLen)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutCLPtr( pArray->item.asArray.value->pItems + ulIndex - 1, szText, ulLen ); + hb_itemPutCLPtr( pArray->item.asArray.value->pItems + nIndex - 1, szText, ulLen ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetPtr( PHB_ITEM pArray, HB_SIZE ulIndex, void * pValue ) +HB_BOOL hb_arraySetPtr( PHB_ITEM pArray, HB_SIZE nIndex, void * pValue ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetPtr(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pValue)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetPtr(%p, %" HB_PFS "u, %p)", pArray, nIndex, pValue)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutPtr( pArray->item.asArray.value->pItems + ulIndex - 1, pValue ); + hb_itemPutPtr( pArray->item.asArray.value->pItems + nIndex - 1, pValue ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetPtrGC( PHB_ITEM pArray, HB_SIZE ulIndex, void * pValue ) +HB_BOOL hb_arraySetPtrGC( PHB_ITEM pArray, HB_SIZE nIndex, void * pValue ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetPtrGC(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pValue)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetPtrGC(%p, %" HB_PFS "u, %p)", pArray, nIndex, pValue)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutPtrGC( pArray->item.asArray.value->pItems + ulIndex - 1, pValue ); + hb_itemPutPtrGC( pArray->item.asArray.value->pItems + nIndex - 1, pValue ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetSymbol( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_SYMB pSymbol ) +HB_BOOL hb_arraySetSymbol( PHB_ITEM pArray, HB_SIZE nIndex, PHB_SYMB pSymbol ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetSymbol(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pSymbol)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetSymbol(%p, %" HB_PFS "u, %p)", pArray, nIndex, pSymbol)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutSymbol( pArray->item.asArray.value->pItems + ulIndex - 1, pSymbol ); + hb_itemPutSymbol( pArray->item.asArray.value->pItems + nIndex - 1, pSymbol ); return HB_TRUE; } else @@ -936,9 +936,9 @@ HB_BOOL hb_arrayLast( PHB_ITEM pArray, PHB_ITEM pResult ) if( HB_IS_ARRAY( pArray ) ) { - if( pArray->item.asArray.value->ulLen > 0 ) + if( pArray->item.asArray.value->nLen > 0 ) hb_itemCopy( pResult, pArray->item.asArray.value->pItems + - ( pArray->item.asArray.value->ulLen - 1 ) ); + ( pArray->item.asArray.value->nLen - 1 ) ); else hb_itemSetNil( pResult ); @@ -950,27 +950,27 @@ HB_BOOL hb_arrayLast( PHB_ITEM pArray, PHB_ITEM pResult ) return HB_FALSE; } -HB_BOOL hb_arrayFill( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pulStart, HB_SIZE * pulCount ) +HB_BOOL hb_arrayFill( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB_SIZE * pnCount ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayFill(%p, %p, %p, %p)", pArray, pValue, pulStart, pulCount)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayFill(%p, %p, %p, %p)", pArray, pValue, pnStart, pnCount)); if( HB_IS_ARRAY( pArray ) ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - HB_SIZE ulLen = pBaseArray->ulLen; + HB_SIZE ulLen = pBaseArray->nLen; HB_SIZE ulStart; HB_SIZE ulCount; - if( pulStart && *pulStart ) - ulStart = *pulStart - 1; + if( pnStart && *pnStart ) + ulStart = *pnStart - 1; else ulStart = 0; if( ulStart < ulLen ) { ulCount = ulLen - ulStart; - if( pulCount && *pulCount < ulCount ) - ulCount = *pulCount; + if( pnCount && *pnCount < ulCount ) + ulCount = *pnCount; if( ulCount > 0 ) { @@ -988,27 +988,27 @@ HB_BOOL hb_arrayFill( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pulStart, HB_S return HB_FALSE; } -HB_SIZE hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pulStart, HB_SIZE * pulCount, HB_BOOL fExact ) +HB_SIZE hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB_SIZE * pnCount, HB_BOOL fExact ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayScan(%p, %p, %p, %p, %d)", pArray, pValue, pulStart, pulCount, (int) fExact)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayScan(%p, %p, %p, %p, %d)", pArray, pValue, pnStart, pnCount, (int) fExact)); if( HB_IS_ARRAY( pArray ) ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - HB_SIZE ulLen = pBaseArray->ulLen; + HB_SIZE ulLen = pBaseArray->nLen; HB_SIZE ulStart; HB_SIZE ulCount; - if( pulStart && *pulStart ) - ulStart = *pulStart - 1; + if( pnStart && *pnStart ) + ulStart = *pnStart - 1; else ulStart = 0; if( ulStart < ulLen ) { ulCount = ulLen - ulStart; - if( pulCount && *pulCount < ulCount ) - ulCount = *pulCount; + if( pnCount && *pnCount < ulCount ) + ulCount = *pnCount; if( ulCount > 0 ) { @@ -1029,7 +1029,7 @@ HB_SIZE hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pulStart, HB_S if( HB_IS_LOGICAL( hb_stackReturnItem() ) && hb_stackReturnItem()->item.asLogical.value ) return ulStart; } - while( --ulCount > 0 && ulStart < pBaseArray->ulLen ); + while( --ulCount > 0 && ulStart < pBaseArray->nLen ); } else if( HB_IS_STRING( pValue ) ) { @@ -1152,27 +1152,27 @@ HB_SIZE hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pulStart, HB_S return 0; } -HB_SIZE hb_arrayRevScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pulStart, HB_SIZE * pulCount, HB_BOOL fExact ) +HB_SIZE hb_arrayRevScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pnStart, HB_SIZE * pnCount, HB_BOOL fExact ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayRevScan(%p, %p, %p, %p, %d)", pArray, pValue, pulStart, pulCount, (int) fExact)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayRevScan(%p, %p, %p, %p, %d)", pArray, pValue, pnStart, pnCount, (int) fExact)); if( HB_IS_ARRAY( pArray ) ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - HB_SIZE ulLen = pBaseArray->ulLen; + HB_SIZE ulLen = pBaseArray->nLen; HB_SIZE ulStart; HB_SIZE ulCount; - if( pulStart && *pulStart ) - ulStart = *pulStart - 1; + if( pnStart && *pnStart ) + ulStart = *pnStart - 1; else ulStart = ulLen - 1; if( ulStart < ulLen ) { ulCount = ulStart + 1; - if( pulCount && *pulCount < ulCount ) - ulCount = *pulCount; + if( pnCount && *pnCount < ulCount ) + ulCount = *pnCount; if( ulCount > 0 ) { @@ -1186,7 +1186,7 @@ HB_SIZE hb_arrayRevScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pulStart, H { hb_vmPushEvalSym(); hb_vmPush( pValue ); - if( ulStart < pBaseArray->ulLen ) + if( ulStart < pBaseArray->nLen ) hb_vmPush( pBaseArray->pItems + ulStart ); else hb_vmPushNil(); @@ -1319,27 +1319,27 @@ HB_SIZE hb_arrayRevScan( PHB_ITEM pArray, PHB_ITEM pValue, HB_SIZE * pulStart, H return 0; } -HB_BOOL hb_arrayEval( PHB_ITEM pArray, PHB_ITEM bBlock, HB_SIZE * pulStart, HB_SIZE * pulCount ) +HB_BOOL hb_arrayEval( PHB_ITEM pArray, PHB_ITEM bBlock, HB_SIZE * pnStart, HB_SIZE * pnCount ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayEval(%p, %p, %p, %p)", pArray, bBlock, pulStart, pulCount)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayEval(%p, %p, %p, %p)", pArray, bBlock, pnStart, pnCount)); if( HB_IS_ARRAY( pArray ) && HB_IS_BLOCK( bBlock ) ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - HB_SIZE ulLen = pBaseArray->ulLen; + HB_SIZE ulLen = pBaseArray->nLen; HB_SIZE ulStart; HB_SIZE ulCount; - if( pulStart && *pulStart ) - ulStart = *pulStart - 1; + if( pnStart && *pnStart ) + ulStart = *pnStart - 1; else ulStart = 0; if( ulStart < ulLen ) { ulCount = ulLen - ulStart; - if( pulCount && *pulCount < ulCount ) - ulCount = *pulCount; + if( pnCount && *pnCount < ulCount ) + ulCount = *pnCount; if( ulCount > 0 ) { @@ -1351,9 +1351,9 @@ HB_BOOL hb_arrayEval( PHB_ITEM pArray, PHB_ITEM bBlock, HB_SIZE * pulStart, HB_S hb_vmPushSize( ulStart + 1 ); hb_vmEval( 2 ); } - while( --ulCount > 0 && ++ulStart < pBaseArray->ulLen ); + while( --ulCount > 0 && ++ulStart < pBaseArray->nLen ); /* - * checking for ulStart < pBaseArray->ulLen is fix for + * checking for ulStart < pBaseArray->nLen is fix for * possible GPF when codeblock decrease array size */ } @@ -1368,23 +1368,23 @@ HB_BOOL hb_arrayEval( PHB_ITEM pArray, PHB_ITEM bBlock, HB_SIZE * pulStart, HB_S /* NOTE: CA-Cl*pper 5.3a has a fix for the case when the starting position is greater than the length of the array. [vszakats] */ -HB_BOOL hb_arrayCopy( PHB_ITEM pSrcArray, PHB_ITEM pDstArray, HB_SIZE * pulStart, - HB_SIZE * pulCount, HB_SIZE * pulTarget ) +HB_BOOL hb_arrayCopy( PHB_ITEM pSrcArray, PHB_ITEM pDstArray, HB_SIZE * pnStart, + HB_SIZE * pnCount, HB_SIZE * pulTarget ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayCopy(%p, %p, %p, %p, %p)", pSrcArray, pDstArray, pulStart, pulCount, pulTarget)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayCopy(%p, %p, %p, %p, %p)", pSrcArray, pDstArray, pnStart, pnCount, pulTarget)); if( HB_IS_ARRAY( pSrcArray ) && HB_IS_ARRAY( pDstArray ) ) { PHB_BASEARRAY pSrcBaseArray = pSrcArray->item.asArray.value; PHB_BASEARRAY pDstBaseArray = pDstArray->item.asArray.value; - HB_SIZE ulSrcLen = pSrcBaseArray->ulLen; - HB_SIZE ulDstLen = pDstBaseArray->ulLen; + HB_SIZE ulSrcLen = pSrcBaseArray->nLen; + HB_SIZE ulDstLen = pDstBaseArray->nLen; HB_SIZE ulStart; HB_SIZE ulCount; HB_SIZE ulTarget; - if( pulStart && ( *pulStart >= 1 ) ) - ulStart = *pulStart; + if( pnStart && ( *pnStart >= 1 ) ) + ulStart = *pnStart; else ulStart = 1; @@ -1403,8 +1403,8 @@ HB_BOOL hb_arrayCopy( PHB_ITEM pSrcArray, PHB_ITEM pDstArray, HB_SIZE * pulStart if( ulStart > ulSrcLen ) ulStart = ulSrcLen; #endif - if( pulCount && ( *pulCount <= ulSrcLen - ulStart ) ) - ulCount = *pulCount; + if( pnCount && ( *pnCount <= ulSrcLen - ulStart ) ) + ulCount = *pnCount; else ulCount = ulSrcLen - ulStart + 1; @@ -1445,7 +1445,7 @@ static void hb_arrayCloneBody( PHB_BASEARRAY pSrcBaseArray, PHB_BASEARRAY pDstBa pDstBaseArray->uiClass = pSrcBaseArray->uiClass; - for( ulLen = pSrcBaseArray->ulLen; ulLen; --ulLen, ++pSrcItem, ++pDstItem ) + for( ulLen = pSrcBaseArray->nLen; ulLen; --ulLen, ++pSrcItem, ++pDstItem ) hb_cloneNested( pDstItem, pSrcItem, pClonedList ); } @@ -1469,7 +1469,7 @@ void hb_cloneNested( PHB_ITEM pDstItem, PHB_ITEM pSrcItem, PHB_NESTED_CLONED pCl hb_itemCopy( pDstItem, pCloned->pDest ); else { - hb_arrayNew( pDstItem, pBaseArray->ulLen ); + hb_arrayNew( pDstItem, pBaseArray->nLen ); pCloned = ( PHB_NESTED_CLONED ) hb_xgrab( sizeof( HB_NESTED_CLONED ) ); pCloned->value = ( void * ) pBaseArray; @@ -1518,7 +1518,7 @@ PHB_ITEM hb_arrayCloneTo( PHB_ITEM pDstArray, PHB_ITEM pSrcArray ) { PHB_NESTED_CLONED pClonedList, pCloned; PHB_BASEARRAY pSrcBaseArray = pSrcArray->item.asArray.value; - HB_SIZE ulSrcLen = pSrcBaseArray->ulLen; + HB_SIZE ulSrcLen = pSrcBaseArray->nLen; hb_arrayNew( pDstArray, ulSrcLen ); pClonedList = ( PHB_NESTED_CLONED ) hb_xgrab( sizeof( HB_NESTED_CLONED ) ); diff --git a/harbour/src/vm/asort.c b/harbour/src/vm/asort.c index 84c7f8135c..47dee964d3 100644 --- a/harbour/src/vm/asort.c +++ b/harbour/src/vm/asort.c @@ -73,7 +73,7 @@ static HB_BOOL hb_itemIsLess( PHB_ITEM pItem1, PHB_ITEM pItem2, PHB_ITEM pBlock, hb_vmPush( pItem2 ); hb_vmSend( 2 ); - if( pBaseArray->ulLen <= ulLast ) + if( pBaseArray->nLen <= ulLast ) return HB_FALSE; else { @@ -172,7 +172,7 @@ static HB_ISIZ hb_arraySortQuickPartition( PHB_BASEARRAY pBaseArray, HB_ISIZ lb, } /* pivot belongs in pBaseArray->pItems[j] */ - if( j > lb && pBaseArray->ulLen > ( HB_SIZE ) j ) + if( j > lb && pBaseArray->nLen > ( HB_SIZE ) j ) hb_itemSwap( pBaseArray->pItems + lb, pBaseArray->pItems + j ); return j; @@ -186,9 +186,9 @@ static void hb_arraySortQuick( PHB_BASEARRAY pBaseArray, HB_ISIZ lb, HB_ISIZ ub, while( lb < ub ) { - if( ( HB_SIZE ) ub >= pBaseArray->ulLen ) + if( ( HB_SIZE ) ub >= pBaseArray->nLen ) { - ub = pBaseArray->ulLen - 1; + ub = pBaseArray->nLen - 1; if( lb >= ub ) break; } @@ -217,7 +217,7 @@ HB_BOOL hb_arraySort( PHB_ITEM pArray, HB_SIZE * pulStart, HB_SIZE * pulCount, P if( HB_IS_ARRAY( pArray ) ) { PHB_BASEARRAY pBaseArray = pArray->item.asArray.value; - HB_SIZE ulLen = pBaseArray->ulLen; + HB_SIZE ulLen = pBaseArray->nLen; HB_SIZE ulStart; HB_SIZE ulCount; HB_SIZE ulEnd; diff --git a/harbour/src/vm/classes.c b/harbour/src/vm/classes.c index e0480ee03a..3dde9f2f97 100644 --- a/harbour/src/vm/classes.c +++ b/harbour/src/vm/classes.c @@ -1698,7 +1698,7 @@ PHB_SYMB hb_objGetMethod( PHB_ITEM pObject, PHB_SYMB pMessage, pStack->uiClass = pObject->item.asArray.value->uiClass; if( pObject->item.asArray.value->uiPrevCls ) { - if( pObject->item.asArray.value->ulLen ) + if( pObject->item.asArray.value->nLen ) { /* * Copy real object - do not move! the same super casted diff --git a/harbour/src/vm/hvm.c b/harbour/src/vm/hvm.c index c31aad4e71..49bd4d4ebd 100644 --- a/harbour/src/vm/hvm.c +++ b/harbour/src/vm/hvm.c @@ -4636,8 +4636,8 @@ static void hb_vmEnumStart( int nVars, int nDescend ) { /* the index into an array */ pEnum->item.asEnum.offset = ( nDescend > 0 ) ? 1 : - pBase->item.asArray.value->ulLen; - if( pBase->item.asArray.value->ulLen == 0 ) + pBase->item.asArray.value->nLen; + if( pBase->item.asArray.value->nLen == 0 ) fStart = HB_FALSE; } else if( HB_IS_HASH( pBase ) ) @@ -4717,7 +4717,7 @@ static void hb_vmEnumNext( void ) pEnum->item.asEnum.valuePtr = NULL; } if( ( HB_SIZE ) ++pEnum->item.asEnum.offset > - pBase->item.asArray.value->ulLen ) + pBase->item.asArray.value->nLen ) break; } } @@ -5095,7 +5095,7 @@ static void hb_vmArrayPush( void ) return; } - if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->ulLen ) ) + if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->nLen ) ) { hb_itemCopy( pIndex, pArray->item.asArray.value->pItems + ulIndex - 1 ); hb_itemMove( pArray, pIndex ); @@ -5187,7 +5187,7 @@ static void hb_vmArrayPushRef( void ) hb_stackPop(); return; } - else if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->ulLen ) ) + else if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->nLen ) ) { /* This function is safe for overwriting passed array, [druzus] */ hb_arrayGetItemRef( pArray, ulIndex, pRefer ); @@ -5286,7 +5286,7 @@ static void hb_vmArrayPop( void ) return; } - if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->ulLen ) ) + if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->nLen ) ) { pValue->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT ); hb_itemMoveRef( pArray->item.asArray.value->pItems + ulIndex - 1, pValue ); @@ -5605,7 +5605,7 @@ static void hb_vmPushAParams( void ) pArray = hb_stackItemFromTop( -1 ); if( HB_IS_ARRAY( pArray ) ) { - HB_SIZE ulLen = pArray->item.asArray.value->ulLen, ul; + HB_SIZE ulLen = pArray->item.asArray.value->nLen, ul; if( ulLen ) { @@ -10979,7 +10979,7 @@ static void hb_vmArrayItemPush( HB_SIZE ulIndex ) return; } - if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->ulLen ) ) + if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->nLen ) ) { PHB_ITEM pItem = hb_stackAllocItem(); @@ -11061,7 +11061,7 @@ static void hb_vmArrayItemPop( HB_SIZE ulIndex ) return; } - if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->ulLen ) ) + if( HB_IS_VALID_INDEX( ulIndex, pArray->item.asArray.value->nLen ) ) { pValue->type &= ~( HB_IT_MEMOFLAG | HB_IT_DEFAULT ); hb_itemMoveRef( pArray->item.asArray.value->pItems + ulIndex - 1, pValue ); diff --git a/harbour/src/vm/itemapi.c b/harbour/src/vm/itemapi.c index bddc5b83b2..a3562995be 100644 --- a/harbour/src/vm/itemapi.c +++ b/harbour/src/vm/itemapi.c @@ -172,59 +172,59 @@ HB_BOOL hb_itemRelease( PHB_ITEM pItem ) return HB_FALSE; } -PHB_ITEM hb_itemArrayNew( HB_SIZE ulLen ) +PHB_ITEM hb_itemArrayNew( HB_SIZE nLen ) { PHB_ITEM pItem; - HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayNew(%" HB_PFS "u)", ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayNew(%" HB_PFS "u)", nLen)); pItem = hb_itemNew( NULL ); - hb_arrayNew( pItem, ulLen ); + hb_arrayNew( pItem, nLen ); return pItem; } -PHB_ITEM hb_itemArrayGet( PHB_ITEM pArray, HB_SIZE ulIndex ) +PHB_ITEM hb_itemArrayGet( PHB_ITEM pArray, HB_SIZE nIndex ) { PHB_ITEM pItem; - HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayGet(%p, %" HB_PFS "u)", pArray, ulIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayGet(%p, %" HB_PFS "u)", pArray, nIndex)); pItem = hb_itemNew( NULL ); if( pArray ) - hb_arrayGet( pArray, ulIndex, pItem ); + hb_arrayGet( pArray, nIndex, pItem ); return pItem; } -PHB_ITEM hb_itemArrayPut( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem ) +PHB_ITEM hb_itemArrayPut( PHB_ITEM pArray, HB_SIZE nIndex, PHB_ITEM pItem ) { - HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayPut(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pItem)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayPut(%p, %" HB_PFS "u, %p)", pArray, nIndex, pItem)); if( pArray ) - hb_arraySet( pArray, ulIndex, pItem ); + hb_arraySet( pArray, nIndex, pItem ); return pArray; } PHB_ITEM hb_itemPutC( PHB_ITEM pItem, const char * szText ) { - HB_SIZE ulLen, ulAlloc; + HB_SIZE nLen, nAlloc; HB_TRACE(HB_TR_DEBUG, ("hb_itemPutC(%p, %s)", pItem, szText)); - ulLen = szText ? strlen( szText ) : 0; - if( ulLen > 1 ) + nLen = szText ? strlen( szText ) : 0; + if( nLen > 1 ) { - ulAlloc = ulLen + 1; - szText = ( char * ) hb_xmemcpy( hb_xgrab( ulAlloc ), szText, ulAlloc ); + nAlloc = nLen + 1; + szText = ( char * ) hb_xmemcpy( hb_xgrab( nAlloc ), szText, nAlloc ); } else { - ulAlloc = 0; - szText = ( char * ) ( ulLen ? hb_szAscii[ ( unsigned char ) ( szText[ 0 ] ) ] : "" ); + nAlloc = 0; + szText = ( char * ) ( nLen ? hb_szAscii[ ( unsigned char ) ( szText[ 0 ] ) ] : "" ); } if( pItem ) @@ -237,28 +237,28 @@ PHB_ITEM hb_itemPutC( PHB_ITEM pItem, const char * szText ) pItem->type = HB_IT_STRING; pItem->item.asString.value = ( char * ) szText; - pItem->item.asString.length = ulLen; - pItem->item.asString.allocated = ulAlloc; + pItem->item.asString.length = nLen; + pItem->item.asString.allocated = nAlloc; return pItem; } -PHB_ITEM hb_itemPutCL( PHB_ITEM pItem, const char * szText, HB_SIZE ulLen ) +PHB_ITEM hb_itemPutCL( PHB_ITEM pItem, const char * szText, HB_SIZE nLen ) { - HB_SIZE ulAlloc; + HB_SIZE nAlloc; - HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCL(%p, %.*s, %" HB_PFS "u)", pItem, ( int ) ulLen, szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCL(%p, %.*s, %" HB_PFS "u)", pItem, ( int ) nLen, szText, nLen)); - if( ulLen > 1 ) + if( nLen > 1 ) { - ulAlloc = ulLen + 1; - szText = ( char * ) hb_xmemcpy( hb_xgrab( ulAlloc ), szText, ulLen ); - ( ( char * ) szText )[ ulLen ] = '\0'; + nAlloc = nLen + 1; + szText = ( char * ) hb_xmemcpy( hb_xgrab( nAlloc ), szText, nLen ); + ( ( char * ) szText )[ nLen ] = '\0'; } else { - ulAlloc = 0; - szText = ( ulLen ? hb_szAscii[ ( unsigned char ) ( szText[ 0 ] ) ] : "" ); + nAlloc = 0; + szText = ( nLen ? hb_szAscii[ ( unsigned char ) ( szText[ 0 ] ) ] : "" ); } if( pItem ) @@ -269,14 +269,14 @@ PHB_ITEM hb_itemPutCL( PHB_ITEM pItem, const char * szText, HB_SIZE ulLen ) else pItem = hb_itemNew( NULL ); - /* NOTE: CA-Cl*pper seems to be buggy here, it will return ulLen bytes of + /* NOTE: CA-Cl*pper seems to be buggy here, it will return nLen bytes of trash if the szText buffer is NULL, at least with hb_retclen(). [vszakats] */ pItem->type = HB_IT_STRING; pItem->item.asString.value = ( char * ) szText; - pItem->item.asString.length = ulLen; - pItem->item.asString.allocated = ulAlloc; + pItem->item.asString.length = nLen; + pItem->item.asString.allocated = nAlloc; return pItem; } @@ -310,9 +310,9 @@ PHB_ITEM hb_itemPutCConst( PHB_ITEM pItem, const char * szText ) return pItem; } -PHB_ITEM hb_itemPutCLConst( PHB_ITEM pItem, const char * szText, HB_SIZE ulLen ) +PHB_ITEM hb_itemPutCLConst( PHB_ITEM pItem, const char * szText, HB_SIZE nLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCLConst(%p, %.*s, %" HB_PFS "u)", pItem, ( int ) ulLen, szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCLConst(%p, %.*s, %" HB_PFS "u)", pItem, ( int ) nLen, szText, nLen)); if( pItem ) { @@ -323,12 +323,12 @@ PHB_ITEM hb_itemPutCLConst( PHB_ITEM pItem, const char * szText, HB_SIZE ulLen ) pItem = hb_itemNew( NULL ); pItem->type = HB_IT_STRING; - pItem->item.asString.length = ulLen; + pItem->item.asString.length = nLen; pItem->item.asString.allocated = 0; - if( ulLen == 0 ) + if( nLen == 0 ) pItem->item.asString.value = ( char * ) ""; - else if( szText[ ulLen ] == '\0' ) + else if( szText[ nLen ] == '\0' ) pItem->item.asString.value = ( char * ) szText; else hb_errInternal( 6003, "Internal error: hb_itemPutCLConst() missing termination character", NULL, NULL ); @@ -338,7 +338,7 @@ PHB_ITEM hb_itemPutCLConst( PHB_ITEM pItem, const char * szText, HB_SIZE ulLen ) PHB_ITEM hb_itemPutCPtr( PHB_ITEM pItem, char * szText ) { - HB_SIZE ulLen; + HB_SIZE nLen; HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCPtr(%p, %s)", pItem, szText)); @@ -350,18 +350,18 @@ PHB_ITEM hb_itemPutCPtr( PHB_ITEM pItem, char * szText ) else pItem = hb_itemNew( NULL ); - ulLen = szText ? strlen( szText ) : 0; + nLen = szText ? strlen( szText ) : 0; pItem->type = HB_IT_STRING; - pItem->item.asString.length = ulLen; - if( ulLen == 0 ) + pItem->item.asString.length = nLen; + if( nLen == 0 ) { pItem->item.asString.allocated = 0; pItem->item.asString.value = ( char * ) ""; if( szText ) hb_xfree( szText ); } - else if( ulLen == 1 ) + else if( nLen == 1 ) { pItem->item.asString.allocated = 0; pItem->item.asString.value = ( char * ) hb_szAscii[ ( unsigned char ) ( szText[ 0 ] ) ]; @@ -369,17 +369,17 @@ PHB_ITEM hb_itemPutCPtr( PHB_ITEM pItem, char * szText ) } else { - szText[ ulLen ] = '\0'; - pItem->item.asString.allocated = ulLen + 1; + szText[ nLen ] = '\0'; + pItem->item.asString.allocated = nLen + 1; pItem->item.asString.value = szText; } return pItem; } -PHB_ITEM hb_itemPutCLPtr( PHB_ITEM pItem, char * szText, HB_SIZE ulLen ) +PHB_ITEM hb_itemPutCLPtr( PHB_ITEM pItem, char * szText, HB_SIZE nLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCLPtr(%p, %.*s, %" HB_PFS "u)", pItem, ( int ) ulLen, szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCLPtr(%p, %.*s, %" HB_PFS "u)", pItem, ( int ) nLen, szText, nLen)); if( pItem ) { @@ -390,14 +390,14 @@ PHB_ITEM hb_itemPutCLPtr( PHB_ITEM pItem, char * szText, HB_SIZE ulLen ) pItem = hb_itemNew( NULL ); pItem->type = HB_IT_STRING; - pItem->item.asString.length = ulLen; - if( ulLen == 0 ) + pItem->item.asString.length = nLen; + if( nLen == 0 ) { pItem->item.asString.allocated = 0; pItem->item.asString.value = ( char * ) ""; hb_xfree( szText ); } - else if( ulLen == 1 ) + else if( nLen == 1 ) { pItem->item.asString.allocated = 0; pItem->item.asString.value = ( char * ) hb_szAscii[ ( unsigned char ) ( szText[ 0 ] ) ]; @@ -405,8 +405,8 @@ PHB_ITEM hb_itemPutCLPtr( PHB_ITEM pItem, char * szText, HB_SIZE ulLen ) } else { - szText[ ulLen ] = '\0'; - pItem->item.asString.allocated = ulLen + 1; + szText[ nLen ] = '\0'; + pItem->item.asString.allocated = nLen + 1; pItem->item.asString.value = szText; } @@ -460,18 +460,18 @@ HB_SIZE hb_itemGetCLen( PHB_ITEM pItem ) return 0; } -HB_SIZE hb_itemCopyC( PHB_ITEM pItem, char * szBuffer, HB_SIZE ulLen ) +HB_SIZE hb_itemCopyC( PHB_ITEM pItem, char * szBuffer, HB_SIZE nLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyC(%p, %s, %" HB_PFS "u)", pItem, szBuffer, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyC(%p, %s, %" HB_PFS "u)", pItem, szBuffer, nLen)); if( pItem && HB_IS_STRING( pItem ) ) { - if( ulLen == 0 || ulLen > pItem->item.asString.length ) - ulLen = pItem->item.asString.length; + if( nLen == 0 || nLen > pItem->item.asString.length ) + nLen = pItem->item.asString.length; - hb_xmemcpy( szBuffer, pItem->item.asString.value, ulLen ); + hb_xmemcpy( szBuffer, pItem->item.asString.value, nLen ); - return ulLen; + return nLen; } else return 0; @@ -1851,7 +1851,7 @@ PHB_ITEM hb_itemUnRefOnce( PHB_ITEM pItem ) { /* a reference to a static variable or array item */ if( ( HB_SIZE ) pItem->item.asRefer.value < - pItem->item.asRefer.BasePtr.array->ulLen ) + pItem->item.asRefer.BasePtr.array->nLen ) { pItem = pItem->item.asRefer.BasePtr.array->pItems + pItem->item.asRefer.value; @@ -1868,7 +1868,7 @@ PHB_ITEM hb_itemUnRefOnce( PHB_ITEM pItem ) /* check it again - user error handler can resize the array */ if( ( HB_SIZE ) pItem->item.asRefer.value < - pItem->item.asRefer.BasePtr.array->ulLen ) + pItem->item.asRefer.BasePtr.array->nLen ) { pItem = pItem->item.asRefer.BasePtr.array->pItems + pItem->item.asRefer.value; @@ -1981,30 +1981,30 @@ PHB_ITEM hb_itemUnRefRefer( PHB_ITEM pItem ) /* Internal API, not standard Clipper */ /* Resize string buffer of given string item */ -PHB_ITEM hb_itemReSizeString( PHB_ITEM pItem, HB_SIZE ulSize ) +PHB_ITEM hb_itemReSizeString( PHB_ITEM pItem, HB_SIZE nSize ) { - HB_TRACE(HB_TR_DEBUG, ("hb_itemReSizeString(%p,%" HB_PFS "u)", pItem, ulSize)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemReSizeString(%p,%" HB_PFS "u)", pItem, nSize)); if( pItem->item.asString.allocated == 0 ) { - char * szText = ( char * ) hb_xgrab( ulSize + 1 ); + char * szText = ( char * ) hb_xgrab( nSize + 1 ); hb_xmemcpy( szText, pItem->item.asString.value, pItem->item.asString.length ); - szText[ ulSize ] = '\0'; + szText[ nSize ] = '\0'; pItem->item.asString.value = szText; - pItem->item.asString.length = ulSize; - pItem->item.asString.allocated = ulSize + 1; + pItem->item.asString.length = nSize; + pItem->item.asString.allocated = nSize + 1; } else { - HB_SIZE ulAlloc = ulSize + 1 + - ( pItem->item.asString.allocated <= ulSize ? ulSize : 0 ); + HB_SIZE nAlloc = nSize + 1 + + ( pItem->item.asString.allocated <= nSize ? nSize : 0 ); pItem->item.asString.value = ( char* ) hb_xRefResize( pItem->item.asString.value, pItem->item.asString.length, - ulAlloc, &pItem->item.asString.allocated ); - pItem->item.asString.length = ulSize; - pItem->item.asString.value[ ulSize ] = '\0'; + nAlloc, &pItem->item.asString.allocated ); + pItem->item.asString.length = nSize; + pItem->item.asString.value[ nSize ] = '\0'; } pItem->type &= ~HB_IT_DEFAULT; @@ -2021,9 +2021,9 @@ PHB_ITEM hb_itemUnShareString( PHB_ITEM pItem ) if( pItem->item.asString.allocated == 0 || hb_xRefCount( pItem->item.asString.value ) > 1 ) { - HB_SIZE ulLen = pItem->item.asString.length + 1; - char * szText = ( char * ) hb_xmemcpy( hb_xgrab( ulLen ), - pItem->item.asString.value, ulLen ); + HB_SIZE nLen = pItem->item.asString.length + 1; + char * szText = ( char * ) hb_xmemcpy( hb_xgrab( nLen ), + pItem->item.asString.value, nLen ); if( pItem->item.asString.allocated ) { /* GCLOCK enter */ @@ -2031,7 +2031,7 @@ PHB_ITEM hb_itemUnShareString( PHB_ITEM pItem ) /* GCLOCK leave */ } pItem->item.asString.value = szText; - pItem->item.asString.allocated = ulLen; + pItem->item.asString.allocated = nLen; } pItem->type &= ~HB_IT_DEFAULT; @@ -2051,9 +2051,9 @@ PHB_ITEM hb_itemUnShare( PHB_ITEM pItem ) return pItem; } -HB_BOOL hb_itemGetWriteCL( PHB_ITEM pItem, char ** pszValue, HB_SIZE * pulLen ) +HB_BOOL hb_itemGetWriteCL( PHB_ITEM pItem, char ** pszValue, HB_SIZE * pnLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_itemGetWriteCL(%p,%p,%p)", pItem, pszValue, pulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemGetWriteCL(%p,%p,%p)", pItem, pszValue, pnLen)); if( pItem ) { @@ -2063,7 +2063,7 @@ HB_BOOL hb_itemGetWriteCL( PHB_ITEM pItem, char ** pszValue, HB_SIZE * pulLen ) if( HB_IS_STRING( pItem ) ) { hb_itemUnShareString( pItem ); - *pulLen = pItem->item.asString.length; + *pnLen = pItem->item.asString.length; *pszValue = pItem->item.asString.value; return HB_TRUE; } @@ -2110,37 +2110,37 @@ int hb_itemStrCmp( PHB_ITEM pFirst, PHB_ITEM pSecond, HB_BOOL bForceExact ) HB_STACK_TLS_PRELOAD const char * szFirst; const char * szSecond; - HB_SIZE ulLenFirst; - HB_SIZE ulLenSecond; - HB_SIZE ulMinLen; + HB_SIZE nLenFirst; + HB_SIZE nLenSecond; + HB_SIZE nMinLen; int iRet = 0; /* Current status */ HB_TRACE(HB_TR_DEBUG, ("hb_itemStrCmp(%p, %p, %d)", pFirst, pSecond, ( int ) bForceExact)); szFirst = pFirst->item.asString.value; szSecond = pSecond->item.asString.value; - ulLenFirst = pFirst->item.asString.length; - ulLenSecond = pSecond->item.asString.length; + nLenFirst = pFirst->item.asString.length; + nLenSecond = pSecond->item.asString.length; if( !bForceExact && hb_stackSetStruct()->HB_SET_EXACT ) { /* SET EXACT ON and not using == */ /* Don't include trailing spaces */ - while( ulLenFirst > ulLenSecond && szFirst[ ulLenFirst - 1 ] == ' ' ) - ulLenFirst--; - while( ulLenSecond > ulLenFirst && szSecond[ ulLenSecond - 1 ] == ' ' ) - ulLenSecond--; + while( nLenFirst > nLenSecond && szFirst[ nLenFirst - 1 ] == ' ' ) + nLenFirst--; + while( nLenSecond > nLenFirst && szSecond[ nLenSecond - 1 ] == ' ' ) + nLenSecond--; bForceExact = HB_TRUE; } - ulMinLen = ulLenFirst < ulLenSecond ? ulLenFirst : ulLenSecond; + nMinLen = nLenFirst < nLenSecond ? nLenFirst : nLenSecond; /* Both strings not empty */ - if( ulMinLen ) + if( nMinLen ) { PHB_CODEPAGE cdp = hb_vmCDP(); if( cdp && cdp->sort ) - iRet = hb_cdpcmp( szFirst, ulLenFirst, szSecond, ulLenSecond, + iRet = hb_cdpcmp( szFirst, nLenFirst, szSecond, nLenSecond, cdp, bForceExact ); else { @@ -2154,26 +2154,26 @@ int hb_itemStrCmp( PHB_ITEM pFirst, PHB_ITEM pSecond, HB_BOOL bForceExact ) szFirst++; szSecond++; } - while( --ulMinLen ); + while( --nMinLen ); /* If equal and length is different ! */ - if( !iRet && ulLenFirst != ulLenSecond ) + if( !iRet && nLenFirst != nLenSecond ) { /* Force an exact comparison? */ - if( bForceExact || ulLenSecond > ulLenFirst ) - iRet = ( ulLenFirst < ulLenSecond ) ? -1 : 1; + if( bForceExact || nLenSecond > nLenFirst ) + iRet = ( nLenFirst < nLenSecond ) ? -1 : 1; } } } else { /* Both empty ? */ - if( ulLenFirst != ulLenSecond ) + if( nLenFirst != nLenSecond ) { if( bForceExact ) - iRet = ( ulLenFirst < ulLenSecond ) ? -1 : 1; + iRet = ( nLenFirst < nLenSecond ) ? -1 : 1; else - iRet = ( ulLenSecond == 0 ) ? 0 : -1; + iRet = ( nLenSecond == 0 ) ? 0 : -1; } else /* Both empty => Equal ! */ @@ -2189,37 +2189,37 @@ int hb_itemStrICmp( PHB_ITEM pFirst, PHB_ITEM pSecond, HB_BOOL bForceExact ) HB_STACK_TLS_PRELOAD const char * szFirst; const char * szSecond; - HB_SIZE ulLenFirst; - HB_SIZE ulLenSecond; - HB_SIZE ulMinLen; + HB_SIZE nLenFirst; + HB_SIZE nLenSecond; + HB_SIZE nMinLen; int iRet = 0; /* Current status */ HB_TRACE(HB_TR_DEBUG, ("hb_itemStrICmp(%p, %p, %d)", pFirst, pSecond, ( int ) bForceExact)); szFirst = pFirst->item.asString.value; szSecond = pSecond->item.asString.value; - ulLenFirst = pFirst->item.asString.length; - ulLenSecond = pSecond->item.asString.length; + nLenFirst = pFirst->item.asString.length; + nLenSecond = pSecond->item.asString.length; if( !bForceExact && hb_stackSetStruct()->HB_SET_EXACT ) { /* SET EXACT ON and not using == */ /* Don't include trailing spaces */ - while( ulLenFirst > ulLenSecond && szFirst[ ulLenFirst - 1 ] == ' ' ) - ulLenFirst--; - while( ulLenSecond > ulLenFirst && szSecond[ ulLenSecond - 1 ] == ' ' ) - ulLenSecond--; + while( nLenFirst > nLenSecond && szFirst[ nLenFirst - 1 ] == ' ' ) + nLenFirst--; + while( nLenSecond > nLenFirst && szSecond[ nLenSecond - 1 ] == ' ' ) + nLenSecond--; bForceExact = HB_TRUE; } - ulMinLen = ulLenFirst < ulLenSecond ? ulLenFirst : ulLenSecond; + nMinLen = nLenFirst < nLenSecond ? nLenFirst : nLenSecond; /* Both strings not empty */ - if( ulMinLen ) + if( nMinLen ) { PHB_CODEPAGE cdp = hb_vmCDP(); if( cdp && cdp->sort ) - iRet = hb_cdpicmp( szFirst, ulLenFirst, szSecond, ulLenSecond, + iRet = hb_cdpicmp( szFirst, nLenFirst, szSecond, nLenSecond, cdp, bForceExact ); else { @@ -2235,26 +2235,26 @@ int hb_itemStrICmp( PHB_ITEM pFirst, PHB_ITEM pSecond, HB_BOOL bForceExact ) szFirst++; szSecond++; } - while( --ulMinLen ); + while( --nMinLen ); /* If equal and length is different ! */ - if( !iRet && ulLenFirst != ulLenSecond ) + if( !iRet && nLenFirst != nLenSecond ) { /* Force an exact comparison? */ - if( bForceExact || ulLenSecond > ulLenFirst ) - iRet = ( ulLenFirst < ulLenSecond ) ? -1 : 1; + if( bForceExact || nLenSecond > nLenFirst ) + iRet = ( nLenFirst < nLenSecond ) ? -1 : 1; } } } else { /* Both empty ? */ - if( ulLenFirst != ulLenSecond ) + if( nLenFirst != nLenSecond ) { if( bForceExact ) - iRet = ( ulLenFirst < ulLenSecond ) ? -1 : 1; + iRet = ( nLenFirst < nLenSecond ) ? -1 : 1; else - iRet = ( ulLenSecond == 0 ) ? 0 : -1; + iRet = ( nLenSecond == 0 ) ? 0 : -1; } else /* Both empty => Equal ! */ @@ -2534,18 +2534,18 @@ char * hb_itemStr( PHB_ITEM pNumber, PHB_ITEM pWidth, PHB_ITEM pDec ) As a side effect the caller should never modify the returned buffer since it may point to a constant value. [vszakats] */ -char * hb_itemString( PHB_ITEM pItem, HB_SIZE * ulLen, HB_BOOL * bFreeReq ) +char * hb_itemString( PHB_ITEM pItem, HB_SIZE * nLen, HB_BOOL * bFreeReq ) { char * buffer; - HB_TRACE(HB_TR_DEBUG, ("hb_itemString(%p, %p, %p)", pItem, ulLen, bFreeReq)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemString(%p, %p, %p)", pItem, nLen, bFreeReq)); switch( HB_ITEM_TYPE( pItem ) ) { case HB_IT_STRING: case HB_IT_MEMO: buffer = ( char * ) hb_itemGetCPtr( pItem ); - * ulLen = hb_itemGetCLen( pItem ); + * nLen = hb_itemGetCLen( pItem ); * bFreeReq = HB_FALSE; break; @@ -2558,7 +2558,7 @@ char * hb_itemString( PHB_ITEM pItem, HB_SIZE * ulLen, HB_BOOL * bFreeReq ) buffer = ( char * ) hb_xgrab( 11 ); hb_dateFormat( szDate, buffer, hb_stackSetStruct()->HB_SET_DATEFORMAT ); - * ulLen = strlen( buffer ); + * nLen = strlen( buffer ); * bFreeReq = HB_TRUE; break; } @@ -2575,7 +2575,7 @@ char * hb_itemString( PHB_ITEM pItem, HB_SIZE * ulLen, HB_BOOL * bFreeReq ) pItem->item.asDateTime.time ); buffer = hb_strdup( szDateTime ); - * ulLen = strlen( buffer ); + * nLen = strlen( buffer ); * bFreeReq = HB_TRUE; break; } @@ -2596,13 +2596,13 @@ char * hb_itemString( PHB_ITEM pItem, HB_SIZE * ulLen, HB_BOOL * bFreeReq ) buffer = hb_itemStr( pItem, NULL, NULL ); if( buffer ) { - * ulLen = strlen( buffer ); + * nLen = strlen( buffer ); * bFreeReq = HB_TRUE; } else { buffer = ( char * ) ""; - * ulLen = 0; + * nLen = 0; * bFreeReq = HB_FALSE; } break; @@ -2610,13 +2610,13 @@ char * hb_itemString( PHB_ITEM pItem, HB_SIZE * ulLen, HB_BOOL * bFreeReq ) case HB_IT_NIL: buffer = ( char * ) "NIL"; - * ulLen = 3; + * nLen = 3; * bFreeReq = HB_FALSE; break; case HB_IT_LOGICAL: buffer = ( char * ) ( hb_itemGetL( pItem ) ? ".T." : ".F." ); - * ulLen = 3; + * nLen = 3; * bFreeReq = HB_FALSE; break; @@ -2625,7 +2625,7 @@ char * hb_itemString( PHB_ITEM pItem, HB_SIZE * ulLen, HB_BOOL * bFreeReq ) int size = ( sizeof( void * ) << 1 ) + 3; /* n bytes for address + 0x + \0 */ HB_PTRDIFF addr = ( HB_PTRDIFF ) hb_itemGetPtr( pItem ); - * ulLen = size - 1; + * nLen = size - 1; * bFreeReq = HB_TRUE; buffer = ( char * ) hb_xgrab( size ); buffer[ 0 ] = '0'; @@ -2642,7 +2642,7 @@ char * hb_itemString( PHB_ITEM pItem, HB_SIZE * ulLen, HB_BOOL * bFreeReq ) } default: buffer = ( char * ) ""; - * ulLen = 0; + * nLen = 0; * bFreeReq = HB_FALSE; } @@ -2653,9 +2653,9 @@ char * hb_itemString( PHB_ITEM pItem, HB_SIZE * ulLen, HB_BOOL * bFreeReq ) being padded. If date, convert to string using hb_dateFormat(). If numeric, convert to unpadded string. Return pointer to string and set string length */ -char * hb_itemPadConv( PHB_ITEM pItem, HB_SIZE * pulSize, HB_BOOL * bFreeReq ) +char * hb_itemPadConv( PHB_ITEM pItem, HB_SIZE * pnSize, HB_BOOL * bFreeReq ) { - HB_TRACE(HB_TR_DEBUG, ("hb_itemPadConv(%p, %p, %p)", pItem, pulSize, bFreeReq)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemPadConv(%p, %p, %p)", pItem, pnSize, bFreeReq)); if( pItem ) { @@ -2665,14 +2665,14 @@ char * hb_itemPadConv( PHB_ITEM pItem, HB_SIZE * pulSize, HB_BOOL * bFreeReq ) case HB_IT_MEMO: case HB_IT_DATE: case HB_IT_TIMESTAMP: - return hb_itemString( pItem, pulSize, bFreeReq ); + return hb_itemString( pItem, pnSize, bFreeReq ); case HB_IT_DOUBLE: case HB_IT_INTEGER: case HB_IT_LONG: { int i; - char * buffer = hb_itemString( pItem, pulSize, bFreeReq ); + char * buffer = hb_itemString( pItem, pnSize, bFreeReq ); /* remove leading spaces if any, a little bit redundant but * I don't want to complicate the API interface more. Druzus @@ -2682,7 +2682,7 @@ char * hb_itemPadConv( PHB_ITEM pItem, HB_SIZE * pulSize, HB_BOOL * bFreeReq ) if( i > 0 ) { int j = 0; - * pulSize -= i; + * pnSize -= i; do { buffer[ j++ ] = buffer[ i ]; @@ -2702,16 +2702,16 @@ PHB_ITEM hb_itemValToStr( PHB_ITEM pItem ) { PHB_ITEM pResult; char * buffer; - HB_SIZE ulLen; + HB_SIZE nLen; HB_BOOL bFreeReq; HB_TRACE(HB_TR_DEBUG, ("hb_itemValToStr(%p)", pItem)); - buffer = hb_itemString( pItem, &ulLen, &bFreeReq ); + buffer = hb_itemString( pItem, &nLen, &bFreeReq ); if( bFreeReq ) - pResult = hb_itemPutCLPtr( NULL, buffer, ulLen ); + pResult = hb_itemPutCLPtr( NULL, buffer, nLen ); else - pResult = hb_itemPutCL( NULL, buffer, ulLen ); + pResult = hb_itemPutCL( NULL, buffer, nLen ); return pResult; } diff --git a/harbour/src/vm/memvars.c b/harbour/src/vm/memvars.c index 7259cbec2b..0138880d9f 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; - HB_SIZE ulCount; + HB_SIZE nCount; int iScope; }; @@ -238,14 +238,14 @@ static void hb_memvarAddPrivate( PHB_DYNS pDynSym, PHB_ITEM pValue ) */ if( pMemvar ) { - HB_SIZE ulCount = pPrivateStack->count; - while( ulCount > pPrivateStack->base ) + HB_SIZE nCount = pPrivateStack->count; + while( nCount > pPrivateStack->base ) { - if( pDynSym == pPrivateStack->stack[ ulCount - 1 ].pDynSym ) + if( pDynSym == pPrivateStack->stack[ nCount - 1 ].pDynSym ) break; - --ulCount; + --nCount; } - if( ulCount <= pPrivateStack->base ) + if( nCount <= pPrivateStack->base ) pMemvar = NULL; } @@ -294,24 +294,24 @@ static void hb_memvarAddPrivate( PHB_DYNS pDynSym, PHB_ITEM pValue ) HB_SIZE hb_memvarGetPrivatesBase( void ) { HB_STACK_TLS_PRELOAD - HB_SIZE ulBase; + HB_SIZE nBase; HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetPrivatesBase()")); - ulBase = hb_stackGetPrivateStack()->base; + nBase = hb_stackGetPrivateStack()->base; hb_stackGetPrivateStack()->base = hb_stackGetPrivateStack()->count; - return ulBase; + return nBase; } /* * This function releases PRIVATE variables created after passed base */ -void hb_memvarSetPrivatesBase( HB_SIZE ulBase ) +void hb_memvarSetPrivatesBase( HB_SIZE nBase ) { HB_STACK_TLS_PRELOAD PHB_PRIVATE_STACK pPrivateStack; - HB_TRACE(HB_TR_DEBUG, ("hb_memvarSetPrivatesBase(%" HB_PFS "u)", ulBase)); + HB_TRACE(HB_TR_DEBUG, ("hb_memvarSetPrivatesBase(%" HB_PFS "u)", nBase)); pPrivateStack = hb_stackGetPrivateStack(); @@ -326,7 +326,7 @@ void hb_memvarSetPrivatesBase( HB_SIZE ulBase ) hb_memvarDetachDynSym( pDynSym, pPrivateStack->stack[ pPrivateStack->count ].pPrevMemvar ); } } - pPrivateStack->base = ulBase; + pPrivateStack->base = nBase; } /* @@ -542,13 +542,13 @@ void hb_memvarNewParameter( PHB_SYMB pSymbol, PHB_ITEM pValue ) hb_memvarCreateFromDynSymbol( pSymbol->pDynSym, VS_PRIVATE, pValue ); } -static HB_DYNS_PTR hb_memvarFindSymbol( const char * szArg, HB_SIZE ulLen ) +static HB_DYNS_PTR hb_memvarFindSymbol( const char * szArg, HB_SIZE nLen ) { HB_DYNS_PTR pDynSym = NULL; - HB_TRACE(HB_TR_DEBUG, ("hb_memvarFindSymbol(%p,%" HB_PFS "u)", szArg, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_memvarFindSymbol(%p,%" HB_PFS "u)", szArg, nLen)); - if( ulLen && szArg && *szArg ) + if( nLen && szArg && *szArg ) { char szUprName[ HB_SYMBOL_NAME_LEN + 1 ]; int iSize = 0; @@ -575,7 +575,7 @@ static HB_DYNS_PTR hb_memvarFindSymbol( const char * szArg, HB_SIZE ulLen ) szUprName[ iSize++ ] = cChar; } } - while( --ulLen && iSize < HB_SYMBOL_NAME_LEN ); + while( --nLen && iSize < HB_SYMBOL_NAME_LEN ); if( iSize ) { @@ -586,14 +586,14 @@ static HB_DYNS_PTR hb_memvarFindSymbol( const char * szArg, HB_SIZE ulLen ) return pDynSym; } -char * hb_memvarGetStrValuePtr( char * szVarName, HB_SIZE * pulLen ) +char * hb_memvarGetStrValuePtr( char * szVarName, HB_SIZE * pnLen ) { HB_DYNS_PTR pDynVar; char * szValue = NULL; - HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetStrValuePtr(%s, %p)", szVarName, pulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetStrValuePtr(%s, %p)", szVarName, pnLen)); - pDynVar = hb_memvarFindSymbol( szVarName, *pulLen ); + pDynVar = hb_memvarFindSymbol( szVarName, *pnLen ); if( pDynVar ) { @@ -612,7 +612,7 @@ char * hb_memvarGetStrValuePtr( char * szVarName, HB_SIZE * pulLen ) if( HB_IS_STRING( pMemvar ) ) { szValue = pMemvar->item.asString.value; - *pulLen = pMemvar->item.asString.length; + *pnLen = pMemvar->item.asString.length; } } } @@ -712,14 +712,14 @@ static void hb_memvarRelease( HB_ITEM_PTR pMemvar ) if( pDynSymbol && hb_dynsymGetMemvar( pDynSymbol ) ) { HB_STACK_TLS_PRELOAD - HB_SIZE ulBase = hb_stackGetPrivateStack()->count; + HB_SIZE nBase = hb_stackGetPrivateStack()->count; /* Find the variable with a requested name that is currently visible * Start from the top of the stack. */ - while( ulBase > 0 ) + while( nBase > 0 ) { - if( pDynSymbol == hb_stackGetPrivateStack()->stack[ --ulBase ].pDynSym ) + if( pDynSymbol == hb_stackGetPrivateStack()->stack[ --nBase ].pDynSym ) { /* reset current value to NIL - the overriden variables will be * visible after exit from current procedure @@ -749,17 +749,17 @@ static void hb_memvarRelease( HB_ITEM_PTR pMemvar ) static void hb_memvarReleaseWithMask( const char *szMask, HB_BOOL bInclude ) { HB_STACK_TLS_PRELOAD - HB_SIZE ulBase, ulCount; + HB_SIZE nBase, nCount; PHB_DYNS pDynVar; PHB_ITEM pMemvar; HB_TRACE(HB_TR_DEBUG, ("hb_memvarReleaseWithMask(%s, %d)", szMask, (int) bInclude)); - ulCount = hb_stackGetPrivateStack()->count; - ulBase = hb_stackBaseItem()->item.asSymbol.stackstate->ulPrivateBase; - while( ulCount-- > ulBase ) + nCount = hb_stackGetPrivateStack()->count; + nBase = hb_stackBaseItem()->item.asSymbol.stackstate->ulPrivateBase; + while( nCount-- > nBase ) { - pDynVar = hb_stackGetPrivateStack()->stack[ ulCount ].pDynSym; + pDynVar = hb_stackGetPrivateStack()->stack[ nCount ].pDynSym; /* reset current value to NIL - the overriden variables will be * visible after exit from current procedure */ @@ -784,13 +784,13 @@ static int hb_memvarScopeGet( PHB_DYNS pDynVar ) else { HB_STACK_TLS_PRELOAD - HB_SIZE ulBase = hb_stackGetPrivateStack()->count; /* start from the top of the stack */ + HB_SIZE nBase = hb_stackGetPrivateStack()->count; /* start from the top of the stack */ - while( ulBase ) + while( nBase ) { - if( pDynVar == hb_stackGetPrivateStack()->stack[ --ulBase ].pDynSym ) + if( pDynVar == hb_stackGetPrivateStack()->stack[ --nBase ].pDynSym ) { - if( ulBase >= hb_stackGetPrivateStack()->base ) + if( nBase >= hb_stackGetPrivateStack()->base ) return HB_MV_PRIVATE_LOCAL; else return HB_MV_PRIVATE_GLOBAL; @@ -802,13 +802,13 @@ static int hb_memvarScopeGet( PHB_DYNS pDynVar ) /* This function checks the scope of passed variable name */ -int hb_memvarScope( const char * szVarName, HB_SIZE ulLength ) +int hb_memvarScope( const char * szVarName, HB_SIZE nLength ) { PHB_DYNS pDynVar; - HB_TRACE(HB_TR_DEBUG, ("hb_memvarScope(%s, %" HB_PFS "u)", szVarName, ulLength)); + HB_TRACE(HB_TR_DEBUG, ("hb_memvarScope(%s, %" HB_PFS "u)", szVarName, nLength)); - pDynVar = hb_memvarFindSymbol( szVarName, ulLength ); + pDynVar = hb_memvarFindSymbol( szVarName, nLength ); if( pDynVar ) return hb_memvarScopeGet( pDynVar ); @@ -987,7 +987,7 @@ static HB_DYNS_FUNC( hb_memvarCountVisible ) if( !pMVInfo->iScope || ( hb_memvarScopeGet( pDynSymbol ) & pMVInfo->iScope ) != 0 ) { - pMVInfo->pDyns[ pMVInfo->ulCount++ ] = pDynSymbol; + pMVInfo->pDyns[ pMVInfo->nCount++ ] = pDynSymbol; } } return HB_TRUE; @@ -1013,17 +1013,17 @@ PHB_ITEM hb_memvarSaveInArray( int iScope, HB_BOOL fCopy ) MVInfo.pDyns = ( PHB_DYNS * ) hb_xgrab( hb_stackDynHandlesCount() * sizeof( PHB_DYNS ) ); #endif - MVInfo.ulCount = 0; + MVInfo.nCount = 0; MVInfo.iScope = iScope; hb_dynsymProtectEval( hb_memvarCountVisible, ( void * ) &MVInfo ); - if( MVInfo.ulCount > 0 ) + if( MVInfo.nCount > 0 ) { - pArray = hb_itemArrayNew( MVInfo.ulCount ); + pArray = hb_itemArrayNew( MVInfo.nCount ); do { - pItem = hb_arrayGetItemPtr( pArray, MVInfo.ulCount ); - pDynSymbol = MVInfo.pDyns[ --MVInfo.ulCount ]; + pItem = hb_arrayGetItemPtr( pArray, MVInfo.nCount ); + pDynSymbol = MVInfo.pDyns[ --MVInfo.nCount ]; pMemvar = hb_dynsymGetMemvar( pDynSymbol ), hb_arrayNew( pItem, 2 ); @@ -1041,7 +1041,7 @@ PHB_ITEM hb_memvarSaveInArray( int iScope, HB_BOOL fCopy ) hb_xRefInc( pMemvar ); } } - while( MVInfo.ulCount ); + while( MVInfo.nCount ); } hb_xfree( MVInfo.pDyns ); @@ -1050,12 +1050,12 @@ PHB_ITEM hb_memvarSaveInArray( int iScope, HB_BOOL fCopy ) void hb_memvarRestoreFromArray( PHB_ITEM pArray ) { - HB_SIZE ulCount, ulPos; + HB_SIZE nCount, nPos; - ulCount = hb_arrayLen( pArray ); - for( ulPos = 1; ulPos <= ulCount; ++ulPos ) + nCount = hb_arrayLen( pArray ); + for( nPos = 1; nPos <= nCount; ++nPos ) { - PHB_ITEM pItem = hb_arrayGetItemPtr( pArray, ulPos ); + PHB_ITEM pItem = hb_arrayGetItemPtr( pArray, nPos ); PHB_DYNS pDynSym = hb_arrayGetSymbol( pItem, 1 )->pDynSym; PHB_ITEM pMemvar = hb_arrayGetItemPtr( pItem, 2 )->item.asMemvar.value; hb_memvarValueIncRef( pMemvar ); @@ -1095,10 +1095,10 @@ HB_FUNC( __MVPUBLIC ) { /* we are accepting an one-dimensional array of strings only */ - HB_SIZE j, ulLen = hb_arrayLen( pMemvar ); + HB_SIZE n, nLen = hb_arrayLen( pMemvar ); - for( j = 1; j <= ulLen; j++ ) - hb_memvarCreateFromItem( hb_arrayGetItemPtr( pMemvar, j ), VS_PUBLIC, NULL ); + for( n = 1; n <= nLen; n++ ) + hb_memvarCreateFromItem( hb_arrayGetItemPtr( pMemvar, n ), VS_PUBLIC, NULL ); } else hb_memvarCreateFromItem( pMemvar, VS_PUBLIC, NULL ); @@ -1127,10 +1127,10 @@ HB_FUNC( __MVPRIVATE ) { /* we are accepting an one-dimensional array of strings only */ - HB_SIZE j, ulLen = hb_arrayLen( pMemvar ); + HB_SIZE n, nLen = hb_arrayLen( pMemvar ); - for( j = 1; j <= ulLen; j++ ) - hb_memvarCreateFromItem( hb_arrayGetItemPtr( pMemvar, j ), VS_PRIVATE, NULL ); + for( n = 1; n <= nLen; n++ ) + hb_memvarCreateFromItem( hb_arrayGetItemPtr( pMemvar, n ), VS_PRIVATE, NULL ); } else hb_memvarCreateFromItem( pMemvar, VS_PRIVATE, NULL ); @@ -1159,10 +1159,10 @@ HB_FUNC( __MVXRELEASE ) { /* we are accepting an one-dimensional array of strings only */ - HB_SIZE j, ulLen = hb_arrayLen( pMemvar ); + HB_SIZE n, nLen = hb_arrayLen( pMemvar ); - for( j = 1; j <= ulLen; j++ ) - hb_memvarRelease( hb_arrayGetItemPtr( pMemvar, j ) ); + for( n = 1; n <= nLen; n++ ) + hb_memvarRelease( hb_arrayGetItemPtr( pMemvar, n ) ); } else hb_memvarRelease( pMemvar ); @@ -1385,19 +1385,19 @@ static HB_DYNS_FUNC( hb_memvarSave ) if( HB_IS_STRING( pMemvar ) ) { /* Store the closing zero byte, too */ - HB_SIZE ulLen = hb_itemGetCLen( pMemvar ) + 1; + HB_SIZE nLen = hb_itemGetCLen( pMemvar ) + 1; int iOverFlow = 0; /* Clipper supports only 64KB strings */ - if( ulLen > USHRT_MAX ) + if( nLen > USHRT_MAX ) { - ulLen = USHRT_MAX; + nLen = USHRT_MAX; iOverFlow = 1; } buffer[ 11 ] = 'C' + 128; - HB_PUT_LE_UINT16( &buffer[ 16 ], ulLen ); + HB_PUT_LE_UINT16( &buffer[ 16 ], nLen ); hb_fsWrite( fhnd, buffer, HB_MEM_REC_LEN ); - hb_fsWriteLarge( fhnd, hb_itemGetCPtr( pMemvar ), ulLen - iOverFlow ); + hb_fsWriteLarge( fhnd, hb_itemGetCPtr( pMemvar ), nLen - iOverFlow ); if( iOverFlow ) hb_fsWrite( fhnd, "\0", 1 ); } diff --git a/harbour/src/vm/runner.c b/harbour/src/vm/runner.c index 8f0300e1b0..86429da5e7 100644 --- a/harbour/src/vm/runner.c +++ b/harbour/src/vm/runner.c @@ -99,39 +99,39 @@ static const char s_szHead[ 4 ] = { '\xC0', 'H', 'R', 'B' }; #define SYM_DEFERRED 3 /* lately bound function */ #define SYM_NOT_FOUND 0xFFFFFFFFUL /* Symbol not found. */ -static HB_SIZE hb_hrbCheckSig( const char * szBody, HB_SIZE ulBodySize ) +static HB_SIZE hb_hrbCheckSig( const char * szBody, HB_SIZE nBodySize ) { - return ( ulBodySize > sizeof( s_szHead ) && + return ( nBodySize > sizeof( s_szHead ) && memcmp( s_szHead, szBody, sizeof( s_szHead ) ) == 0 ) ? sizeof( s_szHead ) : 0; } -static int hb_hrbReadHead( const char * szBody, HB_SIZE ulBodySize, HB_SIZE * pulBodyOffset ) +static int hb_hrbReadHead( const char * szBody, HB_SIZE nBodySize, HB_SIZE * pnBodyOffset ) { const char * pVersion; HB_SIZE nSigSize; - HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadHead(%p,%" HB_PFS "u,%p)", szBody, ulBodySize, pulBodyOffset )); + HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadHead(%p,%" HB_PFS "u,%p)", szBody, nBodySize, pnBodyOffset )); - nSigSize = hb_hrbCheckSig( szBody, ulBodySize ); + nSigSize = hb_hrbCheckSig( szBody, nBodySize ); - if( nSigSize == 0 || ulBodySize - nSigSize < 2 ) + if( nSigSize == 0 || nBodySize - nSigSize < 2 ) return 0; pVersion = szBody + nSigSize; - *pulBodyOffset += nSigSize + 2; + *pnBodyOffset += nSigSize + 2; return HB_PCODE_MKSHORT( pVersion ); } -static HB_BOOL hb_hrbReadValue( const char * szBody, HB_SIZE ulBodySize, HB_SIZE * pulBodyOffset, HB_ULONG * pulValue ) +static HB_BOOL hb_hrbReadValue( const char * szBody, HB_SIZE nBodySize, HB_SIZE * pnBodyOffset, HB_ULONG * pulValue ) { - HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadValue(%p,%" HB_PFS "u,%p,%p)", szBody, ulBodySize, pulBodyOffset, pulValue)); + HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadValue(%p,%" HB_PFS "u,%p,%p)", szBody, nBodySize, pnBodyOffset, pulValue)); - if( *pulBodyOffset + 4 < ulBodySize ) + if( *pnBodyOffset + 4 < nBodySize ) { - *pulValue = HB_PCODE_MKLONG( szBody + *pulBodyOffset ); - *pulBodyOffset += 4; + *pulValue = HB_PCODE_MKLONG( szBody + *pnBodyOffset ); + *pnBodyOffset += 4; if( *pulValue <= 0x00FFFFFFUL ) return HB_TRUE; @@ -142,20 +142,20 @@ static HB_BOOL hb_hrbReadValue( const char * szBody, HB_SIZE ulBodySize, HB_SIZE /* ReadId Read the next (zero terminated) identifier */ -static char * hb_hrbReadId( const char * szBody, HB_SIZE ulBodySize, HB_SIZE * ulBodyOffset ) +static char * hb_hrbReadId( const char * szBody, HB_SIZE nBodySize, HB_SIZE * pnBodyOffset ) { const char * szIdx; - HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadId(%p,%" HB_PFS "u,%p)", szBody, ulBodySize, ulBodyOffset)); + HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadId(%p,%" HB_PFS "u,%p)", szBody, nBodySize, pnBodyOffset)); - szIdx = &szBody[ *ulBodyOffset ]; + szIdx = &szBody[ *pnBodyOffset ]; do { - if( *ulBodyOffset > ulBodySize ) + if( *pnBodyOffset > nBodySize ) return NULL; } - while( szBody[ ( *ulBodyOffset )++ ] ); + while( szBody[ ( *pnBodyOffset )++ ] ); return hb_strdup( szIdx ); } @@ -323,15 +323,15 @@ static void hb_hrbUnLoad( PHRB_BODY pHrbBody ) -static PHRB_BODY hb_hrbLoad( const char * szHrbBody, HB_SIZE ulBodySize, HB_USHORT usMode, const char * szFileName ) +static PHRB_BODY hb_hrbLoad( const char * szHrbBody, HB_SIZE nBodySize, HB_USHORT usMode, const char * szFileName ) { PHRB_BODY pHrbBody = NULL; if( szHrbBody ) { - HB_SIZE ulBodyOffset = 0; - HB_SIZE ulSize; /* Size of function */ - HB_SIZE ulPos; + HB_SIZE nBodyOffset = 0; + HB_SIZE nSize; /* Size of function */ + HB_SIZE nPos; HB_ULONG ul; char * buffer, ch; HB_USHORT usBind = ( usMode & HB_HRB_BIND_MODEMASK ); @@ -340,7 +340,7 @@ static PHRB_BODY hb_hrbLoad( const char * szHrbBody, HB_SIZE ulBodySize, HB_USHO PHB_DYNF pDynFunc; /* Functions read */ PHB_DYNS pDynSym; - int iVersion = hb_hrbReadHead( szHrbBody, ulBodySize, &ulBodyOffset ); + int iVersion = hb_hrbReadHead( szHrbBody, nBodySize, &nBodyOffset ); if( iVersion == 0 ) { @@ -357,7 +357,7 @@ static PHRB_BODY hb_hrbLoad( const char * szHrbBody, HB_SIZE ulBodySize, HB_USHO pHrbBody->pSymRead = NULL; pHrbBody->pDynFunc = NULL; pHrbBody->pModuleSymbols = NULL; - if( ! hb_hrbReadValue( szHrbBody, ulBodySize, &ulBodyOffset, &pHrbBody->ulSymbols ) || + if( ! hb_hrbReadValue( szHrbBody, nBodySize, &nBodyOffset, &pHrbBody->ulSymbols ) || pHrbBody->ulSymbols == 0 ) { hb_hrbUnLoad( pHrbBody ); @@ -366,19 +366,19 @@ static PHRB_BODY hb_hrbLoad( const char * szHrbBody, HB_SIZE ulBodySize, HB_USHO } /* calculate the size of dynamic symbol table */ - ulPos = ulBodyOffset; - ulSize = 0; + nPos = nBodyOffset; + nSize = 0; for( ul = 0; ul < pHrbBody->ulSymbols; ul++ ) /* Read symbols in .hrb */ { - while( ulBodyOffset < ulBodySize ) + while( nBodyOffset < nBodySize ) { - ++ulSize; - if( szHrbBody[ ulBodyOffset++ ] == 0 ) + ++nSize; + if( szHrbBody[ nBodyOffset++ ] == 0 ) break; } - ulBodyOffset += 2; - if( ulBodyOffset >= ulBodySize ) + nBodyOffset += 2; + if( nBodyOffset >= nBodySize ) { hb_hrbUnLoad( pHrbBody ); hb_errRT_BASE( EG_CORRUPTION, 9997, NULL, HB_ERR_FUNCNAME, 0 ); @@ -386,19 +386,19 @@ static PHRB_BODY hb_hrbLoad( const char * szHrbBody, HB_SIZE ulBodySize, HB_USHO } } - ulBodyOffset = ulPos; + nBodyOffset = nPos; ul = pHrbBody->ulSymbols * sizeof( HB_SYMB ); - pSymRead = ( PHB_SYMB ) hb_xgrab( ulSize + ul ); + pSymRead = ( PHB_SYMB ) hb_xgrab( nSize + ul ); buffer = ( ( char * ) pSymRead ) + ul; for( ul = 0; ul < pHrbBody->ulSymbols; ul++ ) /* Read symbols in .hrb */ { pSymRead[ ul ].szName = buffer; do - ch = *buffer++ = szHrbBody[ ulBodyOffset++ ]; + ch = *buffer++ = szHrbBody[ nBodyOffset++ ]; while( ch ); - pSymRead[ ul ].scope.value = ( HB_BYTE ) szHrbBody[ ulBodyOffset++ ]; - pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) ( HB_PTRDIFF ) szHrbBody[ ulBodyOffset++ ]; + pSymRead[ ul ].scope.value = ( HB_BYTE ) szHrbBody[ nBodyOffset++ ]; + pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) ( HB_PTRDIFF ) szHrbBody[ nBodyOffset++ ]; pSymRead[ ul ].pDynSym = NULL; if( pHrbBody->lSymStart == -1 && @@ -410,7 +410,7 @@ static PHRB_BODY hb_hrbLoad( const char * szHrbBody, HB_SIZE ulBodySize, HB_USHO } /* Read number of functions */ - if( ! hb_hrbReadValue( szHrbBody, ulBodySize, &ulBodyOffset, &pHrbBody->ulFuncs ) ) + if( ! hb_hrbReadValue( szHrbBody, nBodySize, &nBodyOffset, &pHrbBody->ulFuncs ) ) { hb_xfree( pSymRead ); hb_hrbUnLoad( pHrbBody ); @@ -431,23 +431,23 @@ static PHRB_BODY hb_hrbLoad( const char * szHrbBody, HB_SIZE ulBodySize, HB_USHO HB_ULONG ulValue; /* Read name of function */ - pDynFunc[ ul ].szName = hb_hrbReadId( szHrbBody, ulBodySize, &ulBodyOffset ); + pDynFunc[ ul ].szName = hb_hrbReadId( szHrbBody, nBodySize, &nBodyOffset ); if( pDynFunc[ ul ].szName == NULL ) break; /* Read size of function */ - if( ! hb_hrbReadValue( szHrbBody, ulBodySize, &ulBodyOffset, &ulValue ) ) + if( ! hb_hrbReadValue( szHrbBody, nBodySize, &nBodyOffset, &ulValue ) ) break; - ulSize = ( HB_SIZE ) ulValue; + nSize = ( HB_SIZE ) ulValue; - if( ulBodyOffset + ulSize > ulBodySize ) + if( nBodyOffset + nSize > nBodySize ) break; /* Copy function body */ - pDynFunc[ ul ].pCode = ( HB_BYTE * ) hb_xgrab( ulSize ); - memcpy( ( char * ) pDynFunc[ ul ].pCode, szHrbBody + ulBodyOffset, ulSize ); - ulBodyOffset += ulSize; + pDynFunc[ ul ].pCode = ( HB_BYTE * ) hb_xgrab( nSize ); + memcpy( ( char * ) pDynFunc[ ul ].pCode, szHrbBody + nBodyOffset, nSize ); + nBodyOffset += nSize; pDynFunc[ ul ].pCodeFunc = ( PHB_PCODEFUNC ) hb_xgrab( sizeof( HB_PCODEFUNC ) ); pDynFunc[ ul ].pCodeFunc->pCode = pDynFunc[ ul ].pCode; @@ -468,15 +468,15 @@ static PHRB_BODY hb_hrbLoad( const char * szHrbBody, HB_SIZE ulBodySize, HB_USHO { if( pSymRead[ ul ].value.pCodeFunc == ( PHB_PCODEFUNC ) SYM_FUNC ) { - ulPos = hb_hrbFindSymbol( pSymRead[ ul ].szName, pHrbBody->pDynFunc, pHrbBody->ulFuncs ); + nPos = hb_hrbFindSymbol( pSymRead[ ul ].szName, pHrbBody->pDynFunc, pHrbBody->ulFuncs ); - if( ulPos == SYM_NOT_FOUND ) + if( nPos == SYM_NOT_FOUND ) { pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) SYM_EXTERN; } else { - pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) pHrbBody->pDynFunc[ ulPos ].pCodeFunc; + pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) pHrbBody->pDynFunc[ nPos ].pCodeFunc; pSymRead[ ul ].scope.value |= HB_FS_PCODEFUNC | HB_FS_LOCAL | ( usBind == HB_HRB_BIND_FORCELOCAL ? HB_FS_STATIC : 0 ); } @@ -613,18 +613,18 @@ static PHRB_BODY hb_hrbLoadFromFile( const char * szHrb, HB_USHORT usMode ) if( hFile != FS_ERROR ) { - HB_SIZE ulBodySize = hb_fsSeek( hFile, 0, FS_END ); + HB_SIZE nBodySize = hb_fsSeek( hFile, 0, FS_END ); - if( ulBodySize ) + if( nBodySize ) { char * pbyBuffer; - pbyBuffer = ( char * ) hb_xgrab( ulBodySize + sizeof( char ) + 1 ); + pbyBuffer = ( char * ) hb_xgrab( nBodySize + sizeof( char ) + 1 ); hb_fsSeek( hFile, 0, FS_SET ); - hb_fsReadLarge( hFile, pbyBuffer, ulBodySize ); - pbyBuffer[ ulBodySize ] = '\0'; + hb_fsReadLarge( hFile, pbyBuffer, nBodySize ); + pbyBuffer[ nBodySize ] = '\0'; - pHrbBody = hb_hrbLoad( ( const char * ) pbyBuffer, ulBodySize, usMode, szFileName ); + pHrbBody = hb_hrbLoad( ( const char * ) pbyBuffer, nBodySize, usMode, szFileName ); hb_xfree( pbyBuffer ); } hb_fsClose( hFile ); @@ -707,7 +707,7 @@ HB_FUNC( HB_HRBRUN ) { HB_USHORT usMode = HB_HRB_BIND_DEFAULT; HB_USHORT nParam = 1; - HB_SIZE ulLen; + HB_SIZE nLen; if( HB_ISNUM( 1 ) ) { @@ -715,15 +715,15 @@ HB_FUNC( HB_HRBRUN ) nParam++; } - ulLen = hb_parclen( nParam ); + nLen = hb_parclen( nParam ); - if( ulLen > 0 ) + if( nLen > 0 ) { const char * fileOrBody = hb_parc( nParam ); PHRB_BODY pHrbBody; - if( hb_hrbCheckSig( fileOrBody, ulLen ) != 0 ) - pHrbBody = hb_hrbLoad( fileOrBody, ulLen, usMode, NULL ); + if( hb_hrbCheckSig( fileOrBody, nLen ) != 0 ) + pHrbBody = hb_hrbLoad( fileOrBody, nLen, usMode, NULL ); else pHrbBody = hb_hrbLoadFromFile( fileOrBody, usMode ); @@ -757,7 +757,7 @@ HB_FUNC( HB_HRBLOAD ) { HB_USHORT usMode = HB_HRB_BIND_DEFAULT; HB_USHORT nParam = 1; - HB_SIZE ulLen; + HB_SIZE nLen; if( HB_ISNUM( 1 ) ) { @@ -765,15 +765,15 @@ HB_FUNC( HB_HRBLOAD ) nParam++; } - ulLen = hb_parclen( nParam ); + nLen = hb_parclen( nParam ); - if( ulLen > 0 ) + if( nLen > 0 ) { const char * fileOrBody = hb_parc( nParam ); PHRB_BODY pHrbBody; - if( hb_hrbCheckSig( fileOrBody, ulLen ) != 0 ) - pHrbBody = hb_hrbLoad( fileOrBody, ulLen, usMode, NULL ); + if( hb_hrbCheckSig( fileOrBody, nLen ) != 0 ) + pHrbBody = hb_hrbLoad( fileOrBody, nLen, usMode, NULL ); else pHrbBody = hb_hrbLoadFromFile( fileOrBody, usMode ); @@ -855,9 +855,9 @@ HB_FUNC( HB_HRBGETFUNSYM ) if( pHrbBody && szName ) { PHB_SYMB pSym; - HB_ULONG ulPos; + HB_ULONG nPos; - for( ulPos = 0, pSym = pHrbBody->pSymRead; ulPos < pHrbBody->ulSymbols; ++pSym, ++ulPos ) + for( nPos = 0, pSym = pHrbBody->pSymRead; nPos < pHrbBody->ulSymbols; ++pSym, ++nPos ) { if( pSym->value.pFunPtr != NULL && hb_stricmp( szName, pSym->szName ) == 0 ) { diff --git a/harbour/src/vm/set.c b/harbour/src/vm/set.c index 27546eb46c..637eb4e893 100644 --- a/harbour/src/vm/set.c +++ b/harbour/src/vm/set.c @@ -98,8 +98,8 @@ static char set_char( PHB_ITEM pItem, char oldChar ) if( HB_IS_STRING( pItem ) ) { /* Only replace if string has at least one character. */ - HB_SIZE ulLen = hb_itemGetCLen( pItem ); - if( ulLen > 0 ) + HB_SIZE nLen = hb_itemGetCLen( pItem ); + if( nLen > 0 ) { newChar = *hb_itemGetCPtr( pItem ); } @@ -124,13 +124,13 @@ static HB_BOOL set_logical( PHB_ITEM pItem, HB_BOOL bDefault ) else if( HB_IS_STRING( pItem ) ) { const char * szString = hb_itemGetCPtr( pItem ); - HB_SIZE ulLen = hb_itemGetCLen( pItem ); + HB_SIZE nLen = hb_itemGetCLen( pItem ); - if( ulLen >= 2 + if( nLen >= 2 && ( ( HB_UCHAR ) szString[ 0 ] == 'O' || ( HB_UCHAR ) szString[ 0 ] == 'o' ) && ( ( HB_UCHAR ) szString[ 1 ] == 'N' || ( HB_UCHAR ) szString[ 1 ] == 'n' ) ) bLogical = HB_TRUE; - else if( ulLen >= 3 + else if( nLen >= 3 && ( ( HB_UCHAR ) szString[ 0 ] == 'O' || ( HB_UCHAR ) szString[ 0 ] == 'o' ) && ( ( HB_UCHAR ) szString[ 1 ] == 'F' || ( HB_UCHAR ) szString[ 1 ] == 'f' ) && ( ( HB_UCHAR ) szString[ 2 ] == 'F' || ( HB_UCHAR ) szString[ 2 ] == 'f' ) ) @@ -2655,7 +2655,7 @@ const char * hb_setGetDBCODEPAGE( void ) return hb_stackSetStruct()->HB_SET_DBCODEPAGE; } -const char * hb_osEncodeCP( const char * szName, char ** pszFree, HB_SIZE * pulSize ) +const char * hb_osEncodeCP( const char * szName, char ** pszFree, HB_SIZE * pnSize ) { HB_STACK_TLS_PRELOAD @@ -2669,22 +2669,22 @@ const char * hb_osEncodeCP( const char * szName, char ** pszFree, HB_SIZE * pulS PHB_CODEPAGE cdpHost = hb_vmCDP(); if( cdpHost && cdpHost != cdpOS ) { - HB_SIZE ulSize = 0; + HB_SIZE nSize = 0; char * pszBuf; if( pszFree == NULL ) { pszFree = ( char ** ) &szName; - ulSize = strlen( szName ); + nSize = strlen( szName ); } pszBuf = *pszFree; - if( pulSize == NULL ) - pulSize = &ulSize; - else if( *pulSize > 0 ) - ulSize = *pulSize - 1; + if( pnSize == NULL ) + pnSize = &nSize; + else if( *pnSize > 0 ) + nSize = *pnSize - 1; szName = hb_cdpnDup3( szName, strlen( szName ), - pszBuf, &ulSize, pszFree, pulSize, + pszBuf, &nSize, pszFree, pnSize, cdpHost, cdpOS ); } } @@ -2693,7 +2693,7 @@ const char * hb_osEncodeCP( const char * szName, char ** pszFree, HB_SIZE * pulS return szName; } -const char * hb_osDecodeCP( const char * szName, char ** pszFree, HB_SIZE * pulSize ) +const char * hb_osDecodeCP( const char * szName, char ** pszFree, HB_SIZE * pnSize ) { HB_STACK_TLS_PRELOAD @@ -2707,22 +2707,22 @@ const char * hb_osDecodeCP( const char * szName, char ** pszFree, HB_SIZE * pulS PHB_CODEPAGE cdpHost = hb_vmCDP(); if( cdpHost && cdpHost != cdpOS ) { - HB_SIZE ulSize = 0; + HB_SIZE nSize = 0; char * pszBuf; if( pszFree == NULL ) { pszFree = ( char ** ) &szName; - ulSize = strlen( szName ); + nSize = strlen( szName ); } pszBuf = *pszFree; - if( pulSize == NULL ) - pulSize = &ulSize; - else if( *pulSize > 0 ) - ulSize = *pulSize - 1; + if( pnSize == NULL ) + pnSize = &nSize; + else if( *pnSize > 0 ) + nSize = *pnSize - 1; szName = hb_cdpnDup3( szName, strlen( szName ), - pszBuf, &ulSize, pszFree, pulSize, + pszBuf, &nSize, pszFree, pnSize, cdpOS, cdpHost ); } } diff --git a/harbour/src/vm/strapi.c b/harbour/src/vm/strapi.c index d7e1fc99c4..19bb344f13 100644 --- a/harbour/src/vm/strapi.c +++ b/harbour/src/vm/strapi.c @@ -60,32 +60,32 @@ static const HB_WCHAR s_szConstStr[ 1 ] = { 0 }; HB_SIZE hb_wstrlen( const HB_WCHAR * szText ) { - HB_SIZE ulLen = 0; + HB_SIZE nLen = 0; HB_TRACE(HB_TR_DEBUG, ("hb_wstrlen(%p)", szText)); if( szText ) { - while( szText[ ulLen ] ) - ++ulLen; + while( szText[ nLen ] ) + ++nLen; } - return ulLen; + return nLen; } -HB_SIZE hb_wstrnlen( const HB_WCHAR * szText, HB_SIZE count ) +HB_SIZE hb_wstrnlen( const HB_WCHAR * szText, HB_SIZE nCount ) { - HB_SIZE ulLen = 0; + HB_SIZE nLen = 0; - HB_TRACE(HB_TR_DEBUG, ("hb_wstrnlen(%p,%" HB_PFS "u)", szText, count)); + HB_TRACE(HB_TR_DEBUG, ("hb_wstrnlen(%p,%" HB_PFS "u)", szText, nCount)); if( szText ) { - while( count-- && szText[ ulLen ] ) - ++ulLen; + while( nCount-- && szText[ nLen ] ) + ++nLen; } - return ulLen; + return nLen; } int hb_wstrcmp( const HB_WCHAR * s1, const HB_WCHAR * s2 ) @@ -111,13 +111,13 @@ int hb_wstrcmp( const HB_WCHAR * s1, const HB_WCHAR * s2 ) return rc; } -int hb_wstrncmp( const HB_WCHAR * s1, const HB_WCHAR * s2, HB_SIZE count ) +int hb_wstrncmp( const HB_WCHAR * s1, const HB_WCHAR * s2, HB_SIZE nCount ) { int rc = 0; - HB_TRACE(HB_TR_DEBUG, ("hb_wstrncmp(%p, %p, %" HB_PFS "u)", s1, s2, count)); + HB_TRACE(HB_TR_DEBUG, ("hb_wstrncmp(%p, %p, %" HB_PFS "u)", s1, s2, nCount)); - while( count-- ) + while( nCount-- ) { if( *s1 != *s2 ) { @@ -137,50 +137,50 @@ int hb_wstrncmp( const HB_WCHAR * s1, const HB_WCHAR * s2, HB_SIZE count ) HB_WCHAR * hb_wstrdup( const HB_WCHAR * szText ) { HB_WCHAR * pszDest; - HB_SIZE ulSize; + HB_SIZE nSize; HB_TRACE(HB_TR_DEBUG, ("hb_wstrdup(%p)", szText)); - ulSize = ( hb_wstrlen( szText ) + 1 ) * sizeof( HB_WCHAR ); - pszDest = ( HB_WCHAR * ) hb_xgrab( ulSize ); + nSize = ( hb_wstrlen( szText ) + 1 ) * sizeof( HB_WCHAR ); + pszDest = ( HB_WCHAR * ) hb_xgrab( nSize ); - memcpy( pszDest, szText, ulSize ); + memcpy( pszDest, szText, nSize ); return pszDest; } -HB_WCHAR * hb_wstrndup( const HB_WCHAR * szText, HB_SIZE ulLen ) +HB_WCHAR * hb_wstrndup( const HB_WCHAR * szText, HB_SIZE nLen ) { HB_WCHAR * pszDest; - HB_SIZE ulSize; + HB_SIZE nSize; - HB_TRACE(HB_TR_DEBUG, ("hb_wstrndup(%p,%" HB_PFS "u)", szText,ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_wstrndup(%p,%" HB_PFS "u)", szText, nLen)); - ulSize = hb_wstrlen( szText ); - if( ulSize < ulLen ) - ulLen = ulSize; - ulSize = ulLen * sizeof( HB_WCHAR ); - pszDest = ( HB_WCHAR * ) hb_xgrab( ulSize + sizeof( HB_WCHAR ) ); - memcpy( pszDest, szText, ulSize ); - pszDest[ ulLen ] = 0; + nSize = hb_wstrlen( szText ); + if( nSize < nLen ) + nLen = nSize; + nSize = nLen * sizeof( HB_WCHAR ); + pszDest = ( HB_WCHAR * ) hb_xgrab( nSize + sizeof( HB_WCHAR ) ); + memcpy( pszDest, szText, nSize ); + pszDest[ nLen ] = 0; return pszDest; } -HB_WCHAR * hb_wstrunshare( void ** phStr, const HB_WCHAR * pStr, HB_SIZE ulLen ) +HB_WCHAR * hb_wstrunshare( void ** phStr, const HB_WCHAR * pStr, HB_SIZE nLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_wstrunshare(%p,%p,%" HB_PFS "u)", phStr, pStr, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_wstrunshare(%p,%p,%" HB_PFS "u)", phStr, pStr, nLen)); if( pStr == NULL || phStr == NULL || *phStr == NULL ) return NULL; - if( ulLen > 0 && + if( nLen > 0 && ( *phStr == ( void * ) s_szConstStr || hb_xRefCount( *phStr ) > 1 ) ) { - HB_WCHAR * pszDest = ( HB_WCHAR * ) hb_xgrab( ( ulLen + 1 ) * + HB_WCHAR * pszDest = ( HB_WCHAR * ) hb_xgrab( ( nLen + 1 ) * sizeof( HB_WCHAR ) ); - memcpy( pszDest, pStr, ulLen * sizeof( HB_WCHAR ) ); - pszDest[ ulLen ] = 0; + memcpy( pszDest, pStr, nLen * sizeof( HB_WCHAR ) ); + pszDest[ nLen ] = 0; if( *phStr != ( void * ) s_szConstStr ) hb_xRefDec( *phStr ); * phStr = ( void * ) pszDest; @@ -191,19 +191,19 @@ HB_WCHAR * hb_wstrunshare( void ** phStr, const HB_WCHAR * pStr, HB_SIZE ulLen ) return ( HB_WCHAR * ) pStr; } -char * hb_strunshare( void ** phStr, const char * pStr, HB_SIZE ulLen ) +char * hb_strunshare( void ** phStr, const char * pStr, HB_SIZE nLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_strunshare(%p,%p,%" HB_PFS "u)", phStr, pStr, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_strunshare(%p,%p,%" HB_PFS "u)", phStr, pStr, nLen)); if( pStr == NULL || phStr == NULL || *phStr == NULL ) return NULL; - if( ulLen > 0 && + if( nLen > 0 && ( *phStr == ( void * ) s_szConstStr || hb_xRefCount( *phStr ) > 1 ) ) { - char * pszDest = ( char * ) hb_xgrab( ( ulLen + 1 ) * sizeof( char ) ); - memcpy( pszDest, pStr, ulLen * sizeof( char ) ); - pszDest[ ulLen ] = 0; + char * pszDest = ( char * ) hb_xgrab( ( nLen + 1 ) * sizeof( char ) ); + memcpy( pszDest, pStr, nLen * sizeof( char ) ); + pszDest[ nLen ] = 0; if( *phStr != ( void * ) s_szConstStr ) hb_xRefDec( *phStr ); * phStr = ( void * ) pszDest; @@ -239,19 +239,19 @@ void hb_strfree( void * hString ) -const char * hb_itemGetStr( PHB_ITEM pItem, void * cdp, void ** phString, HB_SIZE * pulLen ) +const char * hb_itemGetStr( PHB_ITEM pItem, void * cdp, void ** phString, HB_SIZE * pnLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_itemGetStr(%p,%p,%p,%p)", pItem, cdp, phString, pulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemGetStr(%p,%p,%p,%p)", pItem, cdp, phString, pnLen)); if( pItem && HB_IS_STRING( pItem ) ) { const char * pString; char * pFree = NULL; - HB_SIZE ulSize = 0; + HB_SIZE nSize = 0; pString = hb_cdpnDup3( pItem->item.asString.value, pItem->item.asString.length, - NULL, pulLen, &pFree, &ulSize, + NULL, pnLen, &pFree, &nSize, hb_vmCDP(), ( PHB_CODEPAGE ) cdp ); if( pFree != NULL ) * phString = ( void * ) pFree; @@ -265,32 +265,32 @@ const char * hb_itemGetStr( PHB_ITEM pItem, void * cdp, void ** phString, HB_SIZ return pString; } - if( pulLen ) - * pulLen = 0; + if( pnLen ) + * pnLen = 0; * phString = NULL; return NULL; } -const char * hb_itemGetStrUTF8( PHB_ITEM pItem, void ** phString, HB_SIZE * pulLen ) +const char * hb_itemGetStrUTF8( PHB_ITEM pItem, void ** phString, HB_SIZE * pnLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_itemGetStrUTF8(%p,%p,%p)", pItem, phString, pulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemGetStrUTF8(%p,%p,%p)", pItem, phString, pnLen)); if( pItem && HB_IS_STRING( pItem ) ) { PHB_CODEPAGE cdp = hb_vmCDP(); - HB_SIZE ulLen = hb_cdpStrAsUTF8Len( cdp, HB_FALSE, - pItem->item.asString.value, - pItem->item.asString.length, 0 ); - if( pulLen ) - *pulLen = ulLen; + HB_SIZE nLen = hb_cdpStrAsUTF8Len( cdp, HB_FALSE, + pItem->item.asString.value, + pItem->item.asString.length, 0 ); + if( pnLen ) + *pnLen = nLen; - if( ulLen != pItem->item.asString.length ) + if( nLen != pItem->item.asString.length ) { - char * pszUtf8 = ( char * ) hb_xgrab( ulLen + 1 ); + char * pszUtf8 = ( char * ) hb_xgrab( nLen + 1 ); hb_cdpStrToUTF8( cdp, HB_FALSE, pItem->item.asString.value, pItem->item.asString.length, - pszUtf8, ulLen + 1 ); + pszUtf8, nLen + 1 ); * phString = ( void * ) pszUtf8; return pszUtf8; } @@ -305,195 +305,195 @@ const char * hb_itemGetStrUTF8( PHB_ITEM pItem, void ** phString, HB_SIZE * pulL return pItem->item.asString.value; } - if( pulLen ) - * pulLen = 0; + if( pnLen ) + * pnLen = 0; * phString = NULL; return NULL; } const HB_WCHAR * hb_itemGetStrU16( PHB_ITEM pItem, int iEndian, - void ** phString, HB_SIZE * pulLen ) + void ** phString, HB_SIZE * pnLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_itemGetStrU16(%p,%d,%p,%p)", pItem, iEndian, phString, pulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemGetStrU16(%p,%d,%p,%p)", pItem, iEndian, phString, pnLen)); if( pItem && HB_IS_STRING( pItem ) ) { HB_WCHAR * pszU16; PHB_CODEPAGE cdp = hb_vmCDP(); - HB_SIZE ulLen = hb_cdpStrAsU16Len( cdp, HB_FALSE, - pItem->item.asString.value, - pItem->item.asString.length, 0 ); - if( pulLen ) - *pulLen = ulLen; + HB_SIZE nLen = hb_cdpStrAsU16Len( cdp, HB_FALSE, + pItem->item.asString.value, + pItem->item.asString.length, 0 ); + if( pnLen ) + *pnLen = nLen; - if( ulLen == 0 ) + if( nLen == 0 ) { * phString = ( void * ) s_szConstStr; return s_szConstStr; } - pszU16 = ( HB_WCHAR * ) hb_xgrab( ( ulLen + 1 ) * sizeof( HB_WCHAR ) ); + pszU16 = ( HB_WCHAR * ) hb_xgrab( ( nLen + 1 ) * sizeof( HB_WCHAR ) ); hb_cdpStrToU16( cdp, HB_FALSE, iEndian, pItem->item.asString.value, pItem->item.asString.length, - pszU16, ulLen + 1 ); + pszU16, nLen + 1 ); * phString = ( void * ) pszU16; return pszU16; } - if( pulLen ) - * pulLen = 0; + if( pnLen ) + * pnLen = 0; * phString = NULL; return NULL; } -HB_SIZE hb_itemCopyStr( PHB_ITEM pItem, void * cdp, char * pStrBuffer, HB_SIZE ulSize ) +HB_SIZE hb_itemCopyStr( PHB_ITEM pItem, void * cdp, char * pStrBuffer, HB_SIZE nSize ) { - HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyStr(%p,%p,%p,%" HB_PFS "u)", pItem, cdp, pStrBuffer, ulSize)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyStr(%p,%p,%p,%" HB_PFS "u)", pItem, cdp, pStrBuffer, nSize)); if( pItem && HB_IS_STRING( pItem ) ) { if( pStrBuffer ) return hb_cdpTransTo( pItem->item.asString.value, pItem->item.asString.length, - pStrBuffer, ulSize, + pStrBuffer, nSize, hb_vmCDP(), ( PHB_CODEPAGE ) cdp ); else return hb_cdpnDup2Len( pItem->item.asString.value, pItem->item.asString.length, - ulSize, hb_vmCDP(), ( PHB_CODEPAGE ) cdp ); + nSize, hb_vmCDP(), ( PHB_CODEPAGE ) cdp ); } - else if( pStrBuffer && ulSize ) + else if( pStrBuffer && nSize ) pStrBuffer[ 0 ] = '\0'; return 0; } -HB_SIZE hb_itemCopyStrUTF8( PHB_ITEM pItem, char * pStrBuffer, HB_SIZE ulSize ) +HB_SIZE hb_itemCopyStrUTF8( PHB_ITEM pItem, char * pStrBuffer, HB_SIZE nSize ) { - HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyStrUTF8(%p,%p,%" HB_PFS "u)", pItem, pStrBuffer, ulSize)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyStrUTF8(%p,%p,%" HB_PFS "u)", pItem, pStrBuffer, nSize)); if( pItem && HB_IS_STRING( pItem ) ) { if( pStrBuffer ) - ulSize = hb_cdpStrToUTF8( hb_vmCDP(), HB_FALSE, - pItem->item.asString.value, - pItem->item.asString.length, - pStrBuffer, ulSize ); - else - ulSize = hb_cdpStrAsUTF8Len( hb_vmCDP(), HB_FALSE, - pItem->item.asString.value, - pItem->item.asString.length, ulSize ); - return ulSize; - } - else if( pStrBuffer && ulSize ) - pStrBuffer[ 0 ] = '\0'; - - return 0; -} - - -HB_SIZE hb_itemCopyStrU16( PHB_ITEM pItem, int iEndian, HB_WCHAR * pStrBuffer, HB_SIZE ulSize ) -{ - HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyStrU16(%p,%d,%p,%" HB_PFS "u)", pItem, iEndian, pStrBuffer, ulSize)); - - if( pItem && HB_IS_STRING( pItem ) ) - { - if( pStrBuffer ) - ulSize = hb_cdpStrToU16( hb_vmCDP(), HB_FALSE, iEndian, + nSize = hb_cdpStrToUTF8( hb_vmCDP(), HB_FALSE, pItem->item.asString.value, pItem->item.asString.length, - pStrBuffer, ulSize ); + pStrBuffer, nSize ); else - ulSize = hb_cdpStrAsU16Len( hb_vmCDP(), HB_FALSE, + nSize = hb_cdpStrAsUTF8Len( hb_vmCDP(), HB_FALSE, pItem->item.asString.value, - pItem->item.asString.length, ulSize ); - return ulSize; + pItem->item.asString.length, nSize ); + return nSize; } - else if( pStrBuffer && ulSize ) + else if( pStrBuffer && nSize ) pStrBuffer[ 0 ] = '\0'; return 0; } -PHB_ITEM hb_itemPutStrLen( PHB_ITEM pItem, void * cdp, const char * pStr, HB_SIZE ulLen ) +HB_SIZE hb_itemCopyStrU16( PHB_ITEM pItem, int iEndian, HB_WCHAR * pStrBuffer, HB_SIZE nSize ) +{ + HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyStrU16(%p,%d,%p,%" HB_PFS "u)", pItem, iEndian, pStrBuffer, nSize)); + + if( pItem && HB_IS_STRING( pItem ) ) + { + if( pStrBuffer ) + nSize = hb_cdpStrToU16( hb_vmCDP(), HB_FALSE, iEndian, + pItem->item.asString.value, + pItem->item.asString.length, + pStrBuffer, nSize ); + else + nSize = hb_cdpStrAsU16Len( hb_vmCDP(), HB_FALSE, + pItem->item.asString.value, + pItem->item.asString.length, nSize ); + return nSize; + } + else if( pStrBuffer && nSize ) + pStrBuffer[ 0 ] = '\0'; + + return 0; +} + + +PHB_ITEM hb_itemPutStrLen( PHB_ITEM pItem, void * cdp, const char * pStr, HB_SIZE nLen ) { char * pszText; - HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrLen(%p,%p,%p,%" HB_PFS "u)", pItem, cdp, pStr, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrLen(%p,%p,%p,%" HB_PFS "u)", pItem, cdp, pStr, nLen)); - if( ulLen == 0 ) + if( nLen == 0 ) return hb_itemPutC( pItem, NULL ); - pszText = hb_cdpnDup( pStr, &ulLen, ( PHB_CODEPAGE ) cdp, hb_vmCDP() ); + pszText = hb_cdpnDup( pStr, &nLen, ( PHB_CODEPAGE ) cdp, hb_vmCDP() ); - return hb_itemPutCLPtr( pItem, pszText, ulLen ); + return hb_itemPutCLPtr( pItem, pszText, nLen ); } -PHB_ITEM hb_itemPutStrLenUTF8( PHB_ITEM pItem, const char * pStr, HB_SIZE ulLen ) +PHB_ITEM hb_itemPutStrLenUTF8( PHB_ITEM pItem, const char * pStr, HB_SIZE nLen ) { PHB_CODEPAGE cdp; char * pszDest; - HB_SIZE ulDest; + HB_SIZE nDest; - HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrLenUTF8(%p,%p,%" HB_PFS "u)", pItem, pStr, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrLenUTF8(%p,%p,%" HB_PFS "u)", pItem, pStr, nLen)); - if( ulLen == 0 ) + if( nLen == 0 ) return hb_itemPutC( pItem, NULL ); cdp = hb_vmCDP(); - ulDest = hb_cdpUTF8AsStrLen( cdp, HB_FALSE, pStr, ulLen, 0 ); - pszDest = ( char * ) hb_xgrab( ulDest + 1 ); - hb_cdpUTF8ToStr( cdp, HB_FALSE, pStr, ulLen, pszDest, ulDest + 1 ); + nDest = hb_cdpUTF8AsStrLen( cdp, HB_FALSE, pStr, nLen, 0 ); + pszDest = ( char * ) hb_xgrab( nDest + 1 ); + hb_cdpUTF8ToStr( cdp, HB_FALSE, pStr, nLen, pszDest, nDest + 1 ); - return hb_itemPutCLPtr( pItem, pszDest, ulDest ); + return hb_itemPutCLPtr( pItem, pszDest, nDest ); } -PHB_ITEM hb_itemPutStrLenU16( PHB_ITEM pItem, int iEndian, const HB_WCHAR * pStr, HB_SIZE ulLen ) +PHB_ITEM hb_itemPutStrLenU16( PHB_ITEM pItem, int iEndian, const HB_WCHAR * pStr, HB_SIZE nLen ) { PHB_CODEPAGE cdp; char * pszDest; - HB_SIZE ulDest; + HB_SIZE nDest; - HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrLenU16(%p,%d,%p,%" HB_PFS "u)", pItem, iEndian, pStr, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrLenU16(%p,%d,%p,%" HB_PFS "u)", pItem, iEndian, pStr, nLen)); - if( ulLen == 0 ) + if( nLen == 0 ) return hb_itemPutC( pItem, NULL ); cdp = hb_vmCDP(); - ulDest = hb_cdpU16AsStrLen( cdp, HB_FALSE, pStr, ulLen, 0 ); - pszDest = ( char * ) hb_xgrab( ulDest + 1 ); - hb_cdpU16ToStr( cdp, HB_FALSE, iEndian, pStr, ulLen, pszDest, ulDest + 1 ); + nDest = hb_cdpU16AsStrLen( cdp, HB_FALSE, pStr, nLen, 0 ); + pszDest = ( char * ) hb_xgrab( nDest + 1 ); + hb_cdpU16ToStr( cdp, HB_FALSE, iEndian, pStr, nLen, pszDest, nDest + 1 ); - return hb_itemPutCLPtr( pItem, pszDest, ulDest ); + return hb_itemPutCLPtr( pItem, pszDest, nDest ); } PHB_ITEM hb_itemPutStr( PHB_ITEM pItem, void * cdp, const char * pStr ) { char * pszText; - HB_SIZE ulLen; + HB_SIZE nLen; HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStr(%p,%p,%p)", pItem, cdp, pStr)); if( pStr == NULL ) return hb_itemPutC( pItem, NULL ); - ulLen = strlen( pStr ); - pszText = hb_cdpnDup( pStr, &ulLen, ( PHB_CODEPAGE ) cdp, hb_vmCDP() ); + nLen = strlen( pStr ); + pszText = hb_cdpnDup( pStr, &nLen, ( PHB_CODEPAGE ) cdp, hb_vmCDP() ); - return hb_itemPutCLPtr( pItem, pszText, ulLen ); + return hb_itemPutCLPtr( pItem, pszText, nLen ); } PHB_ITEM hb_itemPutStrUTF8( PHB_ITEM pItem, const char * pStr ) { PHB_CODEPAGE cdp; char * pszDest; - HB_SIZE ulDest, ulLen; + HB_SIZE nDest, nLen; HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrUTF8(%p,%p)", pItem, pStr)); @@ -501,19 +501,19 @@ PHB_ITEM hb_itemPutStrUTF8( PHB_ITEM pItem, const char * pStr ) return hb_itemPutC( pItem, NULL ); cdp = hb_vmCDP(); - ulLen = strlen( pStr ); - ulDest = hb_cdpUTF8AsStrLen( cdp, HB_FALSE, pStr, ulLen, 0 ); - pszDest = ( char * ) hb_xgrab( ulDest + 1 ); - hb_cdpUTF8ToStr( cdp, HB_FALSE, pStr, ulLen, pszDest, ulDest + 1 ); + nLen = strlen( pStr ); + nDest = hb_cdpUTF8AsStrLen( cdp, HB_FALSE, pStr, nLen, 0 ); + pszDest = ( char * ) hb_xgrab( nDest + 1 ); + hb_cdpUTF8ToStr( cdp, HB_FALSE, pStr, nLen, pszDest, nDest + 1 ); - return hb_itemPutCLPtr( pItem, pszDest, ulDest ); + return hb_itemPutCLPtr( pItem, pszDest, nDest ); } PHB_ITEM hb_itemPutStrU16( PHB_ITEM pItem, int iEndian, const HB_WCHAR * pStr ) { PHB_CODEPAGE cdp; char * pszDest; - HB_SIZE ulDest, ulLen; + HB_SIZE nDest, nLen; HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrU16(%p,%d,%p)", pItem, iEndian, pStr)); @@ -521,102 +521,102 @@ PHB_ITEM hb_itemPutStrU16( PHB_ITEM pItem, int iEndian, const HB_WCHAR * pStr ) return hb_itemPutC( pItem, NULL ); cdp = hb_vmCDP(); - ulLen = hb_wstrlen( pStr ); - ulDest = hb_cdpU16AsStrLen( cdp, HB_FALSE, pStr, ulLen, 0 ); - pszDest = ( char * ) hb_xgrab( ulDest + 1 ); - hb_cdpU16ToStr( cdp, HB_FALSE, iEndian, pStr, ulLen, pszDest, ulDest + 1 ); + nLen = hb_wstrlen( pStr ); + nDest = hb_cdpU16AsStrLen( cdp, HB_FALSE, pStr, nLen, 0 ); + pszDest = ( char * ) hb_xgrab( nDest + 1 ); + hb_cdpU16ToStr( cdp, HB_FALSE, iEndian, pStr, nLen, pszDest, nDest + 1 ); - return hb_itemPutCLPtr( pItem, pszDest, ulDest ); + return hb_itemPutCLPtr( pItem, pszDest, nDest ); } -const char * hb_arrayGetStr( PHB_ITEM pArray, HB_SIZE ulIndex, void * cdp, - void ** phString, HB_SIZE * pulLen ) +const char * hb_arrayGetStr( PHB_ITEM pArray, HB_SIZE nIndex, void * cdp, + void ** phString, HB_SIZE * pnLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetStr(%p, %" HB_PFS "u, %p, %p, %p)", pArray, ulIndex, cdp, phString, pulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetStr(%p, %" HB_PFS "u, %p, %p, %p)", pArray, nIndex, cdp, phString, pnLen)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetStr( pArray->item.asArray.value->pItems + ulIndex - 1, - cdp, phString, pulLen ); - if( pulLen ) - * pulLen = 0; + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetStr( pArray->item.asArray.value->pItems + nIndex - 1, + cdp, phString, pnLen ); + if( pnLen ) + * pnLen = 0; * phString = NULL; return NULL; } -const char * hb_arrayGetStrUTF8( PHB_ITEM pArray, HB_SIZE ulIndex, - void ** phString, HB_SIZE * pulLen ) +const char * hb_arrayGetStrUTF8( PHB_ITEM pArray, HB_SIZE nIndex, + void ** phString, HB_SIZE * pnLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetStrUTF8(%p, %" HB_PFS "u, %p, %p)", pArray, ulIndex, phString, pulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetStrUTF8(%p, %" HB_PFS "u, %p, %p)", pArray, nIndex, phString, pnLen)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetStrUTF8( pArray->item.asArray.value->pItems + ulIndex - 1, - phString, pulLen ); - if( pulLen ) - * pulLen = 0; + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetStrUTF8( pArray->item.asArray.value->pItems + nIndex - 1, + phString, pnLen ); + if( pnLen ) + * pnLen = 0; * phString = NULL; return NULL; } -const HB_WCHAR * hb_arrayGetStrU16( PHB_ITEM pArray, HB_SIZE ulIndex, int iEndian, - void ** phString, HB_SIZE * pulLen ) +const HB_WCHAR * hb_arrayGetStrU16( PHB_ITEM pArray, HB_SIZE nIndex, int iEndian, + void ** phString, HB_SIZE * pnLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetStrU16(%p, %" HB_PFS "u, %d, %p, %p)", pArray, ulIndex, iEndian, phString, pulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetStrU16(%p, %" HB_PFS "u, %d, %p, %p)", pArray, nIndex, iEndian, phString, pnLen)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) - return hb_itemGetStrU16( pArray->item.asArray.value->pItems + ulIndex - 1, - iEndian, phString, pulLen ); - if( pulLen ) - * pulLen = 0; + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) + return hb_itemGetStrU16( pArray->item.asArray.value->pItems + nIndex - 1, + iEndian, phString, pnLen ); + if( pnLen ) + * pnLen = 0; * phString = NULL; return NULL; } -HB_BOOL hb_arraySetStrLen( PHB_ITEM pArray, HB_SIZE ulIndex, void * cdp, - const char * pStr, HB_SIZE ulLen ) +HB_BOOL hb_arraySetStrLen( PHB_ITEM pArray, HB_SIZE nIndex, void * cdp, + const char * pStr, HB_SIZE nLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrLen(%p, %" HB_PFS "u, %p, %p, %" HB_PFS "u)", pArray, ulIndex, cdp, pStr, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrLen(%p, %" HB_PFS "u, %p, %p, %" HB_PFS "u)", pArray, nIndex, cdp, pStr, nLen)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutStrLen( pArray->item.asArray.value->pItems + ulIndex - 1, cdp, - pStr, ulLen ); + hb_itemPutStrLen( pArray->item.asArray.value->pItems + nIndex - 1, cdp, + pStr, nLen ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetStrLenUTF8( PHB_ITEM pArray, HB_SIZE ulIndex, - const char * pStr, HB_SIZE ulLen ) +HB_BOOL hb_arraySetStrLenUTF8( PHB_ITEM pArray, HB_SIZE nIndex, + const char * pStr, HB_SIZE nLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrLenUTF8(%p, %" HB_PFS "u, %p, %" HB_PFS "u)", pArray, ulIndex, pStr, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrLenUTF8(%p, %" HB_PFS "u, %p, %" HB_PFS "u)", pArray, nIndex, pStr, nLen)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutStrLenUTF8( pArray->item.asArray.value->pItems + ulIndex - 1, - pStr, ulLen ); + hb_itemPutStrLenUTF8( pArray->item.asArray.value->pItems + nIndex - 1, + pStr, nLen ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetStrLenU16( PHB_ITEM pArray, HB_SIZE ulIndex, int iEndian, - const HB_WCHAR * pStr, HB_SIZE ulLen ) +HB_BOOL hb_arraySetStrLenU16( PHB_ITEM pArray, HB_SIZE nIndex, int iEndian, + const HB_WCHAR * pStr, HB_SIZE nLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrLenU16(%p, %" HB_PFS "u, %d, %p, %" HB_PFS "u)", pArray, ulIndex, iEndian, pStr, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrLenU16(%p, %" HB_PFS "u, %d, %p, %" HB_PFS "u)", pArray, nIndex, iEndian, pStr, nLen)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutStrLenU16( pArray->item.asArray.value->pItems + ulIndex - 1, - iEndian, pStr, ulLen ); + hb_itemPutStrLenU16( pArray->item.asArray.value->pItems + nIndex - 1, + iEndian, pStr, nLen ); return HB_TRUE; } else @@ -624,39 +624,39 @@ HB_BOOL hb_arraySetStrLenU16( PHB_ITEM pArray, HB_SIZE ulIndex, int iEndian, } -HB_BOOL hb_arraySetStr( PHB_ITEM pArray, HB_SIZE ulIndex, void * cdp, const char * pStr ) +HB_BOOL hb_arraySetStr( PHB_ITEM pArray, HB_SIZE nIndex, void * cdp, const char * pStr ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStr(%p, %" HB_PFS "u, %p, %p)", pArray, ulIndex, cdp, pStr)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStr(%p, %" HB_PFS "u, %p, %p)", pArray, nIndex, cdp, pStr)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutStr( pArray->item.asArray.value->pItems + ulIndex - 1, cdp, pStr ); + hb_itemPutStr( pArray->item.asArray.value->pItems + nIndex - 1, cdp, pStr ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetStrUTF8( PHB_ITEM pArray, HB_SIZE ulIndex, const char * pStr) +HB_BOOL hb_arraySetStrUTF8( PHB_ITEM pArray, HB_SIZE nIndex, const char * pStr) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrUTF8(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pStr)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrUTF8(%p, %" HB_PFS "u, %p)", pArray, nIndex, pStr)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutStrUTF8( pArray->item.asArray.value->pItems + ulIndex - 1, pStr ); + hb_itemPutStrUTF8( pArray->item.asArray.value->pItems + nIndex - 1, pStr ); return HB_TRUE; } else return HB_FALSE; } -HB_BOOL hb_arraySetStrU16( PHB_ITEM pArray, HB_SIZE ulIndex, int iEndian, const HB_WCHAR * pStr ) +HB_BOOL hb_arraySetStrU16( PHB_ITEM pArray, HB_SIZE nIndex, int iEndian, const HB_WCHAR * pStr ) { - HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrU16(%p, %" HB_PFS "u, %d, %p)", pArray, ulIndex, iEndian, pStr)); + HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrU16(%p, %" HB_PFS "u, %d, %p)", pArray, nIndex, iEndian, pStr)); - if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen ) + if( HB_IS_ARRAY( pArray ) && nIndex > 0 && nIndex <= pArray->item.asArray.value->nLen ) { - hb_itemPutStrU16( pArray->item.asArray.value->pItems + ulIndex - 1, iEndian, pStr ); + hb_itemPutStrU16( pArray->item.asArray.value->pItems + nIndex - 1, iEndian, pStr ); return HB_TRUE; } else @@ -666,11 +666,11 @@ HB_BOOL hb_arraySetStrU16( PHB_ITEM pArray, HB_SIZE ulIndex, int iEndian, const -const char * hb_parstr( int iParam, void * cdp, void ** phString, HB_SIZE * pulLen ) +const char * hb_parstr( int iParam, void * cdp, void ** phString, HB_SIZE * pnLen ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_parstr(%d,%p,%p,%p)", iParam, cdp, phString, pulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_parstr(%d,%p,%p,%p)", iParam, cdp, phString, pnLen)); if( iParam >= -1 && iParam <= hb_pcount() ) { @@ -679,21 +679,21 @@ const char * hb_parstr( int iParam, void * cdp, void ** phString, HB_SIZE * pulL if( HB_IS_BYREF( pItem ) ) pItem = hb_itemUnRef( pItem ); - return hb_itemGetStr( pItem, cdp, phString, pulLen ); + return hb_itemGetStr( pItem, cdp, phString, pnLen ); } - if( pulLen ) - * pulLen = 0; + if( pnLen ) + * pnLen = 0; * phString = NULL; return NULL; } -const char * hb_parstr_utf8( int iParam, void ** phString, HB_SIZE * pulLen ) +const char * hb_parstr_utf8( int iParam, void ** phString, HB_SIZE * pnLen ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_parstr_utf8(%d,%p,%p)", iParam, phString, pulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_parstr_utf8(%d,%p,%p)", iParam, phString, pnLen)); if( iParam >= -1 && iParam <= hb_pcount() ) { @@ -702,22 +702,22 @@ const char * hb_parstr_utf8( int iParam, void ** phString, HB_SIZE * pulLen ) if( HB_IS_BYREF( pItem ) ) pItem = hb_itemUnRef( pItem ); - return hb_itemGetStrUTF8( pItem, phString, pulLen ); + return hb_itemGetStrUTF8( pItem, phString, pnLen ); } - if( pulLen ) - * pulLen = 0; + if( pnLen ) + * pnLen = 0; * phString = NULL; return NULL; } const HB_WCHAR * hb_parstr_u16( int iParam, int iEndian, - void ** phString, HB_SIZE * pulLen ) + void ** phString, HB_SIZE * pnLen ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_parstr_u16(%d,%d,%p,%p)", iParam, iEndian, phString, pulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_parstr_u16(%d,%d,%p,%p)", iParam, iEndian, phString, pnLen)); if( iParam >= -1 && iParam <= hb_pcount() ) { @@ -726,11 +726,11 @@ const HB_WCHAR * hb_parstr_u16( int iParam, int iEndian, if( HB_IS_BYREF( pItem ) ) pItem = hb_itemUnRef( pItem ); - return hb_itemGetStrU16( pItem, iEndian, phString, pulLen ); + return hb_itemGetStrU16( pItem, iEndian, phString, pnLen ); } - if( pulLen ) - * pulLen = 0; + if( pnLen ) + * pnLen = 0; * phString = NULL; return NULL; @@ -768,31 +768,31 @@ void hb_retstr_u16( int iEndian, const HB_WCHAR * szText ) } -void hb_retstrlen( void * cdp, const char * szText, HB_SIZE ulLen ) +void hb_retstrlen( void * cdp, const char * szText, HB_SIZE nLen ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_retstrlen(%p,%s,%" HB_PFS "u)", cdp, szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_retstrlen(%p,%s,%" HB_PFS "u)", cdp, szText, nLen)); - hb_itemPutStrLen( hb_stackReturnItem(), cdp, szText, ulLen ); + hb_itemPutStrLen( hb_stackReturnItem(), cdp, szText, nLen ); } -void hb_retstrlen_utf8( const char * szText, HB_SIZE ulLen ) +void hb_retstrlen_utf8( const char * szText, HB_SIZE nLen ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_retstrlen_utf8(%s,%" HB_PFS "u)", szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_retstrlen_utf8(%s,%" HB_PFS "u)", szText, nLen)); - hb_itemPutStrLenUTF8( hb_stackReturnItem(), szText, ulLen ); + hb_itemPutStrLenUTF8( hb_stackReturnItem(), szText, nLen ); } -void hb_retstrlen_u16( int iEndian, const HB_WCHAR * szText, HB_SIZE ulLen ) +void hb_retstrlen_u16( int iEndian, const HB_WCHAR * szText, HB_SIZE nLen ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_retstrlen_u16(%d,%p,%" HB_PFS "u)", iEndian, szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_retstrlen_u16(%d,%p,%" HB_PFS "u)", iEndian, szText, nLen)); - hb_itemPutStrLenU16( hb_stackReturnItem(), iEndian, szText, ulLen ); + hb_itemPutStrLenU16( hb_stackReturnItem(), iEndian, szText, nLen ); } @@ -878,15 +878,15 @@ int hb_storstr_u16( int iEndian, const HB_WCHAR * szText, int iParam ) } -int hb_storstrlen( void * cdp, const char * szText, HB_SIZE ulLen, int iParam ) +int hb_storstrlen( void * cdp, const char * szText, HB_SIZE nLen, int iParam ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_storstrlen(%p,%s,%" HB_PFS "u,%d)", cdp, szText, ulLen, iParam)); + HB_TRACE(HB_TR_DEBUG, ("hb_storstrlen(%p,%s,%" HB_PFS "u,%d)", cdp, szText, nLen, iParam)); if( iParam == -1 ) { - hb_itemPutStrLen( hb_stackReturnItem(), cdp, szText, ulLen ); + hb_itemPutStrLen( hb_stackReturnItem(), cdp, szText, nLen ); return 1; } else if( iParam >= 0 && iParam <= hb_pcount() ) @@ -895,7 +895,7 @@ int hb_storstrlen( void * cdp, const char * szText, HB_SIZE ulLen, int iParam ) if( HB_IS_BYREF( pItem ) ) { - hb_itemPutStrLen( hb_itemUnRef( pItem ), cdp, szText, ulLen ); + hb_itemPutStrLen( hb_itemUnRef( pItem ), cdp, szText, nLen ); return 1; } } @@ -903,15 +903,15 @@ int hb_storstrlen( void * cdp, const char * szText, HB_SIZE ulLen, int iParam ) return 0; } -int hb_storstrlen_utf8( const char * szText, HB_SIZE ulLen, int iParam ) +int hb_storstrlen_utf8( const char * szText, HB_SIZE nLen, int iParam ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_storstrlen_utf8(%s,%" HB_PFS "u,%d)", szText, ulLen, iParam)); + HB_TRACE(HB_TR_DEBUG, ("hb_storstrlen_utf8(%s,%" HB_PFS "u,%d)", szText, nLen, iParam)); if( iParam == -1 ) { - hb_itemPutStrLenUTF8( hb_stackReturnItem(), szText, ulLen ); + hb_itemPutStrLenUTF8( hb_stackReturnItem(), szText, nLen ); return 1; } else if( iParam >= 0 && iParam <= hb_pcount() ) @@ -920,7 +920,7 @@ int hb_storstrlen_utf8( const char * szText, HB_SIZE ulLen, int iParam ) if( HB_IS_BYREF( pItem ) ) { - hb_itemPutStrLenUTF8( hb_itemUnRef( pItem ), szText, ulLen ); + hb_itemPutStrLenUTF8( hb_itemUnRef( pItem ), szText, nLen ); return 1; } } @@ -928,15 +928,15 @@ int hb_storstrlen_utf8( const char * szText, HB_SIZE ulLen, int iParam ) return 0; } -int hb_storstrlen_u16( int iEndian, const HB_WCHAR * szText, HB_SIZE ulLen, int iParam ) +int hb_storstrlen_u16( int iEndian, const HB_WCHAR * szText, HB_SIZE nLen, int iParam ) { HB_STACK_TLS_PRELOAD - HB_TRACE(HB_TR_DEBUG, ("hb_storstrlen_u16(%d,%p,%" HB_PFS "u,%d)", iEndian, szText, ulLen, iParam)); + HB_TRACE(HB_TR_DEBUG, ("hb_storstrlen_u16(%d,%p,%" HB_PFS "u,%d)", iEndian, szText, nLen, iParam)); if( iParam == -1 ) { - hb_itemPutStrLenU16( hb_stackReturnItem(), iEndian, szText, ulLen ); + hb_itemPutStrLenU16( hb_stackReturnItem(), iEndian, szText, nLen ); return 1; } else if( iParam >= 0 && iParam <= hb_pcount() ) @@ -945,7 +945,7 @@ int hb_storstrlen_u16( int iEndian, const HB_WCHAR * szText, HB_SIZE ulLen, int if( HB_IS_BYREF( pItem ) ) { - hb_itemPutStrLenU16( hb_itemUnRef( pItem ), iEndian, szText, ulLen ); + hb_itemPutStrLenU16( hb_itemUnRef( pItem ), iEndian, szText, nLen ); return 1; } } diff --git a/harbour/utils/hbrun/hbrun.prg b/harbour/utils/hbrun/hbrun.prg index 0c34c40578..1b507f9ff0 100644 --- a/harbour/utils/hbrun/hbrun.prg +++ b/harbour/utils/hbrun/hbrun.prg @@ -474,27 +474,30 @@ STATIC FUNCTION hbrun_FindInPath( cFileName ) RETURN cFileName ENDIF - /* Check in the dir of this executable. */ - IF ! Empty( hb_DirBase() ) - IF hb_FileExists( cFileName := hb_FNameMerge( hb_DirBase(), cName, cExt ) ) - RETURN cFileName - ENDIF - ENDIF + IF Empty( cDir ) - /* Check in the PATH. */ - #if defined( __PLATFORM__WINDOWS ) .OR. ; - defined( __PLATFORM__DOS ) .OR. ; - defined( __PLATFORM__OS2 ) - FOR EACH cDirPATH IN hb_ATokens( GetEnv( "PATH" ), hb_osPathListSeparator(), .T., .T. ) - #else - FOR EACH cDirPATH IN hb_ATokens( GetEnv( "PATH" ), hb_osPathListSeparator() ) - #endif - IF ! Empty( cDirPATH ) - IF hb_FileExists( cFileName := hb_FNameMerge( hbrun_DirAddPathSep( hbrun_StrStripQuote( cDirPATH ) ), cName, cExt ) ) + /* Check in the dir of this executable. */ + IF ! Empty( hb_DirBase() ) + IF hb_FileExists( cFileName := hb_FNameMerge( hb_DirBase(), cName, cExt ) ) RETURN cFileName ENDIF ENDIF - NEXT + + /* Check in the PATH. */ + #if defined( __PLATFORM__WINDOWS ) .OR. ; + defined( __PLATFORM__DOS ) .OR. ; + defined( __PLATFORM__OS2 ) + FOR EACH cDirPATH IN hb_ATokens( GetEnv( "PATH" ), hb_osPathListSeparator(), .T., .T. ) + #else + FOR EACH cDirPATH IN hb_ATokens( GetEnv( "PATH" ), hb_osPathListSeparator() ) + #endif + IF ! Empty( cDirPATH ) + IF hb_FileExists( cFileName := hb_FNameMerge( hbrun_DirAddPathSep( hbrun_StrStripQuote( cDirPATH ) ), cName, cExt ) ) + RETURN cFileName + ENDIF + ENDIF + NEXT + ENDIF NEXT RETURN NIL