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

2010-07-07 18:53 UTC+0200 Viktor Szakats (harbour.01 syenar.hu)

Browse Source 
* src/vm/macro.c
    ! Added missing renames from prev session.

  * src/common/expropt1.c
  * src/common/expropt2.c
  * src/compiler/hbmain.c
  * src/compiler/harbour.yyc
  * src/compiler/harbour.y
  * include/hbcompdf.h
  * include/hbexpra.c
  * include/hbexprb.c
    * Some final renames in compiler area.
      (compiler objects verified)

  * contrib/make.hbs
    * Updated header.
This commit is contained in:
Viktor Szakats
2010-07-07 16:53:35 +00:00
parent f9270e4a0e
commit c863e84065
11 changed files with 292 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
harbour/ChangeLog
View File

@@ -16,6 +16,24 @@
The license applies to all entries newer than 2009-04-28.
*/
2010-07-07 18:53 UTC+0200 Viktor Szakats (harbour.01 syenar.hu)
* src/vm/macro.c
! Added missing renames from prev session.
* src/common/expropt1.c
* src/common/expropt2.c
* src/compiler/hbmain.c
* src/compiler/harbour.yyc
* src/compiler/harbour.y
* include/hbcompdf.h
* include/hbexpra.c
* include/hbexprb.c
* Some final renames in compiler area.
(compiler objects verified)
* contrib/make.hbs
* Updated header.
2010-07-07 18:13 UTC+0200 Viktor Szakats (harbour.01 syenar.hu)
* src/compiler/ppcomp.c
* src/compiler/hbmain.c

3
harbour/contrib/make.hbs
View File

@@ -4,8 +4,7 @@
*/
/*
* This Harbour script is part of the GNU Make-based build system.
* WARNING: Running it separately is not supported.
* Contrib build starter script.
*
* Copyright 2010 Viktor Szakats (harbour.01 syenar.hu)
* See COPYING for licensing terms.

18
harbour/include/hbcompdf.h
View File

@@ -430,7 +430,7 @@ typedef struct HB_EXPR_
} asOperator;
struct HB_EXPR_ * asReference;
} value;
HB_SIZE ulLength;
HB_SIZE nLength;
HB_EXPRTYPE ExprType; /* internal expression type */
HB_USHORT ValType; /* language level value type */
struct HB_EXPR_ *pNext; /* next expression in the list of expressions */
@@ -446,7 +446,7 @@ typedef struct HB_ENUMERATOR_
/* support structure for else if pcode fixups */
typedef struct HB_ELSEIF_
{
HB_SIZE ulOffset;
HB_SIZE nOffset;
struct HB_ELSEIF_ * pElseif; /* next ELSEIF in the current IF statement */
struct HB_ELSEIF_ * pPrev; /* previous IF statement */
} HB_ELSEIF, * HB_ELSEIF_PTR;
@@ -454,7 +454,7 @@ typedef struct HB_ELSEIF_
/* support structure for EXIT and LOOP statements */
typedef struct HB_LOOPEXIT_
{
HB_SIZE ulOffset;
HB_SIZE nOffset;
HB_BOOL fCanLoop;
HB_USHORT wSeqCounter;
HB_USHORT wAlwaysCounter;
@@ -467,18 +467,18 @@ typedef struct HB_LOOPEXIT_
/* support structure for SWITCH statement */
typedef struct HB_SWITCHCASE_
{
HB_SIZE ulOffset;
HB_SIZE nOffset;
HB_EXPR_PTR pExpr;
struct HB_SWITCHCASE_ * pNext;
} HB_SWITCHCASE, * HB_SWITCHCASE_PTR;
typedef struct HB_SWITCHCMD_
{
HB_SIZE ulOffset;
HB_SIZE nOffset;
HB_SWITCHCASE_PTR pCases;
HB_SWITCHCASE_PTR pLast;
HB_EXPR_PTR pExpr;
HB_SIZE ulDefault;
HB_SIZE nDefault;
struct HB_SWITCHCMD_ * pPrev;
} HB_SWITCHCMD, *HB_SWITCHCMD_PTR;
@@ -512,8 +512,8 @@ typedef struct __FUNC
int iFuncSuffix; /* function suffix for multiple static functions with the same name */
HB_SIZE * pNOOPs; /* pointer to the NOOP array */
HB_SIZE * pJumps; /* pointer to the Jumps array */
HB_SIZE iNOOPs; /* NOOPs Counter */
HB_SIZE iJumps; /* Jumps Counter */
HB_SIZE nNOOPs; /* NOOPs Counter */
HB_SIZE nJumps; /* Jumps Counter */
HB_BOOL bLateEval; /* HB_TRUE if accessing of declared (compile time) variables is allowed */
HB_BOOL fVParams; /* HB_TRUE if variable number of parameters is used */
HB_BOOL bError; /* error during function compilation */
@@ -776,7 +776,7 @@ typedef struct _HB_COMP
void ( * outErrFunc ) ( void *, const char* );
void * cargo;
HB_SIZE ulOutBufSize; /* memory output buffer size */
HB_SIZE nOutBufSize; /* memory output buffer size */
HB_BYTE * pOutBuf; /* memory output buffer address */
HB_SIZE lastLinePos; /* position of last opcode with line number */

32
harbour/include/hbexpra.c
View File

@@ -58,7 +58,7 @@
#ifndef HB_MACRO_SUPPORT
HB_SIZE hb_compExprListEval( HB_COMP_DECL, HB_EXPR_PTR pExpr, HB_CARGO_FUNC_PTR pEval )
{
HB_SIZE ulLen = 0;
HB_SIZE nLen = 0;
if( pEval && ( pExpr->ExprType == HB_ET_LIST ||
pExpr->ExprType == HB_ET_ARGLIST ) )
@@ -68,18 +68,18 @@ HB_SIZE hb_compExprListEval( HB_COMP_DECL, HB_EXPR_PTR pExpr, HB_CARGO_FUNC_PTR
{
( pEval )( HB_COMP_PARAM, ( void * ) pExpr );
pExpr = pExpr->pNext;
++ulLen;
++nLen;
}
}
return ulLen;
return nLen;
}
HB_SIZE hb_compExprListEval2( HB_COMP_DECL, HB_EXPR_PTR pExpr1, HB_EXPR_PTR pExpr2, HB_CARGO2_FUNC_PTR pEval )
{
HB_SIZE ulLen = 0;
HB_SIZE nLen = 0;
if( !pEval )
return ulLen;
return nLen;
if( ( pExpr1->ExprType == HB_ET_LIST || pExpr1->ExprType == HB_ET_ARGLIST )
&&
@@ -92,7 +92,7 @@ HB_SIZE hb_compExprListEval2( HB_COMP_DECL, HB_EXPR_PTR pExpr1, HB_EXPR_PTR pExp
( pEval )( HB_COMP_PARAM, ( void * ) pExpr1, ( void * ) pExpr2 );
pExpr1 = pExpr1->pNext;
pExpr2 = pExpr2->pNext;
++ulLen;
++nLen;
}
}
else if( pExpr1->ExprType == HB_ET_LIST || pExpr1->ExprType == HB_ET_ARGLIST )
@@ -102,10 +102,10 @@ HB_SIZE hb_compExprListEval2( HB_COMP_DECL, HB_EXPR_PTR pExpr1, HB_EXPR_PTR pExp
{
( pEval )( HB_COMP_PARAM, ( void * ) pExpr1, ( void * ) pExpr2 );
pExpr1 = pExpr1->pNext;
++ulLen;
++nLen;
}
}
return ulLen;
return nLen;
}
#endif
@@ -331,12 +331,12 @@ HB_EXPR_PTR hb_compExprNewFunCall( HB_EXPR_PTR pName, HB_EXPR_PTR pParms, HB_COM
/* NOTE: Clipper strips a string at the first '[' character too
*/
while( ++i < pVar->ulLength )
while( ++i < pVar->nLength )
{
if( szVar[ i ] == '[' )
{
szVar[ i ] = 0;
pVar->ulLength = i;
pVar->nLength = i;
break;
}
}
@@ -628,14 +628,14 @@ HB_EXPR_PTR hb_compExprAssignStatic( HB_EXPR_PTR pLeftExpr, HB_EXPR_PTR pRightEx
return pExpr;
}
HB_EXPR_PTR hb_compExprSetCodeblockBody( HB_EXPR_PTR pExpr, HB_BYTE * pCode, HB_SIZE ulLen )
HB_EXPR_PTR hb_compExprSetCodeblockBody( HB_EXPR_PTR pExpr, HB_BYTE * pCode, HB_SIZE nLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_compExprSetCodeblockBody(%p,%p,%" HB_PFS "u)", pExpr, pCode, ulLen));
HB_TRACE(HB_TR_DEBUG, ("hb_compExprSetCodeblockBody(%p,%p,%" HB_PFS "u)", pExpr, pCode, nLen));
pExpr->value.asCodeblock.string = ( char * ) hb_xgrab( ulLen + 1 );
memcpy( pExpr->value.asCodeblock.string, pCode, ulLen );
pExpr->value.asCodeblock.string[ ulLen ] = '\0';
pExpr->ulLength = ulLen;
pExpr->value.asCodeblock.string = ( char * ) hb_xgrab( nLen + 1 );
memcpy( pExpr->value.asCodeblock.string, pCode, nLen );
pExpr->value.asCodeblock.string[ nLen ] = '\0';
pExpr->nLength = nLen;
return pExpr;
}

130
harbour/include/hbexprb.c
View File

@@ -397,15 +397,15 @@ static HB_EXPR_FUNC( hb_compExprUseString )
case HB_EA_PUSH_PCODE:
{
HB_GEN_FUNC2( PushString, pSelf->value.asString.string,
pSelf->ulLength + 1 );
pSelf->nLength + 1 );
#if ! defined( HB_MACRO_SUPPORT )
if( HB_SUPPORT_MACROTEXT &&
hb_compIsValidMacroText( HB_COMP_PARAM,
pSelf->value.asString.string,
pSelf->ulLength ) )
pSelf->nLength ) )
#else
if( hb_macroIsValidMacroText( pSelf->value.asString.string,
pSelf->ulLength ) )
pSelf->nLength ) )
#endif
{
HB_GEN_FUNC1( PCode1, HB_P_MACROTEXT );
@@ -675,7 +675,7 @@ static HB_EXPR_FUNC( hb_compExprUseHash )
case HB_EA_PUSH_PCODE:
{
HB_USHORT usItems = ( HB_USHORT ) ( pSelf->ulLength >> 1 );
HB_USHORT usItems = ( HB_USHORT ) ( pSelf->nLength >> 1 );
/* Note: direct type change */
pSelf->ExprType = HB_ET_ARGLIST;
HB_EXPR_USE( pSelf, HB_EA_PUSH_PCODE );
@@ -918,40 +918,40 @@ static HB_EXPR_FUNC( hb_compExprUseIIF )
{
/* this is called if all three parts of IIF expression should be generated
*/
HB_ISIZ lPosFalse, lPosEnd;
HB_ISIZ nPosFalse, nPosEnd;
HB_EXPR_PTR pExpr = pSelf->value.asList.pExprList;
HB_EXPR_USE( pExpr, HB_EA_PUSH_PCODE );
lPosFalse = HB_GEN_FUNC1( JumpFalse, 0 );
nPosFalse = HB_GEN_FUNC1( JumpFalse, 0 );
pExpr =pExpr->pNext;
HB_EXPR_USE( pExpr, HB_EA_PUSH_PCODE );
lPosEnd = HB_GEN_FUNC1( Jump, 0 );
nPosEnd = HB_GEN_FUNC1( Jump, 0 );
pExpr =pExpr->pNext;
HB_GEN_FUNC1( JumpHere, lPosFalse );
HB_GEN_FUNC1( JumpHere, nPosFalse );
HB_EXPR_USE( pExpr, HB_EA_PUSH_PCODE );
HB_GEN_FUNC1( JumpHere, lPosEnd );
HB_GEN_FUNC1( JumpHere, nPosEnd );
break;
}
case HB_EA_POP_PCODE:
{
/* this is called if all three parts of IIF expression should be generated
*/
HB_ISIZ lPosFalse, lPosEnd;
HB_ISIZ nPosFalse, nPosEnd;
HB_EXPR_PTR pExpr = pSelf->value.asList.pExprList;
HB_EXPR_USE( pExpr, HB_EA_PUSH_PCODE );
lPosFalse = HB_GEN_FUNC1( JumpFalse, 0 );
nPosFalse = HB_GEN_FUNC1( JumpFalse, 0 );
pExpr =pExpr->pNext;
HB_EXPR_USE( pExpr, HB_EA_POP_PCODE );
lPosEnd = HB_GEN_FUNC1( Jump, 0 );
nPosEnd = HB_GEN_FUNC1( Jump, 0 );
pExpr =pExpr->pNext;
HB_GEN_FUNC1( JumpHere, lPosFalse );
HB_GEN_FUNC1( JumpHere, nPosFalse );
HB_EXPR_USE( pExpr, HB_EA_POP_PCODE );
HB_GEN_FUNC1( JumpHere, lPosEnd );
HB_GEN_FUNC1( JumpHere, nPosEnd );
break;
}
@@ -962,11 +962,11 @@ static HB_EXPR_FUNC( hb_compExprUseIIF )
HB_EXPR_USE( pSelf, HB_EA_PUSH_PCODE );
HB_GEN_FUNC1( PCode1, HB_P_POP ); /* remove a value if used in statement */
#else
HB_SIZE ulPosFalse, ulPosEnd;
HB_SIZE nPosFalse, nPosEnd;
HB_EXPR_PTR pExpr = pSelf->value.asList.pExprList;
HB_EXPR_USE( pExpr, HB_EA_PUSH_PCODE );
ulPosFalse = HB_GEN_FUNC1( JumpFalse, 0 );
nPosFalse = HB_GEN_FUNC1( JumpFalse, 0 );
pExpr =pExpr->pNext;
/* do not generate warning about meaningless use of expression NIL */
@@ -975,27 +975,27 @@ static HB_EXPR_FUNC( hb_compExprUseIIF )
pExpr =pExpr->pNext;
#if defined( HB_MACRO_SUPPORT )
if( HB_PCODE_DATA->nPCodePos == ulPosFalse + 3 )
if( HB_PCODE_DATA->nPCodePos == nPosFalse + 3 )
{
HB_PCODE_DATA->pCode[ ulPosFalse - 1 ] = HB_P_JUMPTRUEFAR;
ulPosEnd = ulPosFalse;
HB_PCODE_DATA->pCode[ nPosFalse - 1 ] = HB_P_JUMPTRUEFAR;
nPosEnd = nPosFalse;
}
#else
if( HB_COMP_PARAM->functions.pLast->nPCodePos == ulPosFalse + 3 )
if( HB_COMP_PARAM->functions.pLast->nPCodePos == nPosFalse + 3 )
{
HB_COMP_PARAM->functions.pLast->pCode[ ulPosFalse - 1 ] = HB_P_JUMPTRUEFAR;
ulPosEnd = ulPosFalse;
HB_COMP_PARAM->functions.pLast->pCode[ nPosFalse - 1 ] = HB_P_JUMPTRUEFAR;
nPosEnd = nPosFalse;
}
#endif
else
{
ulPosEnd = HB_GEN_FUNC1( Jump, 0 );
HB_GEN_FUNC1( JumpHere, ulPosFalse );
nPosEnd = HB_GEN_FUNC1( Jump, 0 );
HB_GEN_FUNC1( JumpHere, nPosFalse );
}
/* do not generate warning about meaningless use of expression NIL */
if( pExpr->ExprType != HB_ET_NIL )
HB_EXPR_USE( pExpr, HB_EA_PUSH_POP );
HB_GEN_FUNC1( JumpHere, ulPosEnd );
HB_GEN_FUNC1( JumpHere, nPosEnd );
#endif
break;
}
@@ -1312,21 +1312,21 @@ static HB_EXPR_FUNC( hb_compExprUseArrayAt )
if( pIdx->ExprType == HB_ET_NUMERIC )
{
HB_EXPR_PTR pExpr = pSelf->value.asList.pExprList; /* the expression that holds an array */
HB_ISIZ lIndex;
HB_ISIZ nIndex;
if( pIdx->value.asNum.NumType == HB_ET_LONG )
lIndex = ( HB_ISIZ ) pIdx->value.asNum.val.l;
nIndex = ( HB_ISIZ ) pIdx->value.asNum.val.l;
else
lIndex = ( HB_ISIZ ) pIdx->value.asNum.val.d;
nIndex = ( HB_ISIZ ) pIdx->value.asNum.val.d;
if( pExpr->ExprType == HB_ET_ARRAY ) /* is it a literal array */
{
HB_SIZE ulSize = hb_compExprParamListCheck( HB_COMP_PARAM, pExpr );
HB_SIZE nSize = hb_compExprParamListCheck( HB_COMP_PARAM, pExpr );
if( pExpr->ExprType == HB_ET_MACROARGLIST )
/* restore original expression type */
pExpr->ExprType = HB_ET_ARRAY;
else if( !HB_IS_VALID_INDEX( lIndex, ulSize ) )
else if( !HB_IS_VALID_INDEX( nIndex, nSize ) )
{
if( !HB_SUPPORT_ARRSTR )
hb_compErrorBound( HB_COMP_PARAM, pIdx );
@@ -1334,7 +1334,7 @@ static HB_EXPR_FUNC( hb_compExprUseArrayAt )
else
{
pExpr = pExpr->value.asList.pExprList; /* the first element in the array */
while( --lIndex && pExpr )
while( --nIndex && pExpr )
pExpr = pExpr->pNext;
if( pExpr ) /* found ? */
@@ -1360,9 +1360,9 @@ static HB_EXPR_FUNC( hb_compExprUseArrayAt )
#if 0
else if( pExpr->ExprType == HB_ET_STRING && HB_SUPPORT_ARRSTR ) /* is it a literal string */
{
if( HB_IS_VALID_INDEX( lIndex, pExpr->ulLength ) )
if( HB_IS_VALID_INDEX( nIndex, pExpr->nLength ) )
{
HB_UCHAR ucValue = ( HB_UCHAR ) pExpr->value.asString.string[ lIndex - 1 ];
HB_UCHAR ucValue = ( HB_UCHAR ) pExpr->value.asString.string[ nIndex - 1 ];
HB_COMP_EXPR_FREE( pSelf );
pSelf = hb_compExprNewLong( ucValue, HB_COMP_PARAM );
@@ -1929,7 +1929,7 @@ static HB_EXPR_FUNC( hb_compExprUseFunCall )
}
if( usCount == 2 )
{
if( pArg->pNext->ExprType == HB_ET_STRING && pArg->pNext->ulLength > 0 )
if( pArg->pNext->ExprType == HB_ET_STRING && pArg->pNext->nLength > 0 )
{
szContext = pArg->pNext->value.asString.string;
--usCount;
@@ -1948,7 +1948,7 @@ static HB_EXPR_FUNC( hb_compExprUseFunCall )
{
if( pArg->ExprType == HB_ET_STRING )
{
if( HB_COMP_PARAM->fI18n && pArg->ulLength > 0 )
if( HB_COMP_PARAM->fI18n && pArg->nLength > 0 )
{
if( pCount )
{
@@ -2552,18 +2552,18 @@ static HB_EXPR_FUNC( hb_compExprUseSetGet )
break;
case HB_EA_PUSH_PCODE:
{
HB_ISIZ lPosFalse, lPosEnd;
HB_ISIZ nPosFalse, nPosEnd;
/* <pVar>==NIL */
HB_EXPR_USE( pSelf->value.asSetGet.pVar, HB_EA_PUSH_PCODE );
HB_GEN_FUNC1( PCode1, HB_P_PUSHNIL );
HB_GEN_FUNC1( PCode1, HB_P_EXACTLYEQUAL );
lPosFalse = HB_GEN_FUNC1( JumpFalse, 0 );
nPosFalse = HB_GEN_FUNC1( JumpFalse, 0 );
/* <pExpr> */
HB_EXPR_USE( pSelf->value.asSetGet.pExpr, HB_EA_PUSH_PCODE );
lPosEnd = HB_GEN_FUNC1( Jump, 0 );
nPosEnd = HB_GEN_FUNC1( Jump, 0 );
/* <pExpr>:=<pVar> */
HB_GEN_FUNC1( JumpHere, lPosFalse );
HB_GEN_FUNC1( JumpHere, nPosFalse );
if( pSelf->value.asSetGet.pExpr->ExprType == HB_ET_SEND )
{
HB_EXPR_PTR pObj, pParams;
@@ -2579,7 +2579,7 @@ static HB_EXPR_FUNC( hb_compExprUseSetGet )
HB_GEN_FUNC1( PCode1, HB_P_PUSHUNREF );
HB_EXPR_USE( pSelf->value.asSetGet.pExpr, HB_EA_POP_PCODE );
}
HB_GEN_FUNC1( JumpHere, lPosEnd );
HB_GEN_FUNC1( JumpHere, nPosEnd );
break;
}
case HB_EA_POP_PCODE:
@@ -2588,18 +2588,18 @@ static HB_EXPR_FUNC( hb_compExprUseSetGet )
case HB_EA_PUSH_POP:
case HB_EA_STATEMENT:
{
HB_ISIZ lPosFalse, lPosEnd;
HB_ISIZ nPosFalse, nPosEnd;
/* <pVar>==NIL */
HB_EXPR_USE( pSelf->value.asSetGet.pVar, HB_EA_PUSH_PCODE );
HB_GEN_FUNC1( PCode1, HB_P_PUSHNIL );
HB_GEN_FUNC1( PCode1, HB_P_EXACTLYEQUAL );
lPosFalse = HB_GEN_FUNC1( JumpFalse, 0 );
nPosFalse = HB_GEN_FUNC1( JumpFalse, 0 );
/* <pExpr> */
HB_EXPR_USE( pSelf->value.asSetGet.pExpr, HB_EA_PUSH_PCODE );
lPosEnd = HB_GEN_FUNC1( Jump, 0 );
nPosEnd = HB_GEN_FUNC1( Jump, 0 );
/* <pExpr>:=<pVar> */
HB_GEN_FUNC1( JumpHere, lPosFalse );
HB_GEN_FUNC1( JumpHere, nPosFalse );
if( pSelf->value.asSetGet.pExpr->ExprType == HB_ET_SEND )
{
HB_EXPR_PTR pObj, pParams;
@@ -2616,7 +2616,7 @@ static HB_EXPR_FUNC( hb_compExprUseSetGet )
HB_EXPR_USE( pSelf->value.asSetGet.pVar, HB_EA_PUSH_PCODE );
HB_EXPR_USE( pSelf->value.asSetGet.pExpr, HB_EA_POP_PCODE );
}
HB_GEN_FUNC1( JumpHere, lPosEnd );
HB_GEN_FUNC1( JumpHere, nPosEnd );
break;
}
@@ -3183,14 +3183,14 @@ static HB_EXPR_FUNC( hb_compExprUseOr )
case HB_EA_PUSH_PCODE:
if( HB_COMP_ISSUPPORTED( HB_COMPFLAG_SHORTCUTS ) )
{
HB_ISIZ lEndPos;
HB_ISIZ nEndPos;
HB_EXPR_USE( pSelf->value.asOperator.pLeft, HB_EA_PUSH_PCODE );
HB_GEN_FUNC1( PCode1, HB_P_DUPLICATE );
lEndPos = HB_GEN_FUNC1( JumpTrue, 0 );
nEndPos = HB_GEN_FUNC1( JumpTrue, 0 );
HB_GEN_FUNC1( PCode1, HB_P_POP );
HB_EXPR_USE( pSelf->value.asOperator.pRight, HB_EA_PUSH_PCODE );
HB_GEN_FUNC1( JumpHere, lEndPos );
HB_GEN_FUNC1( JumpHere, nEndPos );
}
else
{
@@ -3206,9 +3206,9 @@ static HB_EXPR_FUNC( hb_compExprUseOr )
case HB_EA_PUSH_POP:
if( HB_COMP_ISSUPPORTED( HB_COMPFLAG_SHORTCUTS ) )
{
HB_ISIZ lEndPos;
HB_ISIZ nEndPos;
HB_EXPR_USE( pSelf->value.asOperator.pLeft, HB_EA_PUSH_PCODE );
lEndPos = HB_GEN_FUNC1( JumpTrue, 0 );
nEndPos = HB_GEN_FUNC1( JumpTrue, 0 );
/* NOTE: This will not generate a runtime error if incompatible
* data type is used
*/
@@ -3223,7 +3223,7 @@ static HB_EXPR_FUNC( hb_compExprUseOr )
HB_COMP_PARAM->fMeaningful = fMeaningful;
}
#endif
HB_GEN_FUNC1( JumpHere, lEndPos );
HB_GEN_FUNC1( JumpHere, nEndPos );
}
else
{
@@ -3268,14 +3268,14 @@ static HB_EXPR_FUNC( hb_compExprUseAnd )
case HB_EA_PUSH_PCODE:
if( HB_COMP_ISSUPPORTED( HB_COMPFLAG_SHORTCUTS ) )
{
HB_ISIZ lEndPos;
HB_ISIZ nEndPos;
HB_EXPR_USE( pSelf->value.asOperator.pLeft, HB_EA_PUSH_PCODE );
HB_GEN_FUNC1( PCode1, HB_P_DUPLICATE );
lEndPos = HB_GEN_FUNC1( JumpFalse, 0 );
nEndPos = HB_GEN_FUNC1( JumpFalse, 0 );
HB_GEN_FUNC1( PCode1, HB_P_POP );
HB_EXPR_USE( pSelf->value.asOperator.pRight, HB_EA_PUSH_PCODE );
HB_GEN_FUNC1( JumpHere, lEndPos );
HB_GEN_FUNC1( JumpHere, nEndPos );
}
else
{
@@ -3291,9 +3291,9 @@ static HB_EXPR_FUNC( hb_compExprUseAnd )
case HB_EA_PUSH_POP:
if( HB_COMP_ISSUPPORTED( HB_COMPFLAG_SHORTCUTS ) )
{
HB_ISIZ lEndPos;
HB_ISIZ nEndPos;
HB_EXPR_USE( pSelf->value.asOperator.pLeft, HB_EA_PUSH_PCODE );
lEndPos = HB_GEN_FUNC1( JumpFalse, 0 );
nEndPos = HB_GEN_FUNC1( JumpFalse, 0 );
/* NOTE: This will not generate a runtime error if incompatible
* data type is used
*/
@@ -3308,7 +3308,7 @@ static HB_EXPR_FUNC( hb_compExprUseAnd )
HB_COMP_PARAM->fMeaningful = fMeaningful;
}
#endif
HB_GEN_FUNC1( JumpHere, lEndPos );
HB_GEN_FUNC1( JumpHere, nEndPos );
}
else
{
@@ -4512,7 +4512,7 @@ static void hb_compExprCodeblockPush( HB_EXPR_PTR pSelf, HB_BOOL bLateEval, HB_C
static void hb_compExprCodeblockExtPush( HB_EXPR_PTR pSelf, HB_COMP_DECL )
{
hb_compGenPCodeN( ( HB_BYTE * ) pSelf->value.asCodeblock.string,
pSelf->ulLength, HB_COMP_PARAM );
pSelf->nLength, HB_COMP_PARAM );
}
static void hb_compExprCodeblockEarly( HB_EXPR_PTR pSelf, HB_COMP_DECL )
@@ -4544,7 +4544,7 @@ static void hb_compExprCodeblockEarly( HB_EXPR_PTR pSelf, HB_COMP_DECL )
* {|| &variable+1} => &( '{|| &variable+1}' )
*/
hb_compExprCodeblockPush( pSelf, HB_FALSE, HB_COMP_PARAM );
pExpr = hb_compExprNewMacro( hb_compExprNewString( pSelf->value.asCodeblock.string, pSelf->ulLength, HB_FALSE, HB_COMP_PARAM ), 0, NULL, HB_COMP_PARAM );
pExpr = hb_compExprNewMacro( hb_compExprNewString( pSelf->value.asCodeblock.string, pSelf->nLength, HB_FALSE, HB_COMP_PARAM ), 0, NULL, HB_COMP_PARAM );
HB_EXPR_USE( pExpr, HB_EA_PUSH_PCODE );
HB_COMP_EXPR_FREE( pExpr );
hb_compCodeBlockStop( HB_COMP_PARAM );
@@ -5407,20 +5407,20 @@ static HB_EXPR_PTR hb_compExprReduceAliasString( HB_EXPR_PTR pExpr, HB_EXPR_PTR
if( HB_ISFIRSTIDCHAR( *szAlias ) )
{
HB_SIZE ulLen = pAlias->ulLength;
if( ulLen <= HB_SYMBOL_NAME_LEN )
HB_SIZE nLen = pAlias->nLength;
if( nLen <= HB_SYMBOL_NAME_LEN )
{
HB_BOOL fLower = HB_FALSE;
while( ulLen )
while( nLen )
{
char c = szAlias[ ulLen - 1 ];
char c = szAlias[ nLen - 1 ];
if( !HB_ISNEXTIDCHAR( c ) )
break;
if( HB_ISLOWER( c ) )
fLower = HB_TRUE;
--ulLen;
--nLen;
}
if( ulLen == 0 )
if( nLen == 0 )
{
#if defined( HB_MACRO_SUPPORT )
if( fLower )

14
harbour/src/common/expropt1.c
View File

@@ -226,7 +226,7 @@ const char * hb_compExprAsString( HB_EXPR_PTR pExpr )
HB_SIZE hb_compExprAsStringLen( HB_EXPR_PTR pExpr )
{
if( pExpr->ExprType == HB_ET_STRING )
return pExpr->ulLength;
return pExpr->nLength;
return 0;
}
@@ -371,7 +371,7 @@ HB_EXPR_PTR hb_compExprNewString( const char *szValue, HB_SIZE nLen, HB_BOOL fDe
pExpr->value.asString.string = ( char * ) szValue;
pExpr->value.asString.dealloc = fDealloc;
pExpr->ulLength = nLen;
pExpr->nLength = nLen;
pExpr->ValType = HB_EV_STRING;
return pExpr;
@@ -388,7 +388,7 @@ HB_EXPR_PTR hb_compExprNewArray( HB_EXPR_PTR pArrList, HB_COMP_DECL )
pArrList->ExprType = HB_ET_ARRAY; /* change type from ET_LIST */
pArrList->ValType = HB_EV_ARRAY;
pArrList->ulLength = 0;
pArrList->nLength = 0;
pArrList->value.asList.reference = HB_FALSE;
pExpr = pArrList->value.asList.pExprList; /* get first element on the list */
@@ -411,7 +411,7 @@ HB_EXPR_PTR hb_compExprNewArray( HB_EXPR_PTR pArrList, HB_COMP_DECL )
if( pExpr->ExprType == HB_ET_NONE )
pExpr->ExprType = HB_ET_NIL;
pExpr = pExpr->pNext;
++pArrList->ulLength;
++pArrList->nLength;
}
}
pArrList->value.asList.pIndex = NULL;
@@ -436,7 +436,7 @@ HB_EXPR_PTR hb_compExprNewHash( HB_EXPR_PTR pHashList, HB_COMP_DECL )
pHashList->value.asList.pExprList = NULL;
}
pHashList->ValType = HB_EV_HASH;
pHashList->ulLength = 0;
pHashList->nLength = 0;
pHashList->value.asList.reference = HB_FALSE;
pHashList->value.asList.pIndex = NULL;
@@ -450,7 +450,7 @@ HB_EXPR_PTR hb_compExprNewHash( HB_EXPR_PTR pHashList, HB_COMP_DECL )
if( pExpr->ExprType == HB_ET_NONE )
pExpr->ExprType = HB_ET_NIL;
pExpr = pExpr->pNext;
++pHashList->ulLength;
++pHashList->nLength;
}
return pHashList;
@@ -469,7 +469,7 @@ HB_EXPR_PTR hb_compExprNewCodeBlock( char *string, HB_SIZE nLen, int iFlags, HB_
pExpr->ValType = HB_EV_CODEBLOCK;
pExpr->value.asCodeblock.flags = ( HB_USHORT ) iFlags;
pExpr->value.asCodeblock.string = string;
pExpr->ulLength = nLen;
pExpr->nLength = nLen;
return pExpr;
}

114
harbour/src/common/expropt2.c
View File

@@ -81,20 +81,20 @@ static HB_EXPR_PTR hb_compExprReducePlusStrings( HB_EXPR_PTR pLeft, HB_EXPR_PTR
{
if( pLeft->value.asString.dealloc )
{
pLeft->value.asString.string = ( char * ) hb_xrealloc( pLeft->value.asString.string, pLeft->ulLength + pRight->ulLength + 1 );
memcpy( pLeft->value.asString.string + pLeft->ulLength,
pRight->value.asString.string, pRight->ulLength );
pLeft->ulLength += pRight->ulLength;
pLeft->value.asString.string[ pLeft->ulLength ] = '\0';
pLeft->value.asString.string = ( char * ) hb_xrealloc( pLeft->value.asString.string, pLeft->nLength + pRight->nLength + 1 );
memcpy( pLeft->value.asString.string + pLeft->nLength,
pRight->value.asString.string, pRight->nLength );
pLeft->nLength += pRight->nLength;
pLeft->value.asString.string[ pLeft->nLength ] = '\0';
}
else
{
char * szString;
szString = ( char * ) hb_xgrab( pLeft->ulLength + pRight->ulLength + 1 );
memcpy( szString, pLeft->value.asString.string, pLeft->ulLength );
memcpy( szString + pLeft->ulLength, pRight->value.asString.string, pRight->ulLength );
pLeft->ulLength += pRight->ulLength;
szString[ pLeft->ulLength ] = '\0';
szString = ( char * ) hb_xgrab( pLeft->nLength + pRight->nLength + 1 );
memcpy( szString, pLeft->value.asString.string, pLeft->nLength );
memcpy( szString + pLeft->nLength, pRight->value.asString.string, pRight->nLength );
pLeft->nLength += pRight->nLength;
szString[ pLeft->nLength ] = '\0';
pLeft->value.asString.string = szString;
pLeft->value.asString.dealloc = HB_TRUE;
}
@@ -105,30 +105,30 @@ static HB_EXPR_PTR hb_compExprReducePlusStrings( HB_EXPR_PTR pLeft, HB_EXPR_PTR
static HB_EXPR_PTR hb_compExprReduceMinusStrings( HB_EXPR_PTR pLeft, HB_EXPR_PTR pRight, HB_COMP_DECL )
{
char * szText = pLeft->value.asString.string;
HB_SIZE nLen = pLeft->ulLength;
HB_SIZE nLen = pLeft->nLength;
while( nLen && szText[ nLen - 1 ] == ' ' )
--nLen;
if( pLeft->value.asString.dealloc )
{
pLeft->value.asString.string = (char *) hb_xrealloc( pLeft->value.asString.string, pLeft->ulLength + pRight->ulLength + 1 );
pLeft->value.asString.string = (char *) hb_xrealloc( pLeft->value.asString.string, pLeft->nLength + pRight->nLength + 1 );
memcpy( pLeft->value.asString.string + nLen,
pRight->value.asString.string, pRight->ulLength );
memset( pLeft->value.asString.string + nLen + pRight->ulLength, ' ',
pLeft->ulLength - nLen );
pLeft->ulLength += pRight->ulLength;
pLeft->value.asString.string[ pLeft->ulLength ] = '\0';
pRight->value.asString.string, pRight->nLength );
memset( pLeft->value.asString.string + nLen + pRight->nLength, ' ',
pLeft->nLength - nLen );
pLeft->nLength += pRight->nLength;
pLeft->value.asString.string[ pLeft->nLength ] = '\0';
}
else
{
char *szString;
szString = (char *) hb_xgrab( pLeft->ulLength + pRight->ulLength + 1 );
szString = (char *) hb_xgrab( pLeft->nLength + pRight->nLength + 1 );
memcpy( szString, pLeft->value.asString.string, nLen );
memcpy( szString + nLen, pRight->value.asString.string, pRight->ulLength );
memset( szString + nLen + pRight->ulLength, ' ', pLeft->ulLength - nLen );
pLeft->ulLength += pRight->ulLength;
szString[ pLeft->ulLength ] = '\0';
memcpy( szString + nLen, pRight->value.asString.string, pRight->nLength );
memset( szString + nLen + pRight->nLength, ' ', pLeft->nLength - nLen );
pLeft->nLength += pRight->nLength;
szString[ pLeft->nLength ] = '\0';
pLeft->value.asString.string = szString;
pLeft->value.asString.dealloc = HB_TRUE;
}
@@ -575,14 +575,14 @@ HB_EXPR_PTR hb_compExprReduceMinus( HB_EXPR_PTR pSelf, HB_COMP_DECL )
}
else if( pLeft->ExprType == HB_ET_STRING && pRight->ExprType == HB_ET_STRING )
{
if( pRight->ulLength == 0 )
if( pRight->nLength == 0 )
{
pSelf->ExprType = HB_ET_NONE; /* suppress deletion of operator components */
HB_COMP_EXPR_FREE( pSelf );
pSelf = pLeft;
HB_COMP_EXPR_FREE( pRight );
}
else if( pLeft->ulLength == 0 )
else if( pLeft->nLength == 0 )
{
pSelf->ExprType = HB_ET_NONE; /* suppress deletion of operator components */
HB_COMP_EXPR_FREE( pSelf );
@@ -598,7 +598,7 @@ HB_EXPR_PTR hb_compExprReduceMinus( HB_EXPR_PTR pSelf, HB_COMP_DECL )
if( HB_SUPPORT_MACROTEXT )
{
char * szText = pLeft->value.asString.string;
HB_SIZE nLen = pLeft->ulLength;
HB_SIZE nLen = pLeft->nLength;
while( nLen && szText[ nLen - 1 ] == ' ' )
--nLen;
while( nLen-- )
@@ -880,14 +880,14 @@ HB_EXPR_PTR hb_compExprReducePlus( HB_EXPR_PTR pSelf, HB_COMP_DECL )
}
else if( pLeft->ExprType == HB_ET_STRING && pRight->ExprType == HB_ET_STRING )
{
if( pRight->ulLength == 0 )
if( pRight->nLength == 0 )
{
pSelf->ExprType = HB_ET_NONE; /* suppress deletion of operator components */
HB_COMP_EXPR_FREE( pSelf );
pSelf = pLeft;
HB_COMP_EXPR_FREE( pRight );
}
else if( pLeft->ulLength == 0 )
else if( pLeft->nLength == 0 )
{
pSelf->ExprType = HB_ET_NONE; /* suppress deletion of operator components */
HB_COMP_EXPR_FREE( pSelf );
@@ -903,7 +903,7 @@ HB_EXPR_PTR hb_compExprReducePlus( HB_EXPR_PTR pSelf, HB_COMP_DECL )
if( HB_SUPPORT_MACROTEXT )
{
char * szText = pLeft->value.asString.string;
HB_SIZE nLen = pLeft->ulLength;
HB_SIZE nLen = pLeft->nLength;
while( nLen-- )
{
@@ -1002,9 +1002,9 @@ HB_EXPR_PTR hb_compExprReduceIN( HB_EXPR_PTR pSelf, HB_COMP_DECL )
*/
if( !HB_SUPPORT_MACROTEXT ||
( !hb_compExprHasMacro( pLeft->value.asString.string,
pLeft->ulLength, HB_COMP_PARAM ) &&
pLeft->nLength, HB_COMP_PARAM ) &&
!hb_compExprHasMacro( pRight->value.asString.string,
pRight->ulLength, HB_COMP_PARAM ) ) )
pRight->nLength, HB_COMP_PARAM ) ) )
{
HB_BOOL bResult;
@@ -1017,12 +1017,12 @@ HB_EXPR_PTR hb_compExprReduceIN( HB_EXPR_PTR pSelf, HB_COMP_DECL )
* not enabled f.e. in strict Clipper cmpatible mode (-kc)
* [druzus]
*/
if( pLeft->ulLength == 0 )
if( pLeft->nLength == 0 )
bResult = HB_COMP_PARAM->mode == HB_MODE_COMPILER &&
! HB_SUPPORT_HARBOUR;
else
bResult = ( hb_strAt( pLeft->value.asString.string, pLeft->ulLength,
pRight->value.asString.string, pRight->ulLength ) != 0 );
bResult = ( hb_strAt( pLeft->value.asString.string, pLeft->nLength,
pRight->value.asString.string, pRight->nLength ) != 0 );
HB_COMP_EXPR_FREE( pLeft );
HB_COMP_EXPR_FREE( pRight );
@@ -1069,7 +1069,7 @@ HB_EXPR_PTR hb_compExprReduceNE( HB_EXPR_PTR pSelf, HB_COMP_DECL )
* compared - "" != "" is always HB_FALSE regardless of EXACT
* setting
*/
if( ( pLeft->ulLength | pRight->ulLength ) == 0 )
if( ( pLeft->nLength | pRight->nLength ) == 0 )
{
HB_COMP_EXPR_FREE( pLeft );
HB_COMP_EXPR_FREE( pRight );
@@ -1566,18 +1566,18 @@ HB_EXPR_PTR hb_compExprReduceEQ( HB_EXPR_PTR pSelf, HB_COMP_DECL )
* switch) then we cannot reduce also strings which
* have macro operator '&'
*/
if( ( pLeft->ulLength | pRight->ulLength ) == 0 ||
if( ( pLeft->nLength | pRight->nLength ) == 0 ||
( pSelf->ExprType == HB_EO_EQ &&
( !HB_SUPPORT_MACROTEXT ||
( !hb_compExprHasMacro( pLeft->value.asString.string,
pLeft->ulLength, HB_COMP_PARAM ) &&
pLeft->nLength, HB_COMP_PARAM ) &&
!hb_compExprHasMacro( pRight->value.asString.string,
pRight->ulLength, HB_COMP_PARAM ) ) ) ) )
pRight->nLength, HB_COMP_PARAM ) ) ) ) )
{
HB_BOOL bResult = pLeft->ulLength == pRight->ulLength &&
HB_BOOL bResult = pLeft->nLength == pRight->nLength &&
memcmp( pLeft->value.asString.string,
pRight->value.asString.string,
pLeft->ulLength ) == 0;
pLeft->nLength ) == 0;
HB_COMP_EXPR_FREE( pLeft );
HB_COMP_EXPR_FREE( pRight );
pSelf->ExprType = HB_ET_LOGICAL;
@@ -1938,7 +1938,7 @@ HB_BOOL hb_compExprReduceAT( HB_EXPR_PTR pSelf, HB_COMP_DECL )
* not enabled f.e. in strict Clipper cmpatible mode (-kc)
* [druzus]
*/
if( pSub->ulLength == 0 )
if( pSub->nLength == 0 )
{
pReduced = hb_compExprNewLong( ( HB_COMP_PARAM->mode == HB_MODE_COMPILER &&
! HB_SUPPORT_HARBOUR ) ? 1 : 0, HB_COMP_PARAM );
@@ -1946,8 +1946,8 @@ HB_BOOL hb_compExprReduceAT( HB_EXPR_PTR pSelf, HB_COMP_DECL )
else
{
pReduced = hb_compExprNewLong( hb_strAt( pSub->value.asString.string,
pSub->ulLength, pText->value.asString.string,
pText->ulLength ), HB_COMP_PARAM );
pSub->nLength, pText->value.asString.string,
pText->nLength ), HB_COMP_PARAM );
}
HB_COMP_EXPR_FREE( pSelf->value.asFunCall.pFunName );
@@ -1993,20 +1993,20 @@ HB_BOOL hb_compExprReduceCHR( HB_EXPR_PTR pSelf, HB_COMP_DECL )
{
pExpr->value.asString.string = ( char * ) "";
pExpr->value.asString.dealloc = HB_FALSE;
pExpr->ulLength = 0;
pExpr->nLength = 0;
}
else
{
pExpr->value.asString.string = ( char * ) hb_szAscii[ ( int ) pArg->value.asNum.val.l & 0xff ];
pExpr->value.asString.dealloc = HB_FALSE;
pExpr->ulLength = 1;
pExpr->nLength = 1;
}
}
else
{
pExpr->value.asString.string = ( char * ) hb_szAscii[ ( unsigned int ) pArg->value.asNum.val.d & 0xff ];
pExpr->value.asString.dealloc = HB_FALSE;
pExpr->ulLength = 1;
pExpr->nLength = 1;
}
HB_COMP_EXPR_FREE( pParms );
@@ -2029,7 +2029,7 @@ HB_BOOL hb_compExprReduceLEN( HB_EXPR_PTR pSelf, HB_COMP_DECL )
pArg->ExprType == HB_ET_HASH )
{
HB_EXPR_PTR pExpr = hb_compExprNewLong( pArg->ExprType == HB_ET_HASH ?
pArg->ulLength >> 1 : pArg->ulLength, HB_COMP_PARAM );
pArg->nLength >> 1 : pArg->nLength, HB_COMP_PARAM );
HB_COMP_EXPR_FREE( pParms );
HB_COMP_EXPR_FREE( pSelf->value.asFunCall.pFunName );
@@ -2049,13 +2049,13 @@ HB_BOOL hb_compExprReduceEMPTY( HB_EXPR_PTR pSelf, HB_COMP_DECL )
switch( pArg->ExprType )
{
case HB_ET_STRING:
fResult = hb_strEmpty( pArg->value.asString.string, pArg->ulLength );
fResult = hb_strEmpty( pArg->value.asString.string, pArg->nLength );
break;
case HB_ET_ARRAY:
case HB_ET_HASH:
/* TOFIX: do not optimize when array/hash args have user expressions */
fResult = pArg->ulLength == 0;
fResult = pArg->nLength == 0;
break;
case HB_ET_NUMERIC:
@@ -2194,9 +2194,9 @@ HB_BOOL hb_compExprReduceSTOD( HB_EXPR_PTR pSelf, HB_USHORT usCount, HB_COMP_DEC
pExpr = hb_compExprNewDate( 0, HB_COMP_PARAM );
}
else if( pArg && pArg->ExprType == HB_ET_STRING &&
( pArg->ulLength >= 7 || pArg->ulLength == 0 ) )
( pArg->nLength >= 7 || pArg->nLength == 0 ) )
{
pExpr = hb_compExprNewDate( pArg->ulLength == 0 ? 0 :
pExpr = hb_compExprNewDate( pArg->nLength == 0 ? 0 :
hb_dateEncStr( pArg->value.asString.string ),
HB_COMP_PARAM );
}
@@ -2243,7 +2243,7 @@ HB_BOOL hb_compExprReduceCTOD( HB_EXPR_PTR pSelf, HB_COMP_DECL )
HB_EXPR_PTR pParms = pSelf->value.asFunCall.pParms;
HB_EXPR_PTR pArg = pParms->value.asList.pExprList;
if( pArg->ExprType == HB_ET_STRING && pArg->ulLength == 0 )
if( pArg->ExprType == HB_ET_STRING && pArg->nLength == 0 )
{
HB_EXPR_PTR pExpr = hb_compExprNewDate( 0, HB_COMP_PARAM );
@@ -2264,7 +2264,7 @@ HB_BOOL hb_compExprReduceUPPER( HB_EXPR_PTR pSelf, HB_COMP_DECL )
if( pArg->ExprType == HB_ET_STRING )
{
HB_SIZE nLen = pArg->ulLength;
HB_SIZE nLen = pArg->nLength;
HB_BOOL fLower = HB_FALSE;
if( nLen )
@@ -2290,7 +2290,7 @@ HB_BOOL hb_compExprReduceUPPER( HB_EXPR_PTR pSelf, HB_COMP_DECL )
if( fLower )
{
if( pArg->ulLength == 1 )
if( pArg->nLength == 1 )
{
szValue = ( char * ) hb_szAscii[ HB_TOUPPER( ( unsigned char )
pArg->value.asString.string[ 0 ] ) ];
@@ -2306,13 +2306,13 @@ HB_BOOL hb_compExprReduceUPPER( HB_EXPR_PTR pSelf, HB_COMP_DECL )
}
else
{
szValue = ( char * ) hb_xgrab( pArg->ulLength + 1 );
memcpy( szValue, pArg->value.asString.string, pArg->ulLength + 1 );
szValue = ( char * ) hb_xgrab( pArg->nLength + 1 );
memcpy( szValue, pArg->value.asString.string, pArg->nLength + 1 );
fDealloc = HB_TRUE;
}
do
szValue[ nLen ] = ( char ) HB_TOUPPER( ( unsigned char ) szValue[ nLen ] );
while( ++nLen < pArg->ulLength );
while( ++nLen < pArg->nLength );
}
}
else
@@ -2326,7 +2326,7 @@ HB_BOOL hb_compExprReduceUPPER( HB_EXPR_PTR pSelf, HB_COMP_DECL )
pExpr->ValType = HB_EV_STRING;
pExpr->value.asString.string = szValue;
pExpr->value.asString.dealloc = fDealloc;
pExpr->ulLength = pArg->ulLength;
pExpr->nLength = pArg->nLength;
HB_COMP_EXPR_FREE( pParms );
HB_COMP_EXPR_FREE( pSelf->value.asFunCall.pFunName );

44
harbour/src/compiler/harbour.y
View File

@@ -78,7 +78,7 @@ static void hb_compLoopExit( HB_COMP_DECL );
static void hb_compLoopHere( HB_COMP_DECL );
static long hb_compLoopCount( HB_COMP_DECL );
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirstElseIf, HB_SIZE ulOffset ); /* generates a support structure for elseifs pcode fixups */
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirstElseIf, HB_SIZE nOffset ); /* generates a support structure for elseifs pcode fixups */
static void hb_compElseIfFix( HB_COMP_DECL, void * pIfElseIfs ); /* implements the ElseIfs pcode fixups */
static void hb_compRTVariableAdd( HB_COMP_DECL, HB_EXPR_PTR, HB_BOOL );
@@ -1044,7 +1044,7 @@ CodeBlock : BlockHead
{
hb_xfree( $1->value.asCodeblock.string );
$1->value.asCodeblock.string = NULL;
$1->ulLength = 0;
$1->nLength = 0;
}
HB_COMP_PARAM->iVarScope = VS_PARAMETER;
@@ -1966,7 +1966,7 @@ static void hb_compLoopStart( HB_COMP_DECL, HB_BOOL fCanLoop )
else
pFunc->pLoops = pLoop;
pLoop->ulOffset = pFunc->nPCodePos; /* store the start position */
pLoop->nOffset = 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->nPCodePos;
pLoop->nOffset = 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->nPCodePos;
pLoop->nOffset = pFunc->nPCodePos;
hb_compGenJump( 0, HB_COMP_PARAM );
}
}
@@ -2147,7 +2147,7 @@ static void hb_compLoopHere( HB_COMP_DECL )
pLoop = pLoop->pLoopList;
while( pLoop )
{
hb_compGenJumpHere( pLoop->ulOffset + 1, HB_COMP_PARAM );
hb_compGenJumpHere( pLoop->nOffset + 1, HB_COMP_PARAM );
pFree = pLoop;
pLoop = pLoop->pLoopList;
hb_xfree( pFree );
@@ -2175,7 +2175,7 @@ static void hb_compLoopEnd( HB_COMP_DECL )
pExit = pLoop->pExitList;
while( pExit )
{
hb_compGenJumpHere( pExit->ulOffset + 1, HB_COMP_PARAM );
hb_compGenJumpHere( pExit->nOffset + 1, HB_COMP_PARAM );
pFree = pExit;
pExit = pExit->pExitList;
hb_xfree( pFree );
@@ -2212,12 +2212,12 @@ void hb_compLoopKill( PFUNCTION pFunc )
}
}
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirst, HB_SIZE ulOffset )
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirst, HB_SIZE nOffset )
{
HB_ELSEIF_PTR pElseIf = ( HB_ELSEIF_PTR ) hb_xgrab( sizeof( HB_ELSEIF ) ), pLast;
PFUNCTION pFunc = HB_COMP_PARAM->functions.pLast;
pElseIf->ulOffset = ulOffset;
pElseIf->nOffset = nOffset;
pElseIf->pPrev = NULL;
pElseIf->pElseif = NULL;
@@ -2249,7 +2249,7 @@ static void hb_compElseIfFix( HB_COMP_DECL, void * pFixElseIfs )
HB_COMP_PARAM->functions.pLast->elseif = pFix->pPrev;
while( pFix )
{
hb_compGenJumpHere( pFix->ulOffset, HB_COMP_PARAM );
hb_compGenJumpHere( pFix->nOffset, HB_COMP_PARAM );
pDel = pFix;
pFix = pFix->pElseif;
hb_xfree( pDel );
@@ -2552,8 +2552,8 @@ static void hb_compSwitchStart( HB_COMP_DECL, HB_EXPR_PTR pExpr )
pSwitch->pCases = NULL;
pSwitch->pLast = NULL;
pSwitch->ulDefault = 0;
pSwitch->ulOffset = pFunc->nPCodePos;
pSwitch->nDefault = 0;
pSwitch->nOffset = 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->nPCodePos;
pCase->nOffset = pFunc->nPCodePos;
pCase->pNext = NULL;
pExpr = hb_compExprReduce( pExpr, HB_COMP_PARAM );
if( !( hb_compExprIsLong( pExpr ) || hb_compExprIsString( pExpr ) ) )
@@ -2595,14 +2595,14 @@ static void hb_compSwitchAdd( HB_COMP_DECL, HB_EXPR_PTR pExpr )
else
{
/* DEFAULT */
if( pFunc->pSwitch->ulDefault )
if( pFunc->pSwitch->nDefault )
{
/* more than one default clause */
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'E', HB_COMP_ERR_MAYHEM_IN_CASE, NULL, NULL );
}
else
{
pFunc->pSwitch->ulDefault = pFunc->nPCodePos;
pFunc->pSwitch->nDefault = pFunc->nPCodePos;
}
}
}
@@ -2620,7 +2620,7 @@ static void hb_compSwitchEnd( HB_COMP_DECL )
* or in the DEFAULT case
*/
ulExitPos = hb_compGenJump( 0, HB_COMP_PARAM );
hb_compGenJumpHere( pSwitch->ulOffset + 1, HB_COMP_PARAM );
hb_compGenJumpHere( pSwitch->nOffset + 1, HB_COMP_PARAM );
pCase = pSwitch->pCases;
if( hb_compExprIsLong( pExpr ) || hb_compExprIsString( pExpr ) )
@@ -2646,15 +2646,15 @@ static void hb_compSwitchEnd( HB_COMP_DECL )
if( fGen )
{
hb_compGenJumpThere( hb_compGenJump( 0, HB_COMP_PARAM ),
pCase->ulOffset, HB_COMP_PARAM );
pCase->nOffset, HB_COMP_PARAM );
break;
}
pCase = pCase->pNext;
}
if( pSwitch->ulDefault && !fGen )
if( pSwitch->nDefault && !fGen )
{
hb_compGenJumpThere( hb_compGenJump( 0, HB_COMP_PARAM ),
pSwitch->ulDefault, HB_COMP_PARAM );
pSwitch->nDefault, HB_COMP_PARAM );
}
}
else
@@ -2674,16 +2674,16 @@ static void hb_compSwitchEnd( HB_COMP_DECL )
iCount++;
pCase->pExpr = hb_compExprGenPush( pCase->pExpr, HB_COMP_PARAM );
hb_compGenJumpThere( hb_compGenJump( 0, HB_COMP_PARAM ),
pCase->ulOffset, HB_COMP_PARAM );
pCase->nOffset, HB_COMP_PARAM );
}
pCase = pCase->pNext;
}
if( pSwitch->ulDefault )
if( pSwitch->nDefault )
{
iCount++;
hb_compGenPCode1( HB_P_PUSHNIL, HB_COMP_PARAM );
hb_compGenJumpThere( hb_compGenJump( 0, HB_COMP_PARAM ),
pSwitch->ulDefault, HB_COMP_PARAM );
pSwitch->nDefault, HB_COMP_PARAM );
}
HB_PUT_LE_UINT16( pFunc->pCode + ulCountPos, iCount );

44
harbour/src/compiler/harbour.yyc
View File

@@ -377,7 +377,7 @@ static void hb_compLoopExit( HB_COMP_DECL );
static void hb_compLoopHere( HB_COMP_DECL );
static long hb_compLoopCount( HB_COMP_DECL );
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirstElseIf, HB_SIZE ulOffset ); /* generates a support structure for elseifs pcode fixups */
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirstElseIf, HB_SIZE nOffset ); /* generates a support structure for elseifs pcode fixups */
static void hb_compElseIfFix( HB_COMP_DECL, void * pIfElseIfs ); /* implements the ElseIfs pcode fixups */
static void hb_compRTVariableAdd( HB_COMP_DECL, HB_EXPR_PTR, HB_BOOL );
@@ -5721,7 +5721,7 @@ yyreduce:
{
hb_xfree( (yyvsp[(1) - (2)].asExpr)->value.asCodeblock.string );
(yyvsp[(1) - (2)].asExpr)->value.asCodeblock.string = NULL;
(yyvsp[(1) - (2)].asExpr)->ulLength = 0;
(yyvsp[(1) - (2)].asExpr)->nLength = 0;
}
HB_COMP_PARAM->iVarScope = VS_PARAMETER;
@@ -7135,7 +7135,7 @@ static void hb_compLoopStart( HB_COMP_DECL, HB_BOOL fCanLoop )
else
pFunc->pLoops = pLoop;
pLoop->ulOffset = pFunc->nPCodePos; /* store the start position */
pLoop->nOffset = 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->nPCodePos;
pLoop->nOffset = 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->nPCodePos;
pLoop->nOffset = pFunc->nPCodePos;
hb_compGenJump( 0, HB_COMP_PARAM );
}
}
@@ -7316,7 +7316,7 @@ static void hb_compLoopHere( HB_COMP_DECL )
pLoop = pLoop->pLoopList;
while( pLoop )
{
hb_compGenJumpHere( pLoop->ulOffset + 1, HB_COMP_PARAM );
hb_compGenJumpHere( pLoop->nOffset + 1, HB_COMP_PARAM );
pFree = pLoop;
pLoop = pLoop->pLoopList;
hb_xfree( pFree );
@@ -7344,7 +7344,7 @@ static void hb_compLoopEnd( HB_COMP_DECL )
pExit = pLoop->pExitList;
while( pExit )
{
hb_compGenJumpHere( pExit->ulOffset + 1, HB_COMP_PARAM );
hb_compGenJumpHere( pExit->nOffset + 1, HB_COMP_PARAM );
pFree = pExit;
pExit = pExit->pExitList;
hb_xfree( pFree );
@@ -7381,12 +7381,12 @@ void hb_compLoopKill( PFUNCTION pFunc )
}
}
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirst, HB_SIZE ulOffset )
static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirst, HB_SIZE nOffset )
{
HB_ELSEIF_PTR pElseIf = ( HB_ELSEIF_PTR ) hb_xgrab( sizeof( HB_ELSEIF ) ), pLast;
PFUNCTION pFunc = HB_COMP_PARAM->functions.pLast;
pElseIf->ulOffset = ulOffset;
pElseIf->nOffset = nOffset;
pElseIf->pPrev = NULL;
pElseIf->pElseif = NULL;
@@ -7418,7 +7418,7 @@ static void hb_compElseIfFix( HB_COMP_DECL, void * pFixElseIfs )
HB_COMP_PARAM->functions.pLast->elseif = pFix->pPrev;
while( pFix )
{
hb_compGenJumpHere( pFix->ulOffset, HB_COMP_PARAM );
hb_compGenJumpHere( pFix->nOffset, HB_COMP_PARAM );
pDel = pFix;
pFix = pFix->pElseif;
hb_xfree( pDel );
@@ -7721,8 +7721,8 @@ static void hb_compSwitchStart( HB_COMP_DECL, HB_EXPR_PTR pExpr )
pSwitch->pCases = NULL;
pSwitch->pLast = NULL;
pSwitch->ulDefault = 0;
pSwitch->ulOffset = pFunc->nPCodePos;
pSwitch->nDefault = 0;
pSwitch->nOffset = 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->nPCodePos;
pCase->nOffset = pFunc->nPCodePos;
pCase->pNext = NULL;
pExpr = hb_compExprReduce( pExpr, HB_COMP_PARAM );
if( !( hb_compExprIsLong( pExpr ) || hb_compExprIsString( pExpr ) ) )
@@ -7764,14 +7764,14 @@ static void hb_compSwitchAdd( HB_COMP_DECL, HB_EXPR_PTR pExpr )
else
{
/* DEFAULT */
if( pFunc->pSwitch->ulDefault )
if( pFunc->pSwitch->nDefault )
{
/* more than one default clause */
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'E', HB_COMP_ERR_MAYHEM_IN_CASE, NULL, NULL );
}
else
{
pFunc->pSwitch->ulDefault = pFunc->nPCodePos;
pFunc->pSwitch->nDefault = pFunc->nPCodePos;
}
}
}
@@ -7789,7 +7789,7 @@ static void hb_compSwitchEnd( HB_COMP_DECL )
* or in the DEFAULT case
*/
ulExitPos = hb_compGenJump( 0, HB_COMP_PARAM );
hb_compGenJumpHere( pSwitch->ulOffset + 1, HB_COMP_PARAM );
hb_compGenJumpHere( pSwitch->nOffset + 1, HB_COMP_PARAM );
pCase = pSwitch->pCases;
if( hb_compExprIsLong( pExpr ) || hb_compExprIsString( pExpr ) )
@@ -7815,15 +7815,15 @@ static void hb_compSwitchEnd( HB_COMP_DECL )
if( fGen )
{
hb_compGenJumpThere( hb_compGenJump( 0, HB_COMP_PARAM ),
pCase->ulOffset, HB_COMP_PARAM );
pCase->nOffset, HB_COMP_PARAM );
break;
}
pCase = pCase->pNext;
}
if( pSwitch->ulDefault && !fGen )
if( pSwitch->nDefault && !fGen )
{
hb_compGenJumpThere( hb_compGenJump( 0, HB_COMP_PARAM ),
pSwitch->ulDefault, HB_COMP_PARAM );
pSwitch->nDefault, HB_COMP_PARAM );
}
}
else
@@ -7843,16 +7843,16 @@ static void hb_compSwitchEnd( HB_COMP_DECL )
iCount++;
pCase->pExpr = hb_compExprGenPush( pCase->pExpr, HB_COMP_PARAM );
hb_compGenJumpThere( hb_compGenJump( 0, HB_COMP_PARAM ),
pCase->ulOffset, HB_COMP_PARAM );
pCase->nOffset, HB_COMP_PARAM );
}
pCase = pCase->pNext;
}
if( pSwitch->ulDefault )
if( pSwitch->nDefault )
{
iCount++;
hb_compGenPCode1( HB_P_PUSHNIL, HB_COMP_PARAM );
hb_compGenJumpThere( hb_compGenJump( 0, HB_COMP_PARAM ),
pSwitch->ulDefault, HB_COMP_PARAM );
pSwitch->nDefault, HB_COMP_PARAM );
}
HB_PUT_LE_UINT16( pFunc->pCode + ulCountPos, iCount );

80
harbour/src/compiler/hbmain.c
View File

@@ -161,9 +161,9 @@ int hb_compMain( int argc, const char * const argv[],
if( iStatus == EXIT_SUCCESS )
{
* pBufPtr = HB_COMP_PARAM->pOutBuf;
* pnSize = HB_COMP_PARAM->ulOutBufSize;
* pnSize = HB_COMP_PARAM->nOutBufSize;
HB_COMP_PARAM->pOutBuf = NULL;
HB_COMP_PARAM->ulOutBufSize = 0;
HB_COMP_PARAM->nOutBufSize = 0;
}
else
{
@@ -1263,10 +1263,10 @@ static void hb_compOptimizeJumps( HB_COMP_DECL )
fLineStrip = HB_FALSE;
}
if( HB_COMP_PARAM->functions.pLast->iJumps > 0 )
if( HB_COMP_PARAM->functions.pLast->nJumps > 0 )
{
pJumps = HB_COMP_PARAM->functions.pLast->pJumps;
nJump = HB_COMP_PARAM->functions.pLast->iJumps - 1;
nJump = HB_COMP_PARAM->functions.pLast->nJumps - 1;
do
{
@@ -1393,56 +1393,56 @@ static void hb_compOptimizeJumps( HB_COMP_DECL )
if( pCode[ nJumpAddr ] == HB_P_NOOP ||
pCode[ nJumpAddr ] == HB_P_POP )
{
if( HB_COMP_PARAM->functions.pLast->iJumps > nJump + 1 )
if( HB_COMP_PARAM->functions.pLast->nJumps > nJump + 1 )
memmove( &pJumps[ nJump ], &pJumps[ nJump + 1 ],
( HB_COMP_PARAM->functions.pLast->iJumps - nJump - 1 ) *
( HB_COMP_PARAM->functions.pLast->nJumps - nJump - 1 ) *
sizeof( HB_SIZE ) );
HB_COMP_PARAM->functions.pLast->iJumps--;
HB_COMP_PARAM->functions.pLast->nJumps--;
}
}
while( nJump-- );
if( HB_COMP_PARAM->functions.pLast->iJumps == 0 )
if( HB_COMP_PARAM->functions.pLast->nJumps == 0 )
{
hb_xfree( HB_COMP_PARAM->functions.pLast->pJumps );
HB_COMP_PARAM->functions.pLast->pJumps = NULL;
}
}
if( HB_COMP_PARAM->functions.pLast->iNOOPs == 0 )
if( HB_COMP_PARAM->functions.pLast->nNOOPs == 0 )
{
if( iPass == 0 )
continue;
if( fLineStrip )
hb_compStripFuncLines( HB_COMP_PARAM->functions.pLast );
if( HB_COMP_PARAM->functions.pLast->iNOOPs == 0 )
if( HB_COMP_PARAM->functions.pLast->nNOOPs == 0 )
return;
}
pNOOPs = HB_COMP_PARAM->functions.pLast->pNOOPs;
/* Needed so the pasting of PCODE pieces below will work correctly */
qsort( ( void * ) pNOOPs, HB_COMP_PARAM->functions.pLast->iNOOPs, sizeof( HB_SIZE ), hb_compSort_HB_SIZE );
qsort( ( void * ) pNOOPs, HB_COMP_PARAM->functions.pLast->nNOOPs, sizeof( HB_SIZE ), hb_compSort_HB_SIZE );
if( HB_COMP_PARAM->functions.pLast->iJumps )
if( HB_COMP_PARAM->functions.pLast->nJumps )
{
HB_ISIZ * plSizes, * plShifts;
HB_SIZE nSize;
pJumps = HB_COMP_PARAM->functions.pLast->pJumps;
nSize = sizeof( HB_ISIZ ) * HB_COMP_PARAM->functions.pLast->iJumps;
nSize = sizeof( HB_ISIZ ) * HB_COMP_PARAM->functions.pLast->nJumps;
plSizes = ( HB_ISIZ * ) hb_xgrab( nSize );
plShifts = ( HB_ISIZ * ) hb_xgrab( nSize );
for( nJump = 0; nJump < HB_COMP_PARAM->functions.pLast->iJumps; nJump++ )
for( nJump = 0; nJump < HB_COMP_PARAM->functions.pLast->nJumps; nJump++ )
plSizes[ nJump ] = plShifts[ nJump ] = 0;
/* First Scan NOOPS - Adjust Jump addresses. */
for( nNOOP = 0; nNOOP < HB_COMP_PARAM->functions.pLast->iNOOPs; nNOOP++ )
for( nNOOP = 0; nNOOP < HB_COMP_PARAM->functions.pLast->nNOOPs; nNOOP++ )
{
/* Adjusting preceding jumps that pooint to code beyond the current NOOP
or trailing backward jumps pointing to lower address. */
for( nJump = 0; nJump < HB_COMP_PARAM->functions.pLast->iJumps ; nJump++ )
for( nJump = 0; nJump < HB_COMP_PARAM->functions.pLast->nJumps ; nJump++ )
{
nJumpAddr = pJumps[ nJump ];
switch( pCode[ nJumpAddr ] )
@@ -1496,7 +1496,7 @@ static void hb_compOptimizeJumps( HB_COMP_DECL )
}
}
for( nJump = 0; nJump < HB_COMP_PARAM->functions.pLast->iJumps; nJump++ )
for( nJump = 0; nJump < HB_COMP_PARAM->functions.pLast->nJumps; nJump++ )
{
nOffset = plSizes[ nJump ];
if( nOffset != 0 )
@@ -1532,7 +1532,7 @@ static void hb_compOptimizeJumps( HB_COMP_DECL )
nOptimized = nNextByte = 0;
/* Second Scan, after all adjustements been made, we can copy the optimized code. */
for( nNOOP = 0; nNOOP < HB_COMP_PARAM->functions.pLast->iNOOPs; nNOOP++ )
for( nNOOP = 0; nNOOP < HB_COMP_PARAM->functions.pLast->nNOOPs; nNOOP++ )
{
nBytes2Copy = ( pNOOPs[ nNOOP ] - nNextByte ) ;
@@ -1554,7 +1554,7 @@ static void hb_compOptimizeJumps( HB_COMP_DECL )
hb_xfree( HB_COMP_PARAM->functions.pLast->pNOOPs );
HB_COMP_PARAM->functions.pLast->pNOOPs = NULL;
HB_COMP_PARAM->functions.pLast->iNOOPs = 0;
HB_COMP_PARAM->functions.pLast->nNOOPs = 0;
if( iPass <= 1 )
{
@@ -2235,22 +2235,22 @@ static void hb_compNOOPadd( PFUNCTION pFunc, HB_SIZE nPos )
{
pFunc->pCode[ nPos ] = HB_P_NOOP;
if( pFunc->iNOOPs )
pFunc->pNOOPs = ( HB_SIZE * ) hb_xrealloc( pFunc->pNOOPs, sizeof( HB_SIZE ) * ( pFunc->iNOOPs + 1 ) );
if( pFunc->nNOOPs )
pFunc->pNOOPs = ( HB_SIZE * ) hb_xrealloc( pFunc->pNOOPs, sizeof( HB_SIZE ) * ( pFunc->nNOOPs + 1 ) );
else
pFunc->pNOOPs = ( HB_SIZE * ) hb_xgrab( sizeof( HB_SIZE ) );
pFunc->pNOOPs[ pFunc->iNOOPs++ ] = nPos;
pFunc->pNOOPs[ pFunc->nNOOPs++ ] = nPos;
}
static void hb_compPrepareJumps( HB_COMP_DECL )
{
PFUNCTION pFunc = HB_COMP_PARAM->functions.pLast;
if( pFunc->iJumps )
pFunc->pJumps = ( HB_SIZE * ) hb_xrealloc( pFunc->pJumps, sizeof( HB_SIZE ) * ( pFunc->iJumps + 1 ) );
if( pFunc->nJumps )
pFunc->pJumps = ( HB_SIZE * ) hb_xrealloc( pFunc->pJumps, sizeof( HB_SIZE ) * ( pFunc->nJumps + 1 ) );
else
pFunc->pJumps = ( HB_SIZE * ) hb_xgrab( sizeof( HB_SIZE ) );
pFunc->pJumps[ pFunc->iJumps++ ] = ( HB_SIZE ) ( pFunc->nPCodePos - 4 );
pFunc->pJumps[ pFunc->nJumps++ ] = ( HB_SIZE ) ( pFunc->nPCodePos - 4 );
}
HB_SIZE hb_compGenJump( HB_ISIZ nOffset, HB_COMP_DECL )
@@ -3054,14 +3054,14 @@ void hb_compNOOPfill( PFUNCTION pFunc, HB_SIZE nFrom, HB_ISIZ nCount, HB_BOOL fP
pFunc->pCode[ nFrom ] = HB_P_POP;
fPop = HB_FALSE;
}
else if( fCheck && pFunc->pCode[ nFrom ] == HB_P_NOOP && pFunc->iNOOPs )
else if( fCheck && pFunc->pCode[ nFrom ] == HB_P_NOOP && pFunc->nNOOPs )
{
for( n = 0; n < pFunc->iNOOPs; ++n )
for( n = 0; n < pFunc->nNOOPs; ++n )
{
if( pFunc->pNOOPs[ n ] == nFrom )
break;
}
if( n == pFunc->iNOOPs )
if( n == pFunc->nNOOPs )
hb_compNOOPadd( pFunc, nFrom );
}
else
@@ -3096,15 +3096,15 @@ static void hb_compRemovePCODE( HB_COMP_DECL, HB_SIZE nPos, HB_SIZE nCount,
pFunc->nPCodePos - nPos - nCount );
pFunc->nPCodePos -= nCount;
for( n = pFunc->iNOOPs; n; --n )
for( n = pFunc->nNOOPs; n; --n )
{
if( pFunc->pNOOPs[ n ] >= nPos )
{
if( pFunc->pNOOPs[ n ] < nPos + nCount )
{
memmove( &pFunc->pNOOPs[ n ], &pFunc->pNOOPs[ n + 1 ],
pFunc->iNOOPs - n );
pFunc->iNOOPs--;
pFunc->nNOOPs - n );
pFunc->nNOOPs--;
}
else
{
@@ -3119,7 +3119,7 @@ HB_BOOL hb_compHasJump( PFUNCTION pFunc, HB_SIZE nPos )
{
HB_SIZE nJump;
for( nJump = 0; nJump < pFunc->iJumps; nJump++ )
for( nJump = 0; nJump < pFunc->nJumps; nJump++ )
{
HB_SIZE nJumpAddr = pFunc->pJumps[ nJump ];
switch( pFunc->pCode[ nJumpAddr ] )
@@ -3663,14 +3663,14 @@ void hb_compCodeBlockRewind( HB_COMP_DECL )
{
hb_xfree( pCodeblock->pNOOPs );
pCodeblock->pNOOPs = NULL;
pCodeblock->iNOOPs = 0;
pCodeblock->nNOOPs = 0;
}
/* Release the Jumps array. */
if( pCodeblock->pJumps )
{
hb_xfree( pCodeblock->pJumps );
pCodeblock->pJumps = NULL;
pCodeblock->iJumps = 0;
pCodeblock->nJumps = 0;
}
}
@@ -3731,7 +3731,7 @@ static void hb_compGenOutput( HB_COMP_DECL, int iLanguage )
case HB_LANG_PORT_OBJ_BUF:
if( HB_COMP_PARAM->pOutBuf )
hb_xfree( HB_COMP_PARAM->pOutBuf );
hb_compGenBufPortObj( HB_COMP_PARAM, &HB_COMP_PARAM->pOutBuf, &HB_COMP_PARAM->ulOutBufSize );
hb_compGenBufPortObj( HB_COMP_PARAM, &HB_COMP_PARAM->pOutBuf, &HB_COMP_PARAM->nOutBufSize );
break;
}
}
@@ -3960,16 +3960,16 @@ static void hb_compGenIncluded( HB_COMP_DECL )
nLen += strlen( pIncFile->szFileName ) + 1;
pIncFile = pIncFile->pNext;
}
if( HB_COMP_PARAM->ulOutBufSize != 0 )
if( HB_COMP_PARAM->nOutBufSize != 0 )
++nLen;
u = strlen( szDestFile );
if( u )
nLen += u + 2;
HB_COMP_PARAM->pOutBuf = ( HB_BYTE * ) hb_xrealloc(
HB_COMP_PARAM->pOutBuf,
HB_COMP_PARAM->ulOutBufSize + nLen );
buffer = HB_COMP_PARAM->pOutBuf + HB_COMP_PARAM->ulOutBufSize;
if( HB_COMP_PARAM->ulOutBufSize != 0 )
HB_COMP_PARAM->nOutBufSize + nLen );
buffer = HB_COMP_PARAM->pOutBuf + HB_COMP_PARAM->nOutBufSize;
if( HB_COMP_PARAM->nOutBufSize != 0 )
*buffer++ = '\n';
if( u )
{
@@ -3978,7 +3978,7 @@ static void hb_compGenIncluded( HB_COMP_DECL )
*buffer++ = ':';
*buffer++ = ' ';
}
HB_COMP_PARAM->ulOutBufSize += nLen - 1;
HB_COMP_PARAM->nOutBufSize += nLen - 1;
pIncFile = HB_COMP_PARAM->incfiles;
while( pIncFile )
{

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

@@ -113,8 +113,8 @@ static int hb_macroParse( HB_MACRO_PTR pMacro )
/* initialize the output (pcode) buffer - it will be filled by yacc */
pMacro->pCodeInfo = &pMacro->pCodeInfoBuffer;
pMacro->pCodeInfo->lPCodeSize = HB_PCODE_SIZE;
pMacro->pCodeInfo->lPCodePos = 0;
pMacro->pCodeInfo->nPCodeSize = HB_PCODE_SIZE;
pMacro->pCodeInfo->nPCodePos = 0;
pMacro->pCodeInfo->fVParams = HB_FALSE;
pMacro->pCodeInfo->pLocals = NULL;
pMacro->pCodeInfo->pPrev = NULL;
@@ -812,13 +812,13 @@ static void hb_macroBlock( const char * szString, PHB_ITEM pItem )
if( pMacro )
{
pMacro->pCodeInfo->pCode[ pMacro->pCodeInfo->lPCodePos - 1 ] = HB_P_ENDBLOCK;
pMacro->pCodeInfo->pCode[ pMacro->pCodeInfo->nPCodePos - 1 ] = HB_P_ENDBLOCK;
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
pItem->item.asBlock.value = hb_codeblockMacroNew( pMacro->pCodeInfo->pCode,
pMacro->pCodeInfo->lPCodePos );
pMacro->pCodeInfo->nPCodePos );
pItem->type = HB_IT_BLOCK;
pItem->item.asBlock.paramcnt = 0;
pItem->item.asBlock.lineno = 0;
@@ -1121,7 +1121,7 @@ HB_SIZE hb_macroGenJump( HB_ISIZ nOffset, HB_COMP_DECL )
else
hb_macroError( HB_MACRO_TOO_COMPLEX, HB_COMP_PARAM );
return HB_PCODE_DATA->lPCodePos - 3;
return HB_PCODE_DATA->nPCodePos - 3;
}
HB_SIZE hb_macroGenJumpFalse( HB_ISIZ nOffset, HB_COMP_DECL )
@@ -1137,7 +1137,7 @@ HB_SIZE hb_macroGenJumpFalse( HB_ISIZ nOffset, HB_COMP_DECL )
else
hb_macroError( HB_MACRO_TOO_COMPLEX, HB_COMP_PARAM );
return HB_PCODE_DATA->lPCodePos - 3;
return HB_PCODE_DATA->nPCodePos - 3;
}
HB_SIZE hb_macroGenJumpTrue( HB_ISIZ nOffset, HB_COMP_DECL )
@@ -1153,7 +1153,7 @@ HB_SIZE hb_macroGenJumpTrue( HB_ISIZ nOffset, HB_COMP_DECL )
else
hb_macroError( HB_MACRO_TOO_COMPLEX, HB_COMP_PARAM );
return HB_PCODE_DATA->lPCodePos - 3;
return HB_PCODE_DATA->nPCodePos - 3;
}
void hb_macroGenJumpThere( HB_SIZE nFrom, HB_SIZE nTo, HB_COMP_DECL )
@@ -1169,7 +1169,7 @@ void hb_macroGenJumpThere( HB_SIZE nFrom, HB_SIZE nTo, HB_COMP_DECL )
void hb_macroGenJumpHere( HB_SIZE nOffset, HB_COMP_DECL )
{
hb_macroGenJumpThere( nOffset, HB_PCODE_DATA->lPCodePos, HB_COMP_PARAM );
hb_macroGenJumpThere( nOffset, HB_PCODE_DATA->nPCodePos, HB_COMP_PARAM );
}
/*
@@ -1560,61 +1560,61 @@ void hb_macroGenPCode1( HB_BYTE byte, HB_COMP_DECL )
{
HB_PCODE_INFO_PTR pFunc = HB_PCODE_DATA;
if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 1 )
pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize += HB_PCODE_SIZE );
if( ( pFunc->nPCodeSize - pFunc->nPCodePos ) < 1 )
pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->nPCodeSize += HB_PCODE_SIZE );
pFunc->pCode[ pFunc->lPCodePos++ ] = byte;
pFunc->pCode[ pFunc->nPCodePos++ ] = byte;
}
void hb_macroGenPCode2( HB_BYTE byte1, HB_BYTE byte2, HB_COMP_DECL )
{
HB_PCODE_INFO_PTR pFunc = HB_PCODE_DATA;
if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 2 )
pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize += HB_PCODE_SIZE );
if( ( pFunc->nPCodeSize - pFunc->nPCodePos ) < 2 )
pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->nPCodeSize += HB_PCODE_SIZE );
pFunc->pCode[ pFunc->lPCodePos++ ] = byte1;
pFunc->pCode[ pFunc->lPCodePos++ ] = byte2;
pFunc->pCode[ pFunc->nPCodePos++ ] = byte1;
pFunc->pCode[ pFunc->nPCodePos++ ] = byte2;
}
void hb_macroGenPCode3( HB_BYTE byte1, HB_BYTE byte2, HB_BYTE byte3, HB_COMP_DECL )
{
HB_PCODE_INFO_PTR pFunc = HB_PCODE_DATA;
if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 3 )
pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize += HB_PCODE_SIZE );
if( ( pFunc->nPCodeSize - pFunc->nPCodePos ) < 3 )
pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->nPCodeSize += HB_PCODE_SIZE );
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_macroGenPCode4( HB_BYTE byte1, HB_BYTE byte2, HB_BYTE byte3, HB_BYTE byte4, HB_COMP_DECL )
{
HB_PCODE_INFO_PTR pFunc = HB_PCODE_DATA;
if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 4 )
pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize += HB_PCODE_SIZE );
if( ( pFunc->nPCodeSize - pFunc->nPCodePos ) < 4 )
pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->nPCodeSize += HB_PCODE_SIZE );
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_macroGenPCodeN( HB_BYTE * pBuffer, HB_SIZE nSize, HB_COMP_DECL )
{
HB_PCODE_INFO_PTR pFunc = HB_PCODE_DATA;
if( pFunc->lPCodePos + nSize > pFunc->lPCodeSize )
if( pFunc->nPCodePos + nSize > pFunc->nPCodeSize )
{
/* not enough free space in pcode buffer - increase it */
pFunc->lPCodeSize += ( ( ( nSize / HB_PCODE_SIZE ) + 1 ) * HB_PCODE_SIZE );
pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->lPCodeSize );
pFunc->nPCodeSize += ( ( ( nSize / HB_PCODE_SIZE ) + 1 ) * HB_PCODE_SIZE );
pFunc->pCode = ( HB_BYTE * ) hb_xrealloc( pFunc->pCode, pFunc->nPCodeSize );
}
memcpy( pFunc->pCode + pFunc->lPCodePos, pBuffer, nSize );
pFunc->lPCodePos += nSize;
memcpy( pFunc->pCode + pFunc->nPCodePos, pBuffer, nSize );
pFunc->nPCodePos += nSize;
}
/* ************************************************************************* */
@@ -1637,8 +1637,8 @@ void hb_macroCodeBlockStart( HB_COMP_DECL )
pCB = ( HB_PCODE_INFO_PTR ) hb_xgrab( sizeof( HB_PCODE_INFO ) );
pCB->pCode = ( HB_BYTE * ) hb_xgrab( HB_PCODE_SIZE );
pCB->lPCodeSize = HB_PCODE_SIZE;
pCB->lPCodePos = 0;
pCB->nPCodeSize = HB_PCODE_SIZE;
pCB->nPCodePos = 0;
pCB->fVParams = HB_FALSE;
pCB->pLocals = NULL;
@@ -1681,7 +1681,7 @@ void hb_macroCodeBlockEnd( HB_COMP_DECL )
* runtime compiled codeblock cannot reference local variables defined in a
* function
*/
nSize = pCodeblock->lPCodePos + 6;
nSize = pCodeblock->nPCodePos + 6;
/* NOTE: HB_P_MPUSHBLOCK differs from HB_P_PUSHBLOCK - the pcode
* is stored in dynamic memory pool instead of static memory
@@ -1696,7 +1696,7 @@ void hb_macroCodeBlockEnd( HB_COMP_DECL )
hb_macroGenPCode2( HB_LOBYTE( usParms ), HB_HIBYTE( usParms ), HB_COMP_PARAM );
/* copy a codeblock pcode buffer */
hb_macroGenPCodeN( pCodeblock->pCode, pCodeblock->lPCodePos, HB_COMP_PARAM );
hb_macroGenPCodeN( pCodeblock->pCode, pCodeblock->nPCodePos, HB_COMP_PARAM );
hb_macroGenPCode1( HB_P_ENDBLOCK, HB_COMP_PARAM ); /* finish the codeblock */
/* free memory allocated for a codeblock */