From f1bea060aa9e6b0bb5c1fa7394b91b638aa9155e Mon Sep 17 00:00:00 2001 From: Viktor Szakats Date: Wed, 7 Jul 2010 16:09:23 +0000 Subject: [PATCH] 2010-07-07 18:08 UTC+0200 Viktor Szakats (harbour.01 syenar.hu) * src/compiler/hbmain.c * src/compiler/hbfix.c * src/compiler/hbdbginf.c * src/compiler/hbpcode.c * src/compiler/genhrb.c * src/compiler/hbdead.c * src/compiler/genc.c * src/compiler/hbopt.c * src/compiler/gencc.c * src/compiler/hblbl.c * src/compiler/harbour.yyc * src/compiler/hbstripl.c * src/compiler/harbour.y * include/hbcomp.h * include/hbcompdf.h * include/hbexprb.c * lPCodePos -> nPCodePos (objects verified) --- harbour/ChangeLog | 20 + harbour/include/hbcomp.h | 2 +- harbour/include/hbcompdf.h | 4 +- harbour/include/hbexprb.c | 4 +- harbour/src/compiler/genc.c | 866 +++++++++++++++---------------- harbour/src/compiler/gencc.c | 446 ++++++++-------- harbour/src/compiler/genhrb.c | 8 +- harbour/src/compiler/harbour.y | 42 +- harbour/src/compiler/harbour.yyc | 43 +- harbour/src/compiler/hbdbginf.c | 2 +- harbour/src/compiler/hbdead.c | 152 +++--- harbour/src/compiler/hbfix.c | 16 +- harbour/src/compiler/hblbl.c | 48 +- harbour/src/compiler/hbmain.c | 64 +-- harbour/src/compiler/hbopt.c | 360 ++++++------- harbour/src/compiler/hbpcode.c | 88 ++-- harbour/src/compiler/hbstripl.c | 4 +- 17 files changed, 1094 insertions(+), 1075 deletions(-) diff --git a/harbour/ChangeLog b/harbour/ChangeLog index e61c862b9f..28b9447c9a 100644 --- a/harbour/ChangeLog +++ b/harbour/ChangeLog @@ -16,6 +16,26 @@ The license applies to all entries newer than 2009-04-28. */ +2010-07-07 18:08 UTC+0200 Viktor Szakats (harbour.01 syenar.hu) + * src/compiler/hbmain.c + * src/compiler/hbfix.c + * src/compiler/hbdbginf.c + * src/compiler/hbpcode.c + * src/compiler/genhrb.c + * src/compiler/hbdead.c + * src/compiler/genc.c + * src/compiler/hbopt.c + * src/compiler/gencc.c + * src/compiler/hblbl.c + * src/compiler/harbour.yyc + * src/compiler/hbstripl.c + * src/compiler/harbour.y + * include/hbcomp.h + * include/hbcompdf.h + * include/hbexprb.c + * lPCodePos -> nPCodePos + (objects verified) + 2010-07-07 18:03 UTC+0200 Viktor Szakats (harbour.01 syenar.hu) * src/compiler/ppcomp.c * src/compiler/hbmain.c diff --git a/harbour/include/hbcomp.h b/harbour/include/hbcomp.h index 5d186a5553..dcbecd7d30 100644 --- a/harbour/include/hbcomp.h +++ b/harbour/include/hbcomp.h @@ -71,7 +71,7 @@ HB_EXTERN_BEGIN /* definitions for hb_compPCodeEval() support */ typedef void * HB_VOID_PTR; -#define HB_PCODE_FUNC( func, type ) HB_SIZE func( PFUNCTION pFunc, HB_SIZE lPCodePos, type cargo ) +#define HB_PCODE_FUNC( func, type ) HB_SIZE func( PFUNCTION pFunc, HB_SIZE nPCodePos, type cargo ) typedef HB_PCODE_FUNC( HB_PCODE_FUNC_, HB_VOID_PTR ); typedef HB_PCODE_FUNC_ * HB_PCODE_FUNC_PTR; diff --git a/harbour/include/hbcompdf.h b/harbour/include/hbcompdf.h index c2ae43ebed..c0f142e4fa 100644 --- a/harbour/include/hbcompdf.h +++ b/harbour/include/hbcompdf.h @@ -507,7 +507,7 @@ typedef struct __FUNC PVAR pPrivates; /* pointer to private variables list */ HB_BYTE * pCode; /* pointer to a memory block where pcode is stored */ HB_SIZE lPCodeSize; /* total memory size for pcode */ - HB_SIZE lPCodePos; /* actual pcode offset */ + HB_SIZE nPCodePos; /* actual pcode offset */ int iStaticsBase; /* base for this function statics */ int iFuncSuffix; /* function suffix for multiple static functions with the same name */ HB_SIZE * pNOOPs; /* pointer to the NOOP array */ @@ -652,7 +652,7 @@ typedef struct HB_PCODE_INFO_ /* compiled pcode container for macro compiler */ { HB_BYTE * pCode; /* pointer to a memory block where pcode is stored */ HB_SIZE lPCodeSize; /* total memory size for pcode */ - HB_SIZE lPCodePos; /* actual pcode offset */ + HB_SIZE nPCodePos; /* actual pcode offset */ HB_BOOL fVParams; /* function/codeblock with variable parameters */ HB_CBVAR_PTR pLocals; struct HB_PCODE_INFO_ * pPrev; diff --git a/harbour/include/hbexprb.c b/harbour/include/hbexprb.c index c2bf134f70..1e5ac54698 100644 --- a/harbour/include/hbexprb.c +++ b/harbour/include/hbexprb.c @@ -975,13 +975,13 @@ static HB_EXPR_FUNC( hb_compExprUseIIF ) pExpr =pExpr->pNext; #if defined( HB_MACRO_SUPPORT ) - if( HB_PCODE_DATA->lPCodePos == ulPosFalse + 3 ) + if( HB_PCODE_DATA->nPCodePos == ulPosFalse + 3 ) { HB_PCODE_DATA->pCode[ ulPosFalse - 1 ] = HB_P_JUMPTRUEFAR; ulPosEnd = ulPosFalse; } #else - if( HB_COMP_PARAM->functions.pLast->lPCodePos == ulPosFalse + 3 ) + if( HB_COMP_PARAM->functions.pLast->nPCodePos == ulPosFalse + 3 ) { HB_COMP_PARAM->functions.pLast->pCode[ ulPosFalse - 1 ] = HB_P_JUMPTRUEFAR; ulPosEnd = ulPosFalse; diff --git a/harbour/src/compiler/genc.c b/harbour/src/compiler/genc.c index 79d286f0d0..05dcf4404a 100644 --- a/harbour/src/compiler/genc.c +++ b/harbour/src/compiler/genc.c @@ -541,7 +541,7 @@ static void hb_compGenCStaticName( HB_USHORT uiStatic, HB_GENC_INFO_PTR cargo ) static HB_GENC_FUNC( hb_p_and ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_AND,\n" ); return 1; @@ -550,7 +550,7 @@ static HB_GENC_FUNC( hb_p_and ) static HB_GENC_FUNC( hb_p_arraypush ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_ARRAYPUSH,\n" ); return 1; @@ -559,7 +559,7 @@ static HB_GENC_FUNC( hb_p_arraypush ) static HB_GENC_FUNC( hb_p_arraypushref ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_ARRAYPUSHREF,\n" ); return 1; @@ -568,7 +568,7 @@ static HB_GENC_FUNC( hb_p_arraypushref ) static HB_GENC_FUNC( hb_p_arraypop ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_ARRAYPOP,\n" ); return 1; @@ -577,7 +577,7 @@ static HB_GENC_FUNC( hb_p_arraypop ) static HB_GENC_FUNC( hb_p_dec ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_DEC,\n" ); return 1; @@ -586,9 +586,9 @@ static HB_GENC_FUNC( hb_p_dec ) static HB_GENC_FUNC( hb_p_arraydim ) { fprintf( cargo->yyc, "\tHB_P_ARRAYDIM, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -596,7 +596,7 @@ static HB_GENC_FUNC( hb_p_arraydim ) static HB_GENC_FUNC( hb_p_divide ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_DIVIDE,\n" ); return 1; @@ -605,21 +605,21 @@ static HB_GENC_FUNC( hb_p_divide ) static HB_GENC_FUNC( hb_p_do ) { fprintf( cargo->yyc, "\tHB_P_DO, %i, %i,\n", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); return 3; } static HB_GENC_FUNC( hb_p_doshort ) { - fprintf( cargo->yyc, "\tHB_P_DOSHORT, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); + fprintf( cargo->yyc, "\tHB_P_DOSHORT, %i,\n", pFunc->pCode[ nPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_duplicate ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_DUPLICATE,\n" ); return 1; @@ -628,7 +628,7 @@ static HB_GENC_FUNC( hb_p_duplicate ) static HB_GENC_FUNC( hb_p_duplunref ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_DUPLUNREF,\n" ); return 1; @@ -637,7 +637,7 @@ static HB_GENC_FUNC( hb_p_duplunref ) static HB_GENC_FUNC( hb_p_pushunref ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_PUSHUNREF,\n" ); return 1; @@ -645,14 +645,14 @@ static HB_GENC_FUNC( hb_p_pushunref ) static HB_GENC_FUNC( hb_p_swap ) { - fprintf( cargo->yyc, "\tHB_P_SWAP, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); + fprintf( cargo->yyc, "\tHB_P_SWAP, %i,\n", pFunc->pCode[ nPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_equal ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_EQUAL,\n" ); return 1; @@ -661,7 +661,7 @@ static HB_GENC_FUNC( hb_p_equal ) static HB_GENC_FUNC( hb_p_exactlyequal ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_EXACTLYEQUAL,\n" ); return 1; @@ -670,7 +670,7 @@ static HB_GENC_FUNC( hb_p_exactlyequal ) static HB_GENC_FUNC( hb_p_endblock ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_ENDBLOCK,\n" ); return 1; @@ -678,7 +678,7 @@ static HB_GENC_FUNC( hb_p_endblock ) static HB_GENC_FUNC( hb_p_endproc ) { - if( lPCodePos + 1 == pFunc->lPCodePos ) + if( nPCodePos + 1 == pFunc->nPCodePos ) fprintf( cargo->yyc, "\tHB_P_ENDPROC\n" ); else fprintf( cargo->yyc, "\tHB_P_ENDPROC,\n" ); @@ -688,7 +688,7 @@ static HB_GENC_FUNC( hb_p_endproc ) static HB_GENC_FUNC( hb_p_false ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_FALSE,\n" ); return 1; @@ -697,7 +697,7 @@ static HB_GENC_FUNC( hb_p_false ) static HB_GENC_FUNC( hb_p_fortest ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_FORTEST,\n" ); return 1; @@ -706,8 +706,8 @@ static HB_GENC_FUNC( hb_p_fortest ) static HB_GENC_FUNC( hb_p_frame ) { fprintf( cargo->yyc, "\tHB_P_FRAME, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* locals, params */" ); fprintf( cargo->yyc, "\n" ); return 3; @@ -716,7 +716,7 @@ static HB_GENC_FUNC( hb_p_frame ) static HB_GENC_FUNC( hb_p_funcptr ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_FUNCPTR,\n" ); return 1; @@ -725,23 +725,23 @@ static HB_GENC_FUNC( hb_p_funcptr ) static HB_GENC_FUNC( hb_p_function ) { fprintf( cargo->yyc, "\tHB_P_FUNCTION, %i, %i,\n", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); return 3; } static HB_GENC_FUNC( hb_p_functionshort ) { - fprintf( cargo->yyc, "\tHB_P_FUNCTIONSHORT, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); + fprintf( cargo->yyc, "\tHB_P_FUNCTIONSHORT, %i,\n", pFunc->pCode[ nPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_arraygen ) { fprintf( cargo->yyc, "\tHB_P_ARRAYGEN, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -749,9 +749,9 @@ static HB_GENC_FUNC( hb_p_arraygen ) static HB_GENC_FUNC( hb_p_hashgen ) { fprintf( cargo->yyc, "\tHB_P_HASHGEN, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -759,7 +759,7 @@ static HB_GENC_FUNC( hb_p_hashgen ) static HB_GENC_FUNC( hb_p_greater ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_GREATER,\n" ); return 1; @@ -768,7 +768,7 @@ static HB_GENC_FUNC( hb_p_greater ) static HB_GENC_FUNC( hb_p_greaterequal ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_GREATEREQUAL,\n" ); return 1; @@ -777,7 +777,7 @@ static HB_GENC_FUNC( hb_p_greaterequal ) static HB_GENC_FUNC( hb_p_inc ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_INC,\n" ); return 1; @@ -786,7 +786,7 @@ static HB_GENC_FUNC( hb_p_inc ) static HB_GENC_FUNC( hb_p_instring ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_INSTRING,\n" ); return 1; @@ -795,12 +795,12 @@ static HB_GENC_FUNC( hb_p_instring ) static HB_GENC_FUNC( hb_p_jumpnear ) { fprintf( cargo->yyc, "\tHB_P_JUMPNEAR, %i,", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); if( cargo->bVerbose ) { - HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ lPCodePos + 1 ] ); + HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ nPCodePos + 1 ] ); - fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", nOffset, ( HB_ISIZ ) ( lPCodePos + nOffset ) ); + fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) ); } fprintf( cargo->yyc, "\n" ); return 2; @@ -809,13 +809,13 @@ static HB_GENC_FUNC( hb_p_jumpnear ) static HB_GENC_FUNC( hb_p_jump ) { fprintf( cargo->yyc, "\tHB_P_JUMP, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) { - HB_ISIZ nOffset = HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); + HB_ISIZ nOffset = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); - fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", nOffset, ( HB_ISIZ ) ( lPCodePos + nOffset ) ); + fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) ); } fprintf( cargo->yyc, "\n" ); return 3; @@ -824,13 +824,13 @@ static HB_GENC_FUNC( hb_p_jump ) static HB_GENC_FUNC( hb_p_jumpfar ) { fprintf( cargo->yyc, "\tHB_P_JUMPFAR, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); if( cargo->bVerbose ) { - HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 1 ] ); - fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, ( HB_ISIZ ) ( lPCodePos + nOffset ) ); + HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] ); + fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) ); } fprintf( cargo->yyc, "\n" ); return 4; @@ -839,11 +839,11 @@ static HB_GENC_FUNC( hb_p_jumpfar ) static HB_GENC_FUNC( hb_p_jumpfalsenear ) { fprintf( cargo->yyc, "\tHB_P_JUMPFALSENEAR, %i,", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); if( cargo->bVerbose ) { - HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ lPCodePos + 1 ] ); - fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", nOffset, ( HB_ISIZ ) ( lPCodePos + nOffset ) ); + HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ nPCodePos + 1 ] ); + fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) ); } fprintf( cargo->yyc, "\n" ); return 2; @@ -852,12 +852,12 @@ static HB_GENC_FUNC( hb_p_jumpfalsenear ) static HB_GENC_FUNC( hb_p_jumpfalse ) { fprintf( cargo->yyc, "\tHB_P_JUMPFALSE, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) { - HB_ISIZ nOffset = HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); - fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", nOffset, ( HB_ISIZ ) ( lPCodePos + nOffset ) ); + HB_ISIZ nOffset = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); + fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) ); } fprintf( cargo->yyc, "\n" ); return 3; @@ -866,13 +866,13 @@ static HB_GENC_FUNC( hb_p_jumpfalse ) static HB_GENC_FUNC( hb_p_jumpfalsefar ) { fprintf( cargo->yyc, "\tHB_P_JUMPFALSEFAR, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); if( cargo->bVerbose ) { - HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 1 ] ); - fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, ( HB_ISIZ ) ( lPCodePos + nOffset ) ); + HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] ); + fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) ); } fprintf( cargo->yyc, "\n" ); return 4; @@ -881,11 +881,11 @@ static HB_GENC_FUNC( hb_p_jumpfalsefar ) static HB_GENC_FUNC( hb_p_jumptruenear ) { fprintf( cargo->yyc, "\tHB_P_JUMPTRUENEAR, %i,", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); if( cargo->bVerbose ) { - HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ lPCodePos + 1 ] ); - fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", nOffset, ( HB_ISIZ ) ( lPCodePos + nOffset ) ); + HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ nPCodePos + 1 ] ); + fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) ); } fprintf( cargo->yyc, "\n" ); return 2; @@ -894,12 +894,12 @@ static HB_GENC_FUNC( hb_p_jumptruenear ) static HB_GENC_FUNC( hb_p_jumptrue ) { fprintf( cargo->yyc, "\tHB_P_JUMPTRUE, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) { - HB_ISIZ nOffset = HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); - fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", nOffset, ( HB_ISIZ ) ( lPCodePos + nOffset ) ); + HB_ISIZ nOffset = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); + fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) ); } fprintf( cargo->yyc, "\n" ); return 3; @@ -908,13 +908,13 @@ static HB_GENC_FUNC( hb_p_jumptrue ) static HB_GENC_FUNC( hb_p_jumptruefar ) { fprintf( cargo->yyc, "\tHB_P_JUMPTRUEFAR, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); if( cargo->bVerbose ) { - HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 1 ] ); - fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, ( HB_ISIZ ) ( lPCodePos + nOffset ) ); + HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] ); + fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) ); } fprintf( cargo->yyc, "\n" ); return 4; @@ -923,7 +923,7 @@ static HB_GENC_FUNC( hb_p_jumptruefar ) static HB_GENC_FUNC( hb_p_less ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_LESS,\n" ); return 1; @@ -932,7 +932,7 @@ static HB_GENC_FUNC( hb_p_less ) static HB_GENC_FUNC( hb_p_lessequal ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_LESSEQUAL,\n" ); return 1; @@ -941,31 +941,31 @@ static HB_GENC_FUNC( hb_p_lessequal ) static HB_GENC_FUNC( hb_p_line ) { if( cargo->bVerbose ) - fprintf( cargo->yyc, "/* %05li */ ", lPCodePos ); + fprintf( cargo->yyc, "/* %05li */ ", nPCodePos ); else fprintf( cargo->yyc, "\t" ); fprintf( cargo->yyc, "HB_P_LINE, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) - fprintf( cargo->yyc, "\t/* %i */", HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + fprintf( cargo->yyc, "\t/* %i */", HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_localname ) { - HB_SIZE nStart = lPCodePos; + HB_SIZE nStart = nPCodePos; fprintf( cargo->yyc, "\tHB_P_LOCALNAME, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", ( char * ) pFunc->pCode + lPCodePos + 3 ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", ( char * ) pFunc->pCode + nPCodePos + 3 ); fprintf( cargo->yyc, "\n" ); - lPCodePos += 3; - while( pFunc->pCode[ lPCodePos ] ) + nPCodePos += 3; + while( pFunc->pCode[ nPCodePos ] ) { - char chr = pFunc->pCode[ lPCodePos++ ]; + char chr = pFunc->pCode[ nPCodePos++ ]; if( chr == '\'' || chr == '\\') fprintf( cargo->yyc, " \'\\%c\',", chr ); else @@ -973,40 +973,40 @@ static HB_GENC_FUNC( hb_p_localname ) } fprintf( cargo->yyc, " 0,\n" ); - return lPCodePos - nStart + 1; + return nPCodePos - nStart + 1; } static HB_GENC_FUNC( hb_p_macropop ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); - fprintf( cargo->yyc, "\tHB_P_MACROPOP, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); + fprintf( cargo->yyc, "\tHB_P_MACROPOP, %i,\n", pFunc->pCode[ nPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macropopaliased ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); - fprintf( cargo->yyc, "\tHB_P_MACROPOPALIASED, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); + fprintf( cargo->yyc, "\tHB_P_MACROPOPALIASED, %i,\n", pFunc->pCode[ nPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macropush ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); - fprintf( cargo->yyc, "\tHB_P_MACROPUSH, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); + fprintf( cargo->yyc, "\tHB_P_MACROPUSH, %i,\n", pFunc->pCode[ nPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macropushref ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROPUSHREF,\n" ); return 1; @@ -1015,56 +1015,56 @@ static HB_GENC_FUNC( hb_p_macropushref ) static HB_GENC_FUNC( hb_p_macrodo ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACRODO, %i, %i,\n", - pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] ); return 3; } static HB_GENC_FUNC( hb_p_macrofunc ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROFUNC, %i, %i,\n", - pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] ); return 3; } static HB_GENC_FUNC( hb_p_macrosend ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROSEND, %i, %i,\n", - pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] ); return 3; } static HB_GENC_FUNC( hb_p_macroarraygen ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROARRAYGEN, %i, %i,\n", - pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] ); return 3; } static HB_GENC_FUNC( hb_p_macropushlist ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); - fprintf( cargo->yyc, "\tHB_P_MACROPUSHLIST, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); + fprintf( cargo->yyc, "\tHB_P_MACROPUSHLIST, %i,\n", pFunc->pCode[ nPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macropushindex ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROPUSHINDEX,\n" ); return 1; @@ -1073,25 +1073,25 @@ static HB_GENC_FUNC( hb_p_macropushindex ) static HB_GENC_FUNC( hb_p_macropushpare ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); - fprintf( cargo->yyc, "\tHB_P_MACROPUSHPARE, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); + fprintf( cargo->yyc, "\tHB_P_MACROPUSHPARE, %i,\n", pFunc->pCode[ nPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macropushaliased ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); - fprintf( cargo->yyc, "\tHB_P_MACROPUSHALIASED, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); + fprintf( cargo->yyc, "\tHB_P_MACROPUSHALIASED, %i,\n", pFunc->pCode[ nPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macrosymbol ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROSYMBOL,\n" ); return 1; @@ -1100,7 +1100,7 @@ static HB_GENC_FUNC( hb_p_macrosymbol ) static HB_GENC_FUNC( hb_p_macrotext ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROTEXT,\n" ); return 1; @@ -1109,9 +1109,9 @@ static HB_GENC_FUNC( hb_p_macrotext ) static HB_GENC_FUNC( hb_p_message ) { fprintf( cargo->yyc, "\tHB_P_MESSAGE, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1119,7 +1119,7 @@ static HB_GENC_FUNC( hb_p_message ) static HB_GENC_FUNC( hb_p_minus ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MINUS,\n" ); return 1; @@ -1127,16 +1127,16 @@ static HB_GENC_FUNC( hb_p_minus ) static HB_GENC_FUNC( hb_p_modulename ) { - HB_SIZE nStart = lPCodePos; + HB_SIZE nStart = nPCodePos; fprintf( cargo->yyc, "\tHB_P_MODULENAME," ); if( cargo->bVerbose ) - fprintf( cargo->yyc, "\t/* %s */", ( char * ) pFunc->pCode + lPCodePos + 1 ); + fprintf( cargo->yyc, "\t/* %s */", ( char * ) pFunc->pCode + nPCodePos + 1 ); fprintf( cargo->yyc, "\n" ); - lPCodePos++; - while( pFunc->pCode[ lPCodePos ] ) + nPCodePos++; + while( pFunc->pCode[ nPCodePos ] ) { - char chr = pFunc->pCode[ lPCodePos++ ]; + char chr = pFunc->pCode[ nPCodePos++ ]; if( chr == '\'' || chr == '\\') fprintf( cargo->yyc, " \'\\%c\',", chr ); else @@ -1144,13 +1144,13 @@ static HB_GENC_FUNC( hb_p_modulename ) } fprintf( cargo->yyc, " 0,\n" ); - return lPCodePos - nStart + 1; + return nPCodePos - nStart + 1; } static HB_GENC_FUNC( hb_p_modulus ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MODULUS,\n" ); return 1; @@ -1159,7 +1159,7 @@ static HB_GENC_FUNC( hb_p_modulus ) static HB_GENC_FUNC( hb_p_mult ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MULT,\n" ); return 1; @@ -1168,7 +1168,7 @@ static HB_GENC_FUNC( hb_p_mult ) static HB_GENC_FUNC( hb_p_negate ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_NEGATE,\n" ); return 1; @@ -1177,7 +1177,7 @@ static HB_GENC_FUNC( hb_p_negate ) static HB_GENC_FUNC( hb_p_not ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_NOT,\n" ); return 1; @@ -1186,7 +1186,7 @@ static HB_GENC_FUNC( hb_p_not ) static HB_GENC_FUNC( hb_p_notequal ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_NOTEQUAL,\n" ); return 1; @@ -1195,7 +1195,7 @@ static HB_GENC_FUNC( hb_p_notequal ) static HB_GENC_FUNC( hb_p_or ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_OR,\n" ); return 1; @@ -1204,10 +1204,10 @@ static HB_GENC_FUNC( hb_p_or ) static HB_GENC_FUNC( hb_p_parameter ) { fprintf( cargo->yyc, "\tHB_P_PARAMETER, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 4; } @@ -1215,7 +1215,7 @@ static HB_GENC_FUNC( hb_p_parameter ) static HB_GENC_FUNC( hb_p_plus ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_PLUS,\n" ); return 1; @@ -1224,7 +1224,7 @@ static HB_GENC_FUNC( hb_p_plus ) static HB_GENC_FUNC( hb_p_pop ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_POP,\n" ); return 1; @@ -1233,7 +1233,7 @@ static HB_GENC_FUNC( hb_p_pop ) static HB_GENC_FUNC( hb_p_popalias ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_POPALIAS,\n" ); return 1; @@ -1242,9 +1242,9 @@ static HB_GENC_FUNC( hb_p_popalias ) static HB_GENC_FUNC( hb_p_popaliasedfield ) { fprintf( cargo->yyc, "\tHB_P_POPALIASEDFIELD, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1252,8 +1252,8 @@ static HB_GENC_FUNC( hb_p_popaliasedfield ) static HB_GENC_FUNC( hb_p_popaliasedfieldnear ) { fprintf( cargo->yyc, "\tHB_P_POPALIASEDFIELDNEAR, %i,", - pFunc->pCode[ lPCodePos + 1 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, pFunc->pCode[ lPCodePos + 1 ] ) ); + pFunc->pCode[ nPCodePos + 1 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, pFunc->pCode[ nPCodePos + 1 ] ) ); fprintf( cargo->yyc, "\n" ); return 2; } @@ -1261,9 +1261,9 @@ static HB_GENC_FUNC( hb_p_popaliasedfieldnear ) static HB_GENC_FUNC( hb_p_popaliasedvar ) { fprintf( cargo->yyc, "\tHB_P_POPALIASEDVAR, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1271,9 +1271,9 @@ static HB_GENC_FUNC( hb_p_popaliasedvar ) static HB_GENC_FUNC( hb_p_popfield ) { fprintf( cargo->yyc, "\tHB_P_POPFIELD, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1281,12 +1281,12 @@ static HB_GENC_FUNC( hb_p_popfield ) static HB_GENC_FUNC( hb_p_poplocal ) { fprintf( cargo->yyc, "\tHB_P_POPLOCAL, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) { - int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); - hb_compGenCLocalName( pFunc, iVar, lPCodePos, cargo ); + int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); + hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo ); } fprintf( cargo->yyc, "\n" ); return 3; @@ -1295,11 +1295,11 @@ static HB_GENC_FUNC( hb_p_poplocal ) static HB_GENC_FUNC( hb_p_poplocalnear ) { fprintf( cargo->yyc, "\tHB_P_POPLOCALNEAR, %i,", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); if( cargo->bVerbose ) { - int iVar = ( signed char ) pFunc->pCode[ lPCodePos + 1 ]; - hb_compGenCLocalName( pFunc, iVar, lPCodePos, cargo ); + int iVar = ( signed char ) pFunc->pCode[ nPCodePos + 1 ]; + hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo ); } fprintf( cargo->yyc, "\n" ); return 2; @@ -1308,9 +1308,9 @@ static HB_GENC_FUNC( hb_p_poplocalnear ) static HB_GENC_FUNC( hb_p_popmemvar ) { fprintf( cargo->yyc, "\tHB_P_POPMEMVAR, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1318,10 +1318,10 @@ static HB_GENC_FUNC( hb_p_popmemvar ) static HB_GENC_FUNC( hb_p_popstatic ) { fprintf( cargo->yyc, "\tHB_P_POPSTATIC, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) - hb_compGenCStaticName( HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), cargo ); + hb_compGenCStaticName( HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), cargo ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1329,9 +1329,9 @@ static HB_GENC_FUNC( hb_p_popstatic ) static HB_GENC_FUNC( hb_p_popvariable ) { fprintf( cargo->yyc, "\tHB_P_POPVARIABLE, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1339,7 +1339,7 @@ static HB_GENC_FUNC( hb_p_popvariable ) static HB_GENC_FUNC( hb_p_power ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_POWER,\n" ); return 1; @@ -1348,7 +1348,7 @@ static HB_GENC_FUNC( hb_p_power ) static HB_GENC_FUNC( hb_p_pushalias ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_PUSHALIAS,\n" ); return 1; @@ -1357,9 +1357,9 @@ static HB_GENC_FUNC( hb_p_pushalias ) static HB_GENC_FUNC( hb_p_pushaliasedfield ) { fprintf( cargo->yyc, "\tHB_P_PUSHALIASEDFIELD, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1367,8 +1367,8 @@ static HB_GENC_FUNC( hb_p_pushaliasedfield ) static HB_GENC_FUNC( hb_p_pushaliasedfieldnear ) { fprintf( cargo->yyc, "\tHB_P_PUSHALIASEDFIELDNEAR, %i,", - pFunc->pCode[ lPCodePos + 1 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, pFunc->pCode[ lPCodePos + 1 ] ) ); + pFunc->pCode[ nPCodePos + 1 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, pFunc->pCode[ nPCodePos + 1 ] ) ); fprintf( cargo->yyc, "\n" ); return 2; } @@ -1376,9 +1376,9 @@ static HB_GENC_FUNC( hb_p_pushaliasedfieldnear ) static HB_GENC_FUNC( hb_p_pushaliasedvar ) { fprintf( cargo->yyc, "\tHB_P_PUSHALIASEDVAR, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1386,14 +1386,14 @@ static HB_GENC_FUNC( hb_p_pushaliasedvar ) static HB_GENC_FUNC( hb_p_pushblockshort ) { fprintf( cargo->yyc, "\tHB_P_PUSHBLOCKSHORT, %i,", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); fprintf( cargo->yyc, "\n" ); - if( cargo->nEndBlockPos < lPCodePos ) - cargo->nEndBlockPos = lPCodePos + pFunc->pCode[ lPCodePos + 1 ] - 1; + if( cargo->nEndBlockPos < nPCodePos ) + cargo->nEndBlockPos = nPCodePos + pFunc->pCode[ nPCodePos + 1 ] - 1; return 2; } @@ -1401,37 +1401,37 @@ static HB_GENC_FUNC( hb_p_pushblockshort ) static HB_GENC_FUNC( hb_p_pushblock ) { HB_USHORT wVar, w; - HB_SIZE nStart = lPCodePos; + HB_SIZE nStart = nPCodePos; fprintf( cargo->yyc, "\tHB_P_PUSHBLOCK, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); fprintf( cargo->yyc, "\n" ); - w = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 3 ] ); + w = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 3 ] ); fprintf( cargo->yyc, "\t%i, %i,", - pFunc->pCode[ lPCodePos + 3 ], - pFunc->pCode[ lPCodePos + 4 ] ); + pFunc->pCode[ nPCodePos + 3 ], + pFunc->pCode[ nPCodePos + 4 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* number of local parameters (%i) */", w ); fprintf( cargo->yyc, "\n" ); - wVar = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 5 ] ); + wVar = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 5 ] ); fprintf( cargo->yyc, "\t%i, %i,", - pFunc->pCode[ lPCodePos + 5 ], - pFunc->pCode[ lPCodePos + 6 ] ); + pFunc->pCode[ nPCodePos + 5 ], + pFunc->pCode[ nPCodePos + 6 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* number of local variables (%i) */", wVar ); fprintf( cargo->yyc, "\n" ); - lPCodePos += 7; /* codeblock size + number of parameters + number of local variables */ + nPCodePos += 7; /* codeblock size + number of parameters + number of local variables */ /* create the table of referenced local variables */ while( wVar-- ) { fprintf( cargo->yyc, "\t%i, %i,", - pFunc->pCode[ lPCodePos ], - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos ], + pFunc->pCode[ nPCodePos + 1 ] ); /* NOTE: * When a codeblock is used to initialize a static variable * the names of local variables cannot be determined @@ -1440,54 +1440,54 @@ static HB_GENC_FUNC( hb_p_pushblock ) */ if( cargo->bVerbose && ( pFunc->cScope & HB_FS_INITEXIT ) != HB_FS_INITEXIT ) { - w = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos ] ); - hb_compGenCLocalName( pFunc, w, lPCodePos, cargo ); + w = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos ] ); + hb_compGenCLocalName( pFunc, w, nPCodePos, cargo ); } fprintf( cargo->yyc, "\n" ); - lPCodePos += 2; + nPCodePos += 2; } if( cargo->nEndBlockPos < nStart ) cargo->nEndBlockPos = nStart + HB_PCODE_MKUSHORT( &pFunc->pCode[ nStart + 1 ] ) - 1; - return lPCodePos - nStart; + return nPCodePos - nStart; } static HB_GENC_FUNC( hb_p_pushblocklarge ) { HB_USHORT wVar, w; - HB_SIZE nStart = lPCodePos; + HB_SIZE nStart = nPCodePos; fprintf( cargo->yyc, "\tHB_P_PUSHBLOCKLARGE, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %lu */", - HB_PCODE_MKUINT24( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUINT24( &pFunc->pCode[ nPCodePos + 1 ] ) ); fprintf( cargo->yyc, "\n" ); - w = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 4 ] ); + w = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 4 ] ); fprintf( cargo->yyc, "\t%i, %i,", - pFunc->pCode[ lPCodePos + 4 ], - pFunc->pCode[ lPCodePos + 5 ] ); + pFunc->pCode[ nPCodePos + 4 ], + pFunc->pCode[ nPCodePos + 5 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* number of local parameters (%i) */", w ); fprintf( cargo->yyc, "\n" ); - wVar = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 6 ] ); + wVar = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 6 ] ); fprintf( cargo->yyc, "\t%i, %i,", - pFunc->pCode[ lPCodePos + 6 ], - pFunc->pCode[ lPCodePos + 7 ] ); + pFunc->pCode[ nPCodePos + 6 ], + pFunc->pCode[ nPCodePos + 7 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* number of local variables (%i) */", wVar ); fprintf( cargo->yyc, "\n" ); - lPCodePos += 8; /* codeblock size + number of parameters + number of local variables */ + nPCodePos += 8; /* codeblock size + number of parameters + number of local variables */ /* create the table of referenced local variables */ while( wVar-- ) { fprintf( cargo->yyc, "\t%i, %i,", - pFunc->pCode[ lPCodePos ], - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos ], + pFunc->pCode[ nPCodePos + 1 ] ); /* NOTE: * When a codeblock is used to initialize a static variable * the names of local variables cannot be determined @@ -1496,17 +1496,17 @@ static HB_GENC_FUNC( hb_p_pushblocklarge ) */ if( cargo->bVerbose && ( pFunc->cScope & HB_FS_INITEXIT ) != HB_FS_INITEXIT ) { - w = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos ] ); - hb_compGenCLocalName( pFunc, w, lPCodePos, cargo ); + w = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos ] ); + hb_compGenCLocalName( pFunc, w, nPCodePos, cargo ); } fprintf( cargo->yyc, "\n" ); - lPCodePos += 2; + nPCodePos += 2; } if( cargo->nEndBlockPos < nStart ) cargo->nEndBlockPos = nStart + HB_PCODE_MKUINT24( &pFunc->pCode[ nStart + 1 ] ) - 1; - return lPCodePos - nStart; + return nPCodePos - nStart; } static HB_GENC_FUNC( hb_p_pushdouble ) @@ -1514,18 +1514,18 @@ static HB_GENC_FUNC( hb_p_pushdouble ) int i; fprintf( cargo->yyc, "\tHB_P_PUSHDOUBLE," ); - ++lPCodePos; + ++nPCodePos; for( i = 0; i < ( int ) ( sizeof( double ) + sizeof( HB_BYTE ) + sizeof( HB_BYTE ) ); ++i ) { - fprintf( cargo->yyc, " %i,", ( HB_UCHAR ) pFunc->pCode[ lPCodePos + i ] ); + fprintf( cargo->yyc, " %i,", ( HB_UCHAR ) pFunc->pCode[ nPCodePos + i ] ); } if( cargo->bVerbose ) { fprintf( cargo->yyc, "\t/* %.*f, %d, %d */", - ( HB_UCHAR ) pFunc->pCode[ lPCodePos + sizeof( double ) + sizeof( HB_BYTE ) ], - HB_PCODE_MKDOUBLE( &pFunc->pCode[ lPCodePos ] ), - ( HB_UCHAR ) pFunc->pCode[ lPCodePos + sizeof( double ) ], - ( HB_UCHAR ) pFunc->pCode[ lPCodePos + sizeof( double ) + sizeof( HB_BYTE ) ] ); + ( HB_UCHAR ) pFunc->pCode[ nPCodePos + sizeof( double ) + sizeof( HB_BYTE ) ], + HB_PCODE_MKDOUBLE( &pFunc->pCode[ nPCodePos ] ), + ( HB_UCHAR ) pFunc->pCode[ nPCodePos + sizeof( double ) ], + ( HB_UCHAR ) pFunc->pCode[ nPCodePos + sizeof( double ) + sizeof( HB_BYTE ) ] ); } fprintf( cargo->yyc, "\n" ); @@ -1535,9 +1535,9 @@ static HB_GENC_FUNC( hb_p_pushdouble ) static HB_GENC_FUNC( hb_p_pushfield ) { fprintf( cargo->yyc, "\tHB_P_PUSHFIELD, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1545,8 +1545,8 @@ static HB_GENC_FUNC( hb_p_pushfield ) static HB_GENC_FUNC( hb_p_pushbyte ) { fprintf( cargo->yyc, "\tHB_P_PUSHBYTE, %i,", - pFunc->pCode[ lPCodePos + 1 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", ( signed char ) pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", ( signed char ) pFunc->pCode[ nPCodePos + 1 ] ); fprintf( cargo->yyc, "\n" ); return 2; } @@ -1554,9 +1554,9 @@ static HB_GENC_FUNC( hb_p_pushbyte ) static HB_GENC_FUNC( hb_p_pushint ) { fprintf( cargo->yyc, "\tHB_P_PUSHINT, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1564,12 +1564,12 @@ static HB_GENC_FUNC( hb_p_pushint ) static HB_GENC_FUNC( hb_p_pushlocal ) { fprintf( cargo->yyc, "\tHB_P_PUSHLOCAL, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) { - int iVar = (int) HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); - hb_compGenCLocalName( pFunc, iVar, lPCodePos, cargo ); + int iVar = (int) HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); + hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo ); } fprintf( cargo->yyc, "\n" ); return 3; @@ -1578,11 +1578,11 @@ static HB_GENC_FUNC( hb_p_pushlocal ) static HB_GENC_FUNC( hb_p_pushlocalnear ) { fprintf( cargo->yyc, "\tHB_P_PUSHLOCALNEAR, %i,", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); if( cargo->bVerbose ) { - int iVar = ( signed char ) pFunc->pCode[ lPCodePos + 1 ]; - hb_compGenCLocalName( pFunc, iVar, lPCodePos, cargo ); + int iVar = ( signed char ) pFunc->pCode[ nPCodePos + 1 ]; + hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo ); } fprintf( cargo->yyc, "\n" ); return 2; @@ -1591,12 +1591,12 @@ static HB_GENC_FUNC( hb_p_pushlocalnear ) static HB_GENC_FUNC( hb_p_pushlocalref ) { fprintf( cargo->yyc, "\tHB_P_PUSHLOCALREF, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) { - int iVar = (int) HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); - hb_compGenCLocalName( pFunc, iVar, lPCodePos, cargo ); + int iVar = (int) HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); + hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo ); } fprintf( cargo->yyc, "\n" ); return 3; @@ -1605,11 +1605,11 @@ static HB_GENC_FUNC( hb_p_pushlocalref ) static HB_GENC_FUNC( hb_p_pushlong ) { fprintf( cargo->yyc, "\tHB_P_PUSHLONG, %i, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ], - pFunc->pCode[ lPCodePos + 4 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %li */", HB_PCODE_MKLONG( &pFunc->pCode[ lPCodePos + 1 ] ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ], + pFunc->pCode[ nPCodePos + 4 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %li */", HB_PCODE_MKLONG( &pFunc->pCode[ nPCodePos + 1 ] ) ); fprintf( cargo->yyc, "\n" ); return 5; @@ -1618,22 +1618,22 @@ static HB_GENC_FUNC( hb_p_pushlong ) static HB_GENC_FUNC( hb_p_pushlonglong ) { fprintf( cargo->yyc, "\tHB_P_PUSHLONGLONG, %i, %i, %i, %i, %i, %i, %i, %i, ", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ], - pFunc->pCode[ lPCodePos + 4 ], - pFunc->pCode[ lPCodePos + 5 ], - pFunc->pCode[ lPCodePos + 6 ], - pFunc->pCode[ lPCodePos + 7 ], - pFunc->pCode[ lPCodePos + 8 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ], + pFunc->pCode[ nPCodePos + 4 ], + pFunc->pCode[ nPCodePos + 5 ], + pFunc->pCode[ nPCodePos + 6 ], + pFunc->pCode[ nPCodePos + 7 ], + pFunc->pCode[ nPCodePos + 8 ] ); if( cargo->bVerbose ) { #ifdef HB_LONG_LONG_OFF - fprintf( cargo->yyc, "\t/* %lf */", HB_PCODE_MKLONGLONG( &pFunc->pCode[ lPCodePos + 1 ] ) ); + fprintf( cargo->yyc, "\t/* %lf */", HB_PCODE_MKLONGLONG( &pFunc->pCode[ nPCodePos + 1 ] ) ); #else char szBuf[ 24 ]; fprintf( cargo->yyc, "\t/* %s */", hb_numToStr( szBuf, sizeof( szBuf ), - HB_PCODE_MKLONGLONG( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + HB_PCODE_MKLONGLONG( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); #endif } fprintf( cargo->yyc, "\n" ); @@ -1644,9 +1644,9 @@ static HB_GENC_FUNC( hb_p_pushlonglong ) static HB_GENC_FUNC( hb_p_pushmemvar ) { fprintf( cargo->yyc, "\tHB_P_PUSHMEMVAR, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1654,9 +1654,9 @@ static HB_GENC_FUNC( hb_p_pushmemvar ) static HB_GENC_FUNC( hb_p_pushmemvarref ) { fprintf( cargo->yyc, "\tHB_P_PUSHMEMVARREF, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1664,7 +1664,7 @@ static HB_GENC_FUNC( hb_p_pushmemvarref ) static HB_GENC_FUNC( hb_p_pushnil ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_PUSHNIL,\n" ); return 1; @@ -1673,7 +1673,7 @@ static HB_GENC_FUNC( hb_p_pushnil ) static HB_GENC_FUNC( hb_p_pushself ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_PUSHSELF,\n" ); return 1; @@ -1682,10 +1682,10 @@ static HB_GENC_FUNC( hb_p_pushself ) static HB_GENC_FUNC( hb_p_pushstatic ) { fprintf( cargo->yyc, "\tHB_P_PUSHSTATIC, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) - hb_compGenCStaticName( HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), cargo ); + hb_compGenCStaticName( HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), cargo ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1693,19 +1693,19 @@ static HB_GENC_FUNC( hb_p_pushstatic ) static HB_GENC_FUNC( hb_p_pushstaticref ) { fprintf( cargo->yyc, "\tHB_P_PUSHSTATICREF, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) - hb_compGenCStaticName( HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), cargo ); + hb_compGenCStaticName( HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), cargo ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_pushstrshort ) { - HB_USHORT wLen = pFunc->pCode[ lPCodePos + 1 ]; + HB_USHORT wLen = pFunc->pCode[ nPCodePos + 1 ]; - fprintf( cargo->yyc, "\tHB_P_PUSHSTRSHORT, %i,", pFunc->pCode[ lPCodePos + 1 ] ); + fprintf( cargo->yyc, "\tHB_P_PUSHSTRSHORT, %i,", pFunc->pCode[ nPCodePos + 1 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", wLen ); @@ -1713,7 +1713,7 @@ static HB_GENC_FUNC( hb_p_pushstrshort ) if( wLen > 0 ) { fprintf( cargo->yyc, "\n\t" ); - hb_compGenCByteStr( cargo->yyc, &pFunc->pCode[ lPCodePos + 2 ], wLen ); + hb_compGenCByteStr( cargo->yyc, &pFunc->pCode[ nPCodePos + 2 ], wLen ); } fprintf( cargo->yyc, "\n" ); return wLen + 2; @@ -1721,11 +1721,11 @@ static HB_GENC_FUNC( hb_p_pushstrshort ) static HB_GENC_FUNC( hb_p_pushstr ) { - HB_USHORT wLen = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); + HB_USHORT wLen = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); fprintf( cargo->yyc, "\tHB_P_PUSHSTR, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", wLen ); @@ -1733,7 +1733,7 @@ static HB_GENC_FUNC( hb_p_pushstr ) if( wLen > 0 ) { fprintf( cargo->yyc, "\n\t" ); - hb_compGenCByteStr( cargo->yyc, &pFunc->pCode[ lPCodePos + 3 ], wLen ); + hb_compGenCByteStr( cargo->yyc, &pFunc->pCode[ nPCodePos + 3 ], wLen ); } fprintf( cargo->yyc, "\n" ); return wLen + 3; @@ -1741,12 +1741,12 @@ static HB_GENC_FUNC( hb_p_pushstr ) static HB_GENC_FUNC( hb_p_pushstrlarge ) { - HB_SIZE nLen = HB_PCODE_MKUINT24( &pFunc->pCode[ lPCodePos + 1 ] ); + HB_SIZE nLen = HB_PCODE_MKUINT24( &pFunc->pCode[ nPCodePos + 1 ] ); fprintf( cargo->yyc, "\tHB_P_PUSHSTRLARGE, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %" HB_PFS "u */", nLen ); @@ -1754,7 +1754,7 @@ static HB_GENC_FUNC( hb_p_pushstrlarge ) if( nLen > 0 ) { fprintf( cargo->yyc, "\n\t" ); - hb_compGenCByteStr( cargo->yyc, &pFunc->pCode[ lPCodePos + 4 ], nLen ); + hb_compGenCByteStr( cargo->yyc, &pFunc->pCode[ nPCodePos + 4 ], nLen ); } fprintf( cargo->yyc, "\n" ); return nLen + 4; @@ -1762,12 +1762,12 @@ static HB_GENC_FUNC( hb_p_pushstrlarge ) static HB_GENC_FUNC( hb_p_pushstrhidden ) { - HB_USHORT wLen = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 2 ] ); + HB_USHORT wLen = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 2 ] ); fprintf( cargo->yyc, "\tHB_P_PUSHSTRHIDDEN, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", wLen ); @@ -1775,7 +1775,7 @@ static HB_GENC_FUNC( hb_p_pushstrhidden ) if( wLen > 0 ) { fprintf( cargo->yyc, "\n\t" ); - hb_compGenCByteStr( cargo->yyc, &pFunc->pCode[ lPCodePos + 4 ], wLen ); + hb_compGenCByteStr( cargo->yyc, &pFunc->pCode[ nPCodePos + 4 ], wLen ); } fprintf( cargo->yyc, "\n" ); return wLen + 4; @@ -1784,9 +1784,9 @@ static HB_GENC_FUNC( hb_p_pushstrhidden ) static HB_GENC_FUNC( hb_p_pushsym ) { fprintf( cargo->yyc, "\tHB_P_PUSHSYM, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1794,8 +1794,8 @@ static HB_GENC_FUNC( hb_p_pushsym ) static HB_GENC_FUNC( hb_p_pushsymnear ) { fprintf( cargo->yyc, "\tHB_P_PUSHSYMNEAR, %i,", - pFunc->pCode[ lPCodePos + 1 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, pFunc->pCode[ lPCodePos + 1 ] ) ); + pFunc->pCode[ nPCodePos + 1 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, pFunc->pCode[ nPCodePos + 1 ] ) ); fprintf( cargo->yyc, "\n" ); return 2; } @@ -1803,9 +1803,9 @@ static HB_GENC_FUNC( hb_p_pushsymnear ) static HB_GENC_FUNC( hb_p_pushfuncsym ) { fprintf( cargo->yyc, "\tHB_P_PUSHFUNCSYM, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1813,9 +1813,9 @@ static HB_GENC_FUNC( hb_p_pushfuncsym ) static HB_GENC_FUNC( hb_p_pushvariable ) { fprintf( cargo->yyc, "\tHB_P_PUSHVARIABLE, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -1823,7 +1823,7 @@ static HB_GENC_FUNC( hb_p_pushvariable ) static HB_GENC_FUNC( hb_p_retvalue ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_RETVALUE,\n" ); return 1; @@ -1832,21 +1832,21 @@ static HB_GENC_FUNC( hb_p_retvalue ) static HB_GENC_FUNC( hb_p_send ) { fprintf( cargo->yyc, "\tHB_P_SEND, %i, %i,\n", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); return 3; } static HB_GENC_FUNC( hb_p_sendshort ) { - fprintf( cargo->yyc, "\tHB_P_SENDSHORT, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); + fprintf( cargo->yyc, "\tHB_P_SENDSHORT, %i,\n", pFunc->pCode[ nPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_pushovarref ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_PUSHOVARREF,\n" ); return 1; @@ -1855,7 +1855,7 @@ static HB_GENC_FUNC( hb_p_pushovarref ) static HB_GENC_FUNC( hb_p_seqblock ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_SEQBLOCK,\n" ); return 1; @@ -1864,13 +1864,13 @@ static HB_GENC_FUNC( hb_p_seqblock ) static HB_GENC_FUNC( hb_p_seqbegin ) { fprintf( cargo->yyc, "\tHB_P_SEQBEGIN, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); if( cargo->bVerbose ) { - HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 1 ] ); - fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, lPCodePos + nOffset ); + HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] ); + fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, nPCodePos + nOffset ); } fprintf( cargo->yyc, "\n" ); return 4; @@ -1878,16 +1878,16 @@ static HB_GENC_FUNC( hb_p_seqbegin ) static HB_GENC_FUNC( hb_p_seqend ) { - if( cargo->bVerbose ) fprintf( cargo->yyc, "/* %05li */ ", lPCodePos ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "/* %05li */ ", nPCodePos ); else fprintf( cargo->yyc, "\t" ); fprintf( cargo->yyc, "HB_P_SEQEND, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); if( cargo->bVerbose ) { - HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 1 ] ); - fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, lPCodePos + nOffset ); + HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] ); + fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, nPCodePos + nOffset ); } fprintf( cargo->yyc, "\n" ); return 4; @@ -1896,7 +1896,7 @@ static HB_GENC_FUNC( hb_p_seqend ) static HB_GENC_FUNC( hb_p_seqrecover ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_SEQRECOVER,\n" ); return 1; @@ -1905,13 +1905,13 @@ static HB_GENC_FUNC( hb_p_seqrecover ) static HB_GENC_FUNC( hb_p_seqalways ) { fprintf( cargo->yyc, "\tHB_P_SEQALWAYS, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); if( cargo->bVerbose ) { - HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 1 ] ); - fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, lPCodePos + nOffset ); + HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] ); + fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, nPCodePos + nOffset ); } fprintf( cargo->yyc, "\n" ); return 4; @@ -1921,17 +1921,17 @@ static HB_GENC_FUNC( hb_p_alwaysbegin ) { HB_SYMBOL_UNUSED( pFunc ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "/* %05li */ ", lPCodePos ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "/* %05li */ ", nPCodePos ); else fprintf( cargo->yyc, "\t" ); fprintf( cargo->yyc, "HB_P_ALWAYSBEGIN, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); if( cargo->bVerbose ) { - HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 1 ] ); - fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, lPCodePos + nOffset ); + HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] ); + fprintf( cargo->yyc, "\t/* %li (abs: %08li) */", nOffset, nPCodePos + nOffset ); } fprintf( cargo->yyc, "\n" ); return 4; @@ -1941,7 +1941,7 @@ static HB_GENC_FUNC( hb_p_alwaysend ) { HB_SYMBOL_UNUSED( pFunc ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "/* %05li */ ", lPCodePos ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "/* %05li */ ", nPCodePos ); else fprintf( cargo->yyc, "\t" ); fprintf( cargo->yyc, "HB_P_ALWAYSEND,\n" ); @@ -1951,8 +1951,8 @@ static HB_GENC_FUNC( hb_p_alwaysend ) static HB_GENC_FUNC( hb_p_sframe ) { fprintf( cargo->yyc, "\tHB_P_SFRAME, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* symbol (_INITSTATICS) */" ); fprintf( cargo->yyc, "\n" ); return 3; @@ -1961,12 +1961,12 @@ static HB_GENC_FUNC( hb_p_sframe ) static HB_GENC_FUNC( hb_p_statics ) { fprintf( cargo->yyc, "\tHB_P_STATICS, %i, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ], - pFunc->pCode[ lPCodePos + 4 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ], + pFunc->pCode[ nPCodePos + 4 ] ); if( cargo->bVerbose ) - fprintf( cargo->yyc, "\t/* symbol (_INITSTATICS), %i statics */", HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 3 ] ) ); + fprintf( cargo->yyc, "\t/* symbol (_INITSTATICS), %i statics */", HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 3 ] ) ); fprintf( cargo->yyc, "\n" ); return 5; @@ -1974,19 +1974,19 @@ static HB_GENC_FUNC( hb_p_statics ) static HB_GENC_FUNC( hb_p_staticname ) { - HB_SIZE nStart = lPCodePos; + HB_SIZE nStart = nPCodePos; fprintf( cargo->yyc, "\tHB_P_STATICNAME, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", ( char * ) pFunc->pCode + lPCodePos + 4 ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", ( char * ) pFunc->pCode + nPCodePos + 4 ); fprintf( cargo->yyc, "\n" ); - lPCodePos += 4; - while( pFunc->pCode[ lPCodePos ] ) + nPCodePos += 4; + while( pFunc->pCode[ nPCodePos ] ) { - char chr = pFunc->pCode[ lPCodePos++ ]; + char chr = pFunc->pCode[ nPCodePos++ ]; if( chr == '\'' || chr == '\\') fprintf( cargo->yyc, " \'\\%c\',", chr ); else @@ -1994,30 +1994,30 @@ static HB_GENC_FUNC( hb_p_staticname ) } fprintf( cargo->yyc, " 0,\n" ); - return lPCodePos - nStart + 1; + return nPCodePos - nStart + 1; } static HB_GENC_FUNC( hb_p_threadstatics ) { - HB_USHORT w = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), u; + HB_USHORT w = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), u; fprintf( cargo->yyc, "\tHB_P_THREADSTATICS, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* number of thread static variables: %i */", w ); fprintf( cargo->yyc, "\n" ); - lPCodePos += 3; + nPCodePos += 3; for( u = 0; u < w; ++u ) { fprintf( cargo->yyc, "\t%i, %i,", - pFunc->pCode[ lPCodePos ], - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos ], + pFunc->pCode[ nPCodePos + 1 ] ); if( cargo->bVerbose ) - hb_compGenCStaticName( HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos ] ), cargo ); + hb_compGenCStaticName( HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos ] ), cargo ); fprintf( cargo->yyc, "\n" ); - lPCodePos +=2; + nPCodePos +=2; } return ( ( HB_SIZE ) w << 1 ) + 3; @@ -2026,7 +2026,7 @@ static HB_GENC_FUNC( hb_p_threadstatics ) static HB_GENC_FUNC( hb_p_swapalias ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_SWAPALIAS,\n" ); return 1; @@ -2035,7 +2035,7 @@ static HB_GENC_FUNC( hb_p_swapalias ) static HB_GENC_FUNC( hb_p_true ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_TRUE,\n" ); return 1; @@ -2044,7 +2044,7 @@ static HB_GENC_FUNC( hb_p_true ) static HB_GENC_FUNC( hb_p_one ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_ONE,\n" ); return 1; @@ -2053,7 +2053,7 @@ static HB_GENC_FUNC( hb_p_one ) static HB_GENC_FUNC( hb_p_zero ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_ZERO,\n" ); return 1; @@ -2062,7 +2062,7 @@ static HB_GENC_FUNC( hb_p_zero ) static HB_GENC_FUNC( hb_p_noop ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_NOOP,\n" ); return 1; @@ -2072,21 +2072,21 @@ static HB_GENC_FUNC( hb_p_dummy ) { HB_SYMBOL_UNUSED( cargo ); HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); return 1; } static HB_GENC_FUNC( hb_p_enumstart ) { fprintf( cargo->yyc, "\tHB_P_ENUMSTART, %i, %i,\n", - pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] ); return 3; } static HB_GENC_FUNC( hb_p_enumnext ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_ENUMNEXT,\n" ); return 1; } @@ -2094,7 +2094,7 @@ static HB_GENC_FUNC( hb_p_enumnext ) static HB_GENC_FUNC( hb_p_enumprev ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_ENUMPREV,\n" ); return 1; } @@ -2102,7 +2102,7 @@ static HB_GENC_FUNC( hb_p_enumprev ) static HB_GENC_FUNC( hb_p_enumend ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_ENUMEND,\n" ); return 1; } @@ -2110,15 +2110,15 @@ static HB_GENC_FUNC( hb_p_enumend ) static HB_GENC_FUNC( hb_p_switch ) { if( cargo->bVerbose ) - fprintf( cargo->yyc, "/* %05li */ ", lPCodePos ); + fprintf( cargo->yyc, "/* %05li */ ", nPCodePos ); else fprintf( cargo->yyc, "\t" ); - fprintf( cargo->yyc, "HB_P_SWITCH, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); + fprintf( cargo->yyc, "HB_P_SWITCH, %i, %i,", pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) { - fprintf( cargo->yyc, "\t/* %i*/", HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + fprintf( cargo->yyc, "\t/* %i*/", HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); } fprintf( cargo->yyc, "\n" ); @@ -2128,16 +2128,16 @@ static HB_GENC_FUNC( hb_p_switch ) static HB_GENC_FUNC( hb_p_pushdate ) { fprintf( cargo->yyc, "\tHB_P_PUSHDATE, %i, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ], - pFunc->pCode[ lPCodePos + 4 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ], + pFunc->pCode[ nPCodePos + 4 ] ); if( cargo->bVerbose ) { int year, month, day; char date[9]; - hb_dateDecode( HB_PCODE_MKLONG( &pFunc->pCode[ lPCodePos + 1 ] ), &year, &month, &day ); + hb_dateDecode( HB_PCODE_MKLONG( &pFunc->pCode[ nPCodePos + 1 ] ), &year, &month, &day ); hb_dateStrPut( date, year, month, day ); date[8] = '\0'; fprintf( cargo->yyc, "\t/* %s */", date ); @@ -2150,21 +2150,21 @@ static HB_GENC_FUNC( hb_p_pushdate ) static HB_GENC_FUNC( hb_p_pushtimestamp ) { fprintf( cargo->yyc, "\tHB_P_PUSHTIMESTAMP, %i, %i, %i, %i, %i, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ], - pFunc->pCode[ lPCodePos + 4 ], - pFunc->pCode[ lPCodePos + 5 ], - pFunc->pCode[ lPCodePos + 6 ], - pFunc->pCode[ lPCodePos + 7 ], - pFunc->pCode[ lPCodePos + 8 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ], + pFunc->pCode[ nPCodePos + 4 ], + pFunc->pCode[ nPCodePos + 5 ], + pFunc->pCode[ nPCodePos + 6 ], + pFunc->pCode[ nPCodePos + 7 ], + pFunc->pCode[ nPCodePos + 8 ] ); if( cargo->bVerbose ) { char timestamp[24]; hb_timeStampStr( timestamp, - HB_PCODE_MKLONG( &pFunc->pCode[ lPCodePos + 1 ] ), - HB_PCODE_MKLONG( &pFunc->pCode[ lPCodePos + 5 ] ) ); + HB_PCODE_MKLONG( &pFunc->pCode[ nPCodePos + 1 ] ), + HB_PCODE_MKLONG( &pFunc->pCode[ nPCodePos + 5 ] ) ); fprintf( cargo->yyc, "\t/* %s */", timestamp ); } fprintf( cargo->yyc, "\n" ); @@ -2174,15 +2174,15 @@ static HB_GENC_FUNC( hb_p_pushtimestamp ) static HB_GENC_FUNC( hb_p_localnearaddint ) { - fprintf( cargo->yyc, "\tHB_P_LOCALNEARADDINT, %i, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); + fprintf( cargo->yyc, "\tHB_P_LOCALNEARADDINT, %i, %i, %i,", pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); if( cargo->bVerbose ) { - int iVar = ( signed char ) pFunc->pCode[ lPCodePos + 1 ]; - hb_compGenCLocalName( pFunc, iVar, lPCodePos, cargo ); - fprintf( cargo->yyc, "/* %i */", HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 2 ] ) ); + int iVar = ( signed char ) pFunc->pCode[ nPCodePos + 1 ]; + hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo ); + fprintf( cargo->yyc, "/* %i */", HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 2 ] ) ); } fprintf( cargo->yyc, "\n" ); @@ -2191,16 +2191,16 @@ static HB_GENC_FUNC( hb_p_localnearaddint ) static HB_GENC_FUNC( hb_p_localaddint ) { - fprintf( cargo->yyc, "\tHB_P_LOCALADDINT, %i, %i, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ], - pFunc->pCode[ lPCodePos + 4 ] ); + fprintf( cargo->yyc, "\tHB_P_LOCALADDINT, %i, %i, %i, %i,", pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ], + pFunc->pCode[ nPCodePos + 4 ] ); if( cargo->bVerbose ) { - int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); - hb_compGenCLocalName( pFunc, iVar, lPCodePos, cargo ); - fprintf( cargo->yyc, "/* %i */", HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 3 ] ) ); + int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); + hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo ); + fprintf( cargo->yyc, "/* %i */", HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 3 ] ) ); } fprintf( cargo->yyc, "\n" ); @@ -2209,13 +2209,13 @@ static HB_GENC_FUNC( hb_p_localaddint ) static HB_GENC_FUNC( hb_p_localinc ) { - fprintf( cargo->yyc, "\tHB_P_LOCALINC, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + fprintf( cargo->yyc, "\tHB_P_LOCALINC, %i, %i,", pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) { - int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); - hb_compGenCLocalName( pFunc, iVar, lPCodePos, cargo ); + int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); + hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo ); } fprintf( cargo->yyc, "\n" ); @@ -2224,13 +2224,13 @@ static HB_GENC_FUNC( hb_p_localinc ) static HB_GENC_FUNC( hb_p_localdec ) { - fprintf( cargo->yyc, "\tHB_P_LOCALDEC, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + fprintf( cargo->yyc, "\tHB_P_LOCALDEC, %i, %i,", pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) { - int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); - hb_compGenCLocalName( pFunc, iVar, lPCodePos, cargo ); + int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); + hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo ); } fprintf( cargo->yyc, "\n" ); @@ -2239,13 +2239,13 @@ static HB_GENC_FUNC( hb_p_localdec ) static HB_GENC_FUNC( hb_p_localincpush ) { - fprintf( cargo->yyc, "\tHB_P_LOCALINCPUSH, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + fprintf( cargo->yyc, "\tHB_P_LOCALINCPUSH, %i, %i,", pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) { - int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); - hb_compGenCLocalName( pFunc, iVar, lPCodePos, cargo ); + int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); + hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo ); } fprintf( cargo->yyc, "\n" ); @@ -2255,7 +2255,7 @@ static HB_GENC_FUNC( hb_p_localincpush ) static HB_GENC_FUNC( hb_p_pluseqpop ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_PLUSEQPOP,\n" ); return 1; @@ -2264,7 +2264,7 @@ static HB_GENC_FUNC( hb_p_pluseqpop ) static HB_GENC_FUNC( hb_p_minuseqpop ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MINUSEQPOP,\n" ); return 1; @@ -2273,7 +2273,7 @@ static HB_GENC_FUNC( hb_p_minuseqpop ) static HB_GENC_FUNC( hb_p_multeqpop ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MULTEQPOP,\n" ); return 1; @@ -2282,7 +2282,7 @@ static HB_GENC_FUNC( hb_p_multeqpop ) static HB_GENC_FUNC( hb_p_diveqpop ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_DIVEQPOP,\n" ); return 1; @@ -2291,7 +2291,7 @@ static HB_GENC_FUNC( hb_p_diveqpop ) static HB_GENC_FUNC( hb_p_modeqpop ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MODEQPOP,\n" ); return 1; @@ -2300,7 +2300,7 @@ static HB_GENC_FUNC( hb_p_modeqpop ) static HB_GENC_FUNC( hb_p_expeqpop ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_EXPEQPOP,\n" ); return 1; @@ -2309,7 +2309,7 @@ static HB_GENC_FUNC( hb_p_expeqpop ) static HB_GENC_FUNC( hb_p_inceqpop ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_INCEQPOP,\n" ); return 1; @@ -2318,7 +2318,7 @@ static HB_GENC_FUNC( hb_p_inceqpop ) static HB_GENC_FUNC( hb_p_deceqpop ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_DECEQPOP,\n" ); return 1; @@ -2327,7 +2327,7 @@ static HB_GENC_FUNC( hb_p_deceqpop ) static HB_GENC_FUNC( hb_p_pluseq ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_PLUSEQ,\n" ); return 1; @@ -2336,7 +2336,7 @@ static HB_GENC_FUNC( hb_p_pluseq ) static HB_GENC_FUNC( hb_p_minuseq ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MINUSEQ,\n" ); return 1; @@ -2345,7 +2345,7 @@ static HB_GENC_FUNC( hb_p_minuseq ) static HB_GENC_FUNC( hb_p_multeq ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MULTEQ,\n" ); return 1; @@ -2354,7 +2354,7 @@ static HB_GENC_FUNC( hb_p_multeq ) static HB_GENC_FUNC( hb_p_diveq ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_DIVEQ,\n" ); return 1; @@ -2363,7 +2363,7 @@ static HB_GENC_FUNC( hb_p_diveq ) static HB_GENC_FUNC( hb_p_modeq ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_MODEQ,\n" ); return 1; @@ -2372,7 +2372,7 @@ static HB_GENC_FUNC( hb_p_modeq ) static HB_GENC_FUNC( hb_p_expeq ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_EXPEQ,\n" ); return 1; @@ -2381,7 +2381,7 @@ static HB_GENC_FUNC( hb_p_expeq ) static HB_GENC_FUNC( hb_p_inceq ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_INCEQ,\n" ); return 1; @@ -2390,7 +2390,7 @@ static HB_GENC_FUNC( hb_p_inceq ) static HB_GENC_FUNC( hb_p_deceq ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_DECEQ,\n" ); return 1; @@ -2399,7 +2399,7 @@ static HB_GENC_FUNC( hb_p_deceq ) static HB_GENC_FUNC( hb_p_withobjectstart ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_WITHOBJECTSTART,\n" ); return 1; @@ -2408,9 +2408,9 @@ static HB_GENC_FUNC( hb_p_withobjectstart ) static HB_GENC_FUNC( hb_p_withobjectmessage ) { fprintf( cargo->yyc, "\tHB_P_WITHOBJECTMESSAGE, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); - if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); + if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, "\n" ); return 3; } @@ -2418,7 +2418,7 @@ static HB_GENC_FUNC( hb_p_withobjectmessage ) static HB_GENC_FUNC( hb_p_withobjectend ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_WITHOBJECTEND,\n" ); return 1; @@ -2427,8 +2427,8 @@ static HB_GENC_FUNC( hb_p_withobjectend ) static HB_GENC_FUNC( hb_p_vframe ) { fprintf( cargo->yyc, "\tHB_P_VFRAME, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* locals, params */" ); fprintf( cargo->yyc, "\n" ); return 3; @@ -2437,9 +2437,9 @@ static HB_GENC_FUNC( hb_p_vframe ) static HB_GENC_FUNC( hb_p_largeframe ) { fprintf( cargo->yyc, "\tHB_P_LARGEFRAME, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* locals, params */" ); fprintf( cargo->yyc, "\n" ); return 4; @@ -2448,9 +2448,9 @@ static HB_GENC_FUNC( hb_p_largeframe ) static HB_GENC_FUNC( hb_p_largevframe ) { fprintf( cargo->yyc, "\tHB_P_LARGEVFRAME, %i, %i, %i,", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 3 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* locals, params */" ); fprintf( cargo->yyc, "\n" ); return 4; @@ -2459,7 +2459,7 @@ static HB_GENC_FUNC( hb_p_largevframe ) static HB_GENC_FUNC( hb_p_pushvparams ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_PUSHVPARAMS,\n" ); return 1; @@ -2468,7 +2468,7 @@ static HB_GENC_FUNC( hb_p_pushvparams ) static HB_GENC_FUNC( hb_p_pushaparams ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); fprintf( cargo->yyc, "\tHB_P_PUSHAPARAMS,\n" ); return 1; @@ -2683,7 +2683,7 @@ static void hb_compGenCReadable( HB_COMP_DECL, PFUNCTION pFunc, FILE * yyc ) hb_compPCodeEval( pFunc, ( HB_PCODE_FUNC_PTR * ) pFuncTable, ( void * ) &genc_info ); if( genc_info.bVerbose ) - fprintf( yyc, "/* %05li */\n", pFunc->lPCodePos ); + fprintf( yyc, "/* %05li */\n", pFunc->nPCodePos ); fprintf( yyc, " };\n\n" ); fprintf( yyc, " hb_vmExecute( pcode, symbols );\n}\n" ); } @@ -2696,7 +2696,7 @@ static void hb_compGenCCompact( PFUNCTION pFunc, FILE * yyc ) fprintf( yyc, "{\n\tstatic const HB_BYTE pcode[] =\n\t{\n\t\t" ); nChar = 0; - while( nPCodePos < pFunc->lPCodePos ) + while( nPCodePos < pFunc->nPCodePos ) { ++nChar; diff --git a/harbour/src/compiler/gencc.c b/harbour/src/compiler/gencc.c index d0a7ad48d5..b115c9754a 100644 --- a/harbour/src/compiler/gencc.c +++ b/harbour/src/compiler/gencc.c @@ -58,10 +58,10 @@ typedef HB_GENC_FUNC( HB_GENC_FUNC_ ); typedef HB_GENC_FUNC_ * HB_GENC_FUNC_PTR; -#define HB_GENC_GETLABEL(l) ( (l) < pFunc->lPCodePos ? cargo->pulLabels[ (l) ] : 0 ) +#define HB_GENC_GETLABEL(l) ( (l) < pFunc->nPCodePos ? cargo->pulLabels[ (l) ] : 0 ) #define HB_GENC_LABEL() do { \ - HB_SIZE nLab = HB_GENC_GETLABEL( lPCodePos ); \ + HB_SIZE nLab = HB_GENC_GETLABEL( nPCodePos ); \ if( nLab != 0 ) \ fprintf( cargo->yyc, "lab%05ld: ;\n", nLab ); \ } while( 0 ) @@ -331,7 +331,7 @@ static HB_GENC_FUNC( hb_p_arraydim ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmArrayDim( %hu );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -348,7 +348,7 @@ static HB_GENC_FUNC( hb_p_do ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmDo( %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -357,7 +357,7 @@ static HB_GENC_FUNC( hb_p_doshort ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmDo( %d ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -389,7 +389,7 @@ static HB_GENC_FUNC( hb_p_swap ) { HB_GENC_LABEL(); - fprintf( cargo->yyc, "\thb_xvmSwap(%d);\n", pFunc->pCode[ lPCodePos + 1 ] ); + fprintf( cargo->yyc, "\thb_xvmSwap(%d);\n", pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -422,7 +422,7 @@ static HB_GENC_FUNC( hb_p_endproc ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\t/* *** END PROC *** */\n" ); - if( lPCodePos < pFunc->lPCodePos - 1 ) + if( nPCodePos < pFunc->nPCodePos - 1 ) { if( cargo->iNestedBlock ) { @@ -455,7 +455,7 @@ static HB_GENC_FUNC( hb_p_frame ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmFrame( %u, %u );\n", - pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] ); return 3; } @@ -472,7 +472,7 @@ static HB_GENC_FUNC( hb_p_function ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmFunction( %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -481,7 +481,7 @@ static HB_GENC_FUNC( hb_p_functionshort ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmFunction( %d ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -490,7 +490,7 @@ static HB_GENC_FUNC( hb_p_arraygen ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmArrayGen( %hu );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -499,7 +499,7 @@ static HB_GENC_FUNC( hb_p_hashgen ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmHashGen( %hu );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -537,100 +537,100 @@ static HB_GENC_FUNC( hb_p_instring ) static HB_GENC_FUNC( hb_p_jumpnear ) { - HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ lPCodePos + 1 ] ); + HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ nPCodePos + 1 ] ); HB_GENC_LABEL(); fprintf( cargo->yyc, "\tgoto lab%05ld;\n", - HB_GENC_GETLABEL( lPCodePos + nOffset ) ); + HB_GENC_GETLABEL( nPCodePos + nOffset ) ); return 2; } static HB_GENC_FUNC( hb_p_jump ) { - HB_ISIZ nOffset = HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); + HB_ISIZ nOffset = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); HB_GENC_LABEL(); fprintf( cargo->yyc, "\tgoto lab%05ld;\n", - HB_GENC_GETLABEL( lPCodePos + nOffset ) ); + HB_GENC_GETLABEL( nPCodePos + nOffset ) ); return 3; } static HB_GENC_FUNC( hb_p_jumpfar ) { - HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 1 ] ); + HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] ); HB_GENC_LABEL(); fprintf( cargo->yyc, "\tgoto lab%05ld;\n", - HB_GENC_GETLABEL( lPCodePos + nOffset ) ); + HB_GENC_GETLABEL( nPCodePos + nOffset ) ); return 4; } static HB_GENC_FUNC( hb_p_jumpfalsenear ) { - HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ lPCodePos + 1 ] ); + HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ nPCodePos + 1 ] ); HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPopLogical( &fValue ) ) break;\n\tif( !fValue )\n\t\tgoto lab%05ld;\n", - HB_GENC_GETLABEL( lPCodePos + nOffset ) ); + HB_GENC_GETLABEL( nPCodePos + nOffset ) ); return 2; } static HB_GENC_FUNC( hb_p_jumpfalse ) { - HB_ISIZ nOffset = HB_PCODE_MKSHORT( &( pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_ISIZ nOffset = HB_PCODE_MKSHORT( &( pFunc->pCode[ nPCodePos + 1 ] ) ); HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPopLogical( &fValue ) ) break;\n\tif( !fValue )\n\t\tgoto lab%05ld;\n", - HB_GENC_GETLABEL( lPCodePos + nOffset ) ); + HB_GENC_GETLABEL( nPCodePos + nOffset ) ); return 3; } static HB_GENC_FUNC( hb_p_jumpfalsefar ) { - HB_ISIZ nOffset = HB_PCODE_MKINT24( &( pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_ISIZ nOffset = HB_PCODE_MKINT24( &( pFunc->pCode[ nPCodePos + 1 ] ) ); HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPopLogical( &fValue ) ) break;\n\tif( !fValue )\n\t\tgoto lab%05ld;\n", - HB_GENC_GETLABEL( lPCodePos + nOffset ) ); + HB_GENC_GETLABEL( nPCodePos + nOffset ) ); return 4; } static HB_GENC_FUNC( hb_p_jumptruenear ) { - HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ lPCodePos + 1 ] ); + HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ nPCodePos + 1 ] ); HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPopLogical( &fValue ) ) break;\n\tif( fValue )\n\t\tgoto lab%05ld;\n", - HB_GENC_GETLABEL( lPCodePos + nOffset ) ); + HB_GENC_GETLABEL( nPCodePos + nOffset ) ); return 2; } static HB_GENC_FUNC( hb_p_jumptrue ) { - HB_ISIZ nOffset = HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); + HB_ISIZ nOffset = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPopLogical( &fValue ) ) break;\n\tif( fValue )\n\t\tgoto lab%05ld;\n", - HB_GENC_GETLABEL( lPCodePos + nOffset ) ); + HB_GENC_GETLABEL( nPCodePos + nOffset ) ); return 3; } static HB_GENC_FUNC( hb_p_jumptruefar ) { - HB_ISIZ nOffset = HB_PCODE_MKINT24( &( pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_ISIZ nOffset = HB_PCODE_MKINT24( &( pFunc->pCode[ nPCodePos + 1 ] ) ); HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPopLogical( &fValue ) ) break;\n\tif( fValue )\n\t\tgoto lab%05ld;\n", - HB_GENC_GETLABEL( lPCodePos + nOffset ) ); + HB_GENC_GETLABEL( nPCodePos + nOffset ) ); return 4; } @@ -655,7 +655,7 @@ static HB_GENC_FUNC( hb_p_line ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmSetLine( %d );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -665,10 +665,10 @@ static HB_GENC_FUNC( hb_p_localname ) HB_GENC_LABEL(); - usLen = ( HB_USHORT ) strlen( ( char * ) &pFunc->pCode[ lPCodePos + 3 ] ); + usLen = ( HB_USHORT ) strlen( ( char * ) &pFunc->pCode[ nPCodePos + 3 ] ); fprintf( cargo->yyc, "\thb_xvmLocalName( %hu, ", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); - hb_compGenCString( cargo->yyc, &pFunc->pCode[ lPCodePos + 3 ], usLen ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); + hb_compGenCString( cargo->yyc, &pFunc->pCode[ nPCodePos + 3 ], usLen ); fprintf( cargo->yyc, " );\n" ); return usLen + 4; } @@ -678,7 +678,7 @@ static HB_GENC_FUNC( hb_p_macropop ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmMacroPop( %d ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -686,7 +686,7 @@ static HB_GENC_FUNC( hb_p_macropopaliased ) { HB_GENC_LABEL(); - fprintf( cargo->yyc, "\tif( hb_xvmMacroPopAliased( %d ) ) break;\n", pFunc->pCode[ lPCodePos + 1 ] ); + fprintf( cargo->yyc, "\tif( hb_xvmMacroPopAliased( %d ) ) break;\n", pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -695,7 +695,7 @@ static HB_GENC_FUNC( hb_p_macropush ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmMacroPush( %d ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -712,7 +712,7 @@ static HB_GENC_FUNC( hb_p_macrodo ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmMacroDo( %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -721,7 +721,7 @@ static HB_GENC_FUNC( hb_p_macrofunc ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmMacroFunc( %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -730,7 +730,7 @@ static HB_GENC_FUNC( hb_p_macrosend ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmMacroSend( %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -739,7 +739,7 @@ static HB_GENC_FUNC( hb_p_macroarraygen ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmMacroArrayGen( %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -748,7 +748,7 @@ static HB_GENC_FUNC( hb_p_macropushlist ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmMacroPushList( %d ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -765,7 +765,7 @@ static HB_GENC_FUNC( hb_p_macropushpare ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmMacroPushPare( %d ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -774,7 +774,7 @@ static HB_GENC_FUNC( hb_p_macropushaliased ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmMacroPushAliased( %d ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -799,7 +799,7 @@ static HB_GENC_FUNC( hb_p_message ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPushSymbol( symbols + %hu );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -817,9 +817,9 @@ static HB_GENC_FUNC( hb_p_modulename ) HB_GENC_LABEL(); - usLen = ( HB_USHORT ) strlen( ( char * ) &pFunc->pCode[ lPCodePos + 1 ] ); + usLen = ( HB_USHORT ) strlen( ( char * ) &pFunc->pCode[ nPCodePos + 1 ] ); fprintf( cargo->yyc, "\thb_xvmModuleName( " ); - hb_compGenCString( cargo->yyc, &pFunc->pCode[ lPCodePos + 1 ], usLen ); + hb_compGenCString( cargo->yyc, &pFunc->pCode[ nPCodePos + 1 ], usLen ); fprintf( cargo->yyc, " );\n" ); return usLen + 2; } @@ -877,8 +877,8 @@ static HB_GENC_FUNC( hb_p_parameter ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmParameter( symbols + %hu, %d );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), - pFunc->pCode[ lPCodePos + 3 ] ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), + pFunc->pCode[ nPCodePos + 3 ] ); return 4; } @@ -888,7 +888,7 @@ static HB_GENC_FUNC( hb_p_plus ) HB_GENC_LABEL(); - iSkip = hb_gencc_checkPlusAhead( pFunc, lPCodePos + 1, cargo ); + iSkip = hb_gencc_checkPlusAhead( pFunc, nPCodePos + 1, cargo ); if( iSkip != 0 ) return 1 + iSkip; @@ -918,7 +918,7 @@ static HB_GENC_FUNC( hb_p_popaliasedfield ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPopAliasedField( symbols + %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -927,7 +927,7 @@ static HB_GENC_FUNC( hb_p_popaliasedfieldnear ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPopAliasedField( symbols + %u ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -936,7 +936,7 @@ static HB_GENC_FUNC( hb_p_popaliasedvar ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPopAliasedVar( symbols + %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -945,7 +945,7 @@ static HB_GENC_FUNC( hb_p_popfield ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPopField( symbols + %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -954,7 +954,7 @@ static HB_GENC_FUNC( hb_p_poplocal ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPopLocal( %hd );\n", - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -963,7 +963,7 @@ static HB_GENC_FUNC( hb_p_poplocalnear ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPopLocal( %d );\n", - ( signed char ) pFunc->pCode[ lPCodePos + 1 ] ); + ( signed char ) pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -972,7 +972,7 @@ static HB_GENC_FUNC( hb_p_popmemvar ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPopMemvar( symbols + %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -981,7 +981,7 @@ static HB_GENC_FUNC( hb_p_popstatic ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPopStatic( %hu );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -990,7 +990,7 @@ static HB_GENC_FUNC( hb_p_popvariable ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPopVariable( symbols + %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -1015,7 +1015,7 @@ static HB_GENC_FUNC( hb_p_pushaliasedfield ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPushAliasedField( symbols + %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -1024,7 +1024,7 @@ static HB_GENC_FUNC( hb_p_pushaliasedfieldnear ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPushAliasedField( symbols + %d ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -1033,7 +1033,7 @@ static HB_GENC_FUNC( hb_p_pushaliasedvar ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPushAliasedVar( symbols + %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -1043,8 +1043,8 @@ static HB_GENC_FUNC( hb_p_pushblockshort ) HB_GENC_LABEL(); - usSize = pFunc->pCode[ lPCodePos + 1 ] - 2; - lPCodePos += 2; + usSize = pFunc->pCode[ nPCodePos + 1 ] - 2; + nPCodePos += 2; fprintf( cargo->yyc, "\t{\n\t\tstatic const HB_BYTE codeblock[ %hd ] = {", usSize ); @@ -1053,9 +1053,9 @@ static HB_GENC_FUNC( hb_p_pushblockshort ) if( ( us & 0x0f ) == 0 ) fprintf( cargo->yyc, "\n\t\t\t" ); if( us == usSize - 1 ) - fprintf( cargo->yyc, "%d", pFunc->pCode[ lPCodePos + us ] ); + fprintf( cargo->yyc, "%d", pFunc->pCode[ nPCodePos + us ] ); else - fprintf( cargo->yyc, "%d, ", pFunc->pCode[ lPCodePos + us ] ); + fprintf( cargo->yyc, "%d, ", pFunc->pCode[ nPCodePos + us ] ); } fprintf( cargo->yyc, " };\n\t\thb_xvmPushBlockShort( codeblock, symbols );\n\t}\n" ); @@ -1068,8 +1068,8 @@ static HB_GENC_FUNC( hb_p_pushblock ) HB_GENC_LABEL(); - usSize = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) - 3; - lPCodePos += 3; + usSize = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) - 3; + nPCodePos += 3; fprintf( cargo->yyc, "\t{\n\t\tstatic const HB_BYTE codeblock[ %hd ] = {", usSize ); @@ -1078,9 +1078,9 @@ static HB_GENC_FUNC( hb_p_pushblock ) if( ( us & 0x0f ) == 0 ) fprintf( cargo->yyc, "\n\t\t\t" ); if( us == usSize - 1 ) - fprintf( cargo->yyc, "%d", pFunc->pCode[ lPCodePos + us ] ); + fprintf( cargo->yyc, "%d", pFunc->pCode[ nPCodePos + us ] ); else - fprintf( cargo->yyc, "%d, ", pFunc->pCode[ lPCodePos + us ] ); + fprintf( cargo->yyc, "%d, ", pFunc->pCode[ nPCodePos + us ] ); } fprintf( cargo->yyc, " };\n\t\thb_xvmPushBlock( codeblock, symbols );\n\t}\n" ); @@ -1093,8 +1093,8 @@ static HB_GENC_FUNC( hb_p_pushblocklarge ) HB_GENC_LABEL(); - nSize = HB_PCODE_MKUINT24( &pFunc->pCode[ lPCodePos + 1 ] ) - 4; - lPCodePos += 4; + nSize = HB_PCODE_MKUINT24( &pFunc->pCode[ nPCodePos + 1 ] ) - 4; + nPCodePos += 4; fprintf( cargo->yyc, "\t{\n\t\tstatic const HB_BYTE codeblock[ %" HB_PFS "u ] = {", nSize ); @@ -1103,9 +1103,9 @@ static HB_GENC_FUNC( hb_p_pushblocklarge ) if( ( ul & 0x0f ) == 0 ) fprintf( cargo->yyc, "\n\t\t\t" ); if( ul == nSize - 1 ) - fprintf( cargo->yyc, "%d", pFunc->pCode[ lPCodePos + ul ] ); + fprintf( cargo->yyc, "%d", pFunc->pCode[ nPCodePos + ul ] ); else - fprintf( cargo->yyc, "%d, ", pFunc->pCode[ lPCodePos + ul ] ); + fprintf( cargo->yyc, "%d, ", pFunc->pCode[ nPCodePos + ul ] ); } fprintf( cargo->yyc, " };\n\t\thb_xvmPushBlock( codeblock, symbols );\n\t}\n" ); @@ -1118,22 +1118,22 @@ static HB_GENC_FUNC( hb_p_pushdouble ) #if 0 fprintf( cargo->yyc, "\thb_xvmPushDouble( %.*f, %d, %d );\n", - pFunc->pCode[ lPCodePos + 1 + sizeof( double ) + sizeof( HB_BYTE ) ] + 1, - HB_PCODE_MKDOUBLE( &pFunc->pCode[ lPCodePos + 1 ] ), - pFunc->pCode[ lPCodePos + 1 + sizeof( double ) ], - pFunc->pCode[ lPCodePos + 1 + sizeof( double ) + sizeof( HB_BYTE ) ] ); + pFunc->pCode[ nPCodePos + 1 + sizeof( double ) + sizeof( HB_BYTE ) ] + 1, + HB_PCODE_MKDOUBLE( &pFunc->pCode[ nPCodePos + 1 ] ), + pFunc->pCode[ nPCodePos + 1 + sizeof( double ) ], + pFunc->pCode[ nPCodePos + 1 + sizeof( double ) + sizeof( HB_BYTE ) ] ); #else /* * This version keeps double calculation compatible with RT FL functions */ fprintf( cargo->yyc, "\thb_xvmPushDouble( * ( double * ) " ); { - double d = HB_PCODE_MKDOUBLE( &pFunc->pCode[ lPCodePos + 1 ] ); + double d = HB_PCODE_MKDOUBLE( &pFunc->pCode[ nPCodePos + 1 ] ); hb_compGenCString( cargo->yyc, ( HB_BYTE * ) &d, sizeof( double ) ); } fprintf( cargo->yyc, ", %d, %d );\n", - pFunc->pCode[ lPCodePos + 1 + sizeof( double ) ], - pFunc->pCode[ lPCodePos + 1 + sizeof( double ) + sizeof( HB_BYTE ) ] ); + pFunc->pCode[ nPCodePos + 1 + sizeof( double ) ], + pFunc->pCode[ nPCodePos + 1 + sizeof( double ) + sizeof( HB_BYTE ) ] ); #endif return sizeof( double ) + sizeof( HB_BYTE ) + sizeof( HB_BYTE ) + 1; } @@ -1143,17 +1143,17 @@ static HB_GENC_FUNC( hb_p_pushfield ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPushField( symbols + %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } static HB_GENC_FUNC( hb_p_pushbyte ) { - int iVal = ( signed char ) pFunc->pCode[ lPCodePos + 1 ], iSkip; + int iVal = ( signed char ) pFunc->pCode[ nPCodePos + 1 ], iSkip; HB_GENC_LABEL(); - iSkip = hb_gencc_checkNumAhead( iVal, pFunc, lPCodePos + 2, cargo ); + iSkip = hb_gencc_checkNumAhead( iVal, pFunc, nPCodePos + 2, cargo ); if( iSkip == 0 ) fprintf( cargo->yyc, "\thb_xvmPushInteger( %d );\n", iVal ); @@ -1162,11 +1162,11 @@ static HB_GENC_FUNC( hb_p_pushbyte ) static HB_GENC_FUNC( hb_p_pushint ) { - int iVal = HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), iSkip; + int iVal = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), iSkip; HB_GENC_LABEL(); - iSkip = hb_gencc_checkNumAhead( iVal, pFunc, lPCodePos + 3, cargo ); + iSkip = hb_gencc_checkNumAhead( iVal, pFunc, nPCodePos + 3, cargo ); if( iSkip == 0 ) fprintf( cargo->yyc, "\thb_xvmPushInteger( %d );\n", iVal ); @@ -1177,26 +1177,26 @@ static HB_GENC_FUNC( hb_p_pushlocal ) { HB_GENC_LABEL(); - if( HB_GENC_GETLABEL( lPCodePos + 3 ) == 0 ) + if( HB_GENC_GETLABEL( nPCodePos + 3 ) == 0 ) { - switch( pFunc->pCode[ lPCodePos + 3 ] ) + switch( pFunc->pCode[ nPCodePos + 3 ] ) { case HB_P_POPLOCALNEAR: hb_gencc_copyLocals( cargo->yyc, - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), - ( signed char ) pFunc->pCode[ lPCodePos + 4 ] ); + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), + ( signed char ) pFunc->pCode[ nPCodePos + 4 ] ); return 5; case HB_P_POPLOCAL: hb_gencc_copyLocals( cargo->yyc, - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 4 ] ) ); + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 4 ] ) ); return 6; } } fprintf( cargo->yyc, "\thb_xvmPushLocal( %d );\n", - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -1204,26 +1204,26 @@ static HB_GENC_FUNC( hb_p_pushlocalnear ) { HB_GENC_LABEL(); - if( HB_GENC_GETLABEL( lPCodePos + 2 ) == 0 ) + if( HB_GENC_GETLABEL( nPCodePos + 2 ) == 0 ) { - switch( pFunc->pCode[ lPCodePos + 2 ] ) + switch( pFunc->pCode[ nPCodePos + 2 ] ) { case HB_P_POPLOCALNEAR: hb_gencc_copyLocals( cargo->yyc, - ( signed char ) pFunc->pCode[ lPCodePos + 1 ], - ( signed char ) pFunc->pCode[ lPCodePos + 3 ] ); + ( signed char ) pFunc->pCode[ nPCodePos + 1 ], + ( signed char ) pFunc->pCode[ nPCodePos + 3 ] ); return 4; case HB_P_POPLOCAL: hb_gencc_copyLocals( cargo->yyc, - ( signed char ) pFunc->pCode[ lPCodePos + 1 ], - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 3 ] ) ); + ( signed char ) pFunc->pCode[ nPCodePos + 1 ], + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 3 ] ) ); return 5; } } fprintf( cargo->yyc, "\thb_xvmPushLocal( %d );\n", - ( signed char ) pFunc->pCode[ lPCodePos + 1 ] ); + ( signed char ) pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -1232,17 +1232,17 @@ static HB_GENC_FUNC( hb_p_pushlocalref ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPushLocalByRef( %d );\n", - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } static HB_GENC_FUNC( hb_p_pushlong ) { - HB_ISIZ nVal = HB_PCODE_MKLONG( &pFunc->pCode[ lPCodePos + 1 ] ), iSkip; + HB_ISIZ nVal = HB_PCODE_MKLONG( &pFunc->pCode[ nPCodePos + 1 ] ), iSkip; HB_GENC_LABEL(); - iSkip = hb_gencc_checkNumAhead( nVal, pFunc, lPCodePos + 5, cargo ); + iSkip = hb_gencc_checkNumAhead( nVal, pFunc, nPCodePos + 5, cargo ); if( iSkip == 0 ) { @@ -1259,14 +1259,14 @@ static HB_GENC_FUNC( hb_p_pushlonglong ) { #ifdef HB_LONG_LONG_OFF HB_GENC_LABEL(); - fprintf( cargo->yyc, "\thb_xvmPushLongLong( %.1f );\n", HB_PCODE_MKLONGLONG( &pFunc->pCode[ lPCodePos + 1 ] ) ); + fprintf( cargo->yyc, "\thb_xvmPushLongLong( %.1f );\n", HB_PCODE_MKLONGLONG( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 9; #elif LONG_MAX == LONGLONG_MAX - HB_LONGLONG llVal = HB_PCODE_MKLONGLONG( &pFunc->pCode[ lPCodePos + 1 ] ), iSkip; + HB_LONGLONG llVal = HB_PCODE_MKLONGLONG( &pFunc->pCode[ nPCodePos + 1 ] ), iSkip; HB_GENC_LABEL(); - iSkip = hb_gencc_checkNumAhead( llVal, pFunc, lPCodePos + 9, cargo ); + iSkip = hb_gencc_checkNumAhead( llVal, pFunc, nPCodePos + 9, cargo ); if( iSkip == 0 ) { @@ -1278,7 +1278,7 @@ static HB_GENC_FUNC( hb_p_pushlonglong ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPushLongLong( HB_LL( %s ) );\n", hb_numToStr( szBuf, sizeof( szBuf ), - HB_PCODE_MKLONGLONG( &pFunc->pCode[ lPCodePos + 1 ] ) ) ); + HB_PCODE_MKLONGLONG( &pFunc->pCode[ nPCodePos + 1 ] ) ) ); return 9; #endif } @@ -1288,7 +1288,7 @@ static HB_GENC_FUNC( hb_p_pushmemvar ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPushMemvar( symbols + %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -1297,7 +1297,7 @@ static HB_GENC_FUNC( hb_p_pushmemvarref ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPushMemvarByRef( symbols + %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -1305,8 +1305,8 @@ static HB_GENC_FUNC( hb_p_pushnil ) { HB_GENC_LABEL(); - if( pFunc->pCode[ lPCodePos + 1 ] == HB_P_RETVALUE && - HB_GENC_GETLABEL( lPCodePos + 1 ) == 0 ) + if( pFunc->pCode[ nPCodePos + 1 ] == HB_P_RETVALUE && + HB_GENC_GETLABEL( nPCodePos + 1 ) == 0 ) { fprintf( cargo->yyc, "\thb_xvmRetNil();\n" ); return 2; @@ -1331,7 +1331,7 @@ static HB_GENC_FUNC( hb_p_pushstatic ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPushStatic( %hu );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -1340,18 +1340,18 @@ static HB_GENC_FUNC( hb_p_pushstaticref ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPushStaticByRef( %hu );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } static HB_GENC_FUNC( hb_p_pushstrshort ) { - HB_USHORT usLen = pFunc->pCode[ lPCodePos + 1 ] - 1; + HB_USHORT usLen = pFunc->pCode[ nPCodePos + 1 ] - 1; HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPushStringConst( " ); - hb_compGenCString( cargo->yyc, &pFunc->pCode[ lPCodePos + 2 ], usLen ); + hb_compGenCString( cargo->yyc, &pFunc->pCode[ nPCodePos + 2 ], usLen ); fprintf( cargo->yyc, ", %hu );\n", usLen ); return 3 + usLen; @@ -1359,12 +1359,12 @@ static HB_GENC_FUNC( hb_p_pushstrshort ) static HB_GENC_FUNC( hb_p_pushstr ) { - HB_USHORT usLen = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) - 1; + HB_USHORT usLen = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) - 1; HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPushStringConst( " ); - hb_compGenCString( cargo->yyc, &pFunc->pCode[ lPCodePos + 3 ], usLen ); + hb_compGenCString( cargo->yyc, &pFunc->pCode[ nPCodePos + 3 ], usLen ); fprintf( cargo->yyc, ", %hu );\n", usLen ); return 4 + usLen; @@ -1372,12 +1372,12 @@ static HB_GENC_FUNC( hb_p_pushstr ) static HB_GENC_FUNC( hb_p_pushstrlarge ) { - HB_SIZE nLen = HB_PCODE_MKUINT24( &pFunc->pCode[ lPCodePos + 1 ] ) - 1; + HB_SIZE nLen = HB_PCODE_MKUINT24( &pFunc->pCode[ nPCodePos + 1 ] ) - 1; HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPushStringConst( " ); - hb_compGenCString( cargo->yyc, &pFunc->pCode[ lPCodePos + 4 ], nLen ); + hb_compGenCString( cargo->yyc, &pFunc->pCode[ nPCodePos + 4 ], nLen ); fprintf( cargo->yyc, ", %" HB_PFS "u );\n", nLen ); return 5 + nLen; @@ -1385,13 +1385,13 @@ static HB_GENC_FUNC( hb_p_pushstrlarge ) static HB_GENC_FUNC( hb_p_pushstrhidden ) { - HB_USHORT usLen = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 2 ] ); + HB_USHORT usLen = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 2 ] ); HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPushStringHidden( %d, ", - pFunc->pCode[ lPCodePos + 1 ] ); - hb_compGenCString( cargo->yyc, &pFunc->pCode[ lPCodePos + 4 ], usLen ); + pFunc->pCode[ nPCodePos + 1 ] ); + hb_compGenCString( cargo->yyc, &pFunc->pCode[ nPCodePos + 4 ], usLen ); fprintf( cargo->yyc, ", %hu );\n", usLen ); return 4 + usLen; @@ -1401,43 +1401,43 @@ static HB_GENC_FUNC( hb_p_pushsym ) { HB_GENC_LABEL(); - if( HB_GENC_GETLABEL( lPCodePos + 3 ) == 0 ) + if( HB_GENC_GETLABEL( nPCodePos + 3 ) == 0 ) { - switch( pFunc->pCode[ lPCodePos + 3 ] ) + switch( pFunc->pCode[ nPCodePos + 3 ] ) { case HB_P_PUSHNIL: fprintf( cargo->yyc, "\thb_xvmPushFuncSymbol( symbols + %hu );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 4; case HB_P_PUSHALIASEDFIELDNEAR: fprintf( cargo->yyc, "\tif( hb_xvmPushAliasedFieldExt( symbols + %u, symbols + %u ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), - pFunc->pCode[ lPCodePos + 4 ] ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), + pFunc->pCode[ nPCodePos + 4 ] ); return 5; case HB_P_PUSHALIASEDFIELD: fprintf( cargo->yyc, "\tif( hb_xvmPushAliasedFieldExt( symbols + %u, symbols + %u ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 4 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 4 ] ) ); return 6; case HB_P_POPALIASEDFIELDNEAR: fprintf( cargo->yyc, "\tif( hb_xvmPopAliasedFieldExt( symbols + %u, symbols + %u ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), - pFunc->pCode[ lPCodePos + 4 ] ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), + pFunc->pCode[ nPCodePos + 4 ] ); return 5; case HB_P_POPALIASEDFIELD: fprintf( cargo->yyc, "\tif( hb_xvmPopAliasedFieldExt( symbols + %u, symbols + %u ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 4 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 4 ] ) ); return 6; } } fprintf( cargo->yyc, "\thb_xvmPushSymbol( symbols + %hu );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -1445,43 +1445,43 @@ static HB_GENC_FUNC( hb_p_pushsymnear ) { HB_GENC_LABEL(); - if( HB_GENC_GETLABEL( lPCodePos + 2 ) == 0 ) + if( HB_GENC_GETLABEL( nPCodePos + 2 ) == 0 ) { - switch( pFunc->pCode[ lPCodePos + 2 ] ) + switch( pFunc->pCode[ nPCodePos + 2 ] ) { case HB_P_PUSHNIL: fprintf( cargo->yyc, "\thb_xvmPushFuncSymbol( symbols + %u );\n", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); return 3; case HB_P_PUSHALIASEDFIELDNEAR: fprintf( cargo->yyc, "\tif( hb_xvmPushAliasedFieldExt( symbols + %u, symbols + %u ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 3 ] ); return 4; case HB_P_PUSHALIASEDFIELD: fprintf( cargo->yyc, "\tif( hb_xvmPushAliasedFieldExt( symbols + %u, symbols + %u ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ], - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 3 ] ) ); + pFunc->pCode[ nPCodePos + 1 ], + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 3 ] ) ); return 5; case HB_P_POPALIASEDFIELDNEAR: fprintf( cargo->yyc, "\tif( hb_xvmPopAliasedFieldExt( symbols + %u, symbols + %u ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ], - pFunc->pCode[ lPCodePos + 3 ] ); + pFunc->pCode[ nPCodePos + 1 ], + pFunc->pCode[ nPCodePos + 3 ] ); return 4; case HB_P_POPALIASEDFIELD: fprintf( cargo->yyc, "\tif( hb_xvmPopAliasedFieldExt( symbols + %u, symbols + %u ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ], - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 3 ] ) ); + pFunc->pCode[ nPCodePos + 1 ], + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 3 ] ) ); return 5; } } fprintf( cargo->yyc, "\thb_xvmPushSymbol( symbols + %d );\n", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -1490,7 +1490,7 @@ static HB_GENC_FUNC( hb_p_pushfuncsym ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPushFuncSymbol( symbols + %hu );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -1499,7 +1499,7 @@ static HB_GENC_FUNC( hb_p_pushvariable ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmPushVariable( symbols + %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -1516,7 +1516,7 @@ static HB_GENC_FUNC( hb_p_send ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmSend( %hu ) ) break;\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -1525,7 +1525,7 @@ static HB_GENC_FUNC( hb_p_sendshort ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmSend( %d ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ] ); + pFunc->pCode[ nPCodePos + 1 ] ); return 2; } @@ -1582,7 +1582,7 @@ static HB_GENC_FUNC( hb_p_seqbegin ) static HB_GENC_FUNC( hb_p_seqend ) { - HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 1 ] ); + HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] ); HB_GENC_LABEL(); @@ -1590,7 +1590,7 @@ static HB_GENC_FUNC( hb_p_seqend ) fprintf( cargo->yyc, "\t} while( 0 );\n\tif( hb_xvmSeqEnd() ) break;\n" ); else /* RECOVER exists */ fprintf( cargo->yyc, "\tif( hb_xvmSeqEndTest() ) break;\n\tgoto lab%05ld;\n\t} while( 0 );\n", - HB_GENC_GETLABEL( lPCodePos + nOffset ) ); + HB_GENC_GETLABEL( nPCodePos + nOffset ) ); cargo->iNestedBlock--; return 4; } @@ -1608,7 +1608,7 @@ static HB_GENC_FUNC( hb_p_sframe ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmSFrame( symbols + %hu );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -1617,8 +1617,8 @@ static HB_GENC_FUNC( hb_p_statics ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmStatics( symbols + %hu, %hu );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 3 ] ) ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 3 ] ) ); return 5; } @@ -1628,11 +1628,11 @@ static HB_GENC_FUNC( hb_p_staticname ) HB_GENC_LABEL(); - usLen = ( HB_USHORT ) strlen( ( char * ) &pFunc->pCode[ lPCodePos + 4 ] ); + usLen = ( HB_USHORT ) strlen( ( char * ) &pFunc->pCode[ nPCodePos + 4 ] ); fprintf( cargo->yyc, "\thb_xvmStaticName( %hu, %hu, ", - ( HB_USHORT ) pFunc->pCode[ lPCodePos + 1 ], - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 2 ] ) ); - hb_compGenCString( cargo->yyc, &pFunc->pCode[ lPCodePos + 4 ], usLen ); + ( HB_USHORT ) pFunc->pCode[ nPCodePos + 1 ], + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 2 ] ) ); + hb_compGenCString( cargo->yyc, &pFunc->pCode[ nPCodePos + 4 ], usLen ); fprintf( cargo->yyc, " );\n" ); return usLen + 5; } @@ -1644,7 +1644,7 @@ static HB_GENC_FUNC( hb_p_threadstatics ) HB_GENC_LABEL(); - w = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); + w = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); nSize = ( HB_SIZE ) w << 1; fprintf( cargo->yyc, "\t{\n\t\tstatic const HB_BYTE statics[ %" HB_PFS "u ] = {", nSize ); @@ -1654,9 +1654,9 @@ static HB_GENC_FUNC( hb_p_threadstatics ) if( ( ul & 0x0f ) == 0 ) fprintf( cargo->yyc, "\n\t\t\t" ); if( ul == nSize - 1 ) - fprintf( cargo->yyc, "%d", pFunc->pCode[ lPCodePos + ul + 3 ] ); + fprintf( cargo->yyc, "%d", pFunc->pCode[ nPCodePos + ul + 3 ] ); else - fprintf( cargo->yyc, "%d, ", pFunc->pCode[ lPCodePos + ul + 3 ] ); + fprintf( cargo->yyc, "%d, ", pFunc->pCode[ nPCodePos + ul + 3 ] ); } fprintf( cargo->yyc, " };\n\t\thb_xvmThreadStatics( %hu, statics );\n\t}\n", w ); @@ -1685,7 +1685,7 @@ static HB_GENC_FUNC( hb_p_one ) HB_GENC_LABEL(); - iSkip = hb_gencc_checkNumAhead( 1, pFunc, lPCodePos + 1, cargo ); + iSkip = hb_gencc_checkNumAhead( 1, pFunc, nPCodePos + 1, cargo ); if( iSkip == 0 ) fprintf( cargo->yyc, "\thb_xvmPushInteger( 1 );\n" ); return 1 + iSkip; @@ -1697,7 +1697,7 @@ static HB_GENC_FUNC( hb_p_zero ) HB_GENC_LABEL(); - iSkip = hb_gencc_checkNumAhead( 0, pFunc, lPCodePos + 1, cargo ); + iSkip = hb_gencc_checkNumAhead( 0, pFunc, nPCodePos + 1, cargo ); if( iSkip == 0 ) fprintf( cargo->yyc, "\thb_xvmPushInteger( 0 );\n" ); return 1 + iSkip; @@ -1714,7 +1714,7 @@ static HB_GENC_FUNC( hb_p_dummy ) { HB_SYMBOL_UNUSED( cargo ); HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); return 1; } @@ -1723,7 +1723,7 @@ static HB_GENC_FUNC( hb_p_enumstart ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmEnumStart( %d, %d ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] ); return 3; } @@ -1753,45 +1753,45 @@ static HB_GENC_FUNC( hb_p_enumend ) static HB_GENC_FUNC( hb_p_switch ) { - HB_USHORT usCases = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), us; - HB_SIZE nStart = lPCodePos, nNewPos; + HB_USHORT usCases = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), us; + HB_SIZE nStart = nPCodePos, nNewPos; HB_BOOL fNum = HB_FALSE, fStr = HB_FALSE, fDefault = HB_FALSE; HB_GENC_LABEL(); - lPCodePos += 3; + nPCodePos += 3; for( us = 0; us < usCases; ++us ) { - switch( pFunc->pCode[ lPCodePos ] ) + switch( pFunc->pCode[ nPCodePos ] ) { case HB_P_PUSHLONG: fNum = HB_TRUE; - lPCodePos += 5; + nPCodePos += 5; break; case HB_P_PUSHSTRSHORT: fStr = HB_TRUE; - lPCodePos += 2 + pFunc->pCode[ lPCodePos + 1 ]; + nPCodePos += 2 + pFunc->pCode[ nPCodePos + 1 ]; break; case HB_P_PUSHNIL: /* default clause */ fDefault = HB_TRUE; - lPCodePos++; + nPCodePos++; break; } - switch( pFunc->pCode[ lPCodePos ] ) + switch( pFunc->pCode[ nPCodePos ] ) { case HB_P_JUMPNEAR: - nNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ]; - lPCodePos += 2; + nNewPos = nPCodePos + ( signed char ) pFunc->pCode[ nPCodePos + 1 ]; + nPCodePos += 2; break; case HB_P_JUMP: - nNewPos = lPCodePos + HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); - lPCodePos += 3; + nNewPos = nPCodePos + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); + nPCodePos += 3; break; /*case HB_P_JUMPFAR:*/ default: - nNewPos = lPCodePos + HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 1 ] ); - lPCodePos += 4; + nNewPos = nPCodePos + HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] ); + nPCodePos += 4; break; } } @@ -1814,43 +1814,43 @@ static HB_GENC_FUNC( hb_p_switch ) fprintf( cargo->yyc, "\t\tlVal = (type & HB_IT_NUMINT) ? hb_itemGetNL( pSwitch ) : 0;\n\n" ); } - lPCodePos = nStart + 3; + nPCodePos = nStart + 3; for( us = 0; us < usCases; ++us ) { - switch( pFunc->pCode[ lPCodePos ] ) + switch( pFunc->pCode[ nPCodePos ] ) { case HB_P_PUSHLONG: fprintf( cargo->yyc, "\t\tif( (type & HB_IT_NUMINT) != 0 && lVal == %ldL )\n", - HB_PCODE_MKLONG( &pFunc->pCode[ lPCodePos + 1 ] ) ); - lPCodePos += 5; + HB_PCODE_MKLONG( &pFunc->pCode[ nPCodePos + 1 ] ) ); + nPCodePos += 5; break; case HB_P_PUSHSTRSHORT: fprintf( cargo->yyc, "\t\tif( pszText && nLen == %d && !memcmp( pszText, ", - pFunc->pCode[ lPCodePos + 1 ] - 1 ); - hb_compGenCString( cargo->yyc, &pFunc->pCode[ lPCodePos + 2 ], - pFunc->pCode[ lPCodePos + 1 ] - 1 ); - fprintf( cargo->yyc, ", %d ) )\n", pFunc->pCode[ lPCodePos + 1 ] - 1 ); - lPCodePos += 2 + pFunc->pCode[ lPCodePos + 1 ]; + pFunc->pCode[ nPCodePos + 1 ] - 1 ); + hb_compGenCString( cargo->yyc, &pFunc->pCode[ nPCodePos + 2 ], + pFunc->pCode[ nPCodePos + 1 ] - 1 ); + fprintf( cargo->yyc, ", %d ) )\n", pFunc->pCode[ nPCodePos + 1 ] - 1 ); + nPCodePos += 2 + pFunc->pCode[ nPCodePos + 1 ]; break; case HB_P_PUSHNIL: /* default clause */ - lPCodePos++; + nPCodePos++; break; } - switch( pFunc->pCode[ lPCodePos ] ) + switch( pFunc->pCode[ nPCodePos ] ) { case HB_P_JUMPNEAR: - nNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ]; - lPCodePos += 2; + nNewPos = nPCodePos + ( signed char ) pFunc->pCode[ nPCodePos + 1 ]; + nPCodePos += 2; break; case HB_P_JUMP: - nNewPos = lPCodePos + HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); - lPCodePos += 3; + nNewPos = nPCodePos + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); + nPCodePos += 3; break; /*case HB_P_JUMPFAR:*/ default: - nNewPos = lPCodePos + HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 1 ] ); - lPCodePos += 4; + nNewPos = nPCodePos + HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] ); + nPCodePos += 4; break; } fprintf( cargo->yyc, "\t\t{\n\t\t\thb_stackPop();\n\t\t\tgoto lab%05ld;\n\t\t}\n", @@ -1861,7 +1861,7 @@ static HB_GENC_FUNC( hb_p_switch ) if( fStr || fNum ) fprintf( cargo->yyc, "\t}\n" ); - return lPCodePos - nStart; + return nPCodePos - nStart; } static HB_GENC_FUNC( hb_p_pushdate ) @@ -1869,7 +1869,7 @@ static HB_GENC_FUNC( hb_p_pushdate ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPushDate( %ldL );\n", - ( long ) HB_PCODE_MKLONG( &pFunc->pCode[ lPCodePos + 1 ] ) ); + ( long ) HB_PCODE_MKLONG( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 5; } @@ -1878,8 +1878,8 @@ static HB_GENC_FUNC( hb_p_pushtimestamp ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmPushTimeStamp( %ldL, %ldL );\n", - ( long ) HB_PCODE_MKLONG( &pFunc->pCode[ lPCodePos + 1 ] ), - ( long ) HB_PCODE_MKLONG( &pFunc->pCode[ lPCodePos + 5 ] ) ); + ( long ) HB_PCODE_MKLONG( &pFunc->pCode[ nPCodePos + 1 ] ), + ( long ) HB_PCODE_MKLONG( &pFunc->pCode[ nPCodePos + 5 ] ) ); return 9; } @@ -1888,8 +1888,8 @@ static HB_GENC_FUNC( hb_p_localnearaddint ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmLocalAddInt( %d, %d ) ) break;\n", - pFunc->pCode[ lPCodePos + 1 ], - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 2 ] ) ); + pFunc->pCode[ nPCodePos + 1 ], + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 2 ] ) ); return 4; } @@ -1898,25 +1898,25 @@ static HB_GENC_FUNC( hb_p_localaddint ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmLocalAddInt( %d, %d ) ) break;\n", - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 3 ] ) ); + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 3 ] ) ); return 5; } static HB_GENC_FUNC( hb_p_localinc ) { - int iLocal = HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); + int iLocal = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); HB_GENC_LABEL(); - if( HB_GENC_GETLABEL( lPCodePos + 3 ) == 0 && - ( ( pFunc->pCode[ lPCodePos + 3 ] == HB_P_PUSHLOCAL && - iLocal == HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 4 ] ) ) || - ( pFunc->pCode[ lPCodePos + 3 ] == HB_P_PUSHLOCALNEAR && - iLocal == pFunc->pCode[ lPCodePos + 4 ] ) ) ) + if( HB_GENC_GETLABEL( nPCodePos + 3 ) == 0 && + ( ( pFunc->pCode[ nPCodePos + 3 ] == HB_P_PUSHLOCAL && + iLocal == HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 4 ] ) ) || + ( pFunc->pCode[ nPCodePos + 3 ] == HB_P_PUSHLOCALNEAR && + iLocal == pFunc->pCode[ nPCodePos + 4 ] ) ) ) { fprintf( cargo->yyc, "\tif( hb_xvmLocalIncPush( %d ) ) break;\n", iLocal ); - return ( pFunc->pCode[ lPCodePos + 3 ] == HB_P_PUSHLOCAL ) ? 6 : 5; + return ( pFunc->pCode[ nPCodePos + 3 ] == HB_P_PUSHLOCAL ) ? 6 : 5; } fprintf( cargo->yyc, "\tif( hb_xvmLocalInc( %d ) ) break;\n", iLocal ); @@ -1928,7 +1928,7 @@ static HB_GENC_FUNC( hb_p_localdec ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmLocalDec( %d ) ) break;\n", - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -1937,7 +1937,7 @@ static HB_GENC_FUNC( hb_p_localincpush ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\tif( hb_xvmLocalIncPush( %d ) ) break;\n", - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) ); + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ); return 3; } @@ -2088,7 +2088,7 @@ static HB_GENC_FUNC( hb_p_withobjectend ) static HB_GENC_FUNC( hb_p_withobjectmessage ) { - HB_USHORT usSym = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); + HB_USHORT usSym = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); HB_GENC_LABEL(); @@ -2106,7 +2106,7 @@ static HB_GENC_FUNC( hb_p_vframe ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmVFrame( %u, %u );\n", - pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); + pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] ); return 3; } @@ -2115,8 +2115,8 @@ static HB_GENC_FUNC( hb_p_largeframe ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmFrame( %u, %u );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), - pFunc->pCode[ lPCodePos + 3 ] ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), + pFunc->pCode[ nPCodePos + 3 ] ); return 4; } @@ -2125,8 +2125,8 @@ static HB_GENC_FUNC( hb_p_largevframe ) HB_GENC_LABEL(); fprintf( cargo->yyc, "\thb_xvmVFrame( %u, %u );\n", - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), - pFunc->pCode[ lPCodePos + 3 ] ); + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), + pFunc->pCode[ nPCodePos + 3 ] ); return 4; } @@ -2353,12 +2353,12 @@ void hb_compGenCRealCode( HB_COMP_DECL, PFUNCTION pFunc, FILE * yyc ) label_info.fCondJump = HB_FALSE; label_info.fEndRequest = HB_FALSE; label_info.iNestedBlock = 0; - if( pFunc->lPCodePos == 0 ) + if( pFunc->nPCodePos == 0 ) label_info.pulLabels = NULL; else { - label_info.pulLabels = ( HB_SIZE * ) hb_xgrab( pFunc->lPCodePos * sizeof( HB_SIZE ) ); - memset( label_info.pulLabels, 0, pFunc->lPCodePos * sizeof( HB_SIZE ) ); + label_info.pulLabels = ( HB_SIZE * ) hb_xgrab( pFunc->nPCodePos * sizeof( HB_SIZE ) ); + memset( label_info.pulLabels, 0, pFunc->nPCodePos * sizeof( HB_SIZE ) ); hb_compGenLabelTable( pFunc, &label_info ); } diff --git a/harbour/src/compiler/genhrb.c b/harbour/src/compiler/genhrb.c index ba7ee30adc..4bd30dd8a0 100644 --- a/harbour/src/compiler/genhrb.c +++ b/harbour/src/compiler/genhrb.c @@ -61,7 +61,7 @@ static HB_SIZE hb_compHrbSize( HB_COMP_DECL, HB_ULONG * pulSymbols, HB_ULONG * p if( ( pFunc->funFlags & FUN_FILE_DECL ) == 0 ) { ( * pulFunctions )++; - nSize += strlen( pFunc->szName ) + 5 + pFunc->lPCodePos; /* \0 + func_size[4] + function_body */ + nSize += strlen( pFunc->szName ) + 5 + pFunc->nPCodePos; /* \0 + func_size[4] + function_body */ } pFunc = pFunc->pNext; } @@ -129,10 +129,10 @@ void hb_compGenBufPortObj( HB_COMP_DECL, HB_BYTE ** pBufPtr, HB_SIZE * pnSize ) nLen = strlen( pFunc->szName ) + 1; memcpy( ptr, pFunc->szName, nLen ); ptr += nLen; - HB_PUT_LE_UINT32( ptr, pFunc->lPCodePos ); /* function size */ + HB_PUT_LE_UINT32( ptr, pFunc->nPCodePos ); /* function size */ ptr += 4; - memcpy( ptr, pFunc->pCode, pFunc->lPCodePos ); /* function body */ - ptr += pFunc->lPCodePos; + memcpy( ptr, pFunc->pCode, pFunc->nPCodePos ); /* function body */ + ptr += pFunc->nPCodePos; } pFunc = pFunc->pNext; } diff --git a/harbour/src/compiler/harbour.y b/harbour/src/compiler/harbour.y index 778d5d4780..f1bef847f4 100644 --- a/harbour/src/compiler/harbour.y +++ b/harbour/src/compiler/harbour.y @@ -1033,7 +1033,7 @@ CodeBlock : BlockHead | BlockHead Crlf { /* 3 */ HB_CBVAR_PTR pVar; - $$ = HB_COMP_PARAM->functions.pLast->lPCodePos; + $$ = HB_COMP_PARAM->functions.pLast->nPCodePos; hb_compCodeBlockStart( HB_COMP_PARAM, HB_TRUE ); HB_COMP_PARAM->functions.pLast->funFlags |= FUN_EXTBLOCK; HB_COMP_PARAM->functions.pLast->fVParams = @@ -1060,8 +1060,8 @@ CodeBlock : BlockHead hb_compCodeBlockEnd( HB_COMP_PARAM ); $$ = hb_compExprSetCodeblockBody( $1, HB_COMP_PARAM->functions.pLast->pCode + $3, - HB_COMP_PARAM->functions.pLast->lPCodePos - $3 ); - HB_COMP_PARAM->functions.pLast->lPCodePos = $3; + HB_COMP_PARAM->functions.pLast->nPCodePos - $3 ); + HB_COMP_PARAM->functions.pLast->nPCodePos = $3; HB_COMP_PARAM->lastLinePos = 0; } ; @@ -1502,7 +1502,7 @@ DoWhile : WhileBegin ExpList Crlf EmptyStats { hb_compLoopHere( HB_COMP_PARAM ); - hb_compGenJump( $1 - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM ); + hb_compGenJump( $1 - HB_COMP_PARAM->functions.pLast->nPCodePos, HB_COMP_PARAM ); } EndWhile { @@ -1516,7 +1516,7 @@ DoWhile : WhileBegin ExpList Crlf WhileBegin : WHILE { - $$ = HB_COMP_PARAM->functions.pLast->lPCodePos; + $$ = HB_COMP_PARAM->functions.pLast->nPCodePos; hb_compLinePushIfInside( HB_COMP_PARAM ); ++HB_COMP_PARAM->functions.pLast->wWhileCounter; hb_compLoopStart( HB_COMP_PARAM, HB_TRUE ); @@ -1551,7 +1551,7 @@ ForNext : FOR LValue ForAssign Expression /* 1 2 3 4 */ } Crlf /* 10 */ { /* 11 */ - $$ = HB_COMP_PARAM->functions.pLast->lPCodePos; + $$ = HB_COMP_PARAM->functions.pLast->nPCodePos; } ForStatements /* 12 */ { @@ -1589,7 +1589,7 @@ ForNext : FOR LValue ForAssign Expression /* 1 2 3 4 */ hb_compGenPCode1( HB_P_FORTEST, HB_COMP_PARAM ); } - hb_compGenJumpFalse( $11 - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM ); + hb_compGenJumpFalse( $11 - HB_COMP_PARAM->functions.pLast->nPCodePos, HB_COMP_PARAM ); hb_compLoopEnd( HB_COMP_PARAM ); if( hb_compExprAsSymbol( $2 ) ) hb_compForEnd( HB_COMP_PARAM, hb_compExprAsSymbol( $2 ) ); @@ -1651,7 +1651,7 @@ ForEach : FOREACH ForList IN ForArgs /* 1 2 3 4 */ hb_compEnumStart( HB_COMP_PARAM, $2, $4, $6 ); hb_compLoopStart( HB_COMP_PARAM, HB_TRUE ); - $$ = HB_COMP_PARAM->functions.pLast->lPCodePos; + $$ = HB_COMP_PARAM->functions.pLast->nPCodePos; } Crlf /* 8 */ { @@ -1662,7 +1662,7 @@ ForEach : FOREACH ForList IN ForArgs /* 1 2 3 4 */ { hb_compLoopHere( HB_COMP_PARAM ); hb_compEnumNext( HB_COMP_PARAM, $2, $6 ); - hb_compGenJump( $7 - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM ); + hb_compGenJump( $7 - HB_COMP_PARAM->functions.pLast->nPCodePos, HB_COMP_PARAM ); hb_compGenJumpHere( $9, HB_COMP_PARAM ); hb_compLoopEnd( HB_COMP_PARAM ); @@ -1816,7 +1816,7 @@ BlockSeq : /* no always */ { $$ = 0; } { HB_COMP_EXPR_FREE( hb_compExprGenPush( $2, HB_COMP_PARAM ) ); hb_compGenPCode1( HB_P_SEQBLOCK, HB_COMP_PARAM ); - $$ = HB_COMP_PARAM->functions.pLast->lPCodePos; + $$ = HB_COMP_PARAM->functions.pLast->nPCodePos; } ; @@ -1827,7 +1827,7 @@ AlwaysSeq : /* no always */ { $$ = 0; } Always : ALWAYS { HB_COMP_PARAM->functions.pLast->funFlags &= ~ ( FUN_WITH_RETURN | FUN_BREAK_CODE ); - $$ = HB_COMP_PARAM->functions.pLast->lPCodePos; + $$ = HB_COMP_PARAM->functions.pLast->nPCodePos; ++HB_COMP_PARAM->functions.pLast->wAlwaysCounter; hb_compSequenceAlways( HB_COMP_PARAM ); } @@ -1841,7 +1841,7 @@ RecoverSeq : /* no recover */ { $$ = 0; HB_COMP_PARAM->functions.pLast->funFl RecoverEmpty : RECOVER { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; - $$ = HB_COMP_PARAM->functions.pLast->lPCodePos; + $$ = HB_COMP_PARAM->functions.pLast->nPCodePos; if( HB_COMP_PARAM->functions.pLast->wSeqCounter ) --HB_COMP_PARAM->functions.pLast->wSeqCounter; hb_compLinePushIfInside( HB_COMP_PARAM ); @@ -1852,7 +1852,7 @@ RecoverEmpty : RECOVER RecoverUsing : RECOVERUSING IdentName { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; - $$ = HB_COMP_PARAM->functions.pLast->lPCodePos; + $$ = HB_COMP_PARAM->functions.pLast->nPCodePos; if( HB_COMP_PARAM->functions.pLast->wSeqCounter ) --HB_COMP_PARAM->functions.pLast->wSeqCounter; hb_compLinePushIfInside( HB_COMP_PARAM ); @@ -1901,7 +1901,7 @@ WithObject : WITHOBJECT Expression Crlf { hb_compLinePushIfInside( HB_COMP_PARAM ); HB_COMP_EXPR_FREE( hb_compExprGenPush( $2, HB_COMP_PARAM ) ); - $$ = HB_COMP_PARAM->functions.pLast->lPCodePos; + $$ = HB_COMP_PARAM->functions.pLast->nPCodePos; hb_compGenPCode1( HB_P_WITHOBJECTSTART, HB_COMP_PARAM ); HB_COMP_PARAM->functions.pLast->wWithObjectCnt++; } @@ -1966,7 +1966,7 @@ static void hb_compLoopStart( HB_COMP_DECL, HB_BOOL fCanLoop ) else pFunc->pLoops = pLoop; - pLoop->ulOffset = pFunc->lPCodePos; /* store the start position */ + pLoop->ulOffset = pFunc->nPCodePos; /* store the start position */ pLoop->fCanLoop = fCanLoop; /* can we use LOOP inside */ pLoop->wSeqCounter = pFunc->wSeqCounter; /* store current SEQUENCE counter */ pLoop->wWithObjectCnt = pFunc->wWithObjectCnt; /* store current WITH OBJECT counter */ @@ -2068,7 +2068,7 @@ static void hb_compLoopLoop( HB_COMP_DECL ) wWithObjectCnt++; } /* store the position to fix */ - pLoop->ulOffset = pFunc->lPCodePos; + pLoop->ulOffset = pFunc->nPCodePos; hb_compGenJump( 0, HB_COMP_PARAM ); } } @@ -2124,7 +2124,7 @@ static void hb_compLoopExit( HB_COMP_DECL ) wWithObjectCnt++; } /* store the position to fix */ - pLoop->ulOffset = pFunc->lPCodePos; + pLoop->ulOffset = pFunc->nPCodePos; hb_compGenJump( 0, HB_COMP_PARAM ); } } @@ -2553,7 +2553,7 @@ static void hb_compSwitchStart( HB_COMP_DECL, HB_EXPR_PTR pExpr ) pSwitch->pCases = NULL; pSwitch->pLast = NULL; pSwitch->ulDefault = 0; - pSwitch->ulOffset = pFunc->lPCodePos; + pSwitch->ulOffset = pFunc->nPCodePos; pSwitch->pExpr = pExpr; pSwitch->pPrev = pFunc->pSwitch; pFunc->pSwitch = pSwitch; @@ -2570,7 +2570,7 @@ static void hb_compSwitchAdd( HB_COMP_DECL, HB_EXPR_PTR pExpr ) { /* normal CASE */ pCase = (HB_SWITCHCASE_PTR) hb_xgrab( sizeof( HB_SWITCHCASE ) ); - pCase->ulOffset = pFunc->lPCodePos; + pCase->ulOffset = pFunc->nPCodePos; pCase->pNext = NULL; pExpr = hb_compExprReduce( pExpr, HB_COMP_PARAM ); if( !( hb_compExprIsLong( pExpr ) || hb_compExprIsString( pExpr ) ) ) @@ -2602,7 +2602,7 @@ static void hb_compSwitchAdd( HB_COMP_DECL, HB_EXPR_PTR pExpr ) } else { - pFunc->pSwitch->ulDefault = pFunc->lPCodePos; + pFunc->pSwitch->ulDefault = pFunc->nPCodePos; } } } @@ -2663,7 +2663,7 @@ static void hb_compSwitchEnd( HB_COMP_DECL ) HB_BOOL fMacroText = ( HB_COMP_PARAM->supported & HB_COMPFLAG_MACROTEXT ) != 0; pExpr = hb_compExprGenPush( pExpr, HB_COMP_PARAM ); - ulCountPos = pFunc->lPCodePos + 1; + ulCountPos = pFunc->nPCodePos + 1; hb_compGenPCode3( HB_P_SWITCH, 0, 0, HB_COMP_PARAM ); HB_COMP_PARAM->fLongOptimize = HB_FALSE; HB_COMP_PARAM->supported &= ~HB_COMPFLAG_MACROTEXT; diff --git a/harbour/src/compiler/harbour.yyc b/harbour/src/compiler/harbour.yyc index 0b4181e15c..f88bf2b445 100644 --- a/harbour/src/compiler/harbour.yyc +++ b/harbour/src/compiler/harbour.yyc @@ -5710,7 +5710,7 @@ yyreduce: #line 1034 "harbour.y" { /* 3 */ HB_CBVAR_PTR pVar; - (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->lPCodePos; + (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; hb_compCodeBlockStart( HB_COMP_PARAM, HB_TRUE ); HB_COMP_PARAM->functions.pLast->funFlags |= FUN_EXTBLOCK; HB_COMP_PARAM->functions.pLast->fVParams = @@ -5740,8 +5740,8 @@ yyreduce: hb_compCodeBlockEnd( HB_COMP_PARAM ); (yyval.asExpr) = hb_compExprSetCodeblockBody( (yyvsp[(1) - (5)].asExpr), HB_COMP_PARAM->functions.pLast->pCode + (yyvsp[(3) - (5)].sNumber), - HB_COMP_PARAM->functions.pLast->lPCodePos - (yyvsp[(3) - (5)].sNumber) ); - HB_COMP_PARAM->functions.pLast->lPCodePos = (yyvsp[(3) - (5)].sNumber); + HB_COMP_PARAM->functions.pLast->nPCodePos - (yyvsp[(3) - (5)].sNumber) ); + HB_COMP_PARAM->functions.pLast->nPCodePos = (yyvsp[(3) - (5)].sNumber); HB_COMP_PARAM->lastLinePos = 0; ;} break; @@ -6365,7 +6365,7 @@ yyreduce: #line 1503 "harbour.y" { hb_compLoopHere( HB_COMP_PARAM ); - hb_compGenJump( (yyvsp[(1) - (5)].sNumber) - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM ); + hb_compGenJump( (yyvsp[(1) - (5)].sNumber) - HB_COMP_PARAM->functions.pLast->nPCodePos, HB_COMP_PARAM ); ;} break; @@ -6383,7 +6383,7 @@ yyreduce: case 526: #line 1518 "harbour.y" { - (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->lPCodePos; + (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; hb_compLinePushIfInside( HB_COMP_PARAM ); ++HB_COMP_PARAM->functions.pLast->wWhileCounter; hb_compLoopStart( HB_COMP_PARAM, HB_TRUE ); @@ -6422,7 +6422,7 @@ yyreduce: case 532: #line 1553 "harbour.y" { /* 11 */ - (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->lPCodePos; + (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; ;} break; @@ -6463,7 +6463,7 @@ yyreduce: hb_compGenPCode1( HB_P_FORTEST, HB_COMP_PARAM ); } - hb_compGenJumpFalse( (yyvsp[(11) - (12)].sNumber) - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM ); + hb_compGenJumpFalse( (yyvsp[(11) - (12)].sNumber) - HB_COMP_PARAM->functions.pLast->nPCodePos, HB_COMP_PARAM ); hb_compLoopEnd( HB_COMP_PARAM ); if( hb_compExprAsSymbol( (yyvsp[(2) - (12)].asExpr) ) ) hb_compForEnd( HB_COMP_PARAM, hb_compExprAsSymbol( (yyvsp[(2) - (12)].asExpr) ) ); @@ -6544,7 +6544,7 @@ yyreduce: hb_compEnumStart( HB_COMP_PARAM, (yyvsp[(2) - (6)].asExpr), (yyvsp[(4) - (6)].asExpr), (yyvsp[(6) - (6)].iNumber) ); hb_compLoopStart( HB_COMP_PARAM, HB_TRUE ); - (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->lPCodePos; + (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; ;} break; @@ -6561,7 +6561,7 @@ yyreduce: { hb_compLoopHere( HB_COMP_PARAM ); hb_compEnumNext( HB_COMP_PARAM, (yyvsp[(2) - (10)].asExpr), (yyvsp[(6) - (10)].iNumber) ); - hb_compGenJump( (yyvsp[(7) - (10)].sNumber) - HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM ); + hb_compGenJump( (yyvsp[(7) - (10)].sNumber) - HB_COMP_PARAM->functions.pLast->nPCodePos, HB_COMP_PARAM ); hb_compGenJumpHere( (yyvsp[(9) - (10)].sNumber), HB_COMP_PARAM ); hb_compLoopEnd( HB_COMP_PARAM ); @@ -6739,7 +6739,7 @@ yyreduce: { HB_COMP_EXPR_FREE( hb_compExprGenPush( (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ) ); hb_compGenPCode1( HB_P_SEQBLOCK, HB_COMP_PARAM ); - (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->lPCodePos; + (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; ;} break; @@ -6752,7 +6752,7 @@ yyreduce: #line 1828 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ ( FUN_WITH_RETURN | FUN_BREAK_CODE ); - (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->lPCodePos; + (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; ++HB_COMP_PARAM->functions.pLast->wAlwaysCounter; hb_compSequenceAlways( HB_COMP_PARAM ); ;} @@ -6767,7 +6767,7 @@ yyreduce: #line 1842 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; - (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->lPCodePos; + (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; if( HB_COMP_PARAM->functions.pLast->wSeqCounter ) --HB_COMP_PARAM->functions.pLast->wSeqCounter; hb_compLinePushIfInside( HB_COMP_PARAM ); @@ -6779,7 +6779,7 @@ yyreduce: #line 1853 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; - (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->lPCodePos; + (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; if( HB_COMP_PARAM->functions.pLast->wSeqCounter ) --HB_COMP_PARAM->functions.pLast->wSeqCounter; hb_compLinePushIfInside( HB_COMP_PARAM ); @@ -6849,7 +6849,7 @@ yyreduce: { hb_compLinePushIfInside( HB_COMP_PARAM ); HB_COMP_EXPR_FREE( hb_compExprGenPush( (yyvsp[(2) - (3)].asExpr), HB_COMP_PARAM ) ); - (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->lPCodePos; + (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; hb_compGenPCode1( HB_P_WITHOBJECTSTART, HB_COMP_PARAM ); HB_COMP_PARAM->functions.pLast->wWithObjectCnt++; ;} @@ -7135,7 +7135,7 @@ static void hb_compLoopStart( HB_COMP_DECL, HB_BOOL fCanLoop ) else pFunc->pLoops = pLoop; - pLoop->ulOffset = pFunc->lPCodePos; /* store the start position */ + pLoop->ulOffset = pFunc->nPCodePos; /* store the start position */ pLoop->fCanLoop = fCanLoop; /* can we use LOOP inside */ pLoop->wSeqCounter = pFunc->wSeqCounter; /* store current SEQUENCE counter */ pLoop->wWithObjectCnt = pFunc->wWithObjectCnt; /* store current WITH OBJECT counter */ @@ -7237,7 +7237,7 @@ static void hb_compLoopLoop( HB_COMP_DECL ) wWithObjectCnt++; } /* store the position to fix */ - pLoop->ulOffset = pFunc->lPCodePos; + pLoop->ulOffset = pFunc->nPCodePos; hb_compGenJump( 0, HB_COMP_PARAM ); } } @@ -7293,7 +7293,7 @@ static void hb_compLoopExit( HB_COMP_DECL ) wWithObjectCnt++; } /* store the position to fix */ - pLoop->ulOffset = pFunc->lPCodePos; + pLoop->ulOffset = pFunc->nPCodePos; hb_compGenJump( 0, HB_COMP_PARAM ); } } @@ -7722,7 +7722,7 @@ static void hb_compSwitchStart( HB_COMP_DECL, HB_EXPR_PTR pExpr ) pSwitch->pCases = NULL; pSwitch->pLast = NULL; pSwitch->ulDefault = 0; - pSwitch->ulOffset = pFunc->lPCodePos; + pSwitch->ulOffset = pFunc->nPCodePos; pSwitch->pExpr = pExpr; pSwitch->pPrev = pFunc->pSwitch; pFunc->pSwitch = pSwitch; @@ -7739,7 +7739,7 @@ static void hb_compSwitchAdd( HB_COMP_DECL, HB_EXPR_PTR pExpr ) { /* normal CASE */ pCase = (HB_SWITCHCASE_PTR) hb_xgrab( sizeof( HB_SWITCHCASE ) ); - pCase->ulOffset = pFunc->lPCodePos; + pCase->ulOffset = pFunc->nPCodePos; pCase->pNext = NULL; pExpr = hb_compExprReduce( pExpr, HB_COMP_PARAM ); if( !( hb_compExprIsLong( pExpr ) || hb_compExprIsString( pExpr ) ) ) @@ -7771,7 +7771,7 @@ static void hb_compSwitchAdd( HB_COMP_DECL, HB_EXPR_PTR pExpr ) } else { - pFunc->pSwitch->ulDefault = pFunc->lPCodePos; + pFunc->pSwitch->ulDefault = pFunc->nPCodePos; } } } @@ -7832,7 +7832,7 @@ static void hb_compSwitchEnd( HB_COMP_DECL ) HB_BOOL fMacroText = ( HB_COMP_PARAM->supported & HB_COMPFLAG_MACROTEXT ) != 0; pExpr = hb_compExprGenPush( pExpr, HB_COMP_PARAM ); - ulCountPos = pFunc->lPCodePos + 1; + ulCountPos = pFunc->nPCodePos + 1; hb_compGenPCode3( HB_P_SWITCH, 0, 0, HB_COMP_PARAM ); HB_COMP_PARAM->fLongOptimize = HB_FALSE; HB_COMP_PARAM->supported &= ~HB_COMPFLAG_MACROTEXT; @@ -8021,4 +8021,3 @@ void yyerror( HB_COMP_DECL, const char * s ) else hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'E', HB_COMP_ERR_YACC, s, HB_COMP_PARAM->pLex->lasttok ); } - diff --git a/harbour/src/compiler/hbdbginf.c b/harbour/src/compiler/hbdbginf.c index 3819df86d6..c52902490b 100644 --- a/harbour/src/compiler/hbdbginf.c +++ b/harbour/src/compiler/hbdbginf.c @@ -67,7 +67,7 @@ PHB_DEBUGINFO hb_compGetDebugInfo( HB_COMP_DECL ) if( ( pFunc->funFlags & FUN_FILE_DECL ) == 0 ) { nPos = ulLine = 0; - while( nPos < pFunc->lPCodePos ) + while( nPos < pFunc->nPCodePos ) { nSkip = 0; switch( pFunc->pCode[ nPos ] ) diff --git a/harbour/src/compiler/hbdead.c b/harbour/src/compiler/hbdead.c index 8a7869bdb1..66c36cd3c4 100644 --- a/harbour/src/compiler/hbdead.c +++ b/harbour/src/compiler/hbdead.c @@ -126,128 +126,128 @@ static void hb_compCodeTraceMark( PHB_CODETRACE_INFO pInfo, HB_SIZE nPCodePos, H static HB_CODETRACE_FUNC( hb_p_default ) { - HB_SIZE nSize = hb_compPCodeSize( pFunc, lPCodePos ); + HB_SIZE nSize = hb_compPCodeSize( pFunc, nPCodePos ); - hb_compCodeTraceMark( cargo, lPCodePos, nSize ); - return hb_compCodeTraceNextPos( cargo, lPCodePos + nSize ); + hb_compCodeTraceMark( cargo, nPCodePos, nSize ); + return hb_compCodeTraceNextPos( cargo, nPCodePos + nSize ); } static HB_CODETRACE_FUNC( hb_p_jumpnear ) { - HB_SIZE nNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + ( signed char ) pFunc->pCode[ nPCodePos + 1 ]; - hb_compCodeTraceMark( cargo, lPCodePos, 2 ); + hb_compCodeTraceMark( cargo, nPCodePos, 2 ); return hb_compCodeTraceNextPos( cargo, nNewPos ); } static HB_CODETRACE_FUNC( hb_p_jump ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + HB_PCODE_MKSHORT( pAddr ); - hb_compCodeTraceMark( cargo, lPCodePos, 3 ); + hb_compCodeTraceMark( cargo, nPCodePos, 3 ); return hb_compCodeTraceNextPos( cargo, nNewPos ); } static HB_CODETRACE_FUNC( hb_p_jumpfar ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + HB_PCODE_MKINT24( pAddr ); - hb_compCodeTraceMark( cargo, lPCodePos, 4 ); + hb_compCodeTraceMark( cargo, nPCodePos, 4 ); return hb_compCodeTraceNextPos( cargo, nNewPos ); } static HB_CODETRACE_FUNC( hb_p_jumpfalsenear ) { - HB_SIZE nNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + ( signed char ) pFunc->pCode[ nPCodePos + 1 ]; - hb_compCodeTraceMark( cargo, lPCodePos, 2 ); + hb_compCodeTraceMark( cargo, nPCodePos, 2 ); hb_compCodeTraceAddJump( cargo, nNewPos ); - return hb_compCodeTraceNextPos( cargo, lPCodePos + 2 ); + return hb_compCodeTraceNextPos( cargo, nPCodePos + 2 ); } static HB_CODETRACE_FUNC( hb_p_jumpfalse ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + HB_PCODE_MKSHORT( pAddr ); - hb_compCodeTraceMark( cargo, lPCodePos, 3 ); + hb_compCodeTraceMark( cargo, nPCodePos, 3 ); hb_compCodeTraceAddJump( cargo, nNewPos ); - return hb_compCodeTraceNextPos( cargo, lPCodePos + 3 ); + return hb_compCodeTraceNextPos( cargo, nPCodePos + 3 ); } static HB_CODETRACE_FUNC( hb_p_jumpfalsefar ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + HB_PCODE_MKINT24( pAddr ); - hb_compCodeTraceMark( cargo, lPCodePos, 4 ); + hb_compCodeTraceMark( cargo, nPCodePos, 4 ); hb_compCodeTraceAddJump( cargo, nNewPos ); - return hb_compCodeTraceNextPos( cargo, lPCodePos + 4 ); + return hb_compCodeTraceNextPos( cargo, nPCodePos + 4 ); } static HB_CODETRACE_FUNC( hb_p_jumptruenear ) { - HB_SIZE nNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + ( signed char ) pFunc->pCode[ nPCodePos + 1 ]; - hb_compCodeTraceMark( cargo, lPCodePos, 2 ); + hb_compCodeTraceMark( cargo, nPCodePos, 2 ); hb_compCodeTraceAddJump( cargo, nNewPos ); - return hb_compCodeTraceNextPos( cargo, lPCodePos + 2 ); + return hb_compCodeTraceNextPos( cargo, nPCodePos + 2 ); } static HB_CODETRACE_FUNC( hb_p_jumptrue ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + HB_PCODE_MKSHORT( pAddr ); - hb_compCodeTraceMark( cargo, lPCodePos, 3 ); + hb_compCodeTraceMark( cargo, nPCodePos, 3 ); hb_compCodeTraceAddJump( cargo, nNewPos ); - return hb_compCodeTraceNextPos( cargo, lPCodePos + 3 ); + return hb_compCodeTraceNextPos( cargo, nPCodePos + 3 ); } static HB_CODETRACE_FUNC( hb_p_jumptruefar ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + HB_PCODE_MKINT24( pAddr ); - hb_compCodeTraceMark( cargo, lPCodePos, 4 ); + hb_compCodeTraceMark( cargo, nPCodePos, 4 ); hb_compCodeTraceAddJump( cargo, nNewPos ); - return hb_compCodeTraceNextPos( cargo, lPCodePos + 4 ); + return hb_compCodeTraceNextPos( cargo, nPCodePos + 4 ); } static HB_CODETRACE_FUNC( hb_p_seqalways ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nAlwaysPos = lPCodePos + HB_PCODE_MKINT24( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nAlwaysPos = nPCodePos + HB_PCODE_MKINT24( pAddr ); - hb_compCodeTraceMark( cargo, lPCodePos, 4 ); + hb_compCodeTraceMark( cargo, nPCodePos, 4 ); hb_compCodeTraceAddJump( cargo, nAlwaysPos ); - return hb_compCodeTraceNextPos( cargo, lPCodePos + 4 ); + return hb_compCodeTraceNextPos( cargo, nPCodePos + 4 ); } static HB_CODETRACE_FUNC( hb_p_alwaysbegin ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nAlwaysEndPos = lPCodePos + HB_PCODE_MKINT24( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nAlwaysEndPos = nPCodePos + HB_PCODE_MKINT24( pAddr ); - hb_compCodeTraceMark( cargo, lPCodePos, 4 ); + hb_compCodeTraceMark( cargo, nPCodePos, 4 ); hb_compCodeTraceAddJump( cargo, nAlwaysEndPos ); - return hb_compCodeTraceNextPos( cargo, lPCodePos + 4 ); + return hb_compCodeTraceNextPos( cargo, nPCodePos + 4 ); } static HB_CODETRACE_FUNC( hb_p_seqbegin ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nRecoverPos = lPCodePos + HB_PCODE_MKINT24( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nRecoverPos = nPCodePos + HB_PCODE_MKINT24( pAddr ); /* this is a hack for -gc3 output - it's not really necessary * for pure PCODE evaluation @@ -258,18 +258,18 @@ static HB_CODETRACE_FUNC( hb_p_seqbegin ) hb_compCodeTraceAddJump( cargo, nRecoverPos - 4 ); } - hb_compCodeTraceMark( cargo, lPCodePos, 4 ); + hb_compCodeTraceMark( cargo, nPCodePos, 4 ); hb_compCodeTraceAddJump( cargo, nRecoverPos ); - return hb_compCodeTraceNextPos( cargo, lPCodePos + 4 ); + return hb_compCodeTraceNextPos( cargo, nPCodePos + 4 ); } static HB_CODETRACE_FUNC( hb_p_seqend ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + HB_PCODE_MKINT24( pAddr ); - hb_compCodeTraceMark( cargo, lPCodePos, 4 ); + hb_compCodeTraceMark( cargo, nPCodePos, 4 ); return hb_compCodeTraceNextPos( cargo, nNewPos ); } @@ -277,81 +277,81 @@ static HB_CODETRACE_FUNC( hb_p_seqend ) static HB_CODETRACE_FUNC( hb_p_switch ) { - HB_USHORT usCases = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), us; - HB_SIZE nStart = lPCodePos, nNewPos; + HB_USHORT usCases = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), us; + HB_SIZE nStart = nPCodePos, nNewPos; - lPCodePos += 3; + nPCodePos += 3; for( us = 0; us < usCases; ++us ) { - switch( pFunc->pCode[ lPCodePos ] ) + switch( pFunc->pCode[ nPCodePos ] ) { case HB_P_PUSHBYTE: - lPCodePos += 2; + nPCodePos += 2; break; case HB_P_PUSHINT: - lPCodePos += 3; + nPCodePos += 3; break; case HB_P_PUSHLONG: case HB_P_PUSHDATE: - lPCodePos += 5; + nPCodePos += 5; break; case HB_P_PUSHLONGLONG: - lPCodePos += 9; + nPCodePos += 9; break; case HB_P_PUSHSTRSHORT: - lPCodePos += 2 + pFunc->pCode[ lPCodePos + 1 ]; + nPCodePos += 2 + pFunc->pCode[ nPCodePos + 1 ]; break; case HB_P_PUSHSTR: - lPCodePos += 3 + HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); + nPCodePos += 3 + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); break; case HB_P_PUSHSTRLARGE: - lPCodePos += 4 + HB_PCODE_MKUINT24( &pFunc->pCode[ lPCodePos + 1 ] ); + nPCodePos += 4 + HB_PCODE_MKUINT24( &pFunc->pCode[ nPCodePos + 1 ] ); break; case HB_P_PUSHNIL: /* default clause */ us = usCases; - lPCodePos++; + nPCodePos++; break; } - switch( pFunc->pCode[ lPCodePos ] ) + switch( pFunc->pCode[ nPCodePos ] ) { case HB_P_JUMPNEAR: - nNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ]; - lPCodePos += 2; + nNewPos = nPCodePos + ( signed char ) pFunc->pCode[ nPCodePos + 1 ]; + nPCodePos += 2; break; case HB_P_JUMP: - nNewPos = lPCodePos + HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); - lPCodePos += 3; + nNewPos = nPCodePos + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); + nPCodePos += 3; break; /*case HB_P_JUMPFAR:*/ default: - nNewPos = lPCodePos + HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 1 ] ); - lPCodePos += 4; + nNewPos = nPCodePos + HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] ); + nPCodePos += 4; break; } hb_compCodeTraceAddJump( cargo, nNewPos ); } - hb_compCodeTraceMark( cargo, nStart, lPCodePos - nStart ); + hb_compCodeTraceMark( cargo, nStart, nPCodePos - nStart ); return hb_compCodeTraceNextPos( cargo, us > usCases ? - cargo->nPCodeSize : lPCodePos ); + cargo->nPCodeSize : nPCodePos ); } static HB_CODETRACE_FUNC( hb_p_endblock ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); - hb_compCodeTraceMark( cargo, lPCodePos, 1 ); + hb_compCodeTraceMark( cargo, nPCodePos, 1 ); return hb_compCodeTraceNextPos( cargo, cargo->nPCodeSize ); } static HB_CODETRACE_FUNC( hb_p_endproc ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); - hb_compCodeTraceMark( cargo, lPCodePos, 1 ); + hb_compCodeTraceMark( cargo, nPCodePos, 1 ); return hb_compCodeTraceNextPos( cargo, cargo->nPCodeSize ); } @@ -551,7 +551,7 @@ void hb_compCodeTraceMarkDead( HB_COMP_DECL, PFUNCTION pFunc ) const PHB_CODETRACE_FUNC * pFuncTable = s_codeTraceFuncTable; HB_CODETRACE_INFO code_info; - if( ! HB_COMP_ISSUPPORTED( HB_COMPFLAG_OPTJUMP ) || pFunc->lPCodePos < 2 ) + if( ! HB_COMP_ISSUPPORTED( HB_COMPFLAG_OPTJUMP ) || pFunc->nPCodePos < 2 ) return; assert( HB_P_LAST_PCODE == sizeof( s_codeTraceFuncTable ) / sizeof( PHB_CODETRACE_FUNC ) ); @@ -560,7 +560,7 @@ void hb_compCodeTraceMarkDead( HB_COMP_DECL, PFUNCTION pFunc ) code_info.nJumpPos = 0; code_info.nJumpSize = 0; code_info.nJumpCount = 0; - code_info.nPCodeSize = pFunc->lPCodePos; + code_info.nPCodeSize = pFunc->nPCodePos; code_info.fFinished = HB_FALSE; code_info.pCodeMark = ( HB_BYTE * ) hb_xgrab( code_info.nPCodeSize ); @@ -605,7 +605,7 @@ void hb_compCodeTraceMarkDead( HB_COMP_DECL, PFUNCTION pFunc ) */ /* pFunc->pCode[ nPos - nCount ] = pFunc->pCode[ nPos - 1 ]; - pFunc->lPCodePos = pFunc->lPCodeSize = nPos - nCount + 1; + pFunc->nPCodePos = pFunc->lPCodeSize = nPos - nCount + 1; */ hb_compNOOPfill( pFunc, nPos - nCount, nCount, HB_FALSE, HB_TRUE ); } diff --git a/harbour/src/compiler/hbfix.c b/harbour/src/compiler/hbfix.c index 833a06f59c..e60e296a64 100644 --- a/harbour/src/compiler/hbfix.c +++ b/harbour/src/compiler/hbfix.c @@ -66,13 +66,13 @@ typedef HB_FIX_FUNC_ * HB_FIX_FUNC_PTR; static HB_FIX_FUNC( hb_p_pushblock ) { - HB_BYTE * pLocal = &pFunc->pCode[ lPCodePos + 7 ]; + HB_BYTE * pLocal = &pFunc->pCode[ nPCodePos + 7 ]; HB_USHORT wVar; HB_SYMBOL_UNUSED( cargo ); /* opcode + codeblock size + number of parameters + number of local variables */ - wVar = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 5 ] ); + wVar = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 5 ] ); /* fix local variable's reference */ while( wVar-- ) @@ -86,18 +86,18 @@ static HB_FIX_FUNC( hb_p_pushblock ) /* only local variables used outside of a codeblock need fixing * skip the codeblock body */ - return HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); + return HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); } static HB_FIX_FUNC( hb_p_pushblocklarge ) { - HB_BYTE * pLocal = &pFunc->pCode[ lPCodePos + 8 ]; + HB_BYTE * pLocal = &pFunc->pCode[ nPCodePos + 8 ]; HB_USHORT wVar; HB_SYMBOL_UNUSED( cargo ); /* opcode + codeblock size + number of parameters + number of local variables */ - wVar = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 6 ] ); + wVar = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 6 ] ); /* fix local variable's reference */ while( wVar-- ) @@ -111,12 +111,12 @@ static HB_FIX_FUNC( hb_p_pushblocklarge ) /* only local variables used outside of a codeblock need fixing * skip the codeblock body */ - return HB_PCODE_MKUINT24( &pFunc->pCode[ lPCodePos + 1 ] ); + return HB_PCODE_MKUINT24( &pFunc->pCode[ nPCodePos + 1 ] ); } static HB_FIX_FUNC( hb_p_localfix ) { - HB_BYTE * pVar = &pFunc->pCode[ lPCodePos + 1 ]; + HB_BYTE * pVar = &pFunc->pCode[ nPCodePos + 1 ]; HB_SHORT iVar = HB_PCODE_MKSHORT( pVar ); HB_SYMBOL_UNUSED( cargo ); @@ -131,7 +131,7 @@ static HB_FIX_FUNC( hb_p_localfix ) static HB_FIX_FUNC( hb_p_localnearerr ) { HB_SYMBOL_UNUSED( pFunc ); - HB_SYMBOL_UNUSED( lPCodePos ); + HB_SYMBOL_UNUSED( nPCodePos ); /* * this code should never be executed because compiler should * generate only non size optimized HB_P_POPLOCAL pcodes diff --git a/harbour/src/compiler/hblbl.c b/harbour/src/compiler/hblbl.c index 899598f2b4..94e04c70d8 100644 --- a/harbour/src/compiler/hblbl.c +++ b/harbour/src/compiler/hblbl.c @@ -62,7 +62,7 @@ typedef HB_LABEL_FUNC_ * PHB_LABEL_FUNC; */ static HB_LABEL_FUNC( hb_p_jumpnear ) { - HB_SIZE nNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + ( signed char ) pFunc->pCode[ nPCodePos + 1 ]; cargo->pulLabels[ nNewPos ]++; return 2; @@ -70,8 +70,8 @@ static HB_LABEL_FUNC( hb_p_jumpnear ) static HB_LABEL_FUNC( hb_p_jump ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + HB_PCODE_MKSHORT( pAddr ); cargo->pulLabels[ nNewPos ]++; return 3; @@ -79,8 +79,8 @@ static HB_LABEL_FUNC( hb_p_jump ) static HB_LABEL_FUNC( hb_p_jumpfar ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + HB_PCODE_MKINT24( pAddr ); cargo->pulLabels[ nNewPos ]++; return 4; @@ -88,7 +88,7 @@ static HB_LABEL_FUNC( hb_p_jumpfar ) static HB_LABEL_FUNC( hb_p_jumpfalsenear ) { - HB_SIZE nNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + ( signed char ) pFunc->pCode[ nPCodePos + 1 ]; cargo->fCondJump = HB_TRUE; cargo->pulLabels[ nNewPos ]++; @@ -97,8 +97,8 @@ static HB_LABEL_FUNC( hb_p_jumpfalsenear ) static HB_LABEL_FUNC( hb_p_jumpfalse ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + HB_PCODE_MKSHORT( pAddr ); cargo->fCondJump = HB_TRUE; cargo->pulLabels[ nNewPos ]++; @@ -107,8 +107,8 @@ static HB_LABEL_FUNC( hb_p_jumpfalse ) static HB_LABEL_FUNC( hb_p_jumpfalsefar ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + HB_PCODE_MKINT24( pAddr ); cargo->fCondJump = HB_TRUE; cargo->pulLabels[ nNewPos ]++; @@ -117,7 +117,7 @@ static HB_LABEL_FUNC( hb_p_jumpfalsefar ) static HB_LABEL_FUNC( hb_p_jumptruenear ) { - HB_SIZE nNewPos = lPCodePos + ( signed char ) pFunc->pCode[ lPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + ( signed char ) pFunc->pCode[ nPCodePos + 1 ]; cargo->fCondJump = HB_TRUE; cargo->pulLabels[ nNewPos ]++; @@ -126,8 +126,8 @@ static HB_LABEL_FUNC( hb_p_jumptruenear ) static HB_LABEL_FUNC( hb_p_jumptrue ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nNewPos = lPCodePos + HB_PCODE_MKSHORT( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + HB_PCODE_MKSHORT( pAddr ); cargo->fCondJump = HB_TRUE; cargo->pulLabels[ nNewPos ]++; @@ -136,8 +136,8 @@ static HB_LABEL_FUNC( hb_p_jumptrue ) static HB_LABEL_FUNC( hb_p_jumptruefar ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nNewPos = lPCodePos + HB_PCODE_MKINT24( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nNewPos = nPCodePos + HB_PCODE_MKINT24( pAddr ); cargo->fCondJump = HB_TRUE; cargo->pulLabels[ nNewPos ]++; @@ -146,8 +146,8 @@ static HB_LABEL_FUNC( hb_p_jumptruefar ) static HB_LABEL_FUNC( hb_p_seqalways ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nAlwaysPos = lPCodePos + HB_PCODE_MKINT24( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nAlwaysPos = nPCodePos + HB_PCODE_MKINT24( pAddr ); if( cargo->fSetSeqBegin ) cargo->pulLabels[ nAlwaysPos ]++; @@ -156,8 +156,8 @@ static HB_LABEL_FUNC( hb_p_seqalways ) static HB_LABEL_FUNC( hb_p_alwaysbegin ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nAlwaysEndPos = lPCodePos + HB_PCODE_MKINT24( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nAlwaysEndPos = nPCodePos + HB_PCODE_MKINT24( pAddr ); if( cargo->fSetSeqBegin ) cargo->pulLabels[ nAlwaysEndPos ]++; @@ -166,8 +166,8 @@ static HB_LABEL_FUNC( hb_p_alwaysbegin ) static HB_LABEL_FUNC( hb_p_seqbegin ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; - HB_SIZE nRecoverPos = lPCodePos + HB_PCODE_MKINT24( pAddr ); + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; + HB_SIZE nRecoverPos = nPCodePos + HB_PCODE_MKINT24( pAddr ); if( cargo->fSetSeqBegin ) cargo->pulLabels[ nRecoverPos ]++; @@ -176,9 +176,9 @@ static HB_LABEL_FUNC( hb_p_seqbegin ) static HB_LABEL_FUNC( hb_p_seqend ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; HB_ISIZ nOffset = HB_PCODE_MKINT24( pAddr ); - HB_SIZE nNewPos = lPCodePos + nOffset; + HB_SIZE nNewPos = nPCodePos + nOffset; if( cargo->fSetSeqBegin || nOffset != 4 ) cargo->pulLabels[ nNewPos ]++; @@ -385,7 +385,7 @@ void hb_compGenLabelTable( PFUNCTION pFunc, PHB_LABEL_INFO label_info ) hb_compPCodeEval( pFunc, ( HB_PCODE_FUNC_PTR * ) pFuncTable, ( void * ) label_info ); - for( n = 0; n < pFunc->lPCodePos; ++n ) + for( n = 0; n < pFunc->nPCodePos; ++n ) { if( label_info->pulLabels[ n ] ) { diff --git a/harbour/src/compiler/hbmain.c b/harbour/src/compiler/hbmain.c index da647b7a75..71eaeb13d7 100644 --- a/harbour/src/compiler/hbmain.c +++ b/harbour/src/compiler/hbmain.c @@ -1545,11 +1545,11 @@ static void hb_compOptimizeJumps( HB_COMP_DECL ) nNextByte++; } - nBytes2Copy = ( HB_COMP_PARAM->functions.pLast->lPCodePos - nNextByte ) ; + nBytes2Copy = ( HB_COMP_PARAM->functions.pLast->nPCodePos - nNextByte ) ; memmove( pCode + nOptimized, pCode + nNextByte, nBytes2Copy ); nOptimized += nBytes2Copy; - HB_COMP_PARAM->functions.pLast->lPCodePos = nOptimized; + HB_COMP_PARAM->functions.pLast->nPCodePos = nOptimized; HB_COMP_PARAM->functions.pLast->lPCodeSize = nOptimized; hb_xfree( HB_COMP_PARAM->functions.pLast->pNOOPs ); @@ -1590,8 +1590,8 @@ static void hb_compOptimizeFrames( HB_COMP_DECL, PFUNCTION pFunc ) /* if( !( pFunc->funFlags & FUN_USES_STATICS ) ) */ if( pFunc->pCode[ 8 ] == HB_P_ENDPROC ) { - pFunc->lPCodePos -= 3; - memmove( pFunc->pCode + 5, pFunc->pCode + 8, pFunc->lPCodePos - 5 ); + pFunc->nPCodePos -= 3; + memmove( pFunc->pCode + 5, pFunc->pCode + 8, pFunc->nPCodePos - 5 ); } else /* Check Global Statics. */ { @@ -1653,7 +1653,7 @@ static void hb_compOptimizeFrames( HB_COMP_DECL, PFUNCTION pFunc ) * make a room for HB_P_LARGE[V]FRAME */ hb_compGenPCode1( 0, HB_COMP_PARAM ); - memmove( pFunc->pCode + 4, pFunc->pCode + 3, pFunc->lPCodePos - 4 ); + memmove( pFunc->pCode + 4, pFunc->pCode + 3, pFunc->nPCodePos - 4 ); pFunc->pCode[ 0 ] = HB_P_LARGEFRAME; pFunc->pCode[ 1 ] = HB_LOBYTE( iLocals ); pFunc->pCode[ 2 ] = HB_HIBYTE( iLocals ); @@ -1678,13 +1678,13 @@ static void hb_compOptimizeFrames( HB_COMP_DECL, PFUNCTION pFunc ) { if( bSkipSFRAME ) { - pFunc->lPCodePos -= 6; - memmove( pFunc->pCode, pFunc->pCode + 6, pFunc->lPCodePos ); + pFunc->nPCodePos -= 6; + memmove( pFunc->pCode, pFunc->pCode + 6, pFunc->nPCodePos ); } else { - pFunc->lPCodePos -= 3; - memmove( pFunc->pCode, pFunc->pCode + 3, pFunc->lPCodePos ); + pFunc->nPCodePos -= 3; + memmove( pFunc->pCode, pFunc->pCode + 3, pFunc->nPCodePos ); } } else @@ -1694,9 +1694,9 @@ static void hb_compOptimizeFrames( HB_COMP_DECL, PFUNCTION pFunc ) if( bSkipSFRAME ) { - pFunc->lPCodePos -= 3; + pFunc->nPCodePos -= 3; memmove( pFunc->pCode + 3 + iOffset, pFunc->pCode + 6 + iOffset, - pFunc->lPCodePos - 3 - iOffset ); + pFunc->nPCodePos - 3 - iOffset ); } } } @@ -2250,7 +2250,7 @@ static void hb_compPrepareJumps( HB_COMP_DECL ) pFunc->pJumps = ( HB_SIZE * ) hb_xrealloc( pFunc->pJumps, sizeof( HB_SIZE ) * ( pFunc->iJumps + 1 ) ); else pFunc->pJumps = ( HB_SIZE * ) hb_xgrab( sizeof( HB_SIZE ) ); - pFunc->pJumps[ pFunc->iJumps++ ] = ( HB_SIZE ) ( pFunc->lPCodePos - 4 ); + pFunc->pJumps[ pFunc->iJumps++ ] = ( HB_SIZE ) ( pFunc->nPCodePos - 4 ); } HB_SIZE hb_compGenJump( HB_ISIZ nOffset, HB_COMP_DECL ) @@ -2261,7 +2261,7 @@ HB_SIZE hb_compGenJump( HB_ISIZ nOffset, HB_COMP_DECL ) hb_compGenPCode4( HB_P_JUMPFAR, HB_LOBYTE( nOffset ), HB_HIBYTE( nOffset ), ( HB_BYTE ) ( ( nOffset >> 16 ) & 0xFF ), HB_COMP_PARAM ); hb_compPrepareJumps( HB_COMP_PARAM ); - return HB_COMP_PARAM->functions.pLast->lPCodePos - 3; + return HB_COMP_PARAM->functions.pLast->nPCodePos - 3; } HB_SIZE hb_compGenJumpFalse( HB_ISIZ nOffset, HB_COMP_DECL ) @@ -2272,7 +2272,7 @@ HB_SIZE hb_compGenJumpFalse( HB_ISIZ nOffset, HB_COMP_DECL ) hb_compGenPCode4( HB_P_JUMPFALSEFAR, HB_LOBYTE( nOffset ), HB_HIBYTE( nOffset ), ( HB_BYTE ) ( ( nOffset >> 16 ) & 0xFF ), HB_COMP_PARAM ); hb_compPrepareJumps( HB_COMP_PARAM ); - return HB_COMP_PARAM->functions.pLast->lPCodePos - 3; + return HB_COMP_PARAM->functions.pLast->nPCodePos - 3; } HB_SIZE hb_compGenJumpTrue( HB_ISIZ nOffset, HB_COMP_DECL ) @@ -2283,7 +2283,7 @@ HB_SIZE hb_compGenJumpTrue( HB_ISIZ nOffset, HB_COMP_DECL ) hb_compGenPCode4( HB_P_JUMPTRUEFAR, HB_LOBYTE( nOffset ), HB_HIBYTE( nOffset ), ( HB_BYTE ) ( ( nOffset >> 16 ) & 0xFF ), HB_COMP_PARAM ); hb_compPrepareJumps( HB_COMP_PARAM ); - return HB_COMP_PARAM->functions.pLast->lPCodePos - 3; + return HB_COMP_PARAM->functions.pLast->nPCodePos - 3; } void hb_compGenJumpThere( HB_SIZE nFrom, HB_SIZE nTo, HB_COMP_DECL ) @@ -2301,7 +2301,7 @@ void hb_compGenJumpThere( HB_SIZE nFrom, HB_SIZE nTo, HB_COMP_DECL ) void hb_compGenJumpHere( HB_SIZE nOffset, HB_COMP_DECL ) { - hb_compGenJumpThere( nOffset, HB_COMP_PARAM->functions.pLast->lPCodePos, HB_COMP_PARAM ); + hb_compGenJumpThere( nOffset, HB_COMP_PARAM->functions.pLast->nPCodePos, HB_COMP_PARAM ); } void hb_compLinePush( HB_COMP_DECL ) /* generates the pcode with the currently compiled source code line */ @@ -2311,14 +2311,14 @@ void hb_compLinePush( HB_COMP_DECL ) /* generates the pcode with the currently c if( HB_COMP_PARAM->fDebugInfo && HB_COMP_PARAM->lastModule != HB_COMP_PARAM->currModule ) { if( HB_COMP_PARAM->functions.pLast->pCode[ HB_COMP_PARAM->lastLinePos ] == HB_P_LINE && - HB_COMP_PARAM->functions.pLast->lPCodePos - HB_COMP_PARAM->lastLinePos == 3 ) - HB_COMP_PARAM->functions.pLast->lPCodePos -= 3; + HB_COMP_PARAM->functions.pLast->nPCodePos - HB_COMP_PARAM->lastLinePos == 3 ) + HB_COMP_PARAM->functions.pLast->nPCodePos -= 3; hb_compGenModuleName( HB_COMP_PARAM, NULL ); } if( HB_COMP_PARAM->currLine != HB_COMP_PARAM->lastLine ) { - if( HB_COMP_PARAM->functions.pLast->lPCodePos - HB_COMP_PARAM->lastLinePos == 3 && + if( HB_COMP_PARAM->functions.pLast->nPCodePos - HB_COMP_PARAM->lastLinePos == 3 && HB_COMP_PARAM->functions.pLast->pCode[ HB_COMP_PARAM->lastLinePos ] == HB_P_LINE ) { HB_COMP_PARAM->functions.pLast->pCode[ HB_COMP_PARAM->lastLinePos + 1 ] = HB_LOBYTE( HB_COMP_PARAM->currLine ); @@ -2326,7 +2326,7 @@ void hb_compLinePush( HB_COMP_DECL ) /* generates the pcode with the currently c } else { - HB_COMP_PARAM->lastLinePos = HB_COMP_PARAM->functions.pLast->lPCodePos; + HB_COMP_PARAM->lastLinePos = HB_COMP_PARAM->functions.pLast->nPCodePos; hb_compGenPCode3( HB_P_LINE, HB_LOBYTE( HB_COMP_PARAM->currLine ), HB_HIBYTE( HB_COMP_PARAM->currLine ), HB_COMP_PARAM ); } @@ -3093,8 +3093,8 @@ static void hb_compRemovePCODE( HB_COMP_DECL, HB_SIZE nPos, HB_SIZE nCount, else { memmove( pFunc->pCode + nPos, pFunc->pCode + nPos + nCount, - pFunc->lPCodePos - nPos - nCount ); - pFunc->lPCodePos -= nCount; + pFunc->nPCodePos - nPos - nCount ); + pFunc->nPCodePos -= nCount; for( n = pFunc->iNOOPs; n; --n ) { @@ -3168,7 +3168,7 @@ HB_SIZE hb_compSequenceBegin( HB_COMP_DECL ) hb_compGenPCode4( HB_P_SEQBEGIN, 0, 0, 0, HB_COMP_PARAM ); hb_compPrepareJumps( HB_COMP_PARAM ); - return HB_COMP_PARAM->functions.pLast->lPCodePos - 3; + return HB_COMP_PARAM->functions.pLast->nPCodePos - 3; } /* Generate the opcode to close BEGIN/END sequence @@ -3184,7 +3184,7 @@ HB_SIZE hb_compSequenceEnd( HB_COMP_DECL ) hb_compPrepareJumps( HB_COMP_PARAM ); - return HB_COMP_PARAM->functions.pLast->lPCodePos - 3; + return HB_COMP_PARAM->functions.pLast->nPCodePos - 3; } HB_SIZE hb_compSequenceAlways( HB_COMP_DECL ) @@ -3193,7 +3193,7 @@ HB_SIZE hb_compSequenceAlways( HB_COMP_DECL ) hb_compPrepareJumps( HB_COMP_PARAM ); - return HB_COMP_PARAM->functions.pLast->lPCodePos - 3; + return HB_COMP_PARAM->functions.pLast->nPCodePos - 3; } /* Remove unnecessary opcodes in case there were no executable statements @@ -3211,7 +3211,7 @@ void hb_compSequenceFinish( HB_COMP_DECL, HB_SIZE nStartPos, HB_SIZE nEndPos, if( nAlways ) { /* remove HB_P_ALWAYSEND opcode */ - HB_COMP_PARAM->functions.pLast->lPCodePos--; + HB_COMP_PARAM->functions.pLast->nPCodePos--; /* remove HB_P_SEQALWAYS ... HB_P_ALWAYSBEGIN opcodes */ hb_compRemovePCODE( HB_COMP_PARAM, nStartPos, nAlways - nStartPos + 4, fCanMove ); @@ -3219,7 +3219,7 @@ void hb_compSequenceFinish( HB_COMP_DECL, HB_SIZE nStartPos, HB_SIZE nEndPos, else { hb_compRemovePCODE( HB_COMP_PARAM, nStartPos, - HB_COMP_PARAM->functions.pLast->lPCodePos - + HB_COMP_PARAM->functions.pLast->nPCodePos - nStartPos, fCanMove ); } HB_COMP_PARAM->lastLinePos = nStartPos - 3; @@ -3244,7 +3244,7 @@ void hb_compSequenceFinish( HB_COMP_DECL, HB_SIZE nStartPos, HB_SIZE nEndPos, } } /* empty always block? */ - if( HB_COMP_PARAM->functions.pLast->lPCodePos - nAlways == 5 && + if( HB_COMP_PARAM->functions.pLast->nPCodePos - nAlways == 5 && !HB_COMP_PARAM->fDebugInfo ) { /* remove HB_P_ALWAYSBEGIN and HB_P_ALWAYSEND opcodes */ @@ -3519,7 +3519,7 @@ void hb_compCodeBlockEnd( HB_COMP_DECL ) } wLocalsCnt = wLocals; - nSize = pCodeblock->lPCodePos + 2; + nSize = pCodeblock->nPCodePos + 2; if( HB_COMP_PARAM->fDebugInfo ) { nSize += 3 + strlen( HB_COMP_PARAM->currModule ) + strlen( pFuncName ); @@ -3577,7 +3577,7 @@ void hb_compCodeBlockEnd( HB_COMP_DECL ) } - hb_compGenPCodeN( pCodeblock->pCode, pCodeblock->lPCodePos, HB_COMP_PARAM ); + hb_compGenPCodeN( pCodeblock->pCode, pCodeblock->nPCodePos, HB_COMP_PARAM ); if( HB_COMP_PARAM->iWarnings ) { @@ -3631,7 +3631,7 @@ void hb_compCodeBlockStop( HB_COMP_DECL ) * codeblock was defined */ HB_COMP_PARAM->functions.pLast = pCodeblock->pOwner; - hb_compGenPCodeN( pCodeblock->pCode, pCodeblock->lPCodePos, HB_COMP_PARAM ); + hb_compGenPCodeN( pCodeblock->pCode, pCodeblock->nPCodePos, HB_COMP_PARAM ); if( HB_COMP_PARAM->iWarnings ) { @@ -3656,7 +3656,7 @@ void hb_compCodeBlockRewind( HB_COMP_DECL ) PFUNCTION pCodeblock; /* pointer to the current codeblock */ pCodeblock = HB_COMP_PARAM->functions.pLast; - pCodeblock->lPCodePos = 0; + pCodeblock->nPCodePos = 0; /* Release the NOOP array. */ if( pCodeblock->pNOOPs ) diff --git a/harbour/src/compiler/hbopt.c b/harbour/src/compiler/hbopt.c index 253abc63c3..b00c7f27de 100644 --- a/harbour/src/compiler/hbopt.c +++ b/harbour/src/compiler/hbopt.c @@ -61,15 +61,15 @@ typedef HB_OPT_FUNC_ * HB_OPT_FUNC_PTR; static HB_OPT_FUNC( hb_p_poplocal ) { - HB_BYTE * pVar = &pFunc->pCode[ lPCodePos + 1 ]; + HB_BYTE * pVar = &pFunc->pCode[ nPCodePos + 1 ]; HB_SHORT iVar = HB_PCODE_MKSHORT( pVar ); HB_SYMBOL_UNUSED( cargo ); if( HB_LIM_INT8( iVar ) ) { - pFunc->pCode[ lPCodePos ] = HB_P_POPLOCALNEAR; - hb_compNOOPfill( pFunc, lPCodePos + 2, 1, HB_FALSE, HB_FALSE ); + pFunc->pCode[ nPCodePos ] = HB_P_POPLOCALNEAR; + hb_compNOOPfill( pFunc, nPCodePos + 2, 1, HB_FALSE, HB_FALSE ); } return 3; @@ -77,32 +77,32 @@ static HB_OPT_FUNC( hb_p_poplocal ) static HB_OPT_FUNC( hb_p_pushlocal ) { - HB_BYTE * pVar = &pFunc->pCode[ lPCodePos + 1 ]; + HB_BYTE * pVar = &pFunc->pCode[ nPCodePos + 1 ]; HB_SHORT iVar = HB_PCODE_MKSHORT( pVar ); HB_SYMBOL_UNUSED( cargo ); - if( pFunc->pCode[ lPCodePos + 3 ] == HB_P_POPLOCAL && - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 4 ] ) == iVar && - ! hb_compHasJump( pFunc, lPCodePos + 3 ) ) + if( pFunc->pCode[ nPCodePos + 3 ] == HB_P_POPLOCAL && + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 4 ] ) == iVar && + ! hb_compHasJump( pFunc, nPCodePos + 3 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 6, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 6, HB_FALSE, HB_FALSE ); } - else if( pFunc->pCode[ lPCodePos + 3 ] == HB_P_POPLOCALNEAR && - ( HB_SCHAR ) pFunc->pCode[ lPCodePos + 4 ] == iVar && - ! hb_compHasJump( pFunc, lPCodePos + 3 ) ) + else if( pFunc->pCode[ nPCodePos + 3 ] == HB_P_POPLOCALNEAR && + ( HB_SCHAR ) pFunc->pCode[ nPCodePos + 4 ] == iVar && + ! hb_compHasJump( pFunc, nPCodePos + 3 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 5, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 5, HB_FALSE, HB_FALSE ); } - else if( pFunc->pCode[ lPCodePos + 3 ] == HB_P_POP && - ! hb_compHasJump( pFunc, lPCodePos + 3 ) ) + else if( pFunc->pCode[ nPCodePos + 3 ] == HB_P_POP && + ! hb_compHasJump( pFunc, nPCodePos + 3 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 4, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 4, HB_FALSE, HB_FALSE ); } else if( HB_LIM_INT8( iVar ) ) { - pFunc->pCode[ lPCodePos ] = HB_P_PUSHLOCALNEAR; - hb_compNOOPfill( pFunc, lPCodePos + 2, 1, HB_FALSE, HB_FALSE ); + pFunc->pCode[ nPCodePos ] = HB_P_PUSHLOCALNEAR; + hb_compNOOPfill( pFunc, nPCodePos + 2, 1, HB_FALSE, HB_FALSE ); } return 3; @@ -112,23 +112,23 @@ static HB_OPT_FUNC( hb_p_pushlocalnear ) { HB_SYMBOL_UNUSED( cargo ); - if( pFunc->pCode[ lPCodePos + 2 ] == HB_P_POPLOCAL && - ( HB_SCHAR ) pFunc->pCode[ lPCodePos + 1 ] == - HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 3 ] ) && - ! hb_compHasJump( pFunc, lPCodePos + 2 ) ) + if( pFunc->pCode[ nPCodePos + 2 ] == HB_P_POPLOCAL && + ( HB_SCHAR ) pFunc->pCode[ nPCodePos + 1 ] == + HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 3 ] ) && + ! hb_compHasJump( pFunc, nPCodePos + 2 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 5, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 5, HB_FALSE, HB_FALSE ); } - else if( pFunc->pCode[ lPCodePos + 2 ] == HB_P_POPLOCALNEAR && - pFunc->pCode[ lPCodePos + 1 ] == pFunc->pCode[ lPCodePos + 3 ] && - ! hb_compHasJump( pFunc, lPCodePos + 2 ) ) + else if( pFunc->pCode[ nPCodePos + 2 ] == HB_P_POPLOCALNEAR && + pFunc->pCode[ nPCodePos + 1 ] == pFunc->pCode[ nPCodePos + 3 ] && + ! hb_compHasJump( pFunc, nPCodePos + 2 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 4, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 4, HB_FALSE, HB_FALSE ); } - else if( pFunc->pCode[ lPCodePos + 2 ] == HB_P_POP && - ! hb_compHasJump( pFunc, lPCodePos + 2 ) ) + else if( pFunc->pCode[ nPCodePos + 2 ] == HB_P_POP && + ! hb_compHasJump( pFunc, nPCodePos + 2 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 3, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 3, HB_FALSE, HB_FALSE ); } return 2; @@ -136,7 +136,7 @@ static HB_OPT_FUNC( hb_p_pushlocalnear ) static HB_OPT_FUNC( hb_p_localaddint ) { - HB_BYTE * pVar = &pFunc->pCode[ lPCodePos + 1 ]; + HB_BYTE * pVar = &pFunc->pCode[ nPCodePos + 1 ]; HB_SHORT iVar = HB_PCODE_MKSHORT( pVar ); HB_SYMBOL_UNUSED( cargo ); @@ -145,7 +145,7 @@ static HB_OPT_FUNC( hb_p_localaddint ) { pVar[ 0 ] = HB_P_LOCALNEARADDINT; pVar[ 1 ] = HB_LOBYTE( iVar ); - hb_compNOOPfill( pFunc, lPCodePos, 1, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 1, HB_FALSE, HB_FALSE ); } return 5; @@ -155,17 +155,17 @@ static HB_OPT_FUNC( hb_p_pushstatic ) { HB_SYMBOL_UNUSED( cargo ); - if( pFunc->pCode[ lPCodePos + 3 ] == HB_P_POPSTATIC && - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) == - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 4 ] ) && - ! hb_compHasJump( pFunc, lPCodePos + 3 ) ) + if( pFunc->pCode[ nPCodePos + 3 ] == HB_P_POPSTATIC && + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) == + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 4 ] ) && + ! hb_compHasJump( pFunc, nPCodePos + 3 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 6, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 6, HB_FALSE, HB_FALSE ); } - else if( pFunc->pCode[ lPCodePos + 3 ] == HB_P_POP && - ! hb_compHasJump( pFunc, lPCodePos + 3 ) ) + else if( pFunc->pCode[ nPCodePos + 3 ] == HB_P_POP && + ! hb_compHasJump( pFunc, nPCodePos + 3 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 4, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 4, HB_FALSE, HB_FALSE ); } return 3; @@ -175,17 +175,17 @@ static HB_OPT_FUNC( hb_p_pushmemvar ) { HB_SYMBOL_UNUSED( cargo ); - if( pFunc->pCode[ lPCodePos + 3 ] == HB_P_POPMEMVAR && - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) == - HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 4 ] ) && - ! hb_compHasJump( pFunc, lPCodePos + 3 ) ) + if( pFunc->pCode[ nPCodePos + 3 ] == HB_P_POPMEMVAR && + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) == + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 4 ] ) && + ! hb_compHasJump( pFunc, nPCodePos + 3 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 6, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 6, HB_FALSE, HB_FALSE ); } - else if( pFunc->pCode[ lPCodePos + 3 ] == HB_P_POP && - ! hb_compHasJump( pFunc, lPCodePos + 3 ) ) + else if( pFunc->pCode[ nPCodePos + 3 ] == HB_P_POP && + ! hb_compHasJump( pFunc, nPCodePos + 3 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 4, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 4, HB_FALSE, HB_FALSE ); } return 3; @@ -195,10 +195,10 @@ static HB_OPT_FUNC( hb_p_pushnil ) { HB_SYMBOL_UNUSED( cargo ); - if( pFunc->pCode[ lPCodePos + 1 ] == HB_P_POP && - ! hb_compHasJump( pFunc, lPCodePos + 1 ) ) + if( pFunc->pCode[ nPCodePos + 1 ] == HB_P_POP && + ! hb_compHasJump( pFunc, nPCodePos + 1 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 2, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 2, HB_FALSE, HB_FALSE ); } return 1; @@ -208,7 +208,7 @@ static HB_OPT_FUNC( hb_p_false ) { HB_SYMBOL_UNUSED( cargo ); - switch( pFunc->pCode[ lPCodePos + 1 ] ) + switch( pFunc->pCode[ nPCodePos + 1 ] ) { case HB_P_POP: case HB_P_NOT: @@ -218,23 +218,23 @@ static HB_OPT_FUNC( hb_p_false ) case HB_P_JUMPTRUENEAR: case HB_P_JUMPTRUE: case HB_P_JUMPTRUEFAR: - if( ! hb_compHasJump( pFunc, lPCodePos + 1 ) ) + if( ! hb_compHasJump( pFunc, nPCodePos + 1 ) ) { int iCount = 1; - switch( pFunc->pCode[ lPCodePos + 1 ] ) + switch( pFunc->pCode[ nPCodePos + 1 ] ) { case HB_P_JUMPFALSENEAR: - pFunc->pCode[ lPCodePos + 1 ] = HB_P_JUMPNEAR; + pFunc->pCode[ nPCodePos + 1 ] = HB_P_JUMPNEAR; break; case HB_P_JUMPFALSE: - pFunc->pCode[ lPCodePos + 1 ] = HB_P_JUMP; + pFunc->pCode[ nPCodePos + 1 ] = HB_P_JUMP; break; case HB_P_JUMPFALSEFAR: - pFunc->pCode[ lPCodePos + 1 ] = HB_P_JUMPFAR; + pFunc->pCode[ nPCodePos + 1 ] = HB_P_JUMPFAR; break; case HB_P_NOT: - pFunc->pCode[ lPCodePos + 1 ] = HB_P_TRUE; + pFunc->pCode[ nPCodePos + 1 ] = HB_P_TRUE; break; case HB_P_POP: iCount = 2; @@ -249,7 +249,7 @@ static HB_OPT_FUNC( hb_p_false ) iCount = 5; break; } - hb_compNOOPfill( pFunc, lPCodePos, iCount, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, iCount, HB_FALSE, HB_FALSE ); } break; } @@ -260,7 +260,7 @@ static HB_OPT_FUNC( hb_p_true ) { HB_SYMBOL_UNUSED( cargo ); - switch( pFunc->pCode[ lPCodePos + 1 ] ) + switch( pFunc->pCode[ nPCodePos + 1 ] ) { case HB_P_POP: case HB_P_NOT: @@ -270,23 +270,23 @@ static HB_OPT_FUNC( hb_p_true ) case HB_P_JUMPFALSENEAR: case HB_P_JUMPFALSE: case HB_P_JUMPFALSEFAR: - if( ! hb_compHasJump( pFunc, lPCodePos + 1 ) ) + if( ! hb_compHasJump( pFunc, nPCodePos + 1 ) ) { int iCount = 1; - switch( pFunc->pCode[ lPCodePos + 1 ] ) + switch( pFunc->pCode[ nPCodePos + 1 ] ) { case HB_P_JUMPTRUENEAR: - pFunc->pCode[ lPCodePos + 1 ] = HB_P_JUMPNEAR; + pFunc->pCode[ nPCodePos + 1 ] = HB_P_JUMPNEAR; break; case HB_P_JUMPTRUE: - pFunc->pCode[ lPCodePos + 1 ] = HB_P_JUMP; + pFunc->pCode[ nPCodePos + 1 ] = HB_P_JUMP; break; case HB_P_JUMPTRUEFAR: - pFunc->pCode[ lPCodePos + 1 ] = HB_P_JUMPFAR; + pFunc->pCode[ nPCodePos + 1 ] = HB_P_JUMPFAR; break; case HB_P_NOT: - pFunc->pCode[ lPCodePos + 1 ] = HB_P_FALSE; + pFunc->pCode[ nPCodePos + 1 ] = HB_P_FALSE; break; case HB_P_POP: iCount = 2; @@ -301,7 +301,7 @@ static HB_OPT_FUNC( hb_p_true ) iCount = 5; break; } - hb_compNOOPfill( pFunc, lPCodePos, iCount, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, iCount, HB_FALSE, HB_FALSE ); } break; } @@ -312,15 +312,15 @@ static HB_OPT_FUNC( hb_p_duplicate ) { HB_SYMBOL_UNUSED( cargo ); - switch( pFunc->pCode[ lPCodePos + 1 ] ) + switch( pFunc->pCode[ nPCodePos + 1 ] ) { case HB_P_JUMPTRUEFAR: case HB_P_JUMPFALSEFAR: - if( pFunc->pCode[ lPCodePos + 5 ] == HB_P_POP ) + if( pFunc->pCode[ nPCodePos + 5 ] == HB_P_POP ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 2 ]; + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 2 ]; HB_ISIZ nOffset = HB_PCODE_MKINT24( pAddr ), nLastOffset = 0; - HB_SIZE nNewPos = lPCodePos + 1 + nOffset; + HB_SIZE nNewPos = nPCodePos + 1 + nOffset; HB_BOOL fNot = HB_FALSE, fOK = HB_TRUE, fRepeat = HB_TRUE; do @@ -348,11 +348,11 @@ static HB_OPT_FUNC( hb_p_duplicate ) pFunc->pCode[ nNewPos + 1 ] == HB_P_JUMPFALSEFAR ) ) { HB_ISIZ nJump; - if( pFunc->pCode[ nNewPos + 1 ] != pFunc->pCode[ lPCodePos + 1 ] ) + if( pFunc->pCode[ nNewPos + 1 ] != pFunc->pCode[ nPCodePos + 1 ] ) fNot = !fNot; nJump = fNot ? 4 : HB_PCODE_MKINT24( &pFunc->pCode[ nNewPos + 2 ] ); nOffset += nJump + 1; - nNewPos = lPCodePos + 1 + nOffset; + nNewPos = nPCodePos + 1 + nOffset; fRepeat = nJump > 0; } else @@ -369,10 +369,10 @@ static HB_OPT_FUNC( hb_p_duplicate ) if( ( pFunc->pCode[ nNewPos ] == HB_P_JUMPTRUEFAR || pFunc->pCode[ nNewPos ] == HB_P_JUMPFALSEFAR ) && - !hb_compHasJump( pFunc, lPCodePos + 1 ) && - !hb_compHasJump( pFunc, lPCodePos + 5 ) ) + !hb_compHasJump( pFunc, nPCodePos + 1 ) && + !hb_compHasJump( pFunc, nPCodePos + 5 ) ) { - if( pFunc->pCode[ nNewPos ] != pFunc->pCode[ lPCodePos + 1 ] ) + if( pFunc->pCode[ nNewPos ] != pFunc->pCode[ nPCodePos + 1 ] ) fNot = !fNot; if( fNot ) nOffset += 4; @@ -380,8 +380,8 @@ static HB_OPT_FUNC( hb_p_duplicate ) nOffset += HB_PCODE_MKINT24( &pFunc->pCode[ nNewPos + 1 ] ); HB_PUT_LE_UINT24( pAddr, nOffset ); - hb_compNOOPfill( pFunc, lPCodePos, 1, HB_FALSE, HB_FALSE ); - hb_compNOOPfill( pFunc, lPCodePos + 5, 1, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 1, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos + 5, 1, HB_FALSE, HB_FALSE ); } else if( nLastOffset ) { @@ -399,7 +399,7 @@ static HB_OPT_FUNC( hb_p_not ) HB_SYMBOL_UNUSED( cargo ); - switch( pFunc->pCode[ lPCodePos + 1 ] ) + switch( pFunc->pCode[ nPCodePos + 1 ] ) { case HB_P_NOT: opcode = HB_P_NOOP; @@ -425,30 +425,30 @@ static HB_OPT_FUNC( hb_p_not ) /* This optimization will be enabled in the future in a little bit differ form */ #if 0 case HB_P_DUPLICATE: - if( ( pFunc->pCode[ lPCodePos + 2 ] == HB_P_JUMPTRUEFAR || - pFunc->pCode[ lPCodePos + 2 ] == HB_P_JUMPFALSEFAR ) && - pFunc->pCode[ lPCodePos + 6 ] == HB_P_POP ) + if( ( pFunc->pCode[ nPCodePos + 2 ] == HB_P_JUMPTRUEFAR || + pFunc->pCode[ nPCodePos + 2 ] == HB_P_JUMPFALSEFAR ) && + pFunc->pCode[ nPCodePos + 6 ] == HB_P_POP ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 3 ]; + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 3 ]; HB_ISIZ nOffset = HB_PCODE_MKINT24( pAddr ); if( nOffset > 0 ) { - hb_p_duplicate( pFunc, lPCodePos + 1, NULL ); + hb_p_duplicate( pFunc, nPCodePos + 1, NULL ); nOffset = HB_PCODE_MKINT24( pAddr ); } - if( ( pFunc->pCode[ lPCodePos + 1 ] == HB_P_NOT || - ( pFunc->pCode[ lPCodePos + 1 ] == HB_P_DUPLICATE && - pFunc->pCode[ lPCodePos + nOffset + 2 ] == HB_P_NOT ) ) && - ! hb_compHasJump( pFunc, lPCodePos + 1 ) ) + if( ( pFunc->pCode[ nPCodePos + 1 ] == HB_P_NOT || + ( pFunc->pCode[ nPCodePos + 1 ] == HB_P_DUPLICATE && + pFunc->pCode[ nPCodePos + nOffset + 2 ] == HB_P_NOT ) ) && + ! hb_compHasJump( pFunc, nPCodePos + 1 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 1, HB_FALSE, HB_FALSE ); - if( pFunc->pCode[ lPCodePos + 2 ] == HB_P_JUMPTRUEFAR ) - pFunc->pCode[ lPCodePos + 2 ] = HB_P_JUMPFALSEFAR; + hb_compNOOPfill( pFunc, nPCodePos, 1, HB_FALSE, HB_FALSE ); + if( pFunc->pCode[ nPCodePos + 2 ] == HB_P_JUMPTRUEFAR ) + pFunc->pCode[ nPCodePos + 2 ] = HB_P_JUMPFALSEFAR; else - pFunc->pCode[ lPCodePos + 2 ] = HB_P_JUMPTRUEFAR; - if( pFunc->pCode[ lPCodePos + 1 ] == HB_P_DUPLICATE ) + pFunc->pCode[ nPCodePos + 2 ] = HB_P_JUMPTRUEFAR; + if( pFunc->pCode[ nPCodePos + 1 ] == HB_P_DUPLICATE ) { ++nOffset; HB_PUT_LE_UINT24( pAddr, nOffset ); @@ -463,29 +463,29 @@ static HB_OPT_FUNC( hb_p_not ) } if( opcode < HB_P_LAST_PCODE && - ! hb_compHasJump( pFunc, lPCodePos + 1 ) ) + ! hb_compHasJump( pFunc, nPCodePos + 1 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 1, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 1, HB_FALSE, HB_FALSE ); if( opcode == HB_P_NOOP ) - hb_compNOOPfill( pFunc, lPCodePos + 1, 1, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos + 1, 1, HB_FALSE, HB_FALSE ); else - pFunc->pCode[ lPCodePos + 1 ] = opcode; + pFunc->pCode[ nPCodePos + 1 ] = opcode; } return 1; } static HB_OPT_FUNC( hb_p_jumpfar ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; HB_ISIZ nOffset = HB_PCODE_MKINT24( pAddr ); - HB_SIZE nNewPos = lPCodePos + nOffset; + HB_SIZE nNewPos = nPCodePos + nOffset; HB_BOOL fLine = HB_FALSE; HB_SYMBOL_UNUSED( cargo ); if( nOffset == 4 ) { - hb_compNOOPfill( pFunc, lPCodePos, 4, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 4, HB_FALSE, HB_FALSE ); } else { @@ -499,28 +499,28 @@ static HB_OPT_FUNC( hb_p_jumpfar ) { case HB_P_JUMPFAR: nOffset += HB_PCODE_MKINT24( &pFunc->pCode[ nNewPos + 1 ] ); - if( !fLine || pFunc->pCode[ lPCodePos + nOffset ] == HB_P_LINE ) + if( !fLine || pFunc->pCode[ nPCodePos + nOffset ] == HB_P_LINE ) HB_PUT_LE_UINT24( pAddr, nOffset ); break; case HB_P_JUMPFALSEFAR: nNewPos += HB_PCODE_MKINT24( &pFunc->pCode[ nNewPos + 1 ] ); - if( nNewPos == lPCodePos + 4 && ( !fLine || + if( nNewPos == nPCodePos + 4 && ( !fLine || ( pFunc->pCode[ nNewPos ] == HB_P_LINE && - pFunc->pCode[ lPCodePos + nOffset + 4 ] == HB_P_LINE ) ) ) + pFunc->pCode[ nPCodePos + nOffset + 4 ] == HB_P_LINE ) ) ) { - pFunc->pCode[ lPCodePos ] = HB_P_JUMPTRUEFAR; + pFunc->pCode[ nPCodePos ] = HB_P_JUMPTRUEFAR; HB_PUT_LE_UINT24( pAddr, nOffset + 4 ); } break; case HB_P_JUMPTRUEFAR: nNewPos += HB_PCODE_MKINT24( &pFunc->pCode[ nNewPos + 1 ] ); - if( nNewPos == lPCodePos + 4 && ( !fLine || + if( nNewPos == nPCodePos + 4 && ( !fLine || ( pFunc->pCode[ nNewPos ] == HB_P_LINE && - pFunc->pCode[ lPCodePos + nOffset + 4 ] == HB_P_LINE ) ) ) + pFunc->pCode[ nPCodePos + nOffset + 4 ] == HB_P_LINE ) ) ) { - pFunc->pCode[ lPCodePos ] = HB_P_JUMPFALSEFAR; + pFunc->pCode[ nPCodePos ] = HB_P_JUMPFALSEFAR; HB_PUT_LE_UINT24( pAddr, nOffset + 4 ); } break; @@ -531,29 +531,29 @@ static HB_OPT_FUNC( hb_p_jumpfar ) static HB_OPT_FUNC( hb_p_jumpfalsefar ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; HB_ISIZ nOffset = HB_PCODE_MKINT24( pAddr ); - HB_SIZE nNewPos = lPCodePos + nOffset; + HB_SIZE nNewPos = nPCodePos + nOffset; HB_BOOL fLine = HB_FALSE; HB_SYMBOL_UNUSED( cargo ); - if( nOffset == 8 && pFunc->pCode[ lPCodePos + 4 ] == HB_P_JUMPFAR && - ! hb_compHasJump( pFunc, lPCodePos + 4 ) ) + if( nOffset == 8 && pFunc->pCode[ nPCodePos + 4 ] == HB_P_JUMPFAR && + ! hb_compHasJump( pFunc, nPCodePos + 4 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 4, HB_FALSE, HB_FALSE ); - pFunc->pCode[ lPCodePos + 4 ] = HB_P_JUMPTRUEFAR; + hb_compNOOPfill( pFunc, nPCodePos, 4, HB_FALSE, HB_FALSE ); + pFunc->pCode[ nPCodePos + 4 ] = HB_P_JUMPTRUEFAR; } - else if( nOffset == 11 && pFunc->pCode[ lPCodePos + 4 ] == HB_P_LINE && - pFunc->pCode[ lPCodePos + 11 ] == HB_P_LINE && - pFunc->pCode[ lPCodePos + 7 ] == HB_P_JUMPFAR && - pFunc->pCode[ lPCodePos + 7 + - HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 8 ] ) ] == HB_P_LINE && - ! hb_compHasJump( pFunc, lPCodePos + 4 ) && - ! hb_compHasJump( pFunc, lPCodePos + 7 ) ) + else if( nOffset == 11 && pFunc->pCode[ nPCodePos + 4 ] == HB_P_LINE && + pFunc->pCode[ nPCodePos + 11 ] == HB_P_LINE && + pFunc->pCode[ nPCodePos + 7 ] == HB_P_JUMPFAR && + pFunc->pCode[ nPCodePos + 7 + + HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 8 ] ) ] == HB_P_LINE && + ! hb_compHasJump( pFunc, nPCodePos + 4 ) && + ! hb_compHasJump( pFunc, nPCodePos + 7 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 7, HB_FALSE, HB_FALSE ); - pFunc->pCode[ lPCodePos + 7 ] = HB_P_JUMPTRUEFAR; + hb_compNOOPfill( pFunc, nPCodePos, 7, HB_FALSE, HB_FALSE ); + pFunc->pCode[ nPCodePos + 7 ] = HB_P_JUMPTRUEFAR; } else { @@ -566,7 +566,7 @@ static HB_OPT_FUNC( hb_p_jumpfalsefar ) if( pFunc->pCode[ nNewPos ] == HB_P_JUMPFAR ) { nOffset += HB_PCODE_MKINT24( &pFunc->pCode[ nNewPos + 1 ] ); - if( !fLine || pFunc->pCode[ lPCodePos + nOffset ] == HB_P_LINE ) + if( !fLine || pFunc->pCode[ nPCodePos + nOffset ] == HB_P_LINE ) HB_PUT_LE_UINT24( pAddr, nOffset ); } } @@ -575,29 +575,29 @@ static HB_OPT_FUNC( hb_p_jumpfalsefar ) static HB_OPT_FUNC( hb_p_jumptruefar ) { - HB_BYTE * pAddr = &pFunc->pCode[ lPCodePos + 1 ]; + HB_BYTE * pAddr = &pFunc->pCode[ nPCodePos + 1 ]; HB_ISIZ nOffset = HB_PCODE_MKINT24( pAddr ); - HB_SIZE nNewPos = lPCodePos + nOffset; + HB_SIZE nNewPos = nPCodePos + nOffset; HB_BOOL fLine = HB_FALSE; HB_SYMBOL_UNUSED( cargo ); - if( nOffset == 8 && pFunc->pCode[ lPCodePos + 4 ] == HB_P_JUMPFAR && - ! hb_compHasJump( pFunc, lPCodePos + 4 ) ) + if( nOffset == 8 && pFunc->pCode[ nPCodePos + 4 ] == HB_P_JUMPFAR && + ! hb_compHasJump( pFunc, nPCodePos + 4 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 4, HB_FALSE, HB_FALSE ); - pFunc->pCode[ lPCodePos + 4 ] = HB_P_JUMPFALSEFAR; + hb_compNOOPfill( pFunc, nPCodePos, 4, HB_FALSE, HB_FALSE ); + pFunc->pCode[ nPCodePos + 4 ] = HB_P_JUMPFALSEFAR; } - else if( nOffset == 11 && pFunc->pCode[ lPCodePos + 4 ] == HB_P_LINE && - pFunc->pCode[ lPCodePos + 11 ] == HB_P_LINE && - pFunc->pCode[ lPCodePos + 7 ] == HB_P_JUMPFAR && - pFunc->pCode[ lPCodePos + 7 + - HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 8 ] ) ] == HB_P_LINE && - ! hb_compHasJump( pFunc, lPCodePos + 4 ) && - ! hb_compHasJump( pFunc, lPCodePos + 7 ) ) + else if( nOffset == 11 && pFunc->pCode[ nPCodePos + 4 ] == HB_P_LINE && + pFunc->pCode[ nPCodePos + 11 ] == HB_P_LINE && + pFunc->pCode[ nPCodePos + 7 ] == HB_P_JUMPFAR && + pFunc->pCode[ nPCodePos + 7 + + HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 8 ] ) ] == HB_P_LINE && + ! hb_compHasJump( pFunc, nPCodePos + 4 ) && + ! hb_compHasJump( pFunc, nPCodePos + 7 ) ) { - hb_compNOOPfill( pFunc, lPCodePos, 7, HB_FALSE, HB_FALSE ); - pFunc->pCode[ lPCodePos + 7 ] = HB_P_JUMPFALSEFAR; + hb_compNOOPfill( pFunc, nPCodePos, 7, HB_FALSE, HB_FALSE ); + pFunc->pCode[ nPCodePos + 7 ] = HB_P_JUMPFALSEFAR; } else { @@ -610,7 +610,7 @@ static HB_OPT_FUNC( hb_p_jumptruefar ) if( pFunc->pCode[ nNewPos ] == HB_P_JUMPFAR ) { nOffset += HB_PCODE_MKINT24( &pFunc->pCode[ nNewPos + 1 ] ); - if( !fLine || pFunc->pCode[ lPCodePos + nOffset ] == HB_P_LINE ) + if( !fLine || pFunc->pCode[ nPCodePos + nOffset ] == HB_P_LINE ) HB_PUT_LE_UINT24( pAddr, nOffset ); } } @@ -619,71 +619,71 @@ static HB_OPT_FUNC( hb_p_jumptruefar ) static HB_OPT_FUNC( hb_p_switch ) { - HB_USHORT usCases = HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ), us; - HB_SIZE nStart = lPCodePos; + HB_USHORT usCases = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), us; + HB_SIZE nStart = nPCodePos; HB_SYMBOL_UNUSED( cargo ); - lPCodePos += 3; + nPCodePos += 3; for( us = 0; us < usCases; ++us ) { - switch( pFunc->pCode[ lPCodePos ] ) + switch( pFunc->pCode[ nPCodePos ] ) { case HB_P_PUSHBYTE: - lPCodePos += 2; + nPCodePos += 2; break; case HB_P_PUSHINT: - lPCodePos += 3; + nPCodePos += 3; break; case HB_P_PUSHLONG: case HB_P_PUSHDATE: - lPCodePos += 5; + nPCodePos += 5; break; case HB_P_PUSHLONGLONG: - lPCodePos += 9; + nPCodePos += 9; break; case HB_P_PUSHSTRSHORT: - lPCodePos += 2 + pFunc->pCode[ lPCodePos + 1 ]; + nPCodePos += 2 + pFunc->pCode[ nPCodePos + 1 ]; break; case HB_P_PUSHSTR: - lPCodePos += 3 + HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); + nPCodePos += 3 + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); break; case HB_P_PUSHSTRLARGE: - lPCodePos += 4 + HB_PCODE_MKUINT24( &pFunc->pCode[ lPCodePos + 1 ] ); + nPCodePos += 4 + HB_PCODE_MKUINT24( &pFunc->pCode[ nPCodePos + 1 ] ); break; case HB_P_PUSHNIL: /* default clause */ us = usCases; - lPCodePos++; + nPCodePos++; break; } - switch( pFunc->pCode[ lPCodePos ] ) + switch( pFunc->pCode[ nPCodePos ] ) { case HB_P_JUMPNEAR: - lPCodePos += 2; + nPCodePos += 2; break; case HB_P_JUMP: - lPCodePos += 3; + nPCodePos += 3; break; /*case HB_P_JUMPFAR:*/ default: - lPCodePos += 4; + nPCodePos += 4; break; } } - return lPCodePos - nStart; + return nPCodePos - nStart; } static HB_OPT_FUNC( hb_p_function ) { HB_SYMBOL_UNUSED( cargo ); - if( pFunc->pCode[ lPCodePos + 3 ] == HB_P_RETVALUE && - ! hb_compHasJump( pFunc, lPCodePos + 3 ) ) + if( pFunc->pCode[ nPCodePos + 3 ] == HB_P_RETVALUE && + ! hb_compHasJump( pFunc, nPCodePos + 3 ) ) { - pFunc->pCode[ lPCodePos ] = HB_P_DO; - hb_compNOOPfill( pFunc, lPCodePos + 3, 1, HB_FALSE, HB_FALSE ); + pFunc->pCode[ nPCodePos ] = HB_P_DO; + hb_compNOOPfill( pFunc, nPCodePos + 3, 1, HB_FALSE, HB_FALSE ); } return 3; } @@ -692,11 +692,11 @@ static HB_OPT_FUNC( hb_p_functionshort ) { HB_SYMBOL_UNUSED( cargo ); - if( pFunc->pCode[ lPCodePos + 2 ] == HB_P_RETVALUE && - ! hb_compHasJump( pFunc, lPCodePos + 2 ) ) + if( pFunc->pCode[ nPCodePos + 2 ] == HB_P_RETVALUE && + ! hb_compHasJump( pFunc, nPCodePos + 2 ) ) { - pFunc->pCode[ lPCodePos ] = HB_P_DOSHORT; - hb_compNOOPfill( pFunc, lPCodePos + 2, 1, HB_FALSE, HB_FALSE ); + pFunc->pCode[ nPCodePos ] = HB_P_DOSHORT; + hb_compNOOPfill( pFunc, nPCodePos + 2, 1, HB_FALSE, HB_FALSE ); } return 2; } @@ -705,11 +705,11 @@ static HB_OPT_FUNC( hb_p_macrofunc ) { HB_SYMBOL_UNUSED( cargo ); - if( pFunc->pCode[ lPCodePos + 3 ] == HB_P_RETVALUE && - ! hb_compHasJump( pFunc, lPCodePos + 3 ) ) + if( pFunc->pCode[ nPCodePos + 3 ] == HB_P_RETVALUE && + ! hb_compHasJump( pFunc, nPCodePos + 3 ) ) { - pFunc->pCode[ lPCodePos ] = HB_P_MACRODO; - hb_compNOOPfill( pFunc, lPCodePos + 3, 1, HB_FALSE, HB_FALSE ); + pFunc->pCode[ nPCodePos ] = HB_P_MACRODO; + hb_compNOOPfill( pFunc, nPCodePos + 3, 1, HB_FALSE, HB_FALSE ); } return 3; } @@ -718,10 +718,10 @@ static HB_OPT_FUNC( hb_p_endblock ) { HB_SYMBOL_UNUSED( cargo ); - if( lPCodePos + 1 < pFunc->lPCodePos && - pFunc->pCode[ lPCodePos + 1 ] == HB_P_ENDBLOCK ) + if( nPCodePos + 1 < pFunc->nPCodePos && + pFunc->pCode[ nPCodePos + 1 ] == HB_P_ENDBLOCK ) { - hb_compNOOPfill( pFunc, lPCodePos, 1, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 1, HB_FALSE, HB_FALSE ); } return 1; } @@ -730,10 +730,10 @@ static HB_OPT_FUNC( hb_p_endproc ) { HB_SYMBOL_UNUSED( cargo ); - if( lPCodePos + 1 < pFunc->lPCodePos && - pFunc->pCode[ lPCodePos + 1 ] == HB_P_ENDPROC ) + if( nPCodePos + 1 < pFunc->nPCodePos && + pFunc->pCode[ nPCodePos + 1 ] == HB_P_ENDPROC ) { - hb_compNOOPfill( pFunc, lPCodePos, 1, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 1, HB_FALSE, HB_FALSE ); } return 1; } @@ -1046,7 +1046,7 @@ static void hb_compPCodeEnumScanLocals( PFUNCTION pFunc, PHB_OPT_LOCAL pLocals ) HB_SHORT isVar = 0; HB_BOOL fWasJump = 0; - while( nPos < pFunc->lPCodePos ) + while( nPos < pFunc->nPCodePos ) { if( hb_compIsJump( pFunc->pCode[ nPos ] ) ) fWasJump = 1; @@ -1200,7 +1200,7 @@ static void hb_compPCodeEnumSelfifyLocal( PFUNCTION pFunc, HB_SHORT isLocal ) { HB_SIZE nPos = 0, nLastPos = 0; - while( nPos < pFunc->lPCodePos ) + while( nPos < pFunc->nPCodePos ) { switch( pFunc->pCode[ nPos ] ) { @@ -1329,9 +1329,9 @@ static void hb_compPCodeEnumAssignedUnused( HB_COMP_DECL, PFUNCTION pFunc, PHB_O HB_SHORT isLocal; HB_USHORT usLine = 0; - pMap = ( HB_BYTE * ) hb_xgrab( pFunc->lPCodePos ); + pMap = ( HB_BYTE * ) hb_xgrab( pFunc->nPCodePos ); - while( nPos < pFunc->lPCodePos ) + while( nPos < pFunc->nPCodePos ) { HB_BOOL fCheck; @@ -1412,7 +1412,7 @@ static void hb_compPCodeEnumAssignedUnused( HB_COMP_DECL, PFUNCTION pFunc, PHB_O pLocals[ isLocal - 1 ].bFlags != OPT_LOCAL_FLAG_POPSELF && pLocals[ isLocal - 1 ].bFlags != ( OPT_LOCAL_FLAG_PUSH | OPT_LOCAL_FLAG_POPSELF ) ) { - memset( pMap, 0, pFunc->lPCodePos ); + memset( pMap, 0, pFunc->nPCodePos ); pMap[ nPos ] = 1; if( ! hb_compPCodeTraceAssignedUnused( pFunc, nPos + hb_compPCodeSize( pFunc, nPos ), @@ -1448,7 +1448,7 @@ static void hb_compPCodeEnumRenumberLocals( PFUNCTION pFunc, PHB_OPT_LOCAL pLoca { HB_SIZE nPos = 0; - while( nPos < pFunc->lPCodePos ) + while( nPos < pFunc->nPCodePos ) { switch( pFunc->pCode[ nPos ] ) { @@ -1568,7 +1568,7 @@ void hb_compPCodeTraceOptimizer( HB_COMP_DECL ) { HB_SIZE nPos = 0; - while( nPos < pFunc->lPCodePos ) + while( nPos < pFunc->nPCodePos ) { if( pFunc->pCode[ nPos ] == HB_P_PARAMETER ) return; diff --git a/harbour/src/compiler/hbpcode.c b/harbour/src/compiler/hbpcode.c index 2292cdeec9..5934d9d4af 100644 --- a/harbour/src/compiler/hbpcode.c +++ b/harbour/src/compiler/hbpcode.c @@ -38,82 +38,82 @@ static HB_PSIZE_FUNC( hb_p_pushstrshort ) { HB_SYMBOL_UNUSED( cargo ); - return 2 + pFunc->pCode[ lPCodePos + 1 ]; + return 2 + pFunc->pCode[ nPCodePos + 1 ]; } static HB_PSIZE_FUNC( hb_p_pushstr ) { HB_SYMBOL_UNUSED( cargo ); - return 3 + HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); + return 3 + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); } static HB_PSIZE_FUNC( hb_p_pushstrlarge ) { HB_SYMBOL_UNUSED( cargo ); - return 4 + HB_PCODE_MKUINT24( &pFunc->pCode[ lPCodePos + 1 ] ); + return 4 + HB_PCODE_MKUINT24( &pFunc->pCode[ nPCodePos + 1 ] ); } static HB_PSIZE_FUNC( hb_p_pushstrhidden ) { HB_SYMBOL_UNUSED( cargo ); - return 4 + HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 2 ] ); + return 4 + HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 2 ] ); } static HB_PSIZE_FUNC( hb_p_pushblock ) { HB_SYMBOL_UNUSED( cargo ); - return HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ); + return HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ); } static HB_PSIZE_FUNC( hb_p_pushblockshort ) { HB_SYMBOL_UNUSED( cargo ); - return pFunc->pCode[ lPCodePos + 1 ]; + return pFunc->pCode[ nPCodePos + 1 ]; } static HB_PSIZE_FUNC( hb_p_pushblocklarge ) { HB_SYMBOL_UNUSED( cargo ); - return HB_PCODE_MKUINT24( &pFunc->pCode[ lPCodePos + 1 ] ); + return HB_PCODE_MKUINT24( &pFunc->pCode[ nPCodePos + 1 ] ); } static HB_PSIZE_FUNC( hb_p_localname ) { - HB_SIZE nStart = lPCodePos; + HB_SIZE nStart = nPCodePos; HB_SYMBOL_UNUSED( cargo ); - lPCodePos += 3; - while( pFunc->pCode[ lPCodePos++ ] ) {}; + nPCodePos += 3; + while( pFunc->pCode[ nPCodePos++ ] ) {}; - return ( lPCodePos - nStart ); + return ( nPCodePos - nStart ); } static HB_PSIZE_FUNC( hb_p_modulename ) { - HB_SIZE nStart = lPCodePos; + HB_SIZE nStart = nPCodePos; HB_SYMBOL_UNUSED( cargo ); - lPCodePos += 3; - while( pFunc->pCode[ lPCodePos++ ]) {}; + nPCodePos += 3; + while( pFunc->pCode[ nPCodePos++ ]) {}; - return ( lPCodePos - nStart ); + return ( nPCodePos - nStart ); } static HB_PSIZE_FUNC( hb_p_staticname ) { - HB_SIZE nStart = lPCodePos; + HB_SIZE nStart = nPCodePos; HB_SYMBOL_UNUSED( cargo ); - lPCodePos += 4; - while( pFunc->pCode[ lPCodePos++ ] ) {}; + nPCodePos += 4; + while( pFunc->pCode[ nPCodePos++ ] ) {}; - return ( lPCodePos - nStart ); + return ( nPCodePos - nStart ); } static HB_PSIZE_FUNC( hb_p_threadstatics ) { HB_SYMBOL_UNUSED( cargo ); - return 3 + ( ( HB_SIZE ) HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) << 1 ); + return 3 + ( ( HB_SIZE ) HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) << 1 ); } const HB_BYTE hb_comp_pcode_len[] = { @@ -525,7 +525,7 @@ void hb_compPCodeEval( PFUNCTION pFunc, const HB_PCODE_FUNC_PTR * pFunctions, vo assert( sizeof( hb_comp_pcode_len ) == HB_P_LAST_PCODE ); assert( sizeof( s_psize_table ) / sizeof( HB_PCODE_FUNC_PTR ) == HB_P_LAST_PCODE ); - while( nPos < pFunc->lPCodePos ) + while( nPos < pFunc->nPCodePos ) { opcode = pFunc->pCode[ nPos ]; if( opcode < HB_P_LAST_PCODE ) @@ -582,7 +582,7 @@ void hb_compPCodeTrace( PFUNCTION pFunc, const HB_PCODE_FUNC_PTR * pFunctions, v /* Make sure that table is correct */ assert( sizeof( hb_comp_pcode_len ) == HB_P_LAST_PCODE ); - while( nPos < pFunc->lPCodePos ) + while( nPos < pFunc->nPCodePos ) { HB_BYTE opcode = pFunc->pCode[ nPos ]; if( opcode < HB_P_LAST_PCODE ) @@ -611,12 +611,12 @@ void hb_compGenPCode1( HB_BYTE byte, HB_COMP_DECL ) { pFunc->pCode = ( HB_BYTE * ) hb_xgrab( HB_PCODE_CHUNK ); pFunc->lPCodeSize = HB_PCODE_CHUNK; - pFunc->lPCodePos = 0; + pFunc->nPCodePos = 0; } - else if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 1 ) + else if( ( pFunc->lPCodeSize - pFunc->nPCodePos ) < 1 ) pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize += HB_PCODE_CHUNK ); - pFunc->pCode[ pFunc->lPCodePos++ ] = byte; + pFunc->pCode[ pFunc->nPCodePos++ ] = byte; } void hb_compGenPCode2( HB_BYTE byte1, HB_BYTE byte2, HB_COMP_DECL ) @@ -627,13 +627,13 @@ void hb_compGenPCode2( HB_BYTE byte1, HB_BYTE byte2, HB_COMP_DECL ) { pFunc->pCode = ( HB_BYTE * ) hb_xgrab( HB_PCODE_CHUNK ); pFunc->lPCodeSize = HB_PCODE_CHUNK; - pFunc->lPCodePos = 0; + pFunc->nPCodePos = 0; } - else if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 2 ) + else if( ( pFunc->lPCodeSize - pFunc->nPCodePos ) < 2 ) pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize += HB_PCODE_CHUNK ); - pFunc->pCode[ pFunc->lPCodePos++ ] = byte1; - pFunc->pCode[ pFunc->lPCodePos++ ] = byte2; + pFunc->pCode[ pFunc->nPCodePos++ ] = byte1; + pFunc->pCode[ pFunc->nPCodePos++ ] = byte2; } void hb_compGenPCode3( HB_BYTE byte1, HB_BYTE byte2, HB_BYTE byte3, HB_COMP_DECL ) @@ -644,14 +644,14 @@ void hb_compGenPCode3( HB_BYTE byte1, HB_BYTE byte2, HB_BYTE byte3, HB_COMP_DECL { pFunc->pCode = ( HB_BYTE * ) hb_xgrab( HB_PCODE_CHUNK ); pFunc->lPCodeSize = HB_PCODE_CHUNK; - pFunc->lPCodePos = 0; + pFunc->nPCodePos = 0; } - else if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 3 ) + else if( ( pFunc->lPCodeSize - pFunc->nPCodePos ) < 3 ) pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize += HB_PCODE_CHUNK ); - pFunc->pCode[ pFunc->lPCodePos++ ] = byte1; - pFunc->pCode[ pFunc->lPCodePos++ ] = byte2; - pFunc->pCode[ pFunc->lPCodePos++ ] = byte3; + pFunc->pCode[ pFunc->nPCodePos++ ] = byte1; + pFunc->pCode[ pFunc->nPCodePos++ ] = byte2; + pFunc->pCode[ pFunc->nPCodePos++ ] = byte3; } void hb_compGenPCode4( HB_BYTE byte1, HB_BYTE byte2, HB_BYTE byte3, HB_BYTE byte4, HB_COMP_DECL ) @@ -662,15 +662,15 @@ void hb_compGenPCode4( HB_BYTE byte1, HB_BYTE byte2, HB_BYTE byte3, HB_BYTE byte { pFunc->pCode = ( HB_BYTE * ) hb_xgrab( HB_PCODE_CHUNK ); pFunc->lPCodeSize = HB_PCODE_CHUNK; - pFunc->lPCodePos = 0; + pFunc->nPCodePos = 0; } - else if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 4 ) + else if( ( pFunc->lPCodeSize - pFunc->nPCodePos ) < 4 ) pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize += HB_PCODE_CHUNK ); - pFunc->pCode[ pFunc->lPCodePos++ ] = byte1; - pFunc->pCode[ pFunc->lPCodePos++ ] = byte2; - pFunc->pCode[ pFunc->lPCodePos++ ] = byte3; - pFunc->pCode[ pFunc->lPCodePos++ ] = byte4; + pFunc->pCode[ pFunc->nPCodePos++ ] = byte1; + pFunc->pCode[ pFunc->nPCodePos++ ] = byte2; + pFunc->pCode[ pFunc->nPCodePos++ ] = byte3; + pFunc->pCode[ pFunc->nPCodePos++ ] = byte4; } void hb_compGenPCodeN( const HB_BYTE * pBuffer, HB_SIZE nSize, HB_COMP_DECL ) @@ -681,15 +681,15 @@ void hb_compGenPCodeN( const HB_BYTE * pBuffer, HB_SIZE nSize, HB_COMP_DECL ) { pFunc->lPCodeSize = ( ( nSize / HB_PCODE_CHUNK ) + 1 ) * HB_PCODE_CHUNK; pFunc->pCode = ( HB_BYTE * ) hb_xgrab( pFunc->lPCodeSize ); - pFunc->lPCodePos = 0; + pFunc->nPCodePos = 0; } - else if( pFunc->lPCodePos + nSize > pFunc->lPCodeSize ) + else if( pFunc->nPCodePos + nSize > pFunc->lPCodeSize ) { /* not enough free space in pcode buffer - increase it */ pFunc->lPCodeSize += ( ( ( nSize / HB_PCODE_CHUNK ) + 1 ) * HB_PCODE_CHUNK ); pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize ); } - memcpy( pFunc->pCode + pFunc->lPCodePos, pBuffer, nSize ); - pFunc->lPCodePos += nSize; + memcpy( pFunc->pCode + pFunc->nPCodePos, pBuffer, nSize ); + pFunc->nPCodePos += nSize; } diff --git a/harbour/src/compiler/hbstripl.c b/harbour/src/compiler/hbstripl.c index ade991df69..d3e9c6ae95 100644 --- a/harbour/src/compiler/hbstripl.c +++ b/harbour/src/compiler/hbstripl.c @@ -67,9 +67,9 @@ HB_EXTERN_END static HB_STRIP_FUNC( hb_p_line ) { HB_SYMBOL_UNUSED( cargo ); - if( pFunc->pCode[ lPCodePos + 3 ] == HB_P_LINE ) + if( pFunc->pCode[ nPCodePos + 3 ] == HB_P_LINE ) { - hb_compNOOPfill( pFunc, lPCodePos, 3, HB_FALSE, HB_FALSE ); + hb_compNOOPfill( pFunc, nPCodePos, 3, HB_FALSE, HB_FALSE ); } return 3;