diff --git a/harbour/ChangeLog b/harbour/ChangeLog
index 83aeb440ae..cfb09ae5fa 100644
--- a/harbour/ChangeLog
+++ b/harbour/ChangeLog
@@ -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
diff --git a/harbour/contrib/make.hbs b/harbour/contrib/make.hbs
index aca75f4605..60c07a8c7d 100755
--- a/harbour/contrib/make.hbs
+++ b/harbour/contrib/make.hbs
@@ -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.
diff --git a/harbour/include/hbcompdf.h b/harbour/include/hbcompdf.h
index 1ca28ee67e..28d86da36b 100644
--- a/harbour/include/hbcompdf.h
+++ b/harbour/include/hbcompdf.h
@@ -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 */
diff --git a/harbour/include/hbexpra.c b/harbour/include/hbexpra.c
index f1af88039c..083c5335ba 100644
--- a/harbour/include/hbexpra.c
+++ b/harbour/include/hbexpra.c
@@ -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;
 }
diff --git a/harbour/include/hbexprb.c b/harbour/include/hbexprb.c
index 1e5ac54698..f031b9fd8a 100644
--- a/harbour/include/hbexprb.c
+++ b/harbour/include/hbexprb.c
@@ -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 )
diff --git a/harbour/src/common/expropt1.c b/harbour/src/common/expropt1.c
index d02b7b573d..caf71018ab 100644
--- a/harbour/src/common/expropt1.c
+++ b/harbour/src/common/expropt1.c
@@ -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;
 }
 
diff --git a/harbour/src/common/expropt2.c b/harbour/src/common/expropt2.c
index eda2c3c0a4..41965805e3 100644
--- a/harbour/src/common/expropt2.c
+++ b/harbour/src/common/expropt2.c
@@ -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 );
diff --git a/harbour/src/compiler/harbour.y b/harbour/src/compiler/harbour.y
index f1bef847f4..82436bbab4 100644
--- a/harbour/src/compiler/harbour.y
+++ b/harbour/src/compiler/harbour.y
@@ -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 );
 
diff --git a/harbour/src/compiler/harbour.yyc b/harbour/src/compiler/harbour.yyc
index f88bf2b445..e508a2c1a6 100644
--- a/harbour/src/compiler/harbour.yyc
+++ b/harbour/src/compiler/harbour.yyc
@@ -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 );
 
diff --git a/harbour/src/compiler/hbmain.c b/harbour/src/compiler/hbmain.c
index 82deb6fcce..1ec382a2e9 100644
--- a/harbour/src/compiler/hbmain.c
+++ b/harbour/src/compiler/hbmain.c
@@ -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 )
          {
diff --git a/harbour/src/vm/macro.c b/harbour/src/vm/macro.c
index 1e5814ceee..54310889f5 100644
--- a/harbour/src/vm/macro.c
+++ b/harbour/src/vm/macro.c
@@ -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 */