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