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

2010-06-20 10:37 UTC+0200 Viktor Szakats (harbour.01 syenar.hu)

Browse Source 
* src/vm/macro.c
  * src/vm/strapi.c
  * src/vm/runner.c
  * src/vm/codebloc.c
  * src/vm/hashes.c
  * src/vm/debug.c
  * src/vm/itemapi.c
  * src/vm/hvm.c
  * src/vm/arrays.c
  * src/vm/fm.c
  * src/vm/memvars.c
  * src/vm/extend.c
  * src/common/hbstr.c
  * src/common/hbmem.c
  * src/rtl/descend.c
  * src/rtl/gtapi.c
  * src/rtl/filesys.c
  * src/rtl/console.c
  * src/rtl/hbgtcore.c
  * src/rtl/cdpapi.c
  * src/rtl/hardcr.c
  * src/rtl/inkeyapi.c
  * src/rtl/mtran.c
  * src/rtl/hbproces.c
  * src/rtl/ati.c
  * contrib/hbct/ctwin.c
  * contrib/xhb/xhbat.c
  * contrib/xhb/freadlin.c
  * contrib/xhb/txtline.c
  * contrib/xhb/cstructc.c
  * contrib/hbgt/strasint.c
  * contrib/hbmisc/stringsx.c
  * contrib/hbwin/win_prn3.c
    + Using HB_PFS format in HB_TRACE() format strings.

  * contrib/xhb/freadlin.c
  * contrib/xhb/txtline.c
    * Variable names prefixed.

  * src/vm/macro.c
    * Deleted unnecessary '( void * )' casts.

  * INSTALL
    * Cleaned pocc support information.

  * contrib/hbct/files.c
  * contrib/hbct/color.c
  * contrib/hbct/ctwfunc.c
  * contrib/hbct/print.c
    % Optimized to use hb_parn*def() calls instead of inline-if expression
      (where default value is constant or simple variable).
This commit is contained in:
Viktor Szakats
2010-06-20 08:39:13 +00:00
parent 80163a2008
commit af2b63500f
39 changed files with 311 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
harbour/ChangeLog
View File

@@ -16,6 +16,59 @@
The license applies to all entries newer than 2009-04-28.
*/
2010-06-20 10:37 UTC+0200 Viktor Szakats (harbour.01 syenar.hu)
* src/vm/macro.c
* src/vm/strapi.c
* src/vm/runner.c
* src/vm/codebloc.c
* src/vm/hashes.c
* src/vm/debug.c
* src/vm/itemapi.c
* src/vm/hvm.c
* src/vm/arrays.c
* src/vm/fm.c
* src/vm/memvars.c
* src/vm/extend.c
* src/common/hbstr.c
* src/common/hbmem.c
* src/rtl/descend.c
* src/rtl/gtapi.c
* src/rtl/filesys.c
* src/rtl/console.c
* src/rtl/hbgtcore.c
* src/rtl/cdpapi.c
* src/rtl/hardcr.c
* src/rtl/inkeyapi.c
* src/rtl/mtran.c
* src/rtl/hbproces.c
* src/rtl/ati.c
* contrib/hbct/ctwin.c
* contrib/xhb/xhbat.c
* contrib/xhb/freadlin.c
* contrib/xhb/txtline.c
* contrib/xhb/cstructc.c
* contrib/hbgt/strasint.c
* contrib/hbmisc/stringsx.c
* contrib/hbwin/win_prn3.c
+ Using HB_PFS format in HB_TRACE() format strings.
* contrib/xhb/freadlin.c
* contrib/xhb/txtline.c
* Variable names prefixed.
* src/vm/macro.c
* Deleted unnecessary '( void * )' casts.
* INSTALL
* Cleaned pocc support information.
* contrib/hbct/files.c
* contrib/hbct/color.c
* contrib/hbct/ctwfunc.c
* contrib/hbct/print.c
% Optimized to use hb_parn*def() calls instead of inline-if expression
(where default value is constant or simple variable).
2010-06-20 01:13 UTC+0200 Viktor Szakats (harbour.01 syenar.hu)
* config/win/pocc.mk
* config/win/pocc64.mk

6
harbour/INSTALL
View File

@@ -533,8 +533,8 @@ HARBOUR
bcc - Borland/CodeGear/Embarcadero C++ 4.x and above
icc - Intel(R) C/C++
iccia64 - Intel(R) C/C++ IA-64 (Itanium)
pocc - Pelles C 4.5 and 5.0
pocc64 - Pelles C x86-64 5.0
pocc - Pelles C 4.5 and above
pocc64 - Pelles C x86-64 5.0 and above
xcc - Pelles C for xhb
cygwin - Cygwin GNU C
@@ -543,7 +543,7 @@ HARBOUR
mingw - MinGW GNU C x86
mingwarm - MinGW GNU C ARM (CEGCC 0.55 and above)
msvcarm - Microsoft Visual C++ ARM
poccarm - Pelles C 5.0 ARM
poccarm - Pelles C ARM 5.0 and above
dos
---

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

@@ -194,16 +194,14 @@ HB_FUNC( COLORTON )
HB_FUNC( NTOCOLOR )
{
char szColorString[ 10 ];
int iColor;
iColor = HB_ISNUM( 1 ) ? hb_parni( 1 ) : -1;
int iColor = hb_parnidef( 1, -1 );
if( iColor >= 0x00 && iColor <= 0xff )
{
if( hb_parl( 2 ) )
hb_gtColorsToString( &iColor, 1, szColorString, 10 );
hb_gtColorsToString( &iColor, 1, szColorString, sizeof( szColorString ) );
else
hb_snprintf( szColorString, 10, "%02d/%02d", iColor & 0x0f, iColor >> 4 );
hb_snprintf( szColorString, sizeof( szColorString ), "%02d/%02d", iColor & 0x0f, iColor >> 4 );
hb_retc( szColorString );
}
else

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

@@ -384,17 +384,13 @@ HB_FUNC( WSHOW )
/* Harbour extension */
HB_FUNC( WSHADOW )
{
int iAttr;
iAttr = HB_ISNUM( 1 ) ? hb_parni( 1 ) : HB_CTW_SHADOW_UNDEF;
hb_retni( hb_ctwSetWindowShadow( hb_ctwCurrentWindow(), iAttr ) );
hb_retni( hb_ctwSetWindowShadow( hb_ctwCurrentWindow(),
hb_parnidef( 1, HB_CTW_SHADOW_UNDEF ) /* nAttr */ ) );
}
/* Harbour extension */
HB_FUNC( WLEVEL )
{
int iLevel;
iLevel = HB_ISNUM( 1 ) ? hb_parni( 1 ) : HB_CTW_UNDEF;
hb_retni( hb_ctwSetWindowLevel( hb_ctwCurrentWindow(), iLevel ) );
hb_retni( hb_ctwSetWindowLevel( hb_ctwCurrentWindow(),
hb_parnidef( 1, HB_CTW_UNDEF ) /* nLevel */ ) );
}

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

@@ -1326,7 +1326,7 @@ static void hb_ctw_gt_WriteCon( PHB_GT pGT, const char * pText, HB_SIZE ulLength
int iRow, iCol, iMaxRow, iMaxCol;
char szString[ WRITECON_BUFFER_SIZE ];
HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_WriteCon(%p,%p,%lu)", pGT, pText, ulLength));
HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_WriteCon(%p,%p,%" HB_PFS "u)", pGT, pText, ulLength));
iMaxRow = HB_GTSELF_MAXROW( pGT );
iMaxCol = HB_GTSELF_MAXCOL( pGT );

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

@@ -196,8 +196,7 @@ HB_FUNC( SETFATTR )
{
int iResult;
if( hb_fsSetAttr( hb_parcx( 1 ),
HB_ISNUM( 2 ) ? hb_parnl( 2 ) : HB_FA_ARCHIVE ) )
if( hb_fsSetAttr( hb_parcx( 1 ), hb_parnldef( 2, HB_FA_ARCHIVE ) ) )
iResult = 0;
else
iResult = -1;

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

@@ -91,7 +91,7 @@
HB_FUNC( PRINTSTAT )
{
HB_USHORT uiPort = HB_ISNUM( 1 ) ? ( HB_USHORT ) hb_parni( 1 ) : 1;
HB_USHORT uiPort = ( HB_USHORT ) hb_parnidef( 1, 1 );
int Status = 0;
#if defined( HB_OS_DOS )
@@ -144,7 +144,7 @@ HB_FUNC( PRINTREADY )
{
char szLPT[ 8 ];
hb_snprintf( szLPT, sizeof( szLPT ), "LPT%hu", HB_ISNUM( 1 ) ? ( HB_USHORT ) hb_parni( 1 ) : 1 );
hb_snprintf( szLPT, sizeof( szLPT ), "LPT%hu", ( HB_USHORT ) hb_parnidef( 1, 1 ) );
hb_retl( hb_printerIsReady( szLPT ) );
}

2
harbour/contrib/hbgt/strasint.c
View File

@@ -17,7 +17,7 @@ int _GT_Internal_StringAsInt(char *String, HB_ISIZ Start, HB_ISIZ End)
int Value = 0;
HB_ISIZ Digit;
HB_TRACE(HB_TR_DEBUG, ("_GT_Internal_StringAsInt(%s, %d, %d)", String, Start, End));
HB_TRACE(HB_TR_DEBUG, ("_GT_Internal_StringAsInt(%s, %" HB_PFS "d, %" HB_PFS "d)", String, Start, End));
for (Digit = End; Digit >= Start; Digit--)
{

2
harbour/contrib/hbmisc/stringsx.c
View File

@@ -14,7 +14,7 @@ static const char *hb_strtoken(const char *szText,
HB_ISIZ wEnd = 0;
HB_ISIZ wCounter = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_strtoken(%s, %ld, %ld, %d, %p)", szText, lText, lIndex, (int) cDelimiter, lLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strtoken(%s, %" HB_PFS "d, %" HB_PFS "d, %d, %p)", szText, lText, lIndex, (int) cDelimiter, lLen));
do
{

2
harbour/contrib/hbwin/win_prn3.c
View File

@@ -61,7 +61,7 @@ static TCHAR * hb_tstrncat( TCHAR * pDest, const TCHAR * pSource, HB_SIZE nLen )
{
TCHAR * pBuf = pDest;
HB_TRACE(HB_TR_DEBUG, ("hb_tstrncat(%p, %p, %lu)", pDest, pSource, nLen));
HB_TRACE(HB_TR_DEBUG, ("hb_tstrncat(%p, %p, %" HB_PFS "u)", pDest, pSource, nLen));
pDest[ nLen ] = TEXT( '\0' );

8
harbour/contrib/xhb/cstructc.c
View File

@@ -63,7 +63,7 @@
static PHB_ITEM hb_itemPutCRaw( PHB_ITEM pItem, const char * szText, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCRaw(%p, %s, %lu)", pItem, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCRaw(%p, %s, %" HB_PFS "u)", pItem, szText, ulLen));
if( pItem )
{
@@ -92,7 +92,7 @@ static PHB_ITEM hb_itemPutCRaw( PHB_ITEM pItem, const char * szText, HB_SIZE ulL
#endif
static PHB_ITEM hb_itemPutCRawStatic( PHB_ITEM pItem, const char * szText, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCRawStatic(%p, %s, %lu)", pItem, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCRawStatic(%p, %s, %" HB_PFS "u)", pItem, szText, ulLen));
if( pItem )
{
@@ -251,7 +251,7 @@ static unsigned int SizeOfCStructure( PHB_ITEM aDef, unsigned int uiAlign )
uiSize += uiMemberSize;
/* printf( "#%lu Size: %u Align: %u Pad: %u Shift %i Size: %u\n", ulIndex, uiMemberSize, uiAlign, uiPad, cShift, uiSize ); */
/* printf( "#%" HB_PFS "u Size: %u Align: %u Pad: %u Shift %i Size: %u\n", ulIndex, uiMemberSize, uiAlign, uiPad, cShift, uiSize ); */
}
@@ -260,7 +260,7 @@ static unsigned int SizeOfCStructure( PHB_ITEM aDef, unsigned int uiAlign )
uiSize += ( uiAlign - cShift );
}
/* printf( "#%lu Size: %u Align: %u Pad: %u Shift %i Size: %u\n", ulIndex, uiMemberSize, uiAlign, uiPad, cShift, uiSize ); */
/* printf( "#%" HB_PFS "u Size: %u Align: %u Pad: %u Shift %i Size: %u\n", ulIndex, uiMemberSize, uiAlign, uiPad, cShift, uiSize ); */
return uiSize;
}

68
harbour/contrib/xhb/freadlin.c
View File

@@ -58,17 +58,17 @@
#define READING_BLOCK 4096
char * hb_fsReadLine( HB_FHANDLE hFileHandle, HB_ISIZ * plBuffLen, const char ** Term, HB_ISIZ * iTermSizes, HB_ISIZ iTerms, HB_BOOL * bFound, HB_BOOL * bEOF )
char * hb_fsReadLine( HB_FHANDLE hFileHandle, HB_ISIZ * plBuffLen, const char ** pTerm, HB_ISIZ * piTermSizes, HB_ISIZ iTerms, HB_BOOL * pbFound, HB_BOOL * pbEOF )
{
HB_ISIZ iPosTerm = 0, iPos, iPosition;
int nTries;
HB_ISIZ lRead = 0, lOffset, lSize;
char * pBuff;
HB_TRACE(HB_TR_DEBUG, ("hb_fsReadLine(%p, %ld, %p, %p, %ld, %p, %p)", ( void * ) ( HB_PTRDIFF ) hFileHandle, *plBuffLen, Term, iTermSizes, ( long ) iTerms, bFound, bEOF ));
HB_TRACE(HB_TR_DEBUG, ("hb_fsReadLine(%p, %" HB_PFS "d, %p, %p, %" HB_PFS "d, %p, %p)", ( void * ) ( HB_PTRDIFF ) hFileHandle, *plBuffLen, pTerm, piTermSizes, iTerms, pbFound, pbEOF ));
*bFound = HB_FALSE;
*bEOF = HB_FALSE;
*pbFound = HB_FALSE;
*pbEOF = HB_FALSE;
nTries = 0;
lOffset = 0;
lSize = *plBuffLen;
@@ -100,31 +100,31 @@ char * hb_fsReadLine( HB_FHANDLE hFileHandle, HB_ISIZ * plBuffLen, const char **
for( iPosTerm = 0; iPosTerm < iTerms; iPosTerm++ )
{
/* Compare with the LAST terminator byte */
if( pBuff[lOffset+iPos] == Term[iPosTerm][iTermSizes[iPosTerm]-1] && (iTermSizes[iPosTerm]-1) <= (iPos+lOffset) )
if( pBuff[lOffset+iPos] == pTerm[iPosTerm][piTermSizes[iPosTerm]-1] && (piTermSizes[iPosTerm]-1) <= (iPos+lOffset) )
{
*bFound = HB_TRUE;
*pbFound = HB_TRUE;
for(iPosition=0; iPosition < (iTermSizes[iPosTerm]-1); iPosition++)
for(iPosition=0; iPosition < (piTermSizes[iPosTerm]-1); iPosition++)
{
if(Term[iPosTerm][iPosition] != pBuff[ lOffset+(iPos-iTermSizes[iPosTerm])+iPosition+1 ])
if(pTerm[iPosTerm][iPosition] != pBuff[ lOffset+(iPos-piTermSizes[iPosTerm])+iPosition+1 ])
{
*bFound = HB_FALSE;
*pbFound = HB_FALSE;
break;
}
}
if( *bFound )
if( *pbFound )
break;
}
}
if( *bFound )
if( *pbFound )
break;
}
if( *bFound )
if( *pbFound )
{
*plBuffLen = lOffset + iPos - iTermSizes[ iPosTerm ] + 1;
*plBuffLen = lOffset + iPos - piTermSizes[ iPosTerm ] + 1;
pBuff[ *plBuffLen ] = '\0';
@@ -136,7 +136,7 @@ char * hb_fsReadLine( HB_FHANDLE hFileHandle, HB_ISIZ * plBuffLen, const char **
}
else
{
if( ! *bFound )
if( ! *pbFound )
{
if( nTries == 0 )
{
@@ -149,13 +149,13 @@ char * hb_fsReadLine( HB_FHANDLE hFileHandle, HB_ISIZ * plBuffLen, const char **
*plBuffLen = lOffset + lRead;
}
*bEOF = HB_TRUE;
*pbEOF = HB_TRUE;
}
}
nTries++;
}
while( ( ! *bFound ) && lRead > 0 );
while( ( ! *pbFound ) && lRead > 0 );
return pBuff;
}
@@ -168,7 +168,7 @@ HB_FUNC( HB_FREADLINE )
HB_FHANDLE hFileHandle = ( HB_FHANDLE ) hb_parnint( 1 );
const char ** Term;
char * pBuffer;
HB_ISIZ * iTermSizes;
HB_ISIZ * piTermSizes;
HB_ISIZ lSize = hb_parns( 4 );
HB_ISIZ i, iTerms;
HB_BOOL bFound, bEOF;
@@ -201,41 +201,41 @@ HB_FUNC( HB_FREADLINE )
}
Term = ( const char ** ) hb_xgrab( sizeof( char * ) * iTerms );
iTermSizes = ( HB_ISIZ * ) hb_xgrab( sizeof( HB_ISIZ ) * iTerms );
piTermSizes = ( HB_ISIZ * ) hb_xgrab( sizeof( HB_ISIZ ) * iTerms );
for( i = 0; i < iTerms; i++ )
{
Term[ i ] = hb_arrayGetCPtr( pTerm1, i + 1 );
iTermSizes[ i ] = hb_arrayGetCLen( pTerm1, i + 1 );
Term[ i ] = hb_arrayGetCPtr( pTerm1, i + 1 );
piTermSizes[ i ] = hb_arrayGetCLen( pTerm1, i + 1 );
}
}
else
{
pTerm1 = hb_param( 3, HB_IT_STRING );
Term = ( const char ** ) hb_xgrab( sizeof( char * ) );
iTermSizes = ( HB_ISIZ * ) hb_xgrab( sizeof( HB_ISIZ ) );
Term[ 0 ] = hb_itemGetCPtr( pTerm1 );
iTermSizes[ 0 ] = hb_itemGetCLen( pTerm1 );
iTerms = 1;
pTerm1 = hb_param( 3, HB_IT_STRING );
Term = ( const char ** ) hb_xgrab( sizeof( char * ) );
piTermSizes = ( HB_ISIZ * ) hb_xgrab( sizeof( HB_ISIZ ) );
Term[ 0 ] = hb_itemGetCPtr( pTerm1 );
piTermSizes[ 0 ] = hb_itemGetCLen( pTerm1 );
iTerms = 1;
}
}
else
{
Term = ( const char ** ) hb_xgrab( sizeof( char * ) );
iTermSizes = ( HB_ISIZ * ) hb_xgrab( sizeof( HB_ISIZ ) );
Term[ 0 ] = "\r\n"; /* Should be preplaced with the default EOL sequence */
iTerms = 1;
iTermSizes[ 0 ] = 2;
Term = ( const char ** ) hb_xgrab( sizeof( char * ) );
piTermSizes = ( HB_ISIZ * ) hb_xgrab( sizeof( HB_ISIZ ) );
Term[ 0 ] = "\r\n"; /* Should be preplaced with the default EOL sequence */
iTerms = 1;
piTermSizes[ 0 ] = 2;
}
if( lSize == 0 )
lSize = READING_BLOCK;
pBuffer = hb_fsReadLine( hFileHandle, &lSize, Term, iTermSizes, iTerms, &bFound, &bEOF );
pBuffer = hb_fsReadLine( hFileHandle, &lSize, Term, piTermSizes, iTerms, &bFound, &bEOF );
if( ! hb_storclen_buffer( pBuffer, lSize, 2 ) )
hb_xfree( pBuffer );
hb_retns( bEOF ? -1 : 0 );
hb_xfree( ( void * ) Term );
hb_xfree( iTermSizes );
hb_xfree( Term );
hb_xfree( piTermSizes );
}

46
harbour/contrib/xhb/txtline.c
View File

@@ -56,13 +56,13 @@
#include "hbapiitm.h"
#include "hbapierr.h"
void hb_readLine( const char * szText, HB_SIZE ulTextLen, HB_SIZE uiLineLen, HB_SIZE uiTabLen, HB_BOOL bWrap, char ** Term, HB_SIZE * iTermSizes, HB_SIZE uiTerms, HB_BOOL * bFound, HB_BOOL * bEOF, HB_ISIZ * lEnd, HB_SIZE * ulEndOffset )
void hb_readLine( const char * szText, HB_SIZE ulTextLen, HB_SIZE uiLineLen, HB_SIZE uiTabLen, HB_BOOL bWrap, char ** pTerm, HB_SIZE * piTermSizes, HB_SIZE uiTerms, HB_BOOL * bFound, HB_BOOL * bEOF, HB_ISIZ * lEnd, HB_SIZE * ulEndOffset )
{
HB_SIZE uiPosTerm, uiPosition;
HB_SIZE ulPos, ulCurrCol, ulLastBlk;
HB_BOOL bBreak = HB_FALSE;
HB_TRACE(HB_TR_DEBUG, ("hb_readLine(%p, %lu, %lu, %lu, %d, %p, %p, %lu, %p, %p, %p, %p)", szText, ulTextLen, uiLineLen, uiTabLen, bWrap, Term, iTermSizes, uiTerms, bFound, bEOF, lEnd, ulEndOffset ));
HB_TRACE(HB_TR_DEBUG, ("hb_readLine(%p, %" HB_PFS "u, %" HB_PFS "u, %" HB_PFS "u, %d, %p, %p, %" HB_PFS "u, %p, %p, %p, %p)", szText, ulTextLen, uiLineLen, uiTabLen, bWrap, pTerm, piTermSizes, uiTerms, bFound, bEOF, lEnd, ulEndOffset ));
*bFound = 0;
*bEOF = 0;
@@ -86,13 +86,13 @@ void hb_readLine( const char * szText, HB_SIZE ulTextLen, HB_SIZE uiLineLen, HB_
/* Check for line terminators */
for( uiPosTerm = 0; uiPosTerm < uiTerms; uiPosTerm++ )
{
if( szText[ulPos] == Term[uiPosTerm][0] && (ulPos + iTermSizes[uiPosTerm] - 1) < ulTextLen )
if( szText[ulPos] == pTerm[uiPosTerm][0] && (ulPos + piTermSizes[uiPosTerm] - 1) < ulTextLen )
{
*bFound = 1;
for( uiPosition = 1; uiPosition < iTermSizes[uiPosTerm]; uiPosition++ )
for( uiPosition = 1; uiPosition < piTermSizes[uiPosTerm]; uiPosition++ )
{
if( Term[uiPosTerm][uiPosition] != szText[ ulPos+uiPosition ] )
if( pTerm[uiPosTerm][uiPosition] != szText[ ulPos+uiPosition ] )
{
*bFound = 0;
break;
@@ -104,12 +104,12 @@ void hb_readLine( const char * szText, HB_SIZE ulTextLen, HB_SIZE uiLineLen, HB_
if( ulPos == 0 )
{
*lEnd = -1;
*ulEndOffset = iTermSizes[uiPosTerm];
*ulEndOffset = piTermSizes[uiPosTerm];
}
else
{
*lEnd = ulPos - 1;
*ulEndOffset = ulPos + iTermSizes[uiPosTerm];
*ulEndOffset = ulPos + piTermSizes[uiPosTerm];
}
break;
}
@@ -225,8 +225,8 @@ HB_FUNC( HB_READLINE )
{
PHB_ITEM pTerm1;
const char * szText = hb_parcx( 1 );
char ** Term;
HB_SIZE * iTermSizes;
char ** pTerm;
HB_SIZE * piTermSizes;
HB_SIZE uiTabLen, uiTerms;
HB_SIZE ulLineSize = hb_parni(3);
HB_SIZE i;
@@ -244,8 +244,8 @@ HB_FUNC( HB_READLINE )
return;
}
ulTextLen = hb_parclen(1);
uiTabLen = hb_parclen(4);
ulTextLen = hb_parclen( 1 );
uiTabLen = hb_parclen( 4 );
ulStartOffset = hb_parns( 6 );
@@ -270,30 +270,30 @@ HB_FUNC( HB_READLINE )
if( HB_IS_ARRAY( pTerm1 ) )
{
uiTerms = hb_arrayLen( pTerm1 );
Term = ( char ** ) hb_xgrab( sizeof( char * ) * uiTerms );
iTermSizes = ( HB_SIZE * ) hb_xgrab( sizeof( HB_SIZE ) * uiTerms );
pTerm = ( char ** ) hb_xgrab( sizeof( char * ) * uiTerms );
piTermSizes = ( HB_SIZE * ) hb_xgrab( sizeof( HB_SIZE ) * uiTerms );
for( i = 0; i < uiTerms; i++ )
{
hb_arrayGet( pTerm1, i + 1, pOpt );
Term[ i ] = ( char * ) hb_itemGetCPtr( pOpt );
iTermSizes[ i ] = hb_itemGetCLen( pOpt );
pTerm[ i ] = ( char * ) hb_itemGetCPtr( pOpt );
piTermSizes[ i ] = hb_itemGetCLen( pOpt );
}
}
else
{
Term = ( char ** ) hb_xgrab( sizeof( char * ) );
iTermSizes = ( HB_SIZE * ) hb_xgrab( sizeof( HB_SIZE ) * 1 );
Term[ 0 ] = ( char * ) hb_itemGetCPtr( pTerm1 );
iTermSizes[ 0 ] = hb_itemGetCLen( pTerm1 );
uiTerms = 1;
pTerm = ( char ** ) hb_xgrab( sizeof( char * ) );
piTermSizes = ( HB_SIZE * ) hb_xgrab( sizeof( HB_SIZE ) * 1 );
pTerm[ 0 ] = ( char * ) hb_itemGetCPtr( pTerm1 );
piTermSizes[ 0 ] = hb_itemGetCLen( pTerm1 );
uiTerms = 1;
}
hb_itemRelease( pOpt );
ulStartOffset--;
hb_readLine( szText + ulStartOffset, ulTextLen - ulStartOffset, ulLineSize, uiTabLen, bWrap, Term, iTermSizes, uiTerms, &bFound, &bEOF, &lEnd, &ulEndOffset );
hb_readLine( szText + ulStartOffset, ulTextLen - ulStartOffset, ulLineSize, uiTabLen, bWrap, pTerm, piTermSizes, uiTerms, &bFound, &bEOF, &lEnd, &ulEndOffset );
hb_storl( bFound, 7 );
hb_storl( bEOF, 8 );
@@ -303,6 +303,6 @@ HB_FUNC( HB_READLINE )
if( bAlloc_Term1 )
hb_itemRelease( pTerm1 );
hb_xfree( Term );
hb_xfree( iTermSizes );
hb_xfree( pTerm );
hb_xfree( piTermSizes );
}

4
harbour/contrib/xhb/xhbat.c
View File

@@ -61,7 +61,7 @@ HB_SIZE hb_AtSkipStrings( const char * szSub, HB_SIZE ulSubLen, const char * szT
{
char cLastChar = ' ';
HB_TRACE(HB_TR_DEBUG, ("hb_AtSkipStrings(%s, %lu, %s, %lu)", szSub, ulSubLen, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_AtSkipStrings(%s, %" HB_PFS "u, %s, %" HB_PFS "u)", szSub, ulSubLen, szText, ulLen));
if( ulSubLen > 0 && ulLen >= ulSubLen )
{
@@ -168,7 +168,7 @@ HB_FUNC( ATSKIPSTRINGS ) /* cFind, cWhere, nStart */
/* Case insensitive hb_strAt() function */
static HB_SIZE hb_strAtI( const char * szSub, HB_SIZE ulSubLen, const char * szText, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strAtI(%s, %lu, %s, %lu)", szSub, ulSubLen, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strAtI(%s, %" HB_PFS "u, %s, %" HB_PFS "u)", szSub, ulSubLen, szText, ulLen));
if( ulSubLen > 0 && ulLen >= ulSubLen )
{

4
harbour/src/common/hbmem.c
View File

@@ -71,7 +71,7 @@ void * hb_xmemcpy( void * pDestArg, void * pSourceArg, HB_SIZE ulLen )
HB_SIZE ulRemaining;
int iCopySize;
HB_TRACE(HB_TR_DEBUG, ("hb_xmemcpy(%p, %p, %lu)", pDestArg, pSourceArg, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_xmemcpy(%p, %p, %" HB_PFS "u)", pDestArg, pSourceArg, ulLen));
pDest = ( HB_BYTE * ) pDestArg;
pSource = ( HB_BYTE * ) pSourceArg;
@@ -106,7 +106,7 @@ void * hb_xmemset( void * pDestArg, int iFill, HB_SIZE ulLen )
HB_SIZE ulRemaining;
int iSetSize;
HB_TRACE(HB_TR_DEBUG, ("hb_xmemset(%p, %d, %lu)", pDestArg, iFill, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_xmemset(%p, %d, %" HB_PFS "u)", pDestArg, iFill, ulLen));
pDest = ( HB_BYTE * ) pDestArg;
ulRemaining = ulLen;

40
harbour/src/common/hbstr.c
View File

@@ -83,7 +83,7 @@ const char * hb_szAscii[ 256 ] = { "\x00", "\x01", "\x02", "\x03", "\x04", "\x05
HB_SIZE hb_strAt( const char * szSub, HB_SIZE ulSubLen, const char * szText, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strAt(%s, %lu, %s, %lu)", szSub, ulSubLen, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strAt(%s, %" HB_PFS "u, %s, %" HB_PFS "u)", szSub, ulSubLen, szText, ulLen));
if( ulSubLen > 0 && ulLen >= ulSubLen )
{
@@ -116,7 +116,7 @@ HB_SIZE hb_strAt( const char * szSub, HB_SIZE ulSubLen, const char * szText, HB_
HB_BOOL hb_strEmpty( const char * szText, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strEmpty(%s, %lu)", szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strEmpty(%s, %" HB_PFS "u)", szText, ulLen));
while( ulLen-- )
{
@@ -156,9 +156,11 @@ char * hb_strlow( char * pszText )
char * hb_strdup( const char * pszText )
{
char * pszDup;
HB_SIZE ulLen = strlen( pszText ) + 1;
HB_SIZE ulLen;
HB_TRACE(HB_TR_DEBUG, ("hb_strdup(%s, %ld)", pszText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strdup(%s)", pszText));
ulLen = strlen( pszText ) + 1;
pszDup = ( char * ) hb_xgrab( ulLen );
memcpy( pszDup, pszText, ulLen );
@@ -171,7 +173,7 @@ char * hb_strndup( const char * pszText, HB_SIZE ulLen )
char * pszDup;
HB_SIZE ul;
HB_TRACE(HB_TR_DEBUG, ("hb_strndup(%.*s, %ld)", ( int ) ulLen, pszText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strndup(%.*s, %" HB_PFS "d)", ( int ) ulLen, pszText, ulLen));
ul = 0;
pszDup = ( char * ) pszText;
@@ -189,7 +191,7 @@ HB_SIZE hb_strnlen( const char * pszText, HB_SIZE ulLen )
{
HB_SIZE ul = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_strnlen(%.*s, %ld)", ( int ) ulLen, pszText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strnlen(%.*s, %" HB_PFS "d)", ( int ) ulLen, pszText, ulLen));
while( ulLen-- && *pszText++ )
++ul;
@@ -267,7 +269,7 @@ int hb_strnicmp( const char * s1, const char * s2, HB_SIZE count )
HB_SIZE ulCount;
int rc = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_strnicmp(%.*s, %s, %lu)", ( int ) count, s1, s2, count));
HB_TRACE(HB_TR_DEBUG, ("hb_strnicmp(%.*s, %s, %" HB_PFS "u)", ( int ) count, s1, s2, count));
for( ulCount = 0; ulCount < count; ulCount++ )
{
@@ -541,7 +543,7 @@ static HB_BOOL hb_str2number( HB_BOOL fPCode, const char * szNum, HB_SIZE ulLen,
HB_SIZE ulPos = 0;
int c, iWidth, iDec = 0, iDecR = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_str2number(%d, %p, %lu, %p, %p, %p, %p)", (int) fPCode, szNum, ulLen, lVal, dVal, piDec, piWidth ));
HB_TRACE(HB_TR_DEBUG, ("hb_str2number(%d, %p, %" HB_PFS "u, %p, %p, %p, %p)", (int) fPCode, szNum, ulLen, lVal, dVal, piDec, piWidth ));
while( ulPos < ulLen && HB_ISSPACE( szNum[ulPos] ) )
ulPos++;
@@ -702,13 +704,13 @@ static HB_BOOL hb_str2number( HB_BOOL fPCode, const char * szNum, HB_SIZE ulLen,
HB_BOOL hb_compStrToNum( const char* szNum, HB_SIZE ulLen, HB_MAXINT * plVal, double * pdVal, int * piDec, int * piWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_compStrToNum( %s, %lu, %p, %p, %p, %p)", szNum, ulLen, plVal, pdVal, piDec, piWidth ));
HB_TRACE(HB_TR_DEBUG, ("hb_compStrToNum( %s, %" HB_PFS "u, %p, %p, %p, %p)", szNum, ulLen, plVal, pdVal, piDec, piWidth ));
return hb_str2number( HB_TRUE, szNum, ulLen, plVal, pdVal, piDec, piWidth );
}
HB_BOOL hb_valStrnToNum( const char* szNum, HB_SIZE ulLen, HB_MAXINT * plVal, double * pdVal, int * piDec, int * piWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_valStrnToNum( %s, %lu, %p, %p, %p, %p)", szNum, ulLen, plVal, pdVal, piDec, piWidth ));
HB_TRACE(HB_TR_DEBUG, ("hb_valStrnToNum( %s, %" HB_PFS "u, %p, %p, %p, %p)", szNum, ulLen, plVal, pdVal, piDec, piWidth ));
return hb_str2number( HB_FALSE, szNum, ulLen, plVal, pdVal, piDec, piWidth );
}
@@ -720,7 +722,7 @@ HB_BOOL hb_strToNum( const char* szNum, HB_MAXINT * plVal, double * pdVal )
HB_BOOL hb_strnToNum( const char* szNum, HB_SIZE ulLen, HB_MAXINT * plVal, double * pdVal )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strnToNum(%.*s, %lu, %p, %p)", ( int ) ulLen, szNum, ulLen, plVal, pdVal ));
HB_TRACE(HB_TR_DEBUG, ("hb_strnToNum(%.*s, %" HB_PFS "u, %p, %p)", ( int ) ulLen, szNum, ulLen, plVal, pdVal ));
return hb_str2number( HB_FALSE, szNum, ulLen, plVal, pdVal, NULL, NULL );
}
@@ -730,7 +732,7 @@ double hb_strVal( const char * szText, HB_SIZE ulLen )
HB_MAXINT lVal;
double dVal;
HB_TRACE(HB_TR_DEBUG, ("hb_strVal(%.*s, %lu)", ( int ) ulLen, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strVal(%.*s, %" HB_PFS "u)", ( int ) ulLen, szText, ulLen));
if( ! hb_str2number( HB_FALSE, szText, ulLen, &lVal, &dVal, NULL, NULL ) )
dVal = ( double ) lVal;
@@ -758,7 +760,7 @@ char * hb_numToStr( char * szBuf, HB_SIZE ulSize, HB_MAXINT lNumber )
int iPos = ( int ) ulSize;
HB_BOOL fNeg = HB_FALSE;
HB_TRACE(HB_TR_DEBUG, ("hb_numToStr(%p, %lu, %" PFHL "i)", szBuf, ulSize, lNumber));
HB_TRACE(HB_TR_DEBUG, ("hb_numToStr(%p, %" HB_PFS "u, %" PFHL "i)", szBuf, ulSize, lNumber));
szBuf[ --iPos ] = '\0';
if( lNumber < 0 )
@@ -797,7 +799,7 @@ char * hb_strncpy( char * pDest, const char * pSource, HB_SIZE ulLen )
{
char * pBuf = pDest;
HB_TRACE(HB_TR_DEBUG, ("hb_strncpy(%p, %.*s, %lu)", pDest, ( int ) ulLen, pSource, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strncpy(%p, %.*s, %" HB_PFS "u)", pDest, ( int ) ulLen, pSource, ulLen));
pDest[ ulLen ] = '\0';
@@ -816,7 +818,7 @@ char * hb_strncat( char * pDest, const char * pSource, HB_SIZE ulLen )
{
char * pBuf = pDest;
HB_TRACE(HB_TR_DEBUG, ("hb_strncat(%p, %.*s, %lu)", pDest, ( int ) ulLen, pSource, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strncat(%p, %.*s, %" HB_PFS "u)", pDest, ( int ) ulLen, pSource, ulLen));
pDest[ ulLen ] = '\0';
@@ -843,7 +845,7 @@ char * hb_strncpyLower( char * pDest, const char * pSource, HB_SIZE ulLen )
{
char * pBuf = pDest;
HB_TRACE(HB_TR_DEBUG, ("hb_strncpyLower(%p, %.*s, %lu)", pDest, ( int ) ulLen, pSource, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strncpyLower(%p, %.*s, %" HB_PFS "u)", pDest, ( int ) ulLen, pSource, ulLen));
pDest[ ulLen ] = '\0';
@@ -867,7 +869,7 @@ char * hb_strncpyUpper( char * pDest, const char * pSource, HB_SIZE ulLen )
{
char * pBuf = pDest;
HB_TRACE(HB_TR_DEBUG, ("hb_strncpyUpper(%p, %.*s, %lu)", pDest, ( int ) ulLen, pSource, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strncpyUpper(%p, %.*s, %" HB_PFS "u)", pDest, ( int ) ulLen, pSource, ulLen));
pDest[ ulLen ] = '\0';
@@ -892,7 +894,7 @@ char * hb_strncpyUpperTrim( char * pDest, const char * pSource, HB_SIZE ulLen )
char * pBuf = pDest;
HB_SIZE ulSLen;
HB_TRACE(HB_TR_DEBUG, ("hb_strncpyUpperTrim(%p, %.*s, %lu)", pDest, ( int ) ulLen, pSource, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strncpyUpperTrim(%p, %.*s, %" HB_PFS "u)", pDest, ( int ) ulLen, pSource, ulLen));
ulSLen = 0;
while( ulSLen < ulLen && pSource[ ulSLen ] )
@@ -924,7 +926,7 @@ char * hb_strncpyTrim( char * pDest, const char * pSource, HB_SIZE ulLen )
char * pBuf = pDest;
HB_SIZE ulSLen;
HB_TRACE(HB_TR_DEBUG, ("hb_strncpyTrim(%p, %.*s, %lu)", pDest, ( int ) ulLen, pSource, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strncpyTrim(%p, %.*s, %" HB_PFS "u)", pDest, ( int ) ulLen, pSource, ulLen));
ulSLen = 0;
while( ulSLen < ulLen && pSource[ ulSLen ] )

2
harbour/src/rtl/ati.c
View File

@@ -57,7 +57,7 @@
static HB_SIZE hb_strAtI( const char * szSub, HB_SIZE nSubLen, const char * szText, HB_SIZE nLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strAt(%s, %lu, %s, %lu)", szSub, nSubLen, szText, nLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strAt(%s, %" HB_PFS "u, %s, %" HB_PFS "u)", szSub, nSubLen, szText, nLen));
if( nSubLen > 0 && nLen >= nSubLen )
{

4
harbour/src/rtl/cdpapi.c
View File

@@ -223,7 +223,7 @@ int hb_charUpper( int iChar )
char * hb_strLower( char * szText, HB_SIZE nLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strLower(%s, %lu)", szText, nLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strLower(%s, %" HB_PFS "u)", szText, nLen));
{
PHB_CODEPAGE cdp = hb_vmCDP();
@@ -242,7 +242,7 @@ char * hb_strLower( char * szText, HB_SIZE nLen )
char * hb_strUpper( char * szText, HB_SIZE nLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strUpper(%s, %lu)", szText, nLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strUpper(%s, %" HB_PFS "u)", szText, nLen));
{
PHB_CODEPAGE cdp = hb_vmCDP();

8
harbour/src/rtl/console.c
View File

@@ -210,7 +210,7 @@ HB_FUNC( HB_OSNEWLINE )
/* Output an item to STDOUT */
void hb_conOutStd( const char * szStr, HB_SIZE nLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_conOutStd(%s, %lu)", szStr, nLen));
HB_TRACE(HB_TR_DEBUG, ("hb_conOutStd(%s, %" HB_PFS "u)", szStr, nLen));
if( nLen == 0 )
nLen = strlen( szStr );
@@ -222,7 +222,7 @@ void hb_conOutStd( const char * szStr, HB_SIZE nLen )
/* Output an item to STDERR */
void hb_conOutErr( const char * szStr, HB_SIZE nLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_conOutErr(%s, %lu)", szStr, nLen));
HB_TRACE(HB_TR_DEBUG, ("hb_conOutErr(%s, %" HB_PFS "u)", szStr, nLen));
if( nLen == 0 )
nLen = strlen( szStr );
@@ -236,7 +236,7 @@ void hb_conOutAlt( const char * szStr, HB_SIZE nLen )
{
HB_FHANDLE hFile;
HB_TRACE(HB_TR_DEBUG, ("hb_conOutAlt(%s, %lu)", szStr, nLen));
HB_TRACE(HB_TR_DEBUG, ("hb_conOutAlt(%s, %" HB_PFS "u)", szStr, nLen));
if( hb_setGetConsole() )
hb_gtWriteCon( szStr, nLen );
@@ -266,7 +266,7 @@ static void hb_conOutDev( const char * szStr, HB_SIZE nLen )
{
HB_FHANDLE hFile;
HB_TRACE(HB_TR_DEBUG, ("hb_conOutDev(%s, %lu)", szStr, nLen));
HB_TRACE(HB_TR_DEBUG, ("hb_conOutDev(%s, %" HB_PFS "u)", szStr, nLen));
if( ( hFile = hb_setGetPrinterHandle( HB_SET_PRN_DEV ) ) != FS_ERROR )
{

2
harbour/src/rtl/descend.c
View File

@@ -55,7 +55,7 @@
void hb_strDescend( char * szStringTo, const char * szStringFrom, HB_SIZE nLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strDescend(%p, %s, %lu)", szStringTo, szStringFrom, nLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strDescend(%p, %s, %" HB_PFS "u)", szStringTo, szStringFrom, nLen));
if( nLen == 1 && szStringFrom[ 0 ] == '\0' )
szStringTo[ 0 ] = '\0';

8
harbour/src/rtl/filesys.c
View File

@@ -1569,7 +1569,7 @@ HB_SIZE hb_fsReadLarge( HB_FHANDLE hFileHandle, void * pBuff, HB_SIZE nCount )
{
HB_SIZE nRead;
HB_TRACE(HB_TR_DEBUG, ("hb_fsReadLarge(%p, %p, %lu)", ( void * ) ( HB_PTRDIFF ) hFileHandle, pBuff, nCount));
HB_TRACE(HB_TR_DEBUG, ("hb_fsReadLarge(%p, %p, %" HB_PFS "u)", ( void * ) ( HB_PTRDIFF ) hFileHandle, pBuff, nCount));
#if defined( HB_FS_FILE_IO )
@@ -1695,7 +1695,7 @@ HB_SIZE hb_fsWriteLarge( HB_FHANDLE hFileHandle, const void * pBuff, HB_SIZE nCo
{
HB_SIZE nWritten;
HB_TRACE(HB_TR_DEBUG, ("hb_fsWriteLarge(%p, %p, %lu)", ( void * ) ( HB_PTRDIFF ) hFileHandle, pBuff, nCount));
HB_TRACE(HB_TR_DEBUG, ("hb_fsWriteLarge(%p, %p, %" HB_PFS "u)", ( void * ) ( HB_PTRDIFF ) hFileHandle, pBuff, nCount));
#if defined( HB_FS_FILE_IO )
@@ -1845,7 +1845,7 @@ HB_SIZE hb_fsReadAt( HB_FHANDLE hFileHandle, void * pBuff, HB_SIZE nCount, HB_FO
{
HB_SIZE nRead;
HB_TRACE(HB_TR_DEBUG, ("hb_fsReadAt(%p, %p, %lu, %" PFHL "i)", ( void * ) ( HB_PTRDIFF ) hFileHandle, pBuff, nCount, llOffset));
HB_TRACE(HB_TR_DEBUG, ("hb_fsReadAt(%p, %p, %" HB_PFS "u, %" PFHL "i)", ( void * ) ( HB_PTRDIFF ) hFileHandle, pBuff, nCount, llOffset));
#if defined( HB_FS_FILE_IO )
@@ -1983,7 +1983,7 @@ HB_SIZE hb_fsWriteAt( HB_FHANDLE hFileHandle, const void * pBuff, HB_SIZE nCount
{
HB_SIZE nWritten;
HB_TRACE(HB_TR_DEBUG, ("hb_fsWriteAt(%p, %p, %lu, %" PFHL "i)", ( void * ) ( HB_PTRDIFF ) hFileHandle, pBuff, nCount, llOffset));
HB_TRACE(HB_TR_DEBUG, ("hb_fsWriteAt(%p, %p, %" HB_PFS "u, %" PFHL "i)", ( void * ) ( HB_PTRDIFF ) hFileHandle, pBuff, nCount, llOffset));
#if defined( HB_FS_FILE_IO )

14
harbour/src/rtl/gtapi.c
View File

@@ -588,7 +588,7 @@ HB_ERRCODE hb_gtRepChar( int iRow, int iCol, HB_USHORT usChar, HB_SIZE ulCount )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtRepChar(%d, %d, %hu, %lu)", iRow, iCol, usChar, ulCount));
HB_TRACE(HB_TR_DEBUG, ("hb_gtRepChar(%d, %d, %hu, %" HB_PFS "u)", iRow, iCol, usChar, ulCount));
pGT = hb_gt_Base();
if( pGT )
@@ -759,7 +759,7 @@ HB_ERRCODE hb_gtPutText( int iRow, int iCol,
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtPutText(%d, %d, %p, %lu, %d)", iRow, iCol, szStr, ulLength, iColor));
HB_TRACE(HB_TR_DEBUG, ("hb_gtPutText(%d, %d, %p, %" HB_PFS "u, %d)", iRow, iCol, szStr, ulLength, iColor));
pGT = hb_gt_Base();
if( pGT )
@@ -780,7 +780,7 @@ HB_ERRCODE hb_gtWriteAt( int iRow, int iCol, const char * szStr, HB_SIZE ulLengt
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtWriteAt(%d, %d, %p, %lu)", iRow, iCol, szStr, ulLength));
HB_TRACE(HB_TR_DEBUG, ("hb_gtWriteAt(%d, %d, %p, %" HB_PFS "u)", iRow, iCol, szStr, ulLength));
pGT = hb_gt_Base();
if( pGT )
@@ -797,7 +797,7 @@ HB_ERRCODE hb_gtWrite( const char * szStr, HB_SIZE ulLength )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtWrite(%p, %lu)", szStr, ulLength));
HB_TRACE(HB_TR_DEBUG, ("hb_gtWrite(%p, %" HB_PFS "u)", szStr, ulLength));
pGT = hb_gt_Base();
if( pGT )
@@ -814,7 +814,7 @@ HB_ERRCODE hb_gtWriteCon( const char * szStr, HB_SIZE ulLength )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtWriteCon(%p, %lu)", szStr, ulLength));
HB_TRACE(HB_TR_DEBUG, ("hb_gtWriteCon(%p, %" HB_PFS "u)", szStr, ulLength));
pGT = hb_gt_Base();
if( pGT )
@@ -967,7 +967,7 @@ HB_ERRCODE hb_gtOutStd( const char * szStr, HB_SIZE ulLen )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtOutStd(%p, %lu)", szStr, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_gtOutStd(%p, %" HB_PFS "u)", szStr, ulLen));
pGT = hb_gt_Base();
if( pGT )
@@ -985,7 +985,7 @@ HB_ERRCODE hb_gtOutErr( const char * szStr, HB_SIZE ulLen )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_gtOutErr(%p, %lu)", szStr, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_gtOutErr(%p, %" HB_PFS "u)", szStr, ulLen));
pGT = hb_gt_Base();
if( pGT )

2
harbour/src/rtl/hardcr.c
View File

@@ -57,7 +57,7 @@ static char * hb_strHardCR( char * pszString, HB_SIZE ulStringLen )
{
HB_SIZE ulStringPos;
HB_TRACE(HB_TR_DEBUG, ("hb_strHardCR(%s, %lu)", pszString, ulStringLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strHardCR(%s, %" HB_PFS "u)", pszString, ulStringLen));
for( ulStringPos = 0; ulStringPos < ulStringLen; ulStringPos++ )
{

2
harbour/src/rtl/hbgtcore.c
View File

@@ -2517,7 +2517,7 @@ static int hb_gt_def_InkeySetLast( PHB_GT pGT, int iKey )
/* Set text into inkey buffer */
static void hb_gt_def_InkeySetText( PHB_GT pGT, const char * szText, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeySetText(%p,%s,%lu)", pGT, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeySetText(%p,%s,%" HB_PFS "u)", pGT, szText, ulLen));
if( pGT->StrBuffer )
{

2
harbour/src/rtl/hbproces.c
View File

@@ -944,7 +944,7 @@ int hb_fsProcessRun( const char * pszFilename,
char * pszFree = NULL;
int iResult;
HB_TRACE(HB_TR_DEBUG, ("hb_fsProcessRun(%s, %p, %lu, %p, %p, %p, %p, %d)", pStdInBuf, pStdInBuf, ulStdInLen, pStdOutPtr, pulStdOut, pStdErrPtr, pulStdErr, fDetach));
HB_TRACE(HB_TR_DEBUG, ("hb_fsProcessRun(%s, %p, %" HB_PFS "u, %p, %p, %p, %p, %d)", pStdInBuf, pStdInBuf, ulStdInLen, pStdOutPtr, pulStdOut, pStdErrPtr, pulStdErr, fDetach));
pszFilename = hb_osEncodeCP( pszFilename, &pszFree, NULL );

2
harbour/src/rtl/inkeyapi.c
View File

@@ -162,7 +162,7 @@ void hb_inkeySetText( const char * szText, HB_SIZE ulLen )
{
PHB_GT pGT;
HB_TRACE(HB_TR_DEBUG, ("hb_inkeySetText(%s,%lu)", szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_inkeySetText(%s,%" HB_PFS "u)", szText, ulLen));
pGT = hb_gt_Base();
if( pGT )

2
harbour/src/rtl/mtran.c
View File

@@ -60,7 +60,7 @@ static char * hb_strMemotran( char * pszResult, HB_SIZE * ulResultLen, const cha
HB_SIZE ulStringPos = 0;
HB_SIZE ulResultPos = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_strMemotran(%p, %p, %s, %lu, %x, %x)", pszResult, ulResultLen, pszString, ulStringLen, cHardcr, cSoftcr));
HB_TRACE(HB_TR_DEBUG, ("hb_strMemotran(%p, %p, %s, %" HB_PFS "u, %x, %x)", pszResult, ulResultLen, pszString, ulStringLen, cHardcr, cSoftcr));
while( ulStringPos < ulStringLen )
{

90
harbour/src/vm/arrays.c
View File

@@ -185,7 +185,7 @@ HB_BOOL hb_arrayNew( PHB_ITEM pItem, HB_SIZE ulLen ) /* creates a new array */
PHB_ITEM pItems;
HB_SIZE ulPos;
HB_TRACE(HB_TR_DEBUG, ("hb_arrayNew(%p, %lu)", pItem, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayNew(%p, %" HB_PFS "u)", pItem, ulLen));
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
@@ -218,7 +218,7 @@ HB_BOOL hb_arrayNew( PHB_ITEM pItem, HB_SIZE ulLen ) /* creates a new array */
HB_BOOL hb_arraySize( PHB_ITEM pArray, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySize(%p, %lu)", pArray, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySize(%p, %" HB_PFS "u)", pArray, ulLen));
if( HB_IS_ARRAY( pArray ) )
{
@@ -365,7 +365,7 @@ HB_BOOL hb_arrayAddForward( PHB_ITEM pArray, PHB_ITEM pValue )
HB_BOOL hb_arrayDel( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayDel(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayDel(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) )
{
@@ -395,7 +395,7 @@ HB_BOOL hb_arrayDel( PHB_ITEM pArray, HB_SIZE ulIndex )
HB_BOOL hb_arrayIns( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayIns(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayIns(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) )
{
@@ -425,7 +425,7 @@ HB_BOOL hb_arrayIns( PHB_ITEM pArray, HB_SIZE ulIndex )
HB_BOOL hb_arraySet( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySet(%p, %lu, %p)", pArray, ulIndex, pItem));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySet(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pItem));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -438,7 +438,7 @@ HB_BOOL hb_arraySet( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem )
HB_BOOL hb_arraySetForward( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetForward(%p, %lu, %p)", pArray, ulIndex, pItem));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetForward(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pItem));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -454,7 +454,7 @@ 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_TRACE(HB_TR_DEBUG, ("hb_arrayGet(%p, %lu, %p)", pArray, ulIndex, pItem));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGet(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pItem));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -470,7 +470,7 @@ 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_TRACE(HB_TR_DEBUG, ("hb_arrayGetItemRef(%p, %lu, %p)", pArray, ulIndex, pItem));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetItemRef(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pItem));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -499,7 +499,7 @@ HB_BOOL hb_arrayGetItemRef( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem )
*/
PHB_ITEM hb_arrayGetItemPtr( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetItemPtr(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetItemPtr(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return pArray->item.asArray.value->pItems + ulIndex - 1;
@@ -509,7 +509,7 @@ PHB_ITEM hb_arrayGetItemPtr( PHB_ITEM pArray, HB_SIZE ulIndex )
char * hb_arrayGetDS( PHB_ITEM pArray, HB_SIZE ulIndex, char * szDate )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetDS(%p, %lu, %s)", pArray, ulIndex, szDate));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetDS(%p, %" HB_PFS "u, %s)", pArray, ulIndex, 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 );
@@ -521,7 +521,7 @@ char * hb_arrayGetDS( PHB_ITEM pArray, HB_SIZE ulIndex, char * szDate )
long hb_arrayGetDL( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetDL(%p, %lu)", pArray, ulIndex ));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetDL(%p, %" HB_PFS "u)", pArray, ulIndex ));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetDL( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -533,7 +533,7 @@ long hb_arrayGetDL( PHB_ITEM pArray, HB_SIZE ulIndex )
double hb_arrayGetTD( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetTD(%p, %lu)", pArray, ulIndex ));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetTD(%p, %" HB_PFS "u)", pArray, ulIndex ));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetTD( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -543,7 +543,7 @@ double hb_arrayGetTD( PHB_ITEM pArray, HB_SIZE ulIndex )
HB_BOOL hb_arrayGetTDT( PHB_ITEM pArray, HB_SIZE ulIndex, long * plJulian, long * plMilliSec )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetTDT(%p, %lu, %p, %p)", pArray, ulIndex, plJulian, plMilliSec));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetTDT(%p, %" HB_PFS "u, %p, %p)", pArray, ulIndex, 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 );
@@ -556,7 +556,7 @@ HB_BOOL hb_arrayGetTDT( PHB_ITEM pArray, HB_SIZE ulIndex, long * plJulian, long
HB_BOOL hb_arrayGetL( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetL(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetL(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetL( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -566,7 +566,7 @@ HB_BOOL hb_arrayGetL( PHB_ITEM pArray, HB_SIZE ulIndex )
int hb_arrayGetNI( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNI(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNI(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetNI( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -576,7 +576,7 @@ int hb_arrayGetNI( PHB_ITEM pArray, HB_SIZE ulIndex )
long hb_arrayGetNL( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNL(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNL(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetNL( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -586,7 +586,7 @@ long hb_arrayGetNL( PHB_ITEM pArray, HB_SIZE ulIndex )
HB_ISIZ hb_arrayGetNS( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNS(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNS(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetNS( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -597,7 +597,7 @@ HB_ISIZ hb_arrayGetNS( PHB_ITEM pArray, HB_SIZE ulIndex )
#ifndef HB_LONG_LONG_OFF
HB_LONGLONG hb_arrayGetNLL( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNLL(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNLL(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetNLL( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -608,7 +608,7 @@ HB_LONGLONG hb_arrayGetNLL( PHB_ITEM pArray, HB_SIZE ulIndex )
HB_MAXINT hb_arrayGetNInt( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNInt(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetNInt(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetNInt( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -618,7 +618,7 @@ HB_MAXINT hb_arrayGetNInt( PHB_ITEM pArray, HB_SIZE ulIndex )
double hb_arrayGetND( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetND(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetND(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetND( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -628,7 +628,7 @@ double hb_arrayGetND( PHB_ITEM pArray, HB_SIZE ulIndex )
HB_SIZE hb_arrayCopyC( PHB_ITEM pArray, HB_SIZE ulIndex, char * szBuffer, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayCopyC(%p, %lu, %s, %lu)", pArray, ulIndex, szBuffer, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayCopyC(%p, %" HB_PFS "u, %s, %" HB_PFS "u)", pArray, ulIndex, 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 );
@@ -638,7 +638,7 @@ HB_SIZE hb_arrayCopyC( PHB_ITEM pArray, HB_SIZE ulIndex, char * szBuffer, HB_SIZ
char * hb_arrayGetC( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetC(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetC(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetC( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -648,7 +648,7 @@ char * hb_arrayGetC( PHB_ITEM pArray, HB_SIZE ulIndex )
const char * hb_arrayGetCPtr( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetCPtr(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetCPtr(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetCPtr( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -658,7 +658,7 @@ const char * hb_arrayGetCPtr( PHB_ITEM pArray, HB_SIZE ulIndex )
HB_SIZE hb_arrayGetCLen( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetCLen(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetCLen(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetCLen( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -668,7 +668,7 @@ HB_SIZE hb_arrayGetCLen( PHB_ITEM pArray, HB_SIZE ulIndex )
void * hb_arrayGetPtr( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetPtr(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetPtr(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetPtr( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -678,7 +678,7 @@ void * hb_arrayGetPtr( PHB_ITEM pArray, HB_SIZE ulIndex )
void * hb_arrayGetPtrGC( PHB_ITEM pArray, HB_SIZE ulIndex, const HB_GC_FUNCS * pFuncs )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetPtrGC(%p, %lu, %p)", pArray, ulIndex, pFuncs));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetPtrGC(%p, %" HB_PFS "u, %p)", pArray, ulIndex, 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 );
@@ -688,7 +688,7 @@ void * hb_arrayGetPtrGC( PHB_ITEM pArray, HB_SIZE ulIndex, const HB_GC_FUNCS * p
PHB_SYMB hb_arrayGetSymbol( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetSymbol(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetSymbol(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetSymbol( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -699,7 +699,7 @@ PHB_SYMB hb_arrayGetSymbol( PHB_ITEM pArray, HB_SIZE ulIndex )
HB_TYPE hb_arrayGetType( PHB_ITEM pArray, HB_SIZE ulIndex )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetType(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetType(%p, %" HB_PFS "u)", pArray, ulIndex));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemType( pArray->item.asArray.value->pItems + ulIndex - 1 );
@@ -709,7 +709,7 @@ HB_TYPE hb_arrayGetType( PHB_ITEM pArray, HB_SIZE ulIndex )
HB_BOOL hb_arraySetDS( PHB_ITEM pArray, HB_SIZE ulIndex, const char * szDate )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetDS(%p, %lu, %s)", pArray, ulIndex, szDate));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetDS(%p, %" HB_PFS "u, %s)", pArray, ulIndex, szDate));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -722,7 +722,7 @@ HB_BOOL hb_arraySetDS( PHB_ITEM pArray, HB_SIZE ulIndex, const char * szDate )
HB_BOOL hb_arraySetDL( PHB_ITEM pArray, HB_SIZE ulIndex, long lDate )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetDL(%p, %lu, %ld)", pArray, ulIndex, lDate));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetDL(%p, %" HB_PFS "u, %ld)", pArray, ulIndex, lDate));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -735,7 +735,7 @@ HB_BOOL hb_arraySetDL( PHB_ITEM pArray, HB_SIZE ulIndex, long lDate )
HB_BOOL hb_arraySetTD( PHB_ITEM pArray, HB_SIZE ulIndex, double dTimeStamp )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetTD(%p, %lu, %lf)", pArray, ulIndex, dTimeStamp));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetTD(%p, %" HB_PFS "u, %lf)", pArray, ulIndex, dTimeStamp));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -748,7 +748,7 @@ HB_BOOL hb_arraySetTD( PHB_ITEM pArray, HB_SIZE ulIndex, double dTimeStamp )
HB_BOOL hb_arraySetTDT( PHB_ITEM pArray, HB_SIZE ulIndex, long lJulian, long lMilliSec )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetTDT(%p, %lu, %lu, %lu)", pArray, ulIndex, lJulian, lMilliSec));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetTDT(%p, %" HB_PFS "u, %lu, %lu)", pArray, ulIndex, lJulian, lMilliSec));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -761,7 +761,7 @@ HB_BOOL hb_arraySetTDT( PHB_ITEM pArray, HB_SIZE ulIndex, long lJulian, long lMi
HB_BOOL hb_arraySetL( PHB_ITEM pArray, HB_SIZE ulIndex, HB_BOOL fValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetL(%p, %lu, %d)", pArray, ulIndex, fValue));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetL(%p, %" HB_PFS "u, %d)", pArray, ulIndex, fValue));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -774,7 +774,7 @@ HB_BOOL hb_arraySetL( PHB_ITEM pArray, HB_SIZE ulIndex, HB_BOOL fValue )
HB_BOOL hb_arraySetNI( PHB_ITEM pArray, HB_SIZE ulIndex, int iNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNI(%p, %lu, %d)", pArray, ulIndex, iNumber));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNI(%p, %" HB_PFS "u, %d)", pArray, ulIndex, iNumber));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -787,7 +787,7 @@ HB_BOOL hb_arraySetNI( PHB_ITEM pArray, HB_SIZE ulIndex, int iNumber )
HB_BOOL hb_arraySetNL( PHB_ITEM pArray, HB_SIZE ulIndex, long lNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNL(%p, %lu, %lu)", pArray, ulIndex, lNumber));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNL(%p, %" HB_PFS "u, %lu)", pArray, ulIndex, lNumber));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -800,7 +800,7 @@ HB_BOOL hb_arraySetNL( PHB_ITEM pArray, HB_SIZE ulIndex, long lNumber )
HB_BOOL hb_arraySetNS( PHB_ITEM pArray, HB_SIZE ulIndex, HB_ISIZ nNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNS(%p, %lu, %" HB_PFS "d)", pArray, ulIndex, nNumber));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNS(%p, %" HB_PFS "u, %" HB_PFS "d)", pArray, ulIndex, nNumber));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -814,7 +814,7 @@ 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_TRACE(HB_TR_DEBUG, ("hb_arraySetNLL(%p, %lu, %" PFLL "d)", pArray, ulIndex, llNumber));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNLL(%p, %" HB_PFS "u, %" PFLL "d)", pArray, ulIndex, llNumber));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -828,7 +828,7 @@ HB_BOOL hb_arraySetNLL( PHB_ITEM pArray, HB_SIZE ulIndex, HB_LONGLONG llNumber )
HB_BOOL hb_arraySetNInt( PHB_ITEM pArray, HB_SIZE ulIndex, HB_MAXINT lNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNInt(%p, %lu, %" PFHL "d)", pArray, ulIndex, lNumber));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetNInt(%p, %" HB_PFS "u, %" PFHL "d)", pArray, ulIndex, lNumber));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -841,7 +841,7 @@ HB_BOOL hb_arraySetNInt( PHB_ITEM pArray, HB_SIZE ulIndex, HB_MAXINT lNumber )
HB_BOOL hb_arraySetND( PHB_ITEM pArray, HB_SIZE ulIndex, double dNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetND(%p, %lu, %lf)", pArray, ulIndex, dNumber));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetND(%p, %" HB_PFS "u, %lf)", pArray, ulIndex, dNumber));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -854,7 +854,7 @@ HB_BOOL hb_arraySetND( PHB_ITEM pArray, HB_SIZE ulIndex, double dNumber )
HB_BOOL hb_arraySetC( PHB_ITEM pArray, HB_SIZE ulIndex, const char * szText )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetC(%p, %lu, %p)", pArray, ulIndex, szText));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetC(%p, %" HB_PFS "u, %p)", pArray, ulIndex, szText));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -867,7 +867,7 @@ HB_BOOL hb_arraySetC( PHB_ITEM pArray, HB_SIZE ulIndex, const char * szText )
HB_BOOL hb_arraySetCL( PHB_ITEM pArray, HB_SIZE ulIndex, const char * szText, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetC(%p, %lu, %p, %lu)", pArray, ulIndex, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetC(%p, %" HB_PFS "u, %p, %" HB_PFS "u)", pArray, ulIndex, szText, ulLen));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -880,7 +880,7 @@ HB_BOOL hb_arraySetCL( PHB_ITEM pArray, HB_SIZE ulIndex, const char * szText, HB
HB_BOOL hb_arraySetCLPtr( PHB_ITEM pArray, HB_SIZE ulIndex, char * szText, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetCLPtr(%p, %lu, %p, %lu)", pArray, ulIndex, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetCLPtr(%p, %" HB_PFS "u, %p, %" HB_PFS "u)", pArray, ulIndex, szText, ulLen));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -893,7 +893,7 @@ HB_BOOL hb_arraySetCLPtr( PHB_ITEM pArray, HB_SIZE ulIndex, char * szText, HB_SI
HB_BOOL hb_arraySetPtr( PHB_ITEM pArray, HB_SIZE ulIndex, void * pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetPtr(%p, %lu, %p)", pArray, ulIndex, pValue));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetPtr(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pValue));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -906,7 +906,7 @@ HB_BOOL hb_arraySetPtr( PHB_ITEM pArray, HB_SIZE ulIndex, void * pValue )
HB_BOOL hb_arraySetPtrGC( PHB_ITEM pArray, HB_SIZE ulIndex, void * pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetPtrGC(%p, %lu, %p)", pArray, ulIndex, pValue));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetPtrGC(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pValue));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -919,7 +919,7 @@ HB_BOOL hb_arraySetPtrGC( PHB_ITEM pArray, HB_SIZE ulIndex, void * pValue )
HB_BOOL hb_arraySetSymbol( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_SYMB pSymbol )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetSymbol(%p, %lu, %p)", pArray, ulIndex, pSymbol));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetSymbol(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pSymbol));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{

4
harbour/src/vm/codebloc.c
View File

@@ -149,7 +149,7 @@ HB_CODEBLOCK_PTR hb_codeblockNew( const HB_BYTE * pBuffer,
PHB_ITEM pLocals, pBase;
HB_BYTE * pCode;
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockNew(%p, %hu, %p, %p, %lu)", pBuffer, uiLocals, pLocalPosTable, pSymbols, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockNew(%p, %hu, %p, %p, %" HB_PFS "u)", pBuffer, uiLocals, pLocalPosTable, pSymbols, ulLen));
/*
* allocate memory for code block body and detach items hb_gcAllocRaw()
@@ -261,7 +261,7 @@ HB_CODEBLOCK_PTR hb_codeblockMacroNew( const HB_BYTE * pBuffer, HB_SIZE ulLen )
PHB_ITEM pBase;
HB_BYTE * pCode;
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockMacroNew(%p, %lu)", pBuffer, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockMacroNew(%p, %" HB_PFS "u)", pBuffer, ulLen));
/*
* The codeblock pcode is stored in dynamically allocated memory that

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

@@ -112,7 +112,7 @@
* $End$ */
static void AddToArray( PHB_ITEM pItem, PHB_ITEM pReturn, HB_SIZE ulPos )
{
HB_TRACE(HB_TR_DEBUG, ("AddToArray(%p, %p, %lu)", pItem, pReturn, ulPos));
HB_TRACE(HB_TR_DEBUG, ("AddToArray(%p, %p, %" HB_PFS "u)", pItem, pReturn, ulPos));
if( HB_IS_SYMBOL( pItem ) )
{ /* Symbol is pushed as text */

22
harbour/src/vm/extend.c
View File

@@ -149,7 +149,7 @@ HB_SIZE hb_parinfa( int iParamNum, HB_SIZE uiArrayIndex )
{
PHB_ITEM pArray;
HB_TRACE(HB_TR_DEBUG, ("hb_parinfa(%d, %lu)", iParamNum, uiArrayIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_parinfa(%d, %" HB_PFS "u)", iParamNum, uiArrayIndex));
pArray = hb_param( iParamNum, HB_IT_ARRAY );
@@ -1256,7 +1256,7 @@ HB_ISIZ hb_parvns( int iParam, ... )
}
#ifndef HB_LONG_LONG_OFF
HB_LONGLONG hb_parvnll( int iParam, ... )
HB_LONGLONG hb_parvnll( int iParam, ... )
{
HB_STACK_TLS_PRELOAD
@@ -1420,7 +1420,7 @@ void hb_reta( HB_SIZE ulLen ) /* undocumented hb_reta() */
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_reta(%lu)", ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_reta(%" HB_PFS "u)", ulLen));
hb_arrayNew( hb_stackReturnItem(), ulLen );
}
@@ -1470,7 +1470,7 @@ void hb_retclen( const char * szText, HB_SIZE ulLen )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_retclen(%.*s, %lu)", ( int ) ulLen, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_retclen(%.*s, %" HB_PFS "u)", ( int ) ulLen, szText, ulLen));
hb_itemPutCL( hb_stackReturnItem(), szText, ulLen );
}
@@ -1480,7 +1480,7 @@ void hb_retclen_buffer( char * szText, HB_SIZE ulLen )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_retclen_buffer(%.*s, %lu)", ( int ) ulLen, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_retclen_buffer(%.*s, %" HB_PFS "u)", ( int ) ulLen, szText, ulLen));
hb_itemPutCLPtr( hb_stackReturnItem(), szText, ulLen );
}
@@ -1695,7 +1695,7 @@ int hb_stor( int iParam )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_stor( %d )", iParam));
HB_TRACE(HB_TR_DEBUG, ("hb_stor(%d)", iParam));
if( iParam == -1 )
{
@@ -1720,7 +1720,7 @@ int hb_storc( const char * szText, int iParam )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_storc(%s, %d )", szText, iParam));
HB_TRACE(HB_TR_DEBUG, ("hb_storc(%s, %d)", szText, iParam));
if( iParam == -1 )
{
@@ -1745,7 +1745,7 @@ int hb_storclen( const char * szText, HB_SIZE ulLen, int iParam )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_storclen(%.*s, %lu, %d)", ( int ) ulLen, szText, ulLen, iParam));
HB_TRACE(HB_TR_DEBUG, ("hb_storclen(%.*s, %" HB_PFS "u, %d)", ( int ) ulLen, szText, ulLen, iParam));
if( iParam == -1 )
{
@@ -1770,7 +1770,7 @@ int hb_storclen_buffer( char * szText, HB_SIZE ulLen, int iParam )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_storclen_buffer(%.*s, %lu, %d)", ( int ) ulLen, szText, ulLen, iParam));
HB_TRACE(HB_TR_DEBUG, ("hb_storclen_buffer(%.*s, %" HB_PFS "u, %d)", ( int ) ulLen, szText, ulLen, iParam));
if( iParam == -1 )
{
@@ -2161,7 +2161,7 @@ int hb_storvclen( const char * szText, HB_SIZE ulLen, int iParam, ... )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_storvclen(%.*s, %lu, %d, ...)", ( int ) ulLen, szText, ulLen, iParam));
HB_TRACE(HB_TR_DEBUG, ("hb_storvclen(%.*s, %" HB_PFS "u, %d, ...)", ( int ) ulLen, szText, ulLen, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{
@@ -2194,7 +2194,7 @@ int hb_storvclen_buffer( char * szText, HB_SIZE ulLen, int iParam, ... )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_storvclen_buffer(%.*s, %lu, %d, ...)", ( int ) ulLen, szText, ulLen, iParam));
HB_TRACE(HB_TR_DEBUG, ("hb_storvclen_buffer(%.*s, %" HB_PFS "u, %d, ...)", ( int ) ulLen, szText, ulLen, iParam));
if( iParam >= -1 && iParam <= hb_pcount() )
{

6
harbour/src/vm/fm.c
View File

@@ -572,7 +572,7 @@ void * hb_xalloc( HB_SIZE ulSize ) /* allocates fixed memory, returns NU
{
PHB_MEMINFO pMem;
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xalloc(%lu)", ulSize));
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xalloc(%" HB_PFS "u)", ulSize));
if( ulSize == 0 )
hb_errInternal( HB_EI_XALLOCNULLSIZE, NULL, NULL, NULL );
@@ -658,7 +658,7 @@ void * hb_xgrab( HB_SIZE ulSize ) /* allocates fixed memory, exits on fa
{
PHB_MEMINFO pMem;
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xgrab(%lu)", ulSize));
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xgrab(%" HB_PFS "u)", ulSize));
if( ulSize == 0 )
hb_errInternal( HB_EI_XGRABNULLSIZE, NULL, NULL, NULL );
@@ -742,7 +742,7 @@ void * hb_xgrab( HB_SIZE ulSize ) /* allocates fixed memory, exits on fa
void * hb_xrealloc( void * pMem, HB_SIZE ulSize ) /* reallocates memory */
{
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xrealloc(%p, %lu)", pMem, ulSize));
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xrealloc(%p, %" HB_PFS "u)", pMem, ulSize));
#if 0
/* disabled to make hb_xrealloc() ANSI-C realloc() compatible */

8
harbour/src/vm/hashes.c
View File

@@ -519,7 +519,7 @@ HB_SIZE hb_hashLen( PHB_ITEM pHash )
void hb_hashPreallocate( PHB_ITEM pHash, HB_SIZE ulNewSize )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashPreallocate(%p,%lu)", pHash, ulNewSize));
HB_TRACE(HB_TR_DEBUG, ("hb_hashPreallocate(%p,%" HB_PFS "u)", pHash, ulNewSize));
if( HB_IS_HASH( pHash ) )
hb_hashResize( pHash->item.asHash.value, ulNewSize );
@@ -810,7 +810,7 @@ HB_BOOL hb_hashAddNew( PHB_ITEM pHash, PHB_ITEM pKey, PHB_ITEM pValue )
PHB_ITEM hb_hashGetKeyAt( PHB_ITEM pHash, HB_SIZE ulPos )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashGetKeyAt(%p,%lu)", pHash, ulPos));
HB_TRACE(HB_TR_DEBUG, ("hb_hashGetKeyAt(%p,%" HB_PFS "u)", pHash, ulPos));
if( HB_IS_HASH( pHash ) && ulPos > 0 && ulPos <= pHash->item.asHash.value->ulLen )
return &pHash->item.asHash.value->pPairs[ ulPos - 1 ].key;
@@ -820,7 +820,7 @@ PHB_ITEM hb_hashGetKeyAt( PHB_ITEM pHash, HB_SIZE ulPos )
PHB_ITEM hb_hashGetValueAt( PHB_ITEM pHash, HB_SIZE ulPos )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashGetValueAt(%p,%lu)", pHash, ulPos));
HB_TRACE(HB_TR_DEBUG, ("hb_hashGetValueAt(%p,%" HB_PFS "u)", pHash, ulPos));
if( HB_IS_HASH( pHash ) && ulPos > 0 && ulPos <= pHash->item.asHash.value->ulLen )
{
@@ -833,7 +833,7 @@ PHB_ITEM hb_hashGetValueAt( PHB_ITEM pHash, HB_SIZE ulPos )
HB_BOOL hb_hashDelAt( PHB_ITEM pHash, HB_SIZE ulPos )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hashDelAt(%p,%lu)", pHash, ulPos));
HB_TRACE(HB_TR_DEBUG, ("hb_hashDelAt(%p,%" HB_PFS "u)", pHash, ulPos));
if( HB_IS_HASH( pHash ) && ulPos > 0 && ulPos <= pHash->item.asHash.value->ulLen )
{

32
harbour/src/vm/hvm.c
View File

@@ -5325,7 +5325,7 @@ static void hb_vmArrayGen( HB_SIZE ulElements ) /* generates an ulElements Array
PHB_ITEM pArray;
HB_SIZE ulPos;
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayGen(%lu)", ulElements));
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayGen(%" HB_PFS "u)", ulElements));
/* create new array on HVM stack */
pArray = hb_stackAllocItem();
@@ -5409,7 +5409,7 @@ static void hb_vmHashGen( HB_SIZE ulElements ) /* generates an ulElements Hash a
HB_STACK_TLS_PRELOAD
PHB_ITEM pHash, pKey, pVal;
HB_TRACE(HB_TR_DEBUG, ("hb_vmHashGen(%lu)", ulElements));
HB_TRACE(HB_TR_DEBUG, ("hb_vmHashGen(%" HB_PFS "u)", ulElements));
/* create new hash item */
pHash = hb_hashNew( NULL );
@@ -6771,7 +6771,7 @@ void hb_vmPushString( const char * szText, HB_SIZE length )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushString(%s, %lu)", szText, length));
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushString(%s, %" HB_PFS "u)", szText, length));
hb_itemPutCL( hb_stackAllocItem(), szText, length );
}
@@ -6781,7 +6781,7 @@ void hb_vmPushStringPcode( const char * szText, HB_SIZE length )
HB_STACK_TLS_PRELOAD
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushStringPcode(%s, %lu)", szText, length));
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushStringPcode(%s, %" HB_PFS "u)", szText, length));
pItem->type = HB_IT_STRING;
pItem->item.asString.length = length;
@@ -6839,7 +6839,7 @@ static void hb_vmPushBlock( const HB_BYTE * pCode, PHB_SYMB pSymbols, HB_SIZE ul
HB_USHORT uiLocals;
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushBlock(%p,%p,%lu)", pCode, pSymbols, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushBlock(%p,%p,%" HB_PFS "u)", pCode, pSymbols, ulLen));
uiLocals = HB_PCODE_MKUSHORT( &pCode[ 2 ] );
@@ -6875,7 +6875,7 @@ static void hb_vmPushBlockShort( const HB_BYTE * pCode, PHB_SYMB pSymbols, HB_SI
HB_STACK_TLS_PRELOAD
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushBlockShort(%p,%p,%lu)", pCode, pSymbols, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushBlockShort(%p,%p,%" HB_PFS "u)", pCode, pSymbols, ulLen));
pItem->item.asBlock.value =
hb_codeblockNew( pCode, /* pcode buffer */
@@ -6908,7 +6908,7 @@ static void hb_vmPushMacroBlock( const HB_BYTE * pCode, HB_SIZE ulSize, HB_USHOR
HB_STACK_TLS_PRELOAD
PHB_ITEM pItem = hb_stackAllocItem();
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushMacroBlock(%p,%lu,%hu)", pCode, ulSize, usParams));
HB_TRACE(HB_TR_DEBUG, ("hb_vmPushMacroBlock(%p,%" HB_PFS "u,%hu)", pCode, ulSize, usParams));
pItem->item.asBlock.value = hb_codeblockMacroNew( pCode, ulSize );
pItem->type = HB_IT_BLOCK;
@@ -7984,8 +7984,8 @@ PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, HB_USHORT uiModuleSymbols,
}
PHB_SYMB hb_vmProcessDynLibSymbols( PHB_SYMB pSymbols, HB_USHORT uiModuleSymbols,
const char * szModuleName, HB_ULONG ulID,
HB_USHORT uiPCodeVer )
const char * szModuleName, HB_ULONG ulID,
HB_USHORT uiPCodeVer )
{
HB_TRACE(HB_TR_DEBUG, ("hb_vmProcessDynLibSymbols(%p,%hu,%s,%lu,%hu)", pSymbols, uiModuleSymbols, szModuleName, ulID, uiPCodeVer));
@@ -10935,14 +10935,14 @@ void hb_xvmArrayDim( HB_USHORT uiDimensions )
void hb_xvmArrayGen( HB_SIZE ulElements )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayGen(%lu)", ulElements));
HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayGen(%" HB_PFS "u)", ulElements));
hb_vmArrayGen( ulElements );
}
void hb_xvmHashGen( HB_SIZE ulElements )
{
HB_TRACE(HB_TR_DEBUG, ("hb_xvmHashGen(%lu)", ulElements));
HB_TRACE(HB_TR_DEBUG, ("hb_xvmHashGen(%" HB_PFS "u)", ulElements));
hb_vmHashGen( ulElements );
}
@@ -10952,7 +10952,7 @@ static void hb_vmArrayItemPush( HB_SIZE ulIndex )
HB_STACK_TLS_PRELOAD
PHB_ITEM pArray;
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayItemPush(%lu)", ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayItemPush(%" HB_PFS "u)", ulIndex));
pArray = hb_stackItemFromTop( -1 );
@@ -11028,7 +11028,7 @@ static void hb_vmArrayItemPop( HB_SIZE ulIndex )
PHB_ITEM pValue;
PHB_ITEM pArray;
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayItemPop(%lu", ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_vmArrayItemPop(%" HB_PFS "u)", ulIndex));
pValue = hb_stackItemFromTop( -2 );
pArray = hb_stackItemFromTop( -1 );
@@ -11144,7 +11144,7 @@ HB_BOOL hb_xvmArrayItemPush( HB_SIZE ulIndex )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayItemPush(%lu)", ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayItemPush(%" HB_PFS "u)", ulIndex));
hb_vmArrayItemPush( ulIndex );
@@ -11166,7 +11166,7 @@ HB_BOOL hb_xvmArrayItemPop( HB_SIZE ulIndex )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayItemPop(%lu)", ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_xvmArrayItemPop(%" HB_PFS "u)", ulIndex));
hb_vmArrayItemPop( ulIndex );
@@ -11201,7 +11201,7 @@ void hb_xvmPushStringHidden( int iMethod, const char * szText, HB_SIZE ulSize )
HB_STACK_TLS_PRELOAD
char * szString;
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushStringHidden(%d, %s, %lu)", iMethod, szText, ulSize));
HB_TRACE(HB_TR_DEBUG, ("hb_xvmPushStringHidden(%d, %s, %" HB_PFS "u)", iMethod, szText, ulSize));
szString = hb_compDecodeString( iMethod, szText, &ulSize );
hb_itemPutCLPtr( hb_stackAllocItem(), szString, ulSize );

16
harbour/src/vm/itemapi.c
View File

@@ -176,7 +176,7 @@ PHB_ITEM hb_itemArrayNew( HB_SIZE ulLen )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayNew(%lu)", ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayNew(%" HB_PFS "u)", ulLen));
pItem = hb_itemNew( NULL );
@@ -189,7 +189,7 @@ PHB_ITEM hb_itemArrayGet( PHB_ITEM pArray, HB_SIZE ulIndex )
{
PHB_ITEM pItem;
HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayGet(%p, %lu)", pArray, ulIndex));
HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayGet(%p, %" HB_PFS "u)", pArray, ulIndex));
pItem = hb_itemNew( NULL );
@@ -201,7 +201,7 @@ PHB_ITEM hb_itemArrayGet( PHB_ITEM pArray, HB_SIZE ulIndex )
PHB_ITEM hb_itemArrayPut( PHB_ITEM pArray, HB_SIZE ulIndex, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayPut(%p, %lu, %p)", pArray, ulIndex, pItem));
HB_TRACE(HB_TR_DEBUG, ("hb_itemArrayPut(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pItem));
if( pArray )
hb_arraySet( pArray, ulIndex, pItem );
@@ -247,7 +247,7 @@ PHB_ITEM hb_itemPutCL( PHB_ITEM pItem, const char * szText, HB_SIZE ulLen )
{
HB_SIZE ulAlloc;
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCL(%p, %.*s, %lu)", pItem, ( int ) ulLen, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCL(%p, %.*s, %" HB_PFS "u)", pItem, ( int ) ulLen, szText, ulLen));
if( ulLen > 1 )
{
@@ -312,7 +312,7 @@ PHB_ITEM hb_itemPutCConst( PHB_ITEM pItem, const char * szText )
PHB_ITEM hb_itemPutCLConst( PHB_ITEM pItem, const char * szText, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCLConst(%p, %.*s, %lu)", pItem, ( int ) ulLen, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCLConst(%p, %.*s, %" HB_PFS "u)", pItem, ( int ) ulLen, szText, ulLen));
if( pItem )
{
@@ -379,7 +379,7 @@ PHB_ITEM hb_itemPutCPtr( PHB_ITEM pItem, char * szText )
PHB_ITEM hb_itemPutCLPtr( PHB_ITEM pItem, char * szText, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCLPtr(%p, %.*s, %lu)", pItem, ( int ) ulLen, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutCLPtr(%p, %.*s, %" HB_PFS "u)", pItem, ( int ) ulLen, szText, ulLen));
if( pItem )
{
@@ -462,7 +462,7 @@ HB_SIZE hb_itemGetCLen( PHB_ITEM pItem )
HB_SIZE hb_itemCopyC( PHB_ITEM pItem, char * szBuffer, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyC(%p, %s, %lu)", pItem, szBuffer, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyC(%p, %s, %" HB_PFS "u)", pItem, szBuffer, ulLen));
if( pItem && HB_IS_STRING( pItem ) )
{
@@ -1976,7 +1976,7 @@ PHB_ITEM hb_itemUnRefRefer( PHB_ITEM pItem )
PHB_ITEM hb_itemReSizeString( PHB_ITEM pItem, HB_SIZE ulSize )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemReSizeString(%p,%lu)", pItem, ulSize));
HB_TRACE(HB_TR_DEBUG, ("hb_itemReSizeString(%p,%" HB_PFS "u)", pItem, ulSize));
if( pItem->item.asString.allocated == 0 )
{

22
harbour/src/vm/macro.c
View File

@@ -140,7 +140,7 @@ void hb_macroDelete( HB_MACRO_PTR pMacro )
{
HB_TRACE(HB_TR_DEBUG, ("hb_macroDelete(%p)", pMacro));
hb_xfree( ( void * ) pMacro->pCodeInfo->pCode );
hb_xfree( pMacro->pCodeInfo->pCode );
if( pMacro->pError )
hb_errRelease( pMacro->pError );
if( pMacro->Flags & HB_MACRO_DEALLOCATE )
@@ -263,16 +263,16 @@ static char * hb_macroTextSubst( const char * szString, HB_SIZE * pulStringLen )
char * pHead;
char * pTail;
HB_TRACE(HB_TR_DEBUG, ("hb_macroTextSubst(%s, %li)", szString, *pulStringLen));
HB_TRACE(HB_TR_DEBUG, ("hb_macroTextSubst(%s, %" HB_PFS "u)", szString, *pulStringLen));
pHead = (char *) memchr( (void *) szString, '&', *pulStringLen );
pHead = ( char * ) memchr( szString, '&', *pulStringLen );
if( pHead == NULL )
return ( char * ) szString; /* no more processing is required */
/* initial length of the string and the result buffer (it can contain null bytes) */
ulResBufLen = ulResStrLen = *pulStringLen;
/* initial buffer for return value */
szResult = (char *) hb_xgrab( ulResBufLen + 1 );
szResult = ( char * ) hb_xgrab( ulResBufLen + 1 );
/* copy the input string with trailing zero byte
*/
@@ -380,7 +380,7 @@ static char * hb_macroTextSubst( const char * szString, HB_SIZE * pulStringLen )
}
ulCharsLeft = ulResStrLen - ( pHead - szResult );
}
while( ulCharsLeft && ( pHead = (char *) memchr( (void *)pHead, '&', ulCharsLeft ) ) != NULL );
while( ulCharsLeft && ( pHead = ( char * ) memchr( pHead, '&', ulCharsLeft ) ) != NULL );
if( ulResStrLen < ulResBufLen )
{
@@ -694,7 +694,7 @@ char * hb_macroExpandString( const char *szString, HB_SIZE ulLength, HB_BOOL *pf
{
char *szResultString;
HB_TRACE(HB_TR_DEBUG, ("hb_macroExpandString(%s,%lu,%p)", szString, ulLength, pfNewString));
HB_TRACE(HB_TR_DEBUG, ("hb_macroExpandString(%s,%" HB_PFS "u,%p)", szString, ulLength, pfNewString));
if( szString )
szResultString = hb_macroTextSubst( szString, &ulLength );
@@ -708,7 +708,7 @@ char * hb_macroTextSymbol( const char *szString, HB_SIZE ulLength, HB_BOOL *pfNe
{
char *szResult = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_macroTextSymbol(%s,%lu,%p)", szString, ulLength, pfNewString));
HB_TRACE(HB_TR_DEBUG, ("hb_macroTextSymbol(%s,%" HB_PFS "u,%p)", szString, ulLength, pfNewString));
if( szString )
{
@@ -944,7 +944,7 @@ const char * hb_macroGetType( HB_ITEM_PTR pItem )
{
/* Clipper ignores any undeclared symbols or UDFs if the
* compiled expression is a valid codeblock
*/
*/
szType = "B";
}
else if( struMacro.status & HB_MACRO_UNKN_SYM )
@@ -1005,9 +1005,7 @@ const char * hb_macroGetType( HB_ITEM_PTR pItem )
}
}
else
{
szType = "UE";
}
}
else
szType = "UE"; /* syntax error during compilation */
@@ -1702,6 +1700,6 @@ void hb_macroCodeBlockEnd( HB_COMP_DECL )
hb_macroGenPCode1( HB_P_ENDBLOCK, HB_COMP_PARAM ); /* finish the codeblock */
/* free memory allocated for a codeblock */
hb_xfree( ( void * ) pCodeblock->pCode );
hb_xfree( ( void * ) pCodeblock );
hb_xfree( pCodeblock->pCode );
hb_xfree( pCodeblock );
}

4
harbour/src/vm/memvars.c
View File

@@ -546,7 +546,7 @@ static HB_DYNS_PTR hb_memvarFindSymbol( const char * szArg, HB_SIZE ulLen )
{
HB_DYNS_PTR pDynSym = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarFindSymbol(%p,%lu)", szArg, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_memvarFindSymbol(%p,%" HB_PFS "u)", szArg, ulLen));
if( ulLen && szArg && *szArg )
{
@@ -806,7 +806,7 @@ int hb_memvarScope( const char * szVarName, HB_SIZE ulLength )
{
PHB_DYNS pDynVar;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarScope(%s, %lu)", szVarName, ulLength));
HB_TRACE(HB_TR_DEBUG, ("hb_memvarScope(%s, %" HB_PFS "u)", szVarName, ulLength));
pDynVar = hb_memvarFindSymbol( szVarName, ulLength );

6
harbour/src/vm/runner.c
View File

@@ -103,7 +103,7 @@ static int hb_hrbReadHead( const char * szBody, HB_SIZE ulBodySize, HB_SIZE * pu
{
const char * pVersion;
HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadHead(%p,%lu,%p)", szBody, ulBodySize, pulBodyOffset ));
HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadHead(%p,%" HB_PFS "u,%p)", szBody, ulBodySize, pulBodyOffset ));
if( ulBodySize < 6 || memcmp( s_szHead, szBody, 4 ) )
return 0;
@@ -116,7 +116,7 @@ static int hb_hrbReadHead( const char * szBody, HB_SIZE ulBodySize, HB_SIZE * pu
static HB_BOOL hb_hrbReadValue( const char * szBody, HB_SIZE ulBodySize, HB_SIZE * pulBodyOffset, HB_ULONG * pulValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadValue(%p,%lu,%p,%p)", szBody, ulBodySize, pulBodyOffset, pulValue));
HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadValue(%p,%" HB_PFS "u,%p,%p)", szBody, ulBodySize, pulBodyOffset, pulValue));
if( *pulBodyOffset + 4 < ulBodySize )
{
@@ -136,7 +136,7 @@ static char * hb_hrbReadId( const char * szBody, HB_SIZE ulBodySize, HB_SIZE * u
{
const char * szIdx;
HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadId(%p,%lu,%p)", szBody, ulBodySize, ulBodyOffset));
HB_TRACE(HB_TR_DEBUG, ("hb_hrbReadId(%p,%" HB_PFS "u,%p)", szBody, ulBodySize, ulBodyOffset));
szIdx = &szBody[ *ulBodyOffset ];

52
harbour/src/vm/strapi.c
View File

@@ -77,7 +77,7 @@ HB_SIZE hb_wstrnlen( const HB_WCHAR * szText, HB_SIZE count )
{
HB_SIZE ulLen = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_wstrnlen(%p,%lu)", szText, count));
HB_TRACE(HB_TR_DEBUG, ("hb_wstrnlen(%p,%" HB_PFS "u)", szText, count));
if( szText )
{
@@ -115,7 +115,7 @@ int hb_wstrncmp( const HB_WCHAR * s1, const HB_WCHAR * s2, HB_SIZE count )
{
int rc = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_wstrncmp(%p, %p, %lu)", s1, s2, count));
HB_TRACE(HB_TR_DEBUG, ("hb_wstrncmp(%p, %p, %" HB_PFS "u)", s1, s2, count));
while( count-- )
{
@@ -154,7 +154,7 @@ HB_WCHAR * hb_wstrndup( const HB_WCHAR * szText, HB_SIZE ulLen )
HB_WCHAR * pszDest;
HB_SIZE ulSize;
HB_TRACE(HB_TR_DEBUG, ("hb_wstrndup(%p,%lu)", szText,ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_wstrndup(%p,%" HB_PFS "u)", szText,ulLen));
ulSize = hb_wstrlen( szText );
if( ulSize < ulLen )
@@ -169,7 +169,7 @@ HB_WCHAR * hb_wstrndup( const HB_WCHAR * szText, HB_SIZE ulLen )
HB_WCHAR * hb_wstrunshare( void ** phStr, const HB_WCHAR * pStr, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_wstrunshare(%p,%p,%lu)", phStr, pStr, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_wstrunshare(%p,%p,%" HB_PFS "u)", phStr, pStr, ulLen));
if( pStr == NULL || phStr == NULL || *phStr == NULL )
return NULL;
@@ -193,7 +193,7 @@ HB_WCHAR * hb_wstrunshare( void ** phStr, const HB_WCHAR * pStr, HB_SIZE ulLen )
char * hb_strunshare( void ** phStr, const char * pStr, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_strunshare(%p,%p,%lu)", phStr, pStr, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_strunshare(%p,%p,%" HB_PFS "u)", phStr, pStr, ulLen));
if( pStr == NULL || phStr == NULL || *phStr == NULL )
return NULL;
@@ -352,7 +352,7 @@ const HB_WCHAR * hb_itemGetStrU16( PHB_ITEM pItem, int iEndian,
HB_SIZE hb_itemCopyStr( PHB_ITEM pItem, void * cdp, char * pStrBuffer, HB_SIZE ulSize )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyStr(%p,%p,%p,%lu)", pItem, cdp, pStrBuffer, ulSize));
HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyStr(%p,%p,%p,%" HB_PFS "u)", pItem, cdp, pStrBuffer, ulSize));
if( pItem && HB_IS_STRING( pItem ) )
{
@@ -374,7 +374,7 @@ HB_SIZE hb_itemCopyStr( PHB_ITEM pItem, void * cdp, char * pStrBuffer, HB_SIZE u
HB_SIZE hb_itemCopyStrUTF8( PHB_ITEM pItem, char * pStrBuffer, HB_SIZE ulSize )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyStrUTF8(%p,%p,%lu)", pItem, pStrBuffer, ulSize));
HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyStrUTF8(%p,%p,%" HB_PFS "u)", pItem, pStrBuffer, ulSize));
if( pItem && HB_IS_STRING( pItem ) )
{
@@ -398,7 +398,7 @@ HB_SIZE hb_itemCopyStrUTF8( PHB_ITEM pItem, char * pStrBuffer, HB_SIZE ulSize )
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,%lu)", pItem, iEndian, pStrBuffer, ulSize));
HB_TRACE(HB_TR_DEBUG, ("hb_itemCopyStrU16(%p,%d,%p,%" HB_PFS "u)", pItem, iEndian, pStrBuffer, ulSize));
if( pItem && HB_IS_STRING( pItem ) )
{
@@ -424,7 +424,7 @@ PHB_ITEM hb_itemPutStrLen( PHB_ITEM pItem, void * cdp, const char * pStr, HB_SIZ
{
char * pszText;
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrLen(%p,%p,%p,%lu)", pItem, cdp, pStr, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrLen(%p,%p,%p,%" HB_PFS "u)", pItem, cdp, pStr, ulLen));
if( ulLen == 0 )
return hb_itemPutC( pItem, NULL );
@@ -440,7 +440,7 @@ PHB_ITEM hb_itemPutStrLenUTF8( PHB_ITEM pItem, const char * pStr, HB_SIZE ulLen
char * pszDest;
HB_SIZE ulDest;
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrLenUTF8(%p,%p,%lu)", pItem, pStr, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrLenUTF8(%p,%p,%" HB_PFS "u)", pItem, pStr, ulLen));
if( ulLen == 0 )
return hb_itemPutC( pItem, NULL );
@@ -459,7 +459,7 @@ PHB_ITEM hb_itemPutStrLenU16( PHB_ITEM pItem, int iEndian, const HB_WCHAR * pStr
char * pszDest;
HB_SIZE ulDest;
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrLenU16(%p,%d,%p,%lu)", pItem, iEndian, pStr, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutStrLenU16(%p,%d,%p,%" HB_PFS "u)", pItem, iEndian, pStr, ulLen));
if( ulLen == 0 )
return hb_itemPutC( pItem, NULL );
@@ -535,7 +535,7 @@ PHB_ITEM hb_itemPutStrU16( PHB_ITEM pItem, int iEndian, const HB_WCHAR * pStr )
const char * hb_arrayGetStr( PHB_ITEM pArray, HB_SIZE ulIndex, void * cdp,
void ** phString, HB_SIZE * pulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetStr(%p, %lu, %p, %p, %p)", pArray, ulIndex, cdp, phString, pulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetStr(%p, %" HB_PFS "u, %p, %p, %p)", pArray, ulIndex, cdp, phString, pulLen));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetStr( pArray->item.asArray.value->pItems + ulIndex - 1,
@@ -550,7 +550,7 @@ const char * hb_arrayGetStr( PHB_ITEM pArray, HB_SIZE ulIndex, void * cdp,
const char * hb_arrayGetStrUTF8( PHB_ITEM pArray, HB_SIZE ulIndex,
void ** phString, HB_SIZE * pulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetStrUTF8(%p, %lu, %p, %p)", pArray, ulIndex, phString, pulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetStrUTF8(%p, %" HB_PFS "u, %p, %p)", pArray, ulIndex, phString, pulLen));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetStrUTF8( pArray->item.asArray.value->pItems + ulIndex - 1,
@@ -565,7 +565,7 @@ const char * hb_arrayGetStrUTF8( PHB_ITEM pArray, HB_SIZE ulIndex,
const HB_WCHAR * hb_arrayGetStrU16( PHB_ITEM pArray, HB_SIZE ulIndex, int iEndian,
void ** phString, HB_SIZE * pulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetStrU16(%p, %lu, %d, %p, %p)", pArray, ulIndex, iEndian, phString, pulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_arrayGetStrU16(%p, %" HB_PFS "u, %d, %p, %p)", pArray, ulIndex, iEndian, phString, pulLen));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
return hb_itemGetStrU16( pArray->item.asArray.value->pItems + ulIndex - 1,
@@ -581,7 +581,7 @@ const HB_WCHAR * hb_arrayGetStrU16( PHB_ITEM pArray, HB_SIZE ulIndex, int iEndia
HB_BOOL hb_arraySetStrLen( PHB_ITEM pArray, HB_SIZE ulIndex, void * cdp,
const char * pStr, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrLen(%p, %lu, %p, %p, %lu)", pArray, ulIndex, cdp, pStr, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrLen(%p, %" HB_PFS "u, %p, %p, %" HB_PFS "u)", pArray, ulIndex, cdp, pStr, ulLen));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -596,7 +596,7 @@ HB_BOOL hb_arraySetStrLen( PHB_ITEM pArray, HB_SIZE ulIndex, void * cdp,
HB_BOOL hb_arraySetStrLenUTF8( PHB_ITEM pArray, HB_SIZE ulIndex,
const char * pStr, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrLenUTF8(%p, %lu, %p, %lu)", pArray, ulIndex, pStr, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrLenUTF8(%p, %" HB_PFS "u, %p, %" HB_PFS "u)", pArray, ulIndex, pStr, ulLen));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -611,7 +611,7 @@ HB_BOOL hb_arraySetStrLenUTF8( PHB_ITEM pArray, HB_SIZE ulIndex,
HB_BOOL hb_arraySetStrLenU16( PHB_ITEM pArray, HB_SIZE ulIndex, int iEndian,
const HB_WCHAR * pStr, HB_SIZE ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrLenU16(%p, %lu, %d, %p, %lu)", pArray, ulIndex, iEndian, pStr, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrLenU16(%p, %" HB_PFS "u, %d, %p, %" HB_PFS "u)", pArray, ulIndex, iEndian, pStr, ulLen));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -626,7 +626,7 @@ 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_TRACE(HB_TR_DEBUG, ("hb_arraySetStr(%p, %lu, %p, %p)", pArray, ulIndex, cdp, pStr));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStr(%p, %" HB_PFS "u, %p, %p)", pArray, ulIndex, cdp, pStr));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -639,7 +639,7 @@ HB_BOOL hb_arraySetStr( PHB_ITEM pArray, HB_SIZE ulIndex, void * cdp, const char
HB_BOOL hb_arraySetStrUTF8( PHB_ITEM pArray, HB_SIZE ulIndex, const char * pStr)
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrUTF8(%p, %lu, %p)", pArray, ulIndex, pStr));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrUTF8(%p, %" HB_PFS "u, %p)", pArray, ulIndex, pStr));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -652,7 +652,7 @@ HB_BOOL hb_arraySetStrUTF8( PHB_ITEM pArray, HB_SIZE ulIndex, const char * pStr)
HB_BOOL hb_arraySetStrU16( PHB_ITEM pArray, HB_SIZE ulIndex, int iEndian, const HB_WCHAR * pStr )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrU16(%p, %lu, %d, %p)", pArray, ulIndex, iEndian, pStr));
HB_TRACE(HB_TR_DEBUG, ("hb_arraySetStrU16(%p, %" HB_PFS "u, %d, %p)", pArray, ulIndex, iEndian, pStr));
if( HB_IS_ARRAY( pArray ) && ulIndex > 0 && ulIndex <= pArray->item.asArray.value->ulLen )
{
@@ -772,7 +772,7 @@ void hb_retstrlen( void * cdp, const char * szText, HB_SIZE ulLen )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_retstrlen(%p,%s,%lu)", cdp, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_retstrlen(%p,%s,%" HB_PFS "u)", cdp, szText, ulLen));
hb_itemPutStrLen( hb_stackReturnItem(), cdp, szText, ulLen );
}
@@ -781,7 +781,7 @@ void hb_retstrlen_utf8( const char * szText, HB_SIZE ulLen )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_retstrlen_utf8(%s,%lu)", szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_retstrlen_utf8(%s,%" HB_PFS "u)", szText, ulLen));
hb_itemPutStrLenUTF8( hb_stackReturnItem(), szText, ulLen );
}
@@ -790,7 +790,7 @@ void hb_retstrlen_u16( int iEndian, const HB_WCHAR * szText, HB_SIZE ulLen )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_retstrlen_u16(%d,%p,%lu)", iEndian, szText, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_retstrlen_u16(%d,%p,%" HB_PFS "u)", iEndian, szText, ulLen));
hb_itemPutStrLenU16( hb_stackReturnItem(), iEndian, szText, ulLen );
}
@@ -882,7 +882,7 @@ int hb_storstrlen( void * cdp, const char * szText, HB_SIZE ulLen, int iParam )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_storstrlen(%p,%s,%lu,%d)", cdp, szText, ulLen, iParam));
HB_TRACE(HB_TR_DEBUG, ("hb_storstrlen(%p,%s,%" HB_PFS "u,%d)", cdp, szText, ulLen, iParam));
if( iParam == -1 )
{
@@ -907,7 +907,7 @@ int hb_storstrlen_utf8( const char * szText, HB_SIZE ulLen, int iParam )
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_storstrlen_utf8(%s,%lu,%d)", szText, ulLen, iParam));
HB_TRACE(HB_TR_DEBUG, ("hb_storstrlen_utf8(%s,%" HB_PFS "u,%d)", szText, ulLen, iParam));
if( iParam == -1 )
{
@@ -932,7 +932,7 @@ int hb_storstrlen_u16( int iEndian, const HB_WCHAR * szText, HB_SIZE ulLen, int
{
HB_STACK_TLS_PRELOAD
HB_TRACE(HB_TR_DEBUG, ("hb_storstrlen_u16(%d,%p,%lu,%d)", iEndian, szText, ulLen, iParam));
HB_TRACE(HB_TR_DEBUG, ("hb_storstrlen_u16(%d,%p,%" HB_PFS "u,%d)", iEndian, szText, ulLen, iParam));
if( iParam == -1 )
{