diff --git a/harbour/ChangeLog b/harbour/ChangeLog
index ddd52f21af..fa7ca459cd 100644
--- a/harbour/ChangeLog
+++ b/harbour/ChangeLog
@@ -1,3 +1,16 @@
+2001-04-08 16:15 UTC-0800 Ron Pinkas <ron@profit-master.com>
+   * include/hberrors.h
+     ! Corrected typo.
+
+   * source/compiler/harbour.sly
+   * source/compiler/harbour.y
+     ! Corrected few incorrect "Unreachable code warnings".
+     ! Corrected hb_compPushLine() in RECOVER and RECOVERUSING
+
+   * source/compiler/harbour.c
+   * source/compiler/hbpcode.c
+     ! Improved StrongType logic.
+
 2001-04-07 13:25 UTC-0800 Ron Pinkas <ron@profit-master.com>
    * source/compiler/hbpcode.c
      ! Fixed some StrongType logic.
diff --git a/harbour/include/hberrors.h b/harbour/include/hberrors.h
index ef0c38b7db..e126e8c078 100644
--- a/harbour/include/hberrors.h
+++ b/harbour/include/hberrors.h
@@ -106,7 +106,7 @@ extern "C" {
 #define HB_COMP_WARN_FUN_WITH_NO_RETURN         7
 #define HB_COMP_WARN_ASSIGN_TYPE                8
 #define HB_COMP_WARN_OPERAND_TYPE               9
-#define HB_COMP_WARN_OPERANDS_INCOMPATBLE       10
+#define HB_COMP_WARN_OPERANDS_INCOMPATIBLE      10
 #define HB_COMP_WARN_ASSIGN_SUSPECT             11
 #define HB_COMP_WARN_OPERAND_SUSPECT            12
 #define HB_COMP_WARN_NOT_ARRAY                  13
diff --git a/harbour/source/compiler/harbour.c b/harbour/source/compiler/harbour.c
index c7c6e9f692..ec23a95886 100644
--- a/harbour/source/compiler/harbour.c
+++ b/harbour/source/compiler/harbour.c
@@ -1744,19 +1744,19 @@ ULONG hb_compGenJump( LONG lOffset )
    /* Just a place holder, it might be a far jump...*/
    if( lOffset == 0 )
    {
-      hb_compGenPCode4( HB_P_JUMPFAR, 0, 0, 0, ( BOOL ) 0 );
+      hb_compGenPCode4( HB_P_JUMPFAR, 0, 0, 0, ( BOOL ) 1 );
    }
    else if( lOffset >= -128 && lOffset <= 127 )
    {
-      hb_compGenPCode4( HB_P_JUMPNEAR, HB_LOBYTE( lOffset ), HB_P_NOOP, HB_P_NOOP, ( BOOL ) 0 );
+      hb_compGenPCode4( HB_P_JUMPNEAR, HB_LOBYTE( lOffset ), HB_P_NOOP, HB_P_NOOP, ( BOOL ) 1 );
    }
    else if( lOffset >= SHRT_MIN && lOffset <= SHRT_MAX )
    {
-      hb_compGenPCode4( HB_P_JUMP, HB_LOBYTE( lOffset ), HB_HIBYTE( lOffset ), HB_P_NOOP, ( BOOL ) 0 );
+      hb_compGenPCode4( HB_P_JUMP, HB_LOBYTE( lOffset ), HB_HIBYTE( lOffset ), HB_P_NOOP, ( BOOL ) 1 );
    }
    else if( lOffset >= (-8388608L) && lOffset <= 8388607L )
    {
-      hb_compGenPCode4( HB_P_JUMPFAR, HB_LOBYTE( lOffset ), HB_HIBYTE( lOffset ), ( BYTE ) ( ( ( USHORT ) ( lOffset ) >> 16 ) & 0xFF ), ( BOOL ) 0 );
+      hb_compGenPCode4( HB_P_JUMPFAR, HB_LOBYTE( lOffset ), HB_HIBYTE( lOffset ), ( BYTE ) ( ( ( USHORT ) ( lOffset ) >> 16 ) & 0xFF ), ( BOOL ) 1 );
    }
    else
    {
@@ -3223,6 +3223,15 @@ void hb_compCodeBlockStart()
 {
    PFUNCTION pBlock;
 
+   #if 0
+      if( hb_comp_iWarnings >= 3 )
+      {
+	     /* Not generating yet - will be generated in hb_compCodeBlockEnd() */
+         hb_compGenPCode1( HB_P_PUSHBLOCK );
+         pBlock->lPCodePos--;
+      }
+   #endif
+
    pBlock               = hb_compFunctionNew( NULL, HB_FS_STATIC );
    pBlock->pOwner       = hb_comp_functions.pLast;
    pBlock->iStaticsBase = hb_comp_functions.pLast->iStaticsBase;
@@ -3273,9 +3282,7 @@ void hb_compCodeBlockEnd( void )
       ++wLocals;
    }
 
-   if( ( pCodeblock->lPCodePos + 3 ) <= 255 &&
-       pCodeblock->wParamCount == 0 &&
-       wLocals == 0 )
+   if( ( pCodeblock->lPCodePos + 3 ) <= 255 &&  pCodeblock->wParamCount == 0 && wLocals == 0 )
    {
       /* NOTE: 3 = HB_P_PUSHBLOCKSHORT + BYTE( size ) + _ENDBLOCK */
       wSize = ( USHORT ) pCodeblock->lPCodePos + 3;
diff --git a/harbour/source/compiler/harbour.sly b/harbour/source/compiler/harbour.sly
index 2358b1de3f..ec787057b6 100644
--- a/harbour/source/compiler/harbour.sly
+++ b/harbour/source/compiler/harbour.sly
@@ -1538,7 +1538,7 @@ IfElse     : ELSE Crlf { hb_comp_functions.pLast->bFlags &= ~ FUN_BREAK_CODE; }
                 EmptyStats
            ;
 
-IfElseIf   : ELSEIF { hb_compLinePush(); } Expression Crlf
+IfElseIf   : ELSEIF { hb_comp_functions.pLast->bFlags &= ~ FUN_BREAK_CODE; hb_compLinePush(); } Expression Crlf
                 { hb_comp_functions.pLast->bFlags &= ~ FUN_BREAK_CODE;
                   hb_compExprDelete( hb_compExprGenPush( $3 ) );
                   $<iNumber>$ = hb_compGenJumpFalse( 0 );
@@ -1548,7 +1548,7 @@ IfElseIf   : ELSEIF { hb_compLinePush(); } Expression Crlf
                   hb_compGenJumpHere( $<iNumber>5 );
                 }
 
-           | IfElseIf ELSEIF { hb_compLinePush(); } Expression Crlf
+           | IfElseIf ELSEIF { hb_comp_functions.pLast->bFlags &= ~ FUN_BREAK_CODE; hb_compLinePush(); } Expression Crlf
                 { hb_comp_functions.pLast->bFlags &= ~ FUN_BREAK_CODE;
                   hb_compExprDelete( hb_compExprGenPush( $4 ) );
                   $<iNumber>$ = hb_compGenJumpFalse( 0 );
@@ -1654,8 +1654,8 @@ DoWhile    : WhileBegin Expression Crlf
 WhileBegin : WHILE    { $$ = hb_comp_functions.pLast->lPCodePos; hb_compLinePushIfInside(); ++hb_comp_wWhileCounter; hb_compLoopStart(); }
            ;
 
-EndWhile   : END
-           | ENDDO
+EndWhile   : END   { hb_comp_functions.pLast->bFlags &= ~ FUN_BREAK_CODE; }
+           | ENDDO { hb_comp_functions.pLast->bFlags &= ~ FUN_BREAK_CODE; }
            ;
 
 ForNext    : FOR LValue ForAssign Expression          /* 1  2  3  4 */
@@ -1755,7 +1755,8 @@ RecoverEmpty : RECOVER
                   hb_comp_functions.pLast->bFlags &= ~ FUN_BREAK_CODE;
                   $<lNumber>$ = hb_comp_functions.pLast->lPCodePos;
                   --hb_comp_wSeqCounter;
-                  hb_compGenPCode2( HB_P_SEQRECOVER, HB_P_POP, ( BOOL ) 1 );
+                  hb_compLinePush();
+                  hb_compGenPCode2( HB_P_SEQRECOVER, HB_P_POP, ( BOOL ) 0 );
                }
            ;
 
@@ -1764,8 +1765,8 @@ RecoverUsing : RECOVERUSING IdentName
                   hb_comp_functions.pLast->bFlags &= ~ FUN_BREAK_CODE;
                   $<lNumber>$ = hb_comp_functions.pLast->lPCodePos;
                   --hb_comp_wSeqCounter;
-                  hb_compGenPCode1( HB_P_SEQRECOVER );
                   hb_compLinePush();
+                  hb_compGenPCode1( HB_P_SEQRECOVER );
                   hb_compGenPopVar( $2 );
                }
            ;
diff --git a/harbour/source/compiler/harbour.y b/harbour/source/compiler/harbour.y
index c5962ef786..8e38864272 100644
--- a/harbour/source/compiler/harbour.y
+++ b/harbour/source/compiler/harbour.y
@@ -1464,8 +1464,8 @@ DoWhile    : WhileBegin Expression Crlf
 WhileBegin : WHILE    { $$ = hb_comp_functions.pLast->lPCodePos; hb_compLinePushIfInside(); ++hb_comp_wWhileCounter; hb_compLoopStart(); }
            ;
 
-EndWhile   : END
-           | ENDDO
+EndWhile   : END   { hb_comp_functions.pLast->bFlags &= ~ FUN_BREAK_CODE; }
+           | ENDDO { hb_comp_functions.pLast->bFlags &= ~ FUN_BREAK_CODE; }
            ;
 
 ForNext    : FOR LValue ForAssign Expression          /* 1  2  3  4 */
@@ -1565,7 +1565,8 @@ RecoverEmpty : RECOVER
                   hb_comp_functions.pLast->bFlags &= ~ FUN_BREAK_CODE;
                   $<lNumber>$ = hb_comp_functions.pLast->lPCodePos;
                   --hb_comp_wSeqCounter;
-                  hb_compGenPCode2( HB_P_SEQRECOVER, HB_P_POP, ( BOOL ) 1 );
+                  hb_compLinePush();
+                  hb_compGenPCode2( HB_P_SEQRECOVER, HB_P_POP, ( BOOL ) 0 );
                }
            ;
 
@@ -1574,8 +1575,8 @@ RecoverUsing : RECOVERUSING IdentName
                   hb_comp_functions.pLast->bFlags &= ~ FUN_BREAK_CODE;
                   $<lNumber>$ = hb_comp_functions.pLast->lPCodePos;
                   --hb_comp_wSeqCounter;
-                  hb_compGenPCode1( HB_P_SEQRECOVER );
                   hb_compLinePush();
+                  hb_compGenPCode1( HB_P_SEQRECOVER );
                   hb_compGenPopVar( $2 );
                }
            ;
diff --git a/harbour/source/compiler/hbpcode.c b/harbour/source/compiler/hbpcode.c
index 4681e11042..f526bd9907 100644
--- a/harbour/source/compiler/hbpcode.c
+++ b/harbour/source/compiler/hbpcode.c
@@ -234,14 +234,23 @@ void hb_compStrongType( int iSize )
    PCOMDECLARED pDeclared;
    ULONG ulPos = pFunc->lPCodePos - iSize;
    SHORT wVar = 0;
-   BYTE szType1[64], szType2[64], cType, cSubType1 = 0, cSubType2 = 0;
+   BYTE szType0[64], szType1[64], szType2[64], cType, cSubType0 = 0, cSubType1 = 0, cSubType2 = 0;
    BYTE bLast1, bLast2;
+   static int s_aiPreCondStack[ 16 ], s_iCondIndex = 0;
+
+   /*
+   printf( "\nProcessing: %i Stack: %i\n", pFunc->pCode[ ulPos ], pFunc->iStackSize );
+   */
 
    /* Make sure we have enough stack space. */
    if( ! pFunc->pStack )
+   {
       pFunc->pStack = ( BYTE * ) hb_xgrab( pFunc->iStackSize += 16 );
+   }
    else if( pFunc->iStackSize - pFunc->iStackIndex < 4 )
+   {
       pFunc->pStack = ( BYTE * ) hb_xrealloc( pFunc->pStack, pFunc->iStackSize += 16 );
+   }
 
    /* TODO: Split under conitions for the different matching possible iSize. */
 
@@ -274,7 +283,9 @@ void hb_compStrongType( int iSize )
           if( pDeclared )
           {
              if( hb_comp_cCastType == ' ' )
-                ; /* No casting - do nothing. */
+			 {
+                /* No casting - do nothing. */
+			 }
              else if( toupper( hb_comp_cCastType ) == 'S' )
              {
                 PCOMCLASS pClass = hb_compClassFind( hb_comp_szFromClass );
@@ -306,10 +317,14 @@ void hb_compStrongType( int iSize )
              }
 
              /* Variant as SubType. */
-             if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+             if( ( pFunc->pStack[ pFunc->iStackIndex ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+			 {
                 cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT );
+			 }
              else
+			 {
                 cType1 = pFunc->pStack[ pFunc->iStackIndex ];
+			 }
 
              if( cSubType1 )
              {
@@ -366,7 +381,12 @@ void hb_compStrongType( int iSize )
           wVar = pFunc->pCode[ ulPos + 1 ];
 
        if( pFunc->iStackIndex < ( wVar + 2 ) )
+	   {
+		  /*
+		  printf( "\nNeeded %i values, found %i!\n", wVar + 1, pFunc->iStackIndex - 1 );
+		  */
           break;
+	   }
 
        if( pFunc->iStackFunctions > 0 && pFunc->pStackFunctions[ --pFunc->iStackFunctions ] )
        {
@@ -388,31 +408,46 @@ void hb_compStrongType( int iSize )
 
           /*printf( "\nOptionals: %i\n", iOptionals );*/
 
-          //printf( "Exec Function: %s, wVar: %i Parameters: %i Optionals: %i\n", pFunc->pStackFunctions[ pFunc->iStackFunctions ]->szName,wVar, hb_comp_iParamCount, iOptionals );
+          printf( "\nExec Function: %s, wVar: %i Parameters: %i Optionals: %i\n", pFunc->pStackFunctions[ pFunc->iStackFunctions ]->szName,wVar, hb_comp_iParamCount, iOptionals );
 
           /* Now, check the types. */
           if( wVar >= ( hb_comp_iParamCount - iOptionals ) && wVar <= hb_comp_iParamCount )
           {
-             BYTE iParamBase = pFunc->iStackIndex - wVar, cFormalType;
+             BYTE iParamBase = pFunc->iStackIndex - wVar, cFormalType, cParamType;
              int iOffset = wVar;
 
              while ( --iOffset >= 0 )
              {
-                cFormalType = hb_comp_cParamTypes[ iOffset ];
+				cParamType = pFunc->pStack[ iParamBase + iOffset ];
+                if( ( cParamType == '-' + VT_OFFSET_VARIANT ) || cParamType >= ( 'A' + VT_OFFSET_VARIANT ) )
+			    {
+                   cParamType -= VT_OFFSET_VARIANT;
+			    }
 
+                cFormalType = hb_comp_cParamTypes[ iOffset ];
                 if( cFormalType == ( ' ' + VT_OFFSET_OPTIONAL ) || cFormalType >= ( 'A' + VT_OFFSET_OPTIONAL ) )
+				{
                    cFormalType -= VT_OFFSET_OPTIONAL;
+				}
 
                 if( cFormalType == ' ' + VT_OFFSET_BYREF )
+				{
                    cFormalType = '@';
+				}
 
                 if( cFormalType == ' ' )
-                   ; /* Declared is Variant, accept anything. */
-                else if( pFunc->pStack[ iParamBase + iOffset ] == '-' )
-                   ; /* Parameter is NIL, always accepted. */
-                else if( cFormalType == '@' && pFunc->pStack[ iParamBase + iOffset ] >= ( 'A' + VT_OFFSET_BYREF ) )
-                   ; /* Prameter is ANY REFERENCE, and Parameter is SOME REFERENCE. */
-                else if( cFormalType == 'S' && pFunc->pStack[ iParamBase + iOffset ] == 'S' && pFunc->iStackClasses )
+				{
+                   /* Declared is Variant, accept anything. */
+				}
+                else if( cParamType == '-' )
+				{
+                   /* Parameter is NIL, always accepted. */
+				}
+                else if( cFormalType == '@' && cParamType >= ( 'A' + VT_OFFSET_BYREF ) )
+				{
+                   /* Prameter is ANY REFERENCE, and Parameter is SOME REFERENCE. */
+				}
+                else if( cFormalType == 'S' && cParamType == 'S' && pFunc->iStackClasses )
                 {
                    PCOMCLASS hb_comp_pFormalClass = pFunc->pStackFunctions[ pFunc->iStackFunctions ]->pParamClasses[ iOffset ];
                    PCOMCLASS hb_comp_pParamClass = pFunc->pStackClasses[ --pFunc->iStackClasses ];
@@ -424,7 +459,7 @@ void hb_compStrongType( int iSize )
                       hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_PARAM_TYPE, ( char * ) szType1, ( char * ) szType2 );
                    }
                 }
-                else if( cFormalType == 's' && pFunc->pStack[ iParamBase + iOffset ] == 's' && pFunc->iStackClasses )
+                else if( cFormalType == 's' && cParamType == 's' && pFunc->iStackClasses )
                 {
                    PCOMCLASS hb_comp_pFormalClass = pFunc->pStackFunctions[ pFunc->iStackFunctions ]->pParamClasses[ iOffset ];
                    PCOMCLASS hb_comp_pParamClass = pFunc->pStackClasses[ --pFunc->iStackClasses ];
@@ -436,7 +471,7 @@ void hb_compStrongType( int iSize )
                       hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_PARAM_TYPE, ( char * ) szType1, ( char * ) szType2 );
                    }
                 }
-                else if( cFormalType != pFunc->pStack[ iParamBase + iOffset ] )
+                else if( cFormalType != cParamType )
                 {
                    if( cFormalType == 'S' )
                    {
@@ -451,11 +486,17 @@ void hb_compStrongType( int iSize )
                    else
                    {
                       if( cFormalType > ( 'A' + VT_OFFSET_BYREF ) )
+					  {
                          sprintf( ( char * ) szType2, "@%c", cFormalType - VT_OFFSET_BYREF );
+					  }
                       else if( toupper( pFunc->pStack[ iParamBase + iOffset ] ) == 'S' && pFunc->iStackClasses )
+					  {
                          --pFunc->iStackClasses;
+					  }
                       else
+					  {
                          sprintf( ( char * ) szType2, "%c", cFormalType );
+					  }
                    }
 
                    sprintf( ( char * ) szType1, "%i", iOffset + 1 );
@@ -471,21 +512,50 @@ void hb_compStrongType( int iSize )
              hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_PARAM_COUNT, ( char * ) szType1, ( char * ) szType2 );
           }
        }
+	   else
+	   {
+		  /*
+          printf( "\nExec Non Declared Function - Stack: %i Functions: %i\n", pFunc->iStackIndex, pFunc->iStackFunctions );
+		  */
+	   }
 
-       /* Removing all the parameters. Rteurn type already pushed just prior to parameters */
+	   #if 0
+	     {
+		    int i;
+	        for ( i = 0; i < pFunc->iStackIndex; i++ )
+	        {
+		       printf( "\nStack: %i Type: %c", i, pFunc->pStack[ i ] );
+	        }
+	     }
+	     printf( "\Removing %i parameters\n", wVar );
+	   #endif
+
+       /* Removing all the parameters. Return type already pushed just prior to parameters */
        pFunc->iStackIndex -= wVar;
 
        /* Removing the NIL */
        pFunc->iStackIndex--;
 
        if( pFunc->pCode[ ulPos ] == HB_P_DO || pFunc->pCode[ ulPos ] == HB_P_DOSHORT )
+	   {
           /* No return value. */
           pFunc->iStackIndex--;
+		  /*
+          printf( "\nNo Type for Procedure. - Stack: %i\n", pFunc->iStackIndex );
+		  */
+	   }
        else
-         ; /* Declared result already on stack. */
-
-       /*printf( "\nType of Function: \'%c\'\n",  pFunc->pStack[ pFunc->iStackIndex - 1 ] );*/
-
+	   {
+		  #if 0
+             /* Declared result already on stack. */
+		     cType = pFunc->pStack[ pFunc->iStackIndex - 1 ];
+	         if( ( cType == '-' + VT_OFFSET_VARIANT ) || cType >= ( 'A' + VT_OFFSET_VARIANT ) )
+	         {
+	            cType -= VT_OFFSET_VARIANT;
+		     }
+             printf( "\nType of Function \'%c\' - Stack: %i\n", cType, pFunc->iStackIndex );
+		  #endif
+	   }
        break;
 
      case HB_P_MESSAGE :
@@ -494,22 +564,34 @@ void hb_compStrongType( int iSize )
 
        cSubType1 = pFunc->pStack[ pFunc->iStackIndex - 1 ];
 
-       if( cSubType1 >= ( 'A' + VT_OFFSET_VARIANT ) )
+       if( ( cSubType1 == '-' + VT_OFFSET_VARIANT ) || cSubType1 >= ( 'A' + VT_OFFSET_VARIANT ) )
        {
           cSubType1 -= VT_OFFSET_VARIANT;
           if( cSubType1 == 'S' )
+		  {
              sprintf( ( char * ) szType1, "AnyType.SubType[Object]" );
+		  }
           else if( cSubType1 == 's' )
+		  {
              sprintf( ( char * ) szType1, "AnyType.SubType[ARRAY OF Object]" );
+		  }
           else if( islower( cSubType1 ) )
+		  {
              sprintf( ( char * ) szType1, "AnyType.SubType[ARRAY OF %c]", cSubType1 );
+		  }
           else if( cSubType1 == '-' )
+		  {
              strcpy( ( char * ) szType1,  "AnyType.SubType[NIL]" );
+		  }
           else
+		  {
              sprintf( ( char * ) szType1, "AnyType.SubType[%c]", cSubType1 );
+		  }
        }
        else
+	   {
           sprintf( ( char * ) szType1, "%c", cSubType1 );
+	   }
 
        if( cSubType1 == 'O' )
           ;/* The Object is not declared. */
@@ -537,13 +619,19 @@ void hb_compStrongType( int iSize )
           else /* The method is not declared. */
           {
              if( pFunc->iStackFunctions < 8 )
+			 {
                 pFunc->pStackFunctions[ pFunc->iStackFunctions++ ] = NULL;
+			 }
           }
        }
        else if( cSubType1 == ' ' )
+	   {
           hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, "O", NULL );
+	   }
        else
+	   {
           hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_TYPE, ( char * ) szType1, "O" );
+	   }
 
        /* Result will be pushed by HB_P_SEND*/
        break;
@@ -562,8 +650,10 @@ void hb_compStrongType( int iSize )
           break;
 
         cType = pFunc->pStack[ pFunc->iStackIndex - ( wVar + 1 ) ];
-        if( cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
+        if( ( cType == '-' + VT_OFFSET_VARIANT ) || cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
+		{
            cType -= VT_OFFSET_VARIANT;
+		}
 
         if( cType == 'S' &&  pFunc->iStackFunctions > 0 && pFunc->pStackFunctions[ pFunc->iStackFunctions - 1 ] )
         {
@@ -575,7 +665,7 @@ void hb_compStrongType( int iSize )
 
            iParamCount = hb_comp_iParamCount;
 
-           /*printf( "\nExec Method: %s of Class: %s Parameters: %i\n", pFunc->pStackFunctions[ pFunc->iStackFunctions ]->szName, pFunc->pStackClasses[ pFunc->iStackClasses - 1 ]->szName, pFunc->pStackFunctions[ pFunc->iStackFunctions ]->iParamCount );*/
+           printf( "\nExec Method: %s of Class: %s Parameters: %i\n", pFunc->pStackFunctions[ pFunc->iStackFunctions ]->szName, pFunc->pStackClasses[ pFunc->iStackClasses - 1 ]->szName, pFunc->pStackFunctions[ pFunc->iStackFunctions ]->iParamCount );
 
            /* First, find how many optionals. */
            while ( --iParamCount >= 0 )
@@ -686,11 +776,15 @@ void hb_compStrongType( int iSize )
         {
            pFunc->pStack[ pFunc->iStackIndex - 1 ] = pFunc->pStackFunctions[ pFunc->iStackFunctions ]->cType;
 
-           /*printf( "\nDeclared Method!!! Stack: %i Type: %c\n", pFunc->iStackIndex, pFunc->pStack[ pFunc->iStackIndex - 1 ] );*/
+		   /*
+           printf( "\nDeclared Method!!! Stack: %i Type: %c\n", pFunc->iStackIndex, pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+		   */
 
            if( toupper( pFunc->pStack[ pFunc->iStackIndex - 1 ] ) == 'S' && pFunc->iStackClasses < 8 )
            {
-              /*printf( "\nNested CLASS!!! Stack: %i Type: %c Class: %s\n", pFunc->iStackIndex, pFunc->pStack[ pFunc->iStackIndex - 1 ], pFunc->pStackFunctions[ pFunc->iStackFunctions ]->pClass->szName );*/
+              /*
+			  printf( "\nNested CLASS!!! Stack: %i Type: %c Class: %s\n", pFunc->iStackIndex, pFunc->pStack[ pFunc->iStackIndex - 1 ], pFunc->pStackFunctions[ pFunc->iStackFunctions ]->pClass->szName );
+			  */
               pFunc->pStackClasses[ pFunc->iStackClasses++ ] = pFunc->pStackFunctions[ pFunc->iStackFunctions ]->pClass;
            }
         }
@@ -703,94 +797,169 @@ void hb_compStrongType( int iSize )
 
      case HB_P_DEC :
      case HB_P_INC :
-       if( pFunc->pStack[ pFunc->iStackIndex - 1 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+       if( ( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex - 1 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
           cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex - 1 ] -= VT_OFFSET_VARIANT );
+	   }
 
        if( cSubType1 && cSubType1 == '-' )
+	   {
           strcpy( ( char * ) szType1, "AnyType.SubType[NIL]" );
+	   }
        else if( cSubType1 )
+	   {
           sprintf( ( char * ) szType1, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   }
        else if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' )
+	   {
           strcpy( ( char * ) szType1, "NIL" );
+	   }
        else
+	   {
           sprintf( ( char * ) szType1, "%c", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   }
 
        if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == 'N' )
-          ;
+	   {
+		  /* Ok. */
+	   }
        else if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == ' ' )
+	   {
           hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, "N", NULL );
+	   }
        else
+	   {
           hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_TYPE, ( char * ) szType1, "N" );
-
+	   }
        break;
 
+     case HB_P_JUMPNEAR :
+     case HB_P_JUMP :
+     case HB_P_JUMPFAR :
+	   /* Restoring Stack depth. */
+	   if( s_iCondIndex )
+	   {
+	      pFunc->iStackIndex = s_aiPreCondStack[ --s_iCondIndex ];
+	   }
+	   /*
+	   printf( "\nAfter Cond: %i\n", pFunc->iStackIndex );
+	   */
+	   break;
+
      case HB_P_JUMPFALSENEAR :
      case HB_P_JUMPFALSE :
      case HB_P_JUMPFALSEFAR :
      case HB_P_JUMPTRUENEAR :
      case HB_P_JUMPTRUE :
      case HB_P_JUMPTRUEFAR :
-       pFunc->iStackIndex--;
-
-       if( pFunc->iStackIndex < 0 )
-          /* TODO Error Message after finalizing all possible pcodes. */
-          break;
-
-       if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
-          cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT );
-
-       if( cSubType1 && cSubType1 == '-' )
-          strcpy( ( char * ) szType1, "AnyType.SubType[NIL]" );
-       else if( cSubType1 )
-          sprintf( ( char * ) szType1, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex ] );
-       else if( pFunc->pStack[ pFunc->iStackIndex ] == '-' )
-          strcpy( ( char * ) szType1, "NIL" );
-       else
-          sprintf( ( char * ) szType1, "%c", pFunc->pStack[ pFunc->iStackIndex ] );
-
-       if( pFunc->pStack[ pFunc->iStackIndex ] == 'L' )
-          ;
-       else if( pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
-          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, "L", NULL );
-       else
-          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_TYPE, ( char * ) szType1, "L" );
-
-       break;
-
-     case HB_P_INSTRING :
-
-       pFunc->iStackIndex--;
-
        if( pFunc->iStackIndex < 1 )
           /* TODO Error Message after finalizing all possible pcodes. */
           break;
 
-       if( pFunc->pStack[ pFunc->iStackIndex - 1 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
-          cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex - 1 ] -= VT_OFFSET_VARIANT );
+       pFunc->iStackIndex--;
 
-       if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
-          cSubType2 = ( pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT );
+	   /*
+	   printf( "\nBefore Cond: %i\n", pFunc->iStackIndex );
+	   */
+
+	   /* Saving Stack depth befor Jump. */
+	   /* TODO: Remove Hard coded limitation. */
+	   if( s_iCondIndex < 16 )
+	   {
+	      s_aiPreCondStack[ s_iCondIndex++ ] = pFunc->iStackIndex;
+	   }
+
+       if( ( pFunc->pStack[ pFunc->iStackIndex ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
+          cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT );
+	   }
 
        if( cSubType1 && cSubType1 == '-' )
+	   {
           strcpy( ( char * ) szType1, "AnyType.SubType[NIL]" );
+	   }
        else if( cSubType1 )
-          sprintf( ( char * ) szType1, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
-       else if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' )
-          strcpy( ( char * ) szType1, "NIL");
+	   {
+          sprintf( ( char * ) szType1, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex ] );
+	   }
+       else if( pFunc->pStack[ pFunc->iStackIndex ] == '-' )
+	   {
+          strcpy( ( char * ) szType1, "NIL" );
+	   }
        else
+	   {
+          sprintf( ( char * ) szType1, "%c", pFunc->pStack[ pFunc->iStackIndex ] );
+	   }
+
+       if( pFunc->pStack[ pFunc->iStackIndex ] == 'L' )
+	   {
+		  /* Ok. */
+	   }
+       else if( pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
+	   {
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, "L", NULL );
+	   }
+       else
+	   {
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_TYPE, ( char * ) szType1, "L" );
+	   }
+       break;
+
+     case HB_P_INSTRING :
+       if( pFunc->iStackIndex < 2 )
+          /* TODO Error Message after finalizing all possible pcodes. */
+          break;
+
+       pFunc->iStackIndex--;
+
+       if( ( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex - 1 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
+          cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex - 1 ] -= VT_OFFSET_VARIANT );
+	   }
+
+       if( ( pFunc->pStack[ pFunc->iStackIndex ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
+          cSubType2 = ( pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT );
+	   }
+
+       if( cSubType1 && cSubType1 == '-' )
+	   {
+          strcpy( ( char * ) szType1, "AnyType.SubType[NIL]" );
+	   }
+       else if( cSubType1 )
+	   {
+          sprintf( ( char * ) szType1, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   }
+       else if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' )
+	   {
+          strcpy( ( char * ) szType1, "NIL");
+	   }
+       else
+	   {
           sprintf( ( char * ) szType1, "%c", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   }
 
        if( cSubType2 && cSubType2 == '-' )
+	   {
           strcpy( ( char * ) szType2, "AnyType.SubType[NIL]" );
+	   }
        else if( cSubType2 )
+	   {
           sprintf( ( char * ) szType2, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex ] );
+	   }
        else if( pFunc->pStack[ pFunc->iStackIndex ] == '-' )
+	   {
           strcpy( ( char * ) szType2, "NIL" );
+	   }
        else
-         sprintf( ( char * ) szType2, "%c", pFunc->pStack[ pFunc->iStackIndex ] );
+	   {
+          sprintf( ( char * ) szType2, "%c", pFunc->pStack[ pFunc->iStackIndex ] );
+	   }
 
        if( pFunc->pStack[ pFunc->iStackIndex ] == ' ' &&  pFunc->pStack[ pFunc->iStackIndex - 1 ] == ' ' )
-          ;
+	   {
+		  /* Ok. */
+	   }
        else if( pFunc->pStack[ pFunc->iStackIndex ] == 'C' &&  pFunc->pStack[ pFunc->iStackIndex - 1 ] == 'C' )
        {
           /* Override the last item with the new result type */
@@ -831,88 +1000,266 @@ void hb_compStrongType( int iSize )
      case HB_P_NEGATE :
      case HB_P_MULT :
      case HB_P_POWER :
-       pFunc->iStackIndex--;
-
-       if( pFunc->iStackIndex < 1 )
+       if( pFunc->iStackIndex < 2 )
           /* TODO Error Message after finalizing all possible pcodes. */
           break;
 
+       pFunc->iStackIndex--;
+
        /*printf( "\nTop: %c Bottom: %c Typ-SubType: %c Bottom->SubType: %c\n", pFunc->pStack[ pFunc->iStackIndex], pFunc->pStack[ pFunc->iStackIndex - 1 ], pFunc->pStack[ pFunc->iStackIndex] - 100, pFunc->pStack[ pFunc->iStackIndex - 1 ] - 100 );*/
 
-       if( pFunc->pStack[ pFunc->iStackIndex - 1 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
-          cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex - 1 ] -= VT_OFFSET_VARIANT );
+       if( ( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex - 1 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
+          cSubType1 = pFunc->pStack[ pFunc->iStackIndex - 1 ] - VT_OFFSET_VARIANT;
+	   }
 
-       if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
-          cSubType2 = ( pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT );
+       if( ( pFunc->pStack[ pFunc->iStackIndex ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
+          cSubType2 = pFunc->pStack[ pFunc->iStackIndex ] - VT_OFFSET_VARIANT;
+	   }
 
        if( cSubType1 && cSubType1 == '-' )
+	   {
           strcpy( ( char * ) szType1, "AnyType.SubType[NIL]" );
+	   }
        else if( cSubType1 )
-          sprintf( ( char * ) szType1, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   {
+          sprintf( ( char * ) szType1, "AnyType.SubType[%c]", cSubType1 );
+	   }
        else if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' )
+	   {
           strcpy( ( char * ) szType1, "NIL");
+	   }
        else
+	   {
           sprintf( ( char * ) szType1, "%c", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   }
 
        if( cSubType2 && cSubType2 == '-' )
+	   {
           strcpy( ( char * ) szType2, "AnyType.SubType[NIL]" );
+	   }
        else if( cSubType2 )
-          sprintf( ( char * ) szType2, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex ] );
+	   {
+          sprintf( ( char * ) szType2, "AnyType.SubType[%c]", cSubType2 );
+	   }
        else if( pFunc->pStack[ pFunc->iStackIndex ] == '-' )
+	   {
           strcpy( ( char * ) szType2, "NIL" );
+	   }
        else
-         sprintf( ( char * ) szType2, "%c", pFunc->pStack[ pFunc->iStackIndex ] );
+	   {
+          sprintf( ( char * ) szType2, "%c", pFunc->pStack[ pFunc->iStackIndex ] );
+	   }
 
-       if( pFunc->pStack[ pFunc->iStackIndex ] == ' ' &&  pFunc->pStack[ pFunc->iStackIndex - 1 ] == ' ' )
+	   if( ! cSubType1 )
+	   {
+          cSubType1 = pFunc->pStack[ pFunc->iStackIndex - 1 ];
+	   }
+
+	   if( ! cSubType2 )
+	   {
+          cSubType2 = pFunc->pStack[ pFunc->iStackIndex ];
+	   }
+
+       if( cSubType1 == ' ' &&  cSubType2 == ' ' )
        {
           /* Override the last item with the new result type which is already there */
-          ;
        }
-       else if( pFunc->pStack[ pFunc->iStackIndex ] == 'N' && pFunc->pStack[ pFunc->iStackIndex - 1 ] == 'N' )
+       else if( cSubType1 == 'N' && cSubType2 == 'N' )
        {
           /* Override the last item with the new result type wich is already there */
-          ;
        }
        else if( ( pFunc->pCode[ ulPos ] == HB_P_PLUS || pFunc->pCode[ ulPos ] == HB_P_MINUS ) &&
-                 pFunc->pStack[ pFunc->iStackIndex ] == pFunc->pStack[ pFunc->iStackIndex - 1 ] )
+                  cSubType1 == cSubType2 )
        {
           /* Override the last item with the new result type wich is already there */
-          ;
        }
-       else if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == ' ' )
+       else if( cSubType1 == ' ' )
        {
-          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, ( char * ) szType2, NULL );
-
-          /* Override the last item with the new result type wich is already there */
-       }
-       else if( pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
-       {
-          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, ( char * ) szType1, NULL );
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, ( char * ) szType1, szType2 );
 
           /* Override the last item with the new result type. */
-          pFunc->pStack[ pFunc->iStackIndex - 1 ] = ' ';
+          pFunc->pStack[ pFunc->iStackIndex - 1 ] = cSubType2;
        }
-       else if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' )
+       else if( cSubType2 == ' ' )
        {
-          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_TYPE, "NIL", NULL );
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, ( char * ) szType2, szType1 );
+
+          /* Override the last item with the new result type. */
+          pFunc->pStack[ pFunc->iStackIndex - 1 ] = cSubType1;
+       }
+       else if( cSubType1 == '-' )
+       {
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_TYPE, (char *) szType1, szType2 );
 
           /* Override the last item with the new result type. */
           pFunc->pStack[ pFunc->iStackIndex - 1 ] = 'U';
        }
-       else if( pFunc->pStack[ pFunc->iStackIndex ] == '-' )
+       else if( cSubType2 == '-' )
        {
-          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_TYPE, "NIL", NULL );
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_TYPE, (char *) szType2, szType1 );
 
           /* Override the last item with the new result type. */
           pFunc->pStack[ pFunc->iStackIndex - 1 ] = 'U';
        }
        else
        {
-          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERANDS_INCOMPATBLE, ( char * ) szType1, ( char * ) szType2 );
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERANDS_INCOMPATIBLE, ( char * ) szType1, ( char * ) szType2 );
 
           /* Override the last item with the new result type */
           pFunc->pStack[ pFunc->iStackIndex - 1 ] = 'U';
        }
+       break;
+
+     case HB_P_FORTEST :
+	   if( pFunc->iStackIndex < 3 )
+          /* TODO Error Message after finalizing all possible pcodes. */
+          break;
+
+       pFunc->iStackIndex--;
+
+	   /* --- */
+
+       if( ( pFunc->pStack[ pFunc->iStackIndex - 2 ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex - 2 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
+          cSubType0 = pFunc->pStack[ pFunc->iStackIndex - 2 ] - VT_OFFSET_VARIANT;
+	   }
+
+       if( ( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex - 1 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
+          cSubType1 = pFunc->pStack[ pFunc->iStackIndex - 1 ] - VT_OFFSET_VARIANT;
+	   }
+
+       if( ( pFunc->pStack[ pFunc->iStackIndex ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
+          cSubType2 = pFunc->pStack[ pFunc->iStackIndex ] - VT_OFFSET_VARIANT;
+	   }
+
+	   /* --- */
+
+       if( cSubType0 && cSubType0 == '-' )
+	   {
+          strcpy( ( char * ) szType0, "AnyType.SubType[NIL]" );
+	   }
+       else if( cSubType0 )
+	   {
+          sprintf( ( char * ) szType0, "AnyType.SubType[%c]", cSubType0 );
+	   }
+       else if( pFunc->pStack[ pFunc->iStackIndex - 2 ] == '-' )
+	   {
+          strcpy( ( char * ) szType0, "NIL");
+	   }
+       else
+	   {
+          sprintf( ( char * ) szType0, "%c", pFunc->pStack[ pFunc->iStackIndex - 2 ] );
+	   }
+
+	   /* --- */
+
+       if( cSubType1 && cSubType1 == '-' )
+	   {
+          strcpy( ( char * ) szType1, "AnyType.SubType[NIL]" );
+	   }
+       else if( cSubType1 )
+	   {
+          sprintf( ( char * ) szType1, "AnyType.SubType[%c]", cSubType1 );
+	   }
+       else if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' )
+	   {
+          strcpy( ( char * ) szType1, "NIL");
+	   }
+       else
+	   {
+          sprintf( ( char * ) szType1, "%c", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   }
+
+	   /* --- */
+
+       if( cSubType2 && cSubType2 == '-' )
+	   {
+          strcpy( ( char * ) szType2, "AnyType.SubType[NIL]" );
+	   }
+       else if( cSubType2 )
+	   {
+          sprintf( ( char * ) szType2, "AnyType.SubType[%c]", cSubType2 );
+	   }
+       else if( pFunc->pStack[ pFunc->iStackIndex ] == '-' )
+	   {
+          strcpy( ( char * ) szType2, "NIL" );
+	   }
+       else
+	   {
+          sprintf( ( char * ) szType2, "%c", pFunc->pStack[ pFunc->iStackIndex ] );
+	   }
+
+	   /* --- */
+
+	   if( ! cSubType0 )
+	   {
+          cSubType0 = pFunc->pStack[ pFunc->iStackIndex - 2 ];
+	   }
+
+	   if( ! cSubType1 )
+	   {
+          cSubType1 = pFunc->pStack[ pFunc->iStackIndex - 1 ];
+	   }
+
+	   if( ! cSubType2 )
+	   {
+          cSubType2 = pFunc->pStack[ pFunc->iStackIndex ];
+	   }
+
+	   /* --- */
+
+	   if( cSubType0 == 'N' )
+	   {
+		  /* Ok. */
+	   }
+	   else if ( cSubType0 == ' ' )
+	   {
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, "UnKnown", "N" );
+	   }
+	   else
+	   {
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_TYPE, ( char * ) szType0, "N" );
+	   }
+
+	   /* --- */
+
+	   if( cSubType1 == 'N' )
+	   {
+		  /* Ok. */
+	   }
+	   else if ( cSubType1 == ' ' )
+	   {
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, "UnKnown", "N" );
+	   }
+	   else
+	   {
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_TYPE, ( char * ) szType1, "N" );
+	   }
+
+	   /* --- */
+
+	   if( cSubType2 == 'N' )
+	   {
+		  /* Ok. */
+	   }
+	   else if ( cSubType2 == ' ' )
+	   {
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, "UnKnown", "N" );
+	   }
+	   else
+	   {
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_TYPE, ( char * ) szType2, "N" );
+	   }
+
+	   /* Remove Step. */
+       pFunc->iStackIndex--;
+
+       /* Override the last item with Logical */
+       pFunc->pStack[ pFunc->iStackIndex - 1 ] = 'L';
 
        break;
 
@@ -920,40 +1267,59 @@ void hb_compStrongType( int iSize )
      case HB_P_GREATEREQUAL :
      case HB_P_LESSEQUAL :
      case HB_P_LESS :
-
-       pFunc->iStackIndex--;
-
-       if( pFunc->iStackIndex < 1 )
+       if( pFunc->iStackIndex < 2 )
           /* TODO Error Message after finalizing all possible pcodes. */
           break;
 
-       if( pFunc->pStack[ pFunc->iStackIndex - 1 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
-          cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex - 1 ] -= VT_OFFSET_VARIANT );
+       pFunc->iStackIndex--;
 
-       if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+       if( ( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex - 1 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
+          cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex - 1 ] -= VT_OFFSET_VARIANT );
+	   }
+
+       if( ( pFunc->pStack[ pFunc->iStackIndex ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
           cSubType2 = ( pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT );
+	   }
 
        if( cSubType1 && cSubType1 == '-' )
+	   {
           sprintf( ( char * ) szType1, "AnyType.SubType[NIL]" );
+	   }
        else if( cSubType1 )
+	   {
           sprintf( ( char * ) szType1, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   }
        else if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' )
+	   {
           strcpy( ( char * ) szType1, "NIL" );
+	   }
        else
+	   {
           sprintf( ( char * ) szType1, "%c", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   }
 
        if( cSubType2 && cSubType2 == '-' )
+	   {
           strcpy( ( char * ) szType2, "AnyType.SubType[NIL]" );
+	   }
        else if( cSubType2 )
+	   {
           sprintf( ( char * ) szType2, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex ] );
+	   }
        else if( pFunc->pStack[ pFunc->iStackIndex ] == '-' )
+	   {
           strcpy( ( char * ) szType2, "NIL" );
+	   }
        else
+	   {
           sprintf( ( char * ) szType2, "%c", pFunc->pStack[ pFunc->iStackIndex ] );
+	   }
 
        if( pFunc->pStack[ pFunc->iStackIndex ] == '-' || pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-'  )
        {
-          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERANDS_INCOMPATBLE, ( char * ) szType1, ( char * ) szType2 );
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERANDS_INCOMPATIBLE, ( char * ) szType1, ( char * ) szType2 );
 
           /* Override the last item with the new result type wich is already there */
           pFunc->pStack[ pFunc->iStackIndex - 1 ] = 'U';
@@ -983,7 +1349,7 @@ void hb_compStrongType( int iSize )
        }
        else
        {
-          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERANDS_INCOMPATBLE, ( char * ) szType1, ( char * ) szType2 );
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERANDS_INCOMPATIBLE, ( char * ) szType1, ( char * ) szType2 );
 
           /* Override the last item with the new result type */
           pFunc->pStack[ pFunc->iStackIndex - 1 ] = 'U';
@@ -994,92 +1360,129 @@ void hb_compStrongType( int iSize )
      case HB_P_EQUAL :
      case HB_P_EXACTLYEQUAL :
      case HB_P_NOTEQUAL :
-
-       pFunc->iStackIndex--;
-
-       if( pFunc->iStackIndex < 1 )
+       if( pFunc->iStackIndex < 2 )
           /* TODO Error Message after finalizing all possible pcodes. */
           break;
 
-       if( pFunc->pStack[ pFunc->iStackIndex - 1 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
-          cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex - 1 ] -= VT_OFFSET_VARIANT );
+       pFunc->iStackIndex--;
 
-       if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
-          cSubType2 = ( pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT );
+       if( ( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex - 1 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
+          cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex - 1 ] -= VT_OFFSET_VARIANT );
+		  //printf( "\n Op1 = Variant: %c\n", cSubType1 );
+	   }
 
        if( cSubType1 && cSubType1 == '-' )
+	   {
           sprintf( ( char * ) szType1, "AnyType.SubType[NIL]" );
+	   }
        else if( cSubType1 )
-          sprintf( ( char * ) szType1, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   {
+          sprintf( ( char * ) szType1, "AnyType.SubType[%c]", cSubType1 );
+	   }
        else if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' )
+	   {
           strcpy( ( char * ) szType1, "NIL");
+	   }
        else
+	   {
           sprintf( ( char * ) szType1, "%c", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   }
+
+	   /*---*/
+
+       if( ( pFunc->pStack[ pFunc->iStackIndex ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
+          cSubType2 = ( pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT );
+		  //printf( "\n Op2 = Variant: %c\n", cSubType1 );
+	   }
 
        if( cSubType2 && cSubType2 == '-' )
+	   {
           strcpy( ( char * ) szType2, "AnyType.SubType[NIL]" );
+	   }
        else if( cSubType2 )
-          sprintf( ( char * ) szType2, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex ] );
+	   {
+          sprintf( ( char * ) szType2, "AnyType.SubType[%c]", cSubType2 );
+	   }
        else if( pFunc->pStack[ pFunc->iStackIndex ] == '-' )
+	   {
           strcpy( ( char * ) szType2, "NIL" );
+	   }
        else
-         sprintf( ( char * ) szType2, "%c", pFunc->pStack[ pFunc->iStackIndex ] );
+	   {
+          sprintf( ( char * ) szType2, "%c", pFunc->pStack[ pFunc->iStackIndex ] );
+	   }
 
-       if( pFunc->pStack[ pFunc->iStackIndex ] == '-' ||  pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' )
+	   /*---*/
+
+	   if( ! cSubType1 )
+	   {
+          cSubType1 = pFunc->pStack[ pFunc->iStackIndex - 1 ];
+		  //printf( "\n Op1 = %c (%i)\n", cSubType1, cSubType1 );
+	   }
+
+	   if( ! cSubType2 )
+	   {
+          cSubType2 = pFunc->pStack[ pFunc->iStackIndex ];
+		  //printf( "\n Op2 = %c (%i)\n", cSubType2, cSubType2 );
+	   }
+
+       if( cSubType1 == '-' || cSubType2 == '-' )
        {
           /* Override the last item with the new result type */
-          pFunc->pStack[ pFunc->iStackIndex - 1 ] = 'L';
        }
-       else if( pFunc->pStack[ pFunc->iStackIndex ] == ' ' &&  pFunc->pStack[ pFunc->iStackIndex - 1 ] == ' ' )
-       {
-          /* Override the last item with the new result type which is already there */
-          ;
-       }
-       else if( pFunc->pStack[ pFunc->iStackIndex ] == pFunc->pStack[ pFunc->iStackIndex - 1 ] )
+       else if( cSubType1 == cSubType2 )
        {
           /* Override the last item with the new result type */
-          pFunc->pStack[ pFunc->iStackIndex - 1 ] = 'L';
        }
-       else if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == ' ' )
+       else if( cSubType1 == ' ' )
        {
           hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, ( char * ) szType2, NULL );
-
           /* Override the last item with the new result type wich is already there */
        }
-       else if( pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
+       else if( cSubType2 == ' ' )
        {
           hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, ( char * ) szType1, NULL );
-
           /* Override the last item with the new result type */
-          pFunc->pStack[ pFunc->iStackIndex - 1 ] = ' ';
        }
        else
        {
-          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERANDS_INCOMPATBLE, ( char * ) szType1, ( char * ) szType2 );
-
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERANDS_INCOMPATIBLE, ( char * ) szType1, ( char * ) szType2 );
           /* Override the last item with the new result type */
-          pFunc->pStack[ pFunc->iStackIndex - 1 ] = 'U';
        }
 
+       /* Override the last item with the new result type */
+       pFunc->pStack[ pFunc->iStackIndex - 1 ] = 'L';
+
        break;
 
      case HB_P_NOT :
-
        if( pFunc->iStackIndex < 1 )
           /* TODO Error Message after finalizing all possible pcodes. */
           break;
 
-       if( pFunc->pStack[ pFunc->iStackIndex - 1 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+       if( ( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex - 1 ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
           cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex - 1 ] -= VT_OFFSET_VARIANT );
+	   }
 
        if( cSubType1 && cSubType1 == '-' )
+	   {
           strcpy( ( char * ) szType1, "AnyType.SubType[NIL]" );
+	   }
        else if( cSubType1 )
+	   {
           sprintf( ( char * ) szType1, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   }
        else if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' )
+	   {
           strcpy( ( char * ) szType1, "NIL" );
+	   }
        else
-         sprintf( ( char * ) szType1, "%c", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   {
+          sprintf( ( char * ) szType1, "%c", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   }
 
        if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == ' ' )
        {
@@ -1099,35 +1502,55 @@ void hb_compStrongType( int iSize )
 
      case HB_P_AND :
      case HB_P_OR :
-       pFunc->iStackIndex--;
-
-       if( pFunc->iStackIndex < 1 )
+       if( pFunc->iStackIndex < 2 )
           /* TODO Error Message after finalizing all possible pcodes. */
           break;
 
-       if( pFunc->pStack[ pFunc->iStackIndex - 1 ] >= 'A' + VT_OFFSET_VARIANT  )
-          cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex - 1 ] -= VT_OFFSET_VARIANT );
+       pFunc->iStackIndex--;
 
-       if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+       if( ( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex - 1 ] >= 'A' + VT_OFFSET_VARIANT  )
+	   {
+          cSubType1 = ( pFunc->pStack[ pFunc->iStackIndex - 1 ] -= VT_OFFSET_VARIANT );
+	   }
+
+       if( ( pFunc->pStack[ pFunc->iStackIndex ] == '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
           cSubType2 = ( pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT );
+	   }
 
        if( cSubType1 && cSubType1 == '-' )
+	   {
           sprintf( ( char * ) szType1, "AnyType.SubType[NIL]" );
+	   }
        else if( cSubType1 )
+	   {
           sprintf( ( char * ) szType1, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   }
        else if( pFunc->pStack[ pFunc->iStackIndex - 1 ] == '-' )
+	   {
           strcpy( ( char * ) szType1, "NIL");
+	   }
        else
+	   {
           sprintf( ( char * ) szType1, "%c", pFunc->pStack[ pFunc->iStackIndex - 1 ] );
+	   }
 
        if( cSubType2 && cSubType2 == '-' )
+	   {
           strcpy( ( char * ) szType2, "AnyType.SubType[NIL]" );
+	   }
        else if( cSubType2 )
+	   {
           sprintf( ( char * ) szType2, "AnyType.SubType[%c]", pFunc->pStack[ pFunc->iStackIndex ] );
+	   }
        else if( pFunc->pStack[ pFunc->iStackIndex ] == '-' )
+	   {
           strcpy( ( char * ) szType2, "NIL" );
+	   }
        else
+	   {
          sprintf( ( char * ) szType2, "%c", pFunc->pStack[ pFunc->iStackIndex ] );
+	   }
 
        if( ( pFunc->pStack[ pFunc->iStackIndex ] == ' ' &&  pFunc->pStack[ pFunc->iStackIndex - 1 ] == ' ' ) ||
             ( pFunc->pStack[ pFunc->iStackIndex ] == 'L' &&  pFunc->pStack[ pFunc->iStackIndex - 1 ] == 'L' ) )
@@ -1193,18 +1616,17 @@ void hb_compStrongType( int iSize )
        /* Todo find Self's Class. */
        break;
 
+   #if 0
      /* Blcoks */
-	 /*
 	 case HB_P_PUSHBLOCKSHORT :
-	   break;
-
      case HB_P_PUSHBLOCK :
 	   break;
-	 */
+   #endif
 
      case HB_P_ENDBLOCK :
        /* Override the last value of the block left on the stack. */
-       pFunc->pStack[ pFunc->iStackIndex ] = 'B';
+	   /* The last value was actualy generated on the pBlock stack, not in parrent. */
+       pFunc->pStack[ pFunc->iStackIndex++ ] = 'B';
        break;
 
      /* Undefined */
@@ -1239,13 +1661,19 @@ void hb_compStrongType( int iSize )
      case HB_P_MPUSHSYM :
        /* In Private or Public statement can't be a declared function */
        if( ( hb_comp_iVarScope == VS_PRIVATE || hb_comp_iVarScope == VS_PUBLIC ) )
+	   {
           pFunc->pStack[ pFunc->iStackIndex++ ] = ' ';
+	   }
        else
        {
           if( pFunc->pCode[ ulPos ] == HB_P_PUSHSYMNEAR )
+		  {
              pSym = hb_compSymbolGetPos( pFunc->pCode[ ulPos + 1 ] );
+		  }
           else
+		  {
              pSym = hb_compSymbolGetPos( pFunc->pCode[ ulPos + 1 ] + pFunc->pCode[ ulPos + 2 ] * 256 );
+		  }
 
           /*printf( "\nSymbol: %s\n", pSym->szName );*/
 
@@ -1258,18 +1686,24 @@ void hb_compStrongType( int iSize )
                 pFunc->pStack[ pFunc->iStackIndex++ ] = pDeclared->cType;
 
                 if( toupper( pDeclared->cType ) == 'S' && pFunc->iStackClasses < 8 )
+				{
                    pFunc->pStackClasses[ pFunc->iStackClasses++ ] = pDeclared->pClass;
+				}
              }
              else
+			 {
                 pFunc->pStack[ pFunc->iStackIndex++ ] = ' ';
+			 }
 
              /* Storing, will be checked by HB_P_FUNCTION, OK to store NULL */
              /* TODO don't use hard coded size */
              if( pFunc->iStackFunctions < 8 )
-               pFunc->pStackFunctions[ pFunc->iStackFunctions++ ] = pDeclared;
+			 {
+                pFunc->pStackFunctions[ pFunc->iStackFunctions++ ] = pDeclared;
+			 }
 
              /* QUESTION: Add other "safe" functions, or remove adaptive type checking support for memvars? */
-             if( strcmp( pSym->szName, "QOUT" ) )
+             if( strcmp( pSym->szName, "QOUT" ) == 1 )
              {
                 /*printf( "\nRestting privates affected by: %s\n", pSym->szName );*/
 
@@ -1277,19 +1711,29 @@ void hb_compStrongType( int iSize )
                 pVar = pFunc->pMemvars;
                 while ( pVar )
                 {
-                   if( pVar->cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
+                   if( pVar->cType  == ( '-' + VT_OFFSET_VARIANT ) || pVar->cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
+				   {
                       pVar->cType = ' ';
+				   }
 
                    pVar = pVar->pNext;
                 }
              }
+
+			 /*
+			 printf( "\nPushed: %s() Type: %c Stack: %i\n", pSym->szName, pFunc->pStack[ pFunc->iStackIndex - 1], pFunc->iStackIndex - 1 );
+			 */
           }
           else
           {
-            /* Storing, will be checked by FUNCTION, OK to store NULL */
-            /* TODO don't use hard coded size */
-            if( pFunc->iStackFunctions < 8 )
-              pFunc->pStackFunctions[ pFunc->iStackFunctions++ ] = NULL;
+             /* Storing, will be checked by FUNCTION, OK to store NULL */
+             /* TODO don't use hard coded size */
+             if( pFunc->iStackFunctions < 8 )
+			 {
+                pFunc->pStackFunctions[ pFunc->iStackFunctions++ ] = NULL;
+			 }
+
+             pFunc->pStack[ pFunc->iStackIndex++ ] = ' ';
           }
        }
        break;
@@ -1304,9 +1748,13 @@ void hb_compStrongType( int iSize )
      case HB_P_PUSHLOCALREF :
      case HB_P_PUSHLOCAL :
        if( pFunc->pCode[ ulPos ] == HB_P_PUSHLOCALNEAR )
+	   {
           wVar = ( signed char ) pFunc->pCode[ ulPos + 1 ];
+	   }
        else
+	   {
           wVar = * ( ( SHORT * ) &( pFunc->pCode )[ ulPos + 1 ] );
+	   }
 
        /* we are accesing variables within a codeblock */
        if( wVar < 0 )
@@ -1339,8 +1787,14 @@ void hb_compStrongType( int iSize )
 
        if( pVar )
        {
-          if( ! ( pVar->iUsed & VU_INITIALIZED ) )
+          if( pFunc->pCode[ ulPos ] == HB_P_PUSHLOCALREF )
+		  {
+             pVar->iUsed |= VU_INITIALIZED;
+		  }
+		  else if( ! ( pVar->iUsed & VU_INITIALIZED ) )
+		  {
              hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_NOT_INITIALIZED, pVar->szName, NULL );
+		  }
 
 		  /*
 		  printf( "\nUsed: %s\n", pVar->szName );
@@ -1349,10 +1803,14 @@ void hb_compStrongType( int iSize )
           /* Mark as used */
           pVar->iUsed |= VU_USED;
 
-          if( pVar->cType >= ( 'A' + VT_OFFSET_VARIANT ) )
+          if( pVar->cType  == ( '-' + VT_OFFSET_VARIANT ) || pVar->cType >= ( 'A' + VT_OFFSET_VARIANT ) )
+		  {
             cType = pVar->cType - VT_OFFSET_VARIANT;
+		  }
           else
+		  {
             cType = pVar->cType;
+		  }
 
           if( toupper( cType ) == 'S' && pFunc->iStackClasses < 8 )
           {
@@ -1384,7 +1842,9 @@ void hb_compStrongType( int iSize )
        wVar = pFunc->pCode[ ulPos + 1 ] + pFunc->pCode[ ulPos + 2 ] * 256;
 
        while( pTmp->pNext && pTmp->pNext->iStaticsBase < wVar )
+	   {
           pTmp = pTmp->pNext;
+	   }
 
        pVar = hb_compVariableFind( pTmp->pStatics, wVar - pTmp->iStaticsBase );
 
@@ -1405,28 +1865,41 @@ void hb_compStrongType( int iSize )
           /* Mark as used */
           pVar->iUsed |= VU_USED;
 
-          if( pVar->cType >= ( 'A' + VT_OFFSET_VARIANT ) )
-            cType = pVar->cType - VT_OFFSET_VARIANT;
+          if( pVar->cType  == ( '-' + VT_OFFSET_VARIANT ) || pVar->cType >= ( 'A' + VT_OFFSET_VARIANT ) )
+		  {
+             cType = pVar->cType - VT_OFFSET_VARIANT;
+		  }
           else
-            cType = pVar->cType;
+		  {
+             cType = pVar->cType;
+		  }
 
           if( toupper( cType ) == 'S' && pFunc->iStackClasses < 8 )
           {
-            /* Object of declared class */
-            pFunc->pStackClasses[ pFunc->iStackClasses++ ] = pVar->pClass;
+             /* Object of declared class */
+             pFunc->pStackClasses[ pFunc->iStackClasses++ ] = pVar->pClass;
           }
 
           if( pFunc->pCode[ ulPos ] == HB_P_PUSHSTATICREF )
+		  {
              pFunc->pStack[ pFunc->iStackIndex - 1 ] = pVar->cType + VT_OFFSET_BYREF;
+		  }
           else
+		  {
              pFunc->pStack[ pFunc->iStackIndex - 1 ] = pVar->cType;
+		  }
        }
        else
+	   {
           if( pFunc->pCode[ ulPos ] == HB_P_PUSHSTATICREF )
+		  {
              pFunc->pStack[ pFunc->iStackIndex - 1 ] = '@';
+	      }
           else
+		  {
              pFunc->pStack[ pFunc->iStackIndex - 1 ] = ' ';
-
+		  }
+	   }
        break;
 
      case HB_P_PUSHVARIABLE :
@@ -1468,28 +1941,28 @@ void hb_compStrongType( int iSize )
           {
              if( pFunc->pMemvars )
 			 {
-               wVar = hb_compVariableGetPos( pFunc->pMemvars, pSym->szName );
+                wVar = hb_compVariableGetPos( pFunc->pMemvars, pSym->szName );
 			 }
 
              if( wVar )
 			 {
-               pVar = hb_compVariableFind( pFunc->pMemvars, wVar );
+                pVar = hb_compVariableFind( pFunc->pMemvars, wVar );
 			 }
 
              if( ! pVar )
 			 {
-               pVar = hb_compPrivateFind( pSym->szName );
+                pVar = hb_compPrivateFind( pSym->szName );
 			 }
 
              if( ( ! pVar ) && hb_comp_functions.pFirst->pMemvars )
              {
-               wVar = hb_compVariableGetPos( hb_comp_functions.pFirst->pMemvars, pSym->szName );
-               if( wVar )
-			   {
-                 pVar = hb_compVariableFind( hb_comp_functions.pFirst->pMemvars, wVar );
-				 /* May have been initialized in any other function - can't check. */
-                 pVar->iUsed |= VU_INITIALIZED;
-			   }
+                wVar = hb_compVariableGetPos( hb_comp_functions.pFirst->pMemvars, pSym->szName );
+                if( wVar )
+			    {
+                   pVar = hb_compVariableFind( hb_comp_functions.pFirst->pMemvars, wVar );
+				   /* May have been initialized in any other function - can't check. */
+                   pVar->iUsed |= VU_INITIALIZED;
+			    }
              }
           }
 
@@ -1499,17 +1972,27 @@ void hb_compStrongType( int iSize )
 
              /*printf( "\nPushed: %s Type: %c SubType: %c\n", pVar->szName, pVar->cType, pVar->cType - 100 );*/
 
-             if( ! ( pVar->iUsed & VU_INITIALIZED ) )
-               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_NOT_INITIALIZED, pVar->szName, NULL );
+             if( pFunc->pCode[ ulPos ] == HB_P_PUSHMEMVARREF )
+			 {
+                pVar->iUsed |= VU_INITIALIZED;
+			 }
+			 else if( ! ( pVar->iUsed & VU_INITIALIZED ) )
+			 {
+                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_NOT_INITIALIZED, pVar->szName, NULL );
+			 }
 
-             if( cType >= ( 'A' + VT_OFFSET_VARIANT ) )
-               cType -= VT_OFFSET_VARIANT;
+             if( cType  == ( '-' + VT_OFFSET_VARIANT ) || cType >= ( 'A' + VT_OFFSET_VARIANT ) )
+			 {
+                cType -= VT_OFFSET_VARIANT;
+			 }
 
              /* Mark as used */
              pVar->iUsed |= VU_USED;
 
              if( pFunc->pCode[ ulPos ] == HB_P_PUSHMEMVARREF )
+			 {
                 pFunc->pStack[ pFunc->iStackIndex - 1 ] = pVar->cType + VT_OFFSET_BYREF;
+			 }
              else if( toupper( cType ) == 'S' && pFunc->iStackClasses < 8 )
              {
                 /* Object of declared class */
@@ -1517,7 +2000,9 @@ void hb_compStrongType( int iSize )
                 pFunc->pStack[ pFunc->iStackIndex++ ] = pVar->cType;
              }
              else
+			 {
                 pFunc->pStack[ pFunc->iStackIndex - 1 ] = pVar->cType;
+			 }
           }
           else
           {
@@ -1525,11 +2010,15 @@ void hb_compStrongType( int iSize )
 
              /*printf( "\nPushed Symbol: %s Type: %c SubType: %c\n", pSym->szName, pSym->cType, pSym->cType - 100 );*/
 
-             if( cType >= ( 'A' + VT_OFFSET_VARIANT ) )
-               cType -= VT_OFFSET_VARIANT;
+             if( cType  == ( '-' + VT_OFFSET_VARIANT ) || cType >= ( 'A' + VT_OFFSET_VARIANT ) )
+			 {
+                cType -= VT_OFFSET_VARIANT;
+			 }
 
              if( pFunc->pCode[ ulPos ] == HB_P_PUSHMEMVARREF )
+			 {
                 pFunc->pStack[ pFunc->iStackIndex - 1 ] = pSym->cType + VT_OFFSET_BYREF;
+			 }
              else if( toupper( cType ) == 'S' && pFunc->iStackClasses < 8 )
              {
                 /* Object of declared class */
@@ -1569,118 +2058,120 @@ void hb_compStrongType( int iSize )
      case HB_P_ARRAYGEN :
        wVar = pFunc->pCode[ ulPos + 1 ] + pFunc->pCode[ ulPos + 2 ] * 256;
 
-       if( pFunc->iStackIndex == 0 )
-       {
-          pFunc->pStack[ pFunc->iStackIndex++ ] = 'A';
-          break;
-       }
-
+       /* TODO Error Message after finalizing all possible pcodes. */
        if( pFunc->iStackIndex < wVar )
-          /* TODO Error Message after finalizing all possible pcodes. */
+	   {
+          pFunc->iStackIndex = 1;
+          pFunc->pStack[ 0 ] = 'A';
           break;
+	   }
 
-       if( wVar )
-          cType = pFunc->pStack[ pFunc->iStackIndex - 1 ];
-       else
-          cType = 'A';
-
-       while ( --wVar > 0 )
-       {
-          pFunc->iStackIndex--;
-
-          if( cType == ' ' || cType != pFunc->pStack[ pFunc->iStackIndex - 1 ] )
-          {
-             cType = 'A';
-             break;
-          }
-       }
-
-       /* Lower Case Indicates array of ...*/
-       if( cType != 'A' )
-          cType = tolower( cType );
-
-       pFunc->pStack[ pFunc->iStackIndex - 1 ] = cType;
+	   /* Pop the Elements. */
+       pFunc->iStackIndex -= wVar;
 
+	   /* Push the array. */
+       pFunc->pStack[ pFunc->iStackIndex++ ] = 'A';
        break;
 
      case HB_P_ARRAYPUSH :
-       /* Poping the Array Index. */
-       pFunc->iStackIndex--;
-
-       if( pFunc->iStackIndex < 0 )
+       if( pFunc->iStackIndex < 1 )
           /* TODO Error Message after finalizing all possible pcodes. */
           break;
 
+       /* Poping the Array Index. */
+       pFunc->iStackIndex--;
+
+       cType = pFunc->pStack[ pFunc->iStackIndex - 1 ];
+
+       /*printf( "\n Base Type: %c\n", cType );*/
+
+       if( cType  == ( '-' + VT_OFFSET_VARIANT ) || cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
+	   {
+          cType -= VT_OFFSET_VARIANT;
+	   }
+
+       if( cType == ' ' )
        {
-          BYTE cVarType = pFunc->pStack[ pFunc->iStackIndex - 1 ];
-
-          /*printf( "\n Base Type: %c\n", cVarType );*/
-
-          if( cVarType  >= ( 'A' + VT_OFFSET_VARIANT ) )
-             cVarType -= VT_OFFSET_VARIANT;
-
-          if( cVarType == ' ' )
-          {
-             /* Type unknown. */
-             hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, "A", NULL );
-             pFunc->pStack[ pFunc->iStackIndex - 1 ] = ' ';
-          }
-          else if( cVarType == 'A' )
-             /* Variant Array Element - Type unknown. */
-             pFunc->pStack[ pFunc->iStackIndex - 1 ] = ' ';
-          else if( cVarType == 'a' )
-             /* Variant Array Element - Type unknown. */
-             pFunc->pStack[ pFunc->iStackIndex - 1 ] = ' ';
-          else if( islower( cVarType ) )
-            /* Now we have the declared array element on the stack.*/
-            pFunc->pStack[ pFunc->iStackIndex - 1 ] = toupper( cVarType );
-          else
-             hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_NOT_ARRAY, NULL, NULL );
+          /* Type unknown. */
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, "A", NULL );
+          pFunc->pStack[ pFunc->iStackIndex - 1 ] = ' ';
        }
-
+       else if( cType == 'A' )
+	   {
+          /* Variant Array Element - Type unknown. */
+          pFunc->pStack[ pFunc->iStackIndex - 1 ] = ' ';
+	   }
+       else if( cType == 'a' )
+	   {
+          /* Variant Array Element - Type unknown. */
+          pFunc->pStack[ pFunc->iStackIndex - 1 ] = ' ';
+	   }
+       else if( islower( cType ) )
+	   {
+         /* Now we have the declared array element on the stack.*/
+         pFunc->pStack[ pFunc->iStackIndex - 1 ] = toupper( cType );
+	   }
+       else
+	   {
+          hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_NOT_ARRAY, NULL, NULL );
+	   }
        break;
 
      case HB_P_ARRAYPOP :
-       /* Poping the Array Index. */
-       pFunc->iStackIndex--;
-
-       if( pFunc->iStackIndex < 2 )
+       if( pFunc->iStackIndex < 3 )
           /* TODO Error Message after finalizing all possible pcodes. */
           break;
 
+       /* Poping the Array Index. */
+       pFunc->iStackIndex--;
+
        {
-          BYTE cVarType = pFunc->pStack[ pFunc->iStackIndex - 1 ], cElementType = pFunc->pStack[ pFunc->iStackIndex - 2 ];
+          BYTE cElementType = pFunc->pStack[ pFunc->iStackIndex - 2 ];
 
-          if( cVarType  >= ( 'A' + VT_OFFSET_VARIANT ) )
-             cVarType -= VT_OFFSET_VARIANT;
+		  cType = pFunc->pStack[ pFunc->iStackIndex - 1 ];
 
-          if( cElementType  >= ( 'A' + VT_OFFSET_VARIANT ) )
+          if( cType  == ( '-' + VT_OFFSET_VARIANT ) || cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
+		  {
+             cType -= VT_OFFSET_VARIANT;
+		  }
+
+          if( cElementType  == ( '-' + VT_OFFSET_VARIANT ) || cElementType  >= ( 'A' + VT_OFFSET_VARIANT ) )
+		  {
              cElementType -= VT_OFFSET_VARIANT;
+		  }
 
-          if( cVarType == ' ' )
+          if( cType == ' ' )
+		  {
              hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_OPERAND_SUSPECT, "A", NULL );
-          else if( cVarType == 'A' )
+		  }
+          else if( cType == 'A' )
+		  {
              /* Array of variant can hold any value. */
-             ;
-          else if( cVarType == 'a' )
+		  }
+          else if( cType == 'a' )
+		  {
              /* Array of variant can hold any value. */
-             ;
-          else if( islower( cVarType ) && cElementType == ' ' )
+          }
+          else if( islower( cType ) && cElementType == ' ' )
           {
              /* Array Of explicit type. */
              char szType[2];
-             sprintf( ( char * ) szType, "%c", toupper( cVarType ) );
+
+             sprintf( ( char * ) szType, "%c", toupper( cType ) );
              hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, ( char * ) szType, NULL );
           }
-          else if( islower( cVarType ) && toupper( cVarType ) != cElementType && cElementType != '-' )
+          else if( islower( cType ) && toupper( cType ) != cElementType && cElementType != '-' )
           {
              /* Array Of explicit type. */
              char szType[2];
-             sprintf( ( char * ) szType, "%c", toupper( cVarType ) );
+
+             sprintf( ( char * ) szType, "%c", toupper( cType ) );
              hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_TYPE, ( char * ) szType, NULL );
           }
           else
+		  {
              hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_NOT_ARRAY, NULL, NULL );
+		  }
        }
 
        /* Poping the Assigned Value. */
@@ -1697,7 +2188,7 @@ void hb_compStrongType( int iSize )
      case HB_P_MPUSHVARIABLE :
      case HB_P_MACROPUSHALIASED :
      case HB_P_MACROPUSH :
-       if( pFunc->iStackIndex < 0 )
+       if( pFunc->iStackIndex < 1 )
           /* TODO Error Message after finalizing all possible pcodes. */
           break;
 
@@ -1706,7 +2197,7 @@ void hb_compStrongType( int iSize )
        break;
 
      case HB_P_MACROSYMBOL :
-       if( pFunc->iStackIndex < 0 )
+       if( pFunc->iStackIndex < 1 )
           /* TODO Error Message after finalizing all possible pcodes. */
           break;
 
@@ -1782,12 +2273,12 @@ void hb_compStrongType( int iSize )
        /* Fall through, don't put break!!!*/
 
      case HB_P_POPMEMVAR :
-       pFunc->iStackIndex--;
-
-       if( pFunc->iStackIndex < 0 )
+       if( pFunc->iStackIndex < 1 )
           /* TODO Error Message after finalizing all possible pcodes. */
           break;
 
+       pFunc->iStackIndex--;
+
        if( pFunc->pCode[ ulPos ] == HB_P_POPMEMVAR )
           wVar = pFunc->pCode[ ulPos + 1 ] + pFunc->pCode[ ulPos + 2 ] * 256;
 
@@ -1830,26 +2321,40 @@ void hb_compStrongType( int iSize )
              /*printf( "\nSymbol: %s Variable: %s Type: %c #%i Function: %s\n", pSym->szName, pVar->szName, pVar->cType, wVar, pFunc->szName );*/
 
              /* Allow any type into a Variant, and record the subtype */
-             if( pVar->cType == ' ' || pVar->cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
+             if( pVar->cType == ' ' || pVar->cType  == ( '-' + VT_OFFSET_VARIANT ) || pVar->cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
              {
                 if( pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
+				{
                    pVar->cType = ' ';
-                else if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+				}
+                else if( pFunc->pStack[ pFunc->iStackIndex ]  == ( '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+				{
                    pVar->cType = pFunc->pStack[ pFunc->iStackIndex ];
+				}
                 else
+				{
                    pVar->cType = pFunc->pStack[ pFunc->iStackIndex ] + VT_OFFSET_VARIANT;
+				}
 
                 /* Will need the Class Handle. */
                 cType = pVar->cType;
-                if( cType >= ( 'A' + VT_OFFSET_VARIANT  ) )
+                if( cType == ( '-' + VT_OFFSET_VARIANT  ) || cType >= ( 'A' + VT_OFFSET_VARIANT  ) )
+				{
                    cType -= VT_OFFSET_VARIANT;
+				}
 
                 if( toupper( cType ) == 'S' && pFunc->iStackClasses )
+				{
                    pVar->pClass = pFunc->pStackClasses[ pFunc->iStackClasses - 1 ];
+				}
                 else
+				{
                    pVar->pClass = NULL;
+				}
 
-                /*printf( "\nSymbol: %s Variable: %s Assigned Type: \'%c\' SubType: %c #%i Stack: %i\n", pSym->szName, pVar->szName, pVar->cType, pVar->cType - 100, wVar, pFunc->iStackIndex );*/
+                /*
+				printf( "\nSymbol: %s Variable: %s Assigned Type: \'%c\' SubType: %c #%i Stack: %i\n", pSym->szName, pVar->szName, pVar->cType, pVar->cType - 100, wVar, pFunc->iStackIndex );
+				*/
              }
              else
              {
@@ -1897,96 +2402,163 @@ void hb_compStrongType( int iSize )
                    hb_comp_cCastType = ' ';
                 }
 
-                if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+                if( pFunc->pStack[ pFunc->iStackIndex ]  == ( '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+				{
                    pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT;
+				}
 
                 if( pFunc->pStack[ pFunc->iStackIndex ] == '-' )
-                   ; /* NIL allowed into all types */
+				{
+                   /* NIL allowed into all types */
+				}
                 else if( pVar->cType == 'a' && islower( pFunc->pStack[ pFunc->iStackIndex ] ) )
-                   ; /* Array Of ANYTYPE may accept any Array  */
+				{
+                   /* Array Of ANYTYPE may accept any Array  */
+				}
                 else if( islower( pVar->cType ) && pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
+				{
                    hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, ( char * ) szType, NULL );
+				}
                 else if( islower( pVar->cType ) && pFunc->pStack[ pFunc->iStackIndex ] == 'A' )
+				{
                    hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, ( char * ) szType, NULL );
+				}
                 else if( islower( pVar->cType ) && pVar->cType != pFunc->pStack[ pFunc->iStackIndex ] )
+				{
                    hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_TYPE, ( char * ) szType, NULL );
+				}
                 else if( pVar->cType != ' ' && pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
+				{
                    hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+				}
                 else if( pVar->cType == 'S' && pFunc->pStack[ pFunc->iStackIndex ] == 'O' )
+				{
                    hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+				}
                 else if( pVar->cType == 's' && pFunc->pStack[ pFunc->iStackIndex ] == 'o' )
+				{
                    hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+				}
                 else if( pVar->cType == 'S' && pFunc->pStack[ pFunc->iStackIndex ] == 'S' )
                 {
                    if( pFunc->iStackClasses && pVar->pClass == pFunc->pStackClasses[ pFunc->iStackClasses - 1 ] )
-                      ; /* Same class */
+				   {
+                      /* Same class */
+				   }
                    else
+				   {
                       hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_TYPE, pVar->szName, ( char * ) szType );
+				   }
                 }
                 else if( pVar->cType == 's' && pFunc->pStack[ pFunc->iStackIndex ] == 's' )
                 {
                    if( pFunc->iStackClasses && pVar->pClass == pFunc->pStackClasses[ pFunc->iStackClasses - 1 ] )
-                      ; /* Same class */
+				   {
+                      /* Same class */
+				   }
                    else
+				   {
                       hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_TYPE, pVar->szName, ( char * ) szType );
+				   }
                 }
                 else if( isupper( pVar->cType ) && pVar->cType != pFunc->pStack[ pFunc->iStackIndex ] )
+				{
                    hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_TYPE, pVar->szName, ( char * ) szType );
+				}
              }
           }
           else
           {
              /* Allow any type into a Variant, and record the subtype */
-             if( pSym->cType == ' ' || pSym->cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
+             if( pSym->cType == ' ' || pSym->cType  == ( '-' + VT_OFFSET_VARIANT ) || pSym->cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
              {
                 if( pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
+				{
                    pSym->cType = ' ';
-                else if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+				}
+                else if( pFunc->pStack[ pFunc->iStackIndex ]  == ( '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+				{
                    pSym->cType = pFunc->pStack[ pFunc->iStackIndex ];
+				}
                 else
+				{
                    pSym->cType = pFunc->pStack[ pFunc->iStackIndex ] + VT_OFFSET_VARIANT;
+				}
 
                 /* Will need the Class Handle. */
                 if( toupper( pFunc->pStack[ pFunc->iStackIndex ] ) == 'S' && pFunc->iStackClasses )
+				{
                    pSym->pClass = pFunc->pStackClasses[ pFunc->iStackClasses - 1 ];
+				}
              }
              else
              {
                 char szType[2];
-                if( pSym->cType == 'S' )
-                  sprintf( ( char * ) szType, "%s", pSym->pClass->szName );
-                else if( pSym->cType == 's' )
-                  sprintf( ( char * ) szType, "ARRAY OF %s", pSym->pClass->szName );
-                else if( islower( pSym->cType ) )
-                  sprintf( ( char * ) szType, "ARRAY OF %c", toupper( pSym->cType ) );
-                else
-                  sprintf( ( char * ) szType, "%c", pSym->cType );
 
-                if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+                if( pSym->cType == 'S' )
+				{
+                   sprintf( ( char * ) szType, "%s", pSym->pClass->szName );
+				}
+                else if( pSym->cType == 's' )
+				{
+                   sprintf( ( char * ) szType, "ARRAY OF %s", pSym->pClass->szName );
+				}
+                else if( islower( pSym->cType ) )
+				{
+                   sprintf( ( char * ) szType, "ARRAY OF %c", toupper( pSym->cType ) );
+				}
+                else
+				{
+                   sprintf( ( char * ) szType, "%c", pSym->cType );
+				}
+
+                if( pFunc->pStack[ pFunc->iStackIndex ]  == ( '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+				{
                    pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT;
+				}
 
                 if( pFunc->pStack[ pFunc->iStackIndex ] == '-' )
-                   ; /* NIL allowed into all types */
+				{
+                   /* NIL allowed into all types */
+				}
                 else if( pSym->cType == 'a' && islower( pFunc->pStack[ pFunc->iStackIndex ] ) )
-                   ; /* Array Of ANYTYPE may accept any Array  */
+				{
+                   /* Array Of ANYTYPE may accept any Array  */
+				}
                 else if( islower( pSym->cType ) && pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
+				{
                    hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, ( char * ) szType, NULL );
+				}
                 else if( islower( pSym->cType ) && pFunc->pStack[ pFunc->iStackIndex ] == 'A' )
+				{
                    hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, ( char * ) szType, NULL );
+				}
                 else if( islower( pSym->cType ) && pSym->cType != pFunc->pStack[ pFunc->iStackIndex ] )
+				{
                    hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_TYPE, ( char * ) szType, NULL );
+				}
                 else if( pSym->cType != ' ' && pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
+				{
                    hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_SUSPECT, pSym->szName, ( char * ) szType );
+				}
                 else if( pSym->cType == 'S' && pFunc->pStack[ pFunc->iStackIndex ] == 'O' )
+				{
                    hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_SUSPECT, pSym->szName, ( char * ) szType );
+				}
                 else if( pSym->cType == 's' && pFunc->pStack[ pFunc->iStackIndex ] == 'o' )
+				{
                    hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, pSym->szName, ( char * ) szType );
+				}
                 else if( pSym->cType == 'S' && pFunc->pStack[ pFunc->iStackIndex ] == 'S' )
                 {
                    if( pFunc->iStackClasses && pSym->pClass == pFunc->pStackClasses[ pFunc->iStackClasses - 1 ] )
-                      ; /* Same class */
+				   {
+                      /* Same class */
+				   }
                    else
+				   {
                       hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_TYPE, pSym->szName, ( char * ) szType );
+				   }
                 }
                 else if( pSym->cType == 's' && pFunc->pStack[ pFunc->iStackIndex ] == 's' )
                 {
@@ -2009,16 +2581,23 @@ void hb_compStrongType( int iSize )
 
      case HB_P_POPLOCALNEAR :
      case HB_P_POPLOCAL :
+       /* TODO Error Message after finalizing all possible pcodes. */
+       if( pFunc->iStackIndex < 1 )
+	   {
+		  printf( "Oops - Stack: %i\n", pFunc->iStackIndex );
+          break;
+	   }
+
        pFunc->iStackIndex--;
 
-       if( pFunc->iStackIndex < 0 )
-          /* TODO Error Message after finalizing all possible pcodes. */
-          break;
-
        if( pFunc->pCode[ ulPos ] == HB_P_POPLOCAL )
+	   {
           wVar = * ( ( SHORT * ) &( pFunc->pCode )[ ulPos + 1 ] );
+	   }
        else
+	   {
           wVar = ( SHORT ) pFunc->pCode[ ulPos + 1 ];
+	   }
 
        /* we are accesing variables within a codeblock */
        if( wVar < 0 )
@@ -2054,23 +2633,35 @@ void hb_compStrongType( int iSize )
          pVar->iUsed |= VU_INITIALIZED;
 
          /* Allow any type into a Variant, and record the subtype */
-         if( pVar->cType == ' ' || pVar->cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
+         if( pVar->cType == ' ' || pVar->cType  == ( '-' + VT_OFFSET_VARIANT ) || pVar->cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
          {
             if( pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
+			{
                pVar->cType = ' ';
-            else if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+			}
+            else if( pFunc->pStack[ pFunc->iStackIndex ]  == ( '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+			{
                pVar->cType = pFunc->pStack[ pFunc->iStackIndex ];
+			}
             else
+			{
                pVar->cType = pFunc->pStack[ pFunc->iStackIndex ] + VT_OFFSET_VARIANT;
+			}
 
             cType = pVar->cType;
-            if( cType >= ( 'A' + VT_OFFSET_VARIANT  ) )
+            if( cType == ( '-' + VT_OFFSET_VARIANT ) || cType >= ( 'A' + VT_OFFSET_VARIANT ) )
+			{
                cType -= VT_OFFSET_VARIANT;
+			}
 
             if( toupper( cType ) == 'S' && pFunc->iStackClasses )
+			{
                pVar->pClass = pFunc->pStackClasses[ pFunc->iStackClasses - 1 ];
+			}
             else
+			{
                pVar->pClass = NULL;
+			}
          }
          else
          {
@@ -2117,31 +2708,53 @@ void hb_compStrongType( int iSize )
                hb_comp_cCastType = ' ';
             }
 
-            if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+            if( pFunc->pStack[ pFunc->iStackIndex ] == ( '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ] >= ( 'A' + VT_OFFSET_VARIANT ) )
+			{
                pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT;
+			}
 
             if( pFunc->pStack[ pFunc->iStackIndex ] == '-' )
-                ; /* NIL allowed into all types */
+			{
+               /* NIL allowed into all types */
+			}
             else if( pVar->cType == 'a' && islower( pFunc->pStack[ pFunc->iStackIndex ] ) )
-                ; /* Array Of ANYTYPE may accept any Array  */
+			{
+               /* Array Of ANYTYPE may accept any Array  */
+			}
             else if( islower( pVar->cType ) && pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
-                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, ( char * ) szType, NULL );
+			{
+               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, ( char * ) szType, NULL );
+			}
             else if( islower( pVar->cType ) && pFunc->pStack[ pFunc->iStackIndex ] == 'A' )
-                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, ( char * ) szType, NULL );
+			{
+               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, ( char * ) szType, NULL );
+			}
             else if( islower( pVar->cType ) && pVar->cType != pFunc->pStack[ pFunc->iStackIndex ] )
-                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_TYPE, ( char * ) szType, NULL );
+			{
+               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_TYPE, ( char * ) szType, NULL );
+			}
             else if( pVar->cType != ' ' && pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
-                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+			{
+               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+			}
             else if( pVar->cType == 'S' && pFunc->pStack[ pFunc->iStackIndex ] == 'O' )
-                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+			{
+               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+			}
             else if( pVar->cType == 's' && pFunc->pStack[ pFunc->iStackIndex ] == 'o' )
-                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+			{
+               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+			}
             else if( pVar->cType == 'S' && pFunc->pStack[ pFunc->iStackIndex ] == 'S' )
             {
                if( pFunc->iStackClasses && pVar->pClass == pFunc->pStackClasses[ pFunc->iStackClasses - 1 ] )
-                 ; /* Same class */
+			   {
+                  /* Same class */
+			   }
                else
-                 hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_TYPE, pVar->szName, ( char * ) szType );
+			   {
+                  hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_TYPE, pVar->szName, ( char * ) szType );
+			   }
             }
             else if( pVar->cType == 's' && pFunc->pStack[ pFunc->iStackIndex ] == 's' )
             {
@@ -2162,12 +2775,12 @@ void hb_compStrongType( int iSize )
        break;
 
      case HB_P_POPSTATIC :
-       pFunc->iStackIndex--;
-
-       if( pFunc->iStackIndex < 0 )
+       if( pFunc->iStackIndex < 1 )
           /* TODO Error Message after finalizing all possible pcodes. */
           break;
 
+       pFunc->iStackIndex--;
+
        pTmp = hb_comp_functions.pFirst;
        wVar = pFunc->pCode[ ulPos + 1 ] + pFunc->pCode[ ulPos + 2 ] * 256;
 
@@ -2181,25 +2794,38 @@ void hb_compStrongType( int iSize )
          pVar->iUsed |= VU_INITIALIZED;
 
          /* Allow any type into a Variant, and record the subtype */
-         if( pVar->cType == ' ' || pVar->cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
+         if( pVar->cType == ' ' || pVar->cType  == ( '-' + VT_OFFSET_VARIANT ) || pVar->cType  >= ( 'A' + VT_OFFSET_VARIANT ) )
          {
             if( pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
+			{
                pVar->cType = ' ';
-            else if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+			}
+            else if( pFunc->pStack[ pFunc->iStackIndex ]  == ( '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+			{
                pVar->cType = pFunc->pStack[ pFunc->iStackIndex ];
+			}
             else
+			{
                pVar->cType = pFunc->pStack[ pFunc->iStackIndex ] + VT_OFFSET_VARIANT;
+			}
 
             cType = pVar->cType;
-            if( cType >= ( 'A' + VT_OFFSET_VARIANT  ) )
+            if( cType == ( '-' + VT_OFFSET_VARIANT  ) || cType >= ( 'A' + VT_OFFSET_VARIANT  ) )
+			{
                cType -= VT_OFFSET_VARIANT;
-
+			}
             if( toupper( cType ) == 'S' && pFunc->iStackClasses )
+			{
                pVar->pClass = pFunc->pStackClasses[ pFunc->iStackClasses - 1 ];
+			}
             else
+			{
                pVar->pClass = NULL;
+			}
 
-            /*printf( "\nStack: %c Asc: %i, Var: %c Asc: %i\n", pFunc->pStack[ pFunc->iStackIndex ], pFunc->pStack[ pFunc->iStackIndex ], pVar->cType, pVar->cType );*/
+            /*
+			printf( "\nStack: %c Asc: %i, Var: %c Asc: %i\n", pFunc->pStack[ pFunc->iStackIndex ], pFunc->pStack[ pFunc->iStackIndex ], pVar->cType, pVar->cType );
+		    */
          }
          else
          {
@@ -2245,48 +2871,77 @@ void hb_compStrongType( int iSize )
                hb_comp_cCastType = ' ';
             }
 
-            if( pFunc->pStack[ pFunc->iStackIndex ]  >= ( 'A' + VT_OFFSET_VARIANT ) )
+            if( pFunc->pStack[ pFunc->iStackIndex ] == ( '-' + VT_OFFSET_VARIANT ) || pFunc->pStack[ pFunc->iStackIndex ] >= ( 'A' + VT_OFFSET_VARIANT ) )
+			{
                pFunc->pStack[ pFunc->iStackIndex ] -= VT_OFFSET_VARIANT;
+			}
 
             if( pFunc->pStack[ pFunc->iStackIndex ] == '-' )
-                ; /* NIL allowed into all types */
+			{
+               /* NIL allowed into all types */
+			}
             else if( pVar->cType == 'a' && islower( pFunc->pStack[ pFunc->iStackIndex ] ) )
-                ; /* Array Of ANYTYPE may accept any Array  */
+			{
+               /* Array Of ANYTYPE may accept any Array  */
+			}
             else if( islower( pVar->cType ) && pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
-                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, ( char * ) szType, NULL );
+			{
+               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, ( char * ) szType, NULL );
+			}
             else if( islower( pVar->cType ) && pFunc->pStack[ pFunc->iStackIndex ] == 'A' )
-                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, ( char * ) szType, NULL );
+			{
+               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, ( char * ) szType, NULL );
+			}
             else if( islower( pVar->cType ) && pVar->cType != pFunc->pStack[ pFunc->iStackIndex ] )
-                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_TYPE, ( char * ) szType, NULL );
+			{
+               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_TYPE, ( char * ) szType, NULL );
+			}
             else if( pVar->cType != ' ' && pFunc->pStack[ pFunc->iStackIndex ] == ' ' )
-                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+			{
+               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+			}
             else if( pVar->cType == 'S' && pFunc->pStack[ pFunc->iStackIndex ] == 'O' )
-                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+			{
+               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+			}
             else if( pVar->cType == 's' && pFunc->pStack[ pFunc->iStackIndex ] == 'o' )
-                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+			{
+               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_SUSPECT, pVar->szName, ( char * ) szType );
+			}
             else if( pVar->cType == 'S' && pFunc->pStack[ pFunc->iStackIndex ] == 'S' )
             {
                if( pFunc->iStackClasses && pVar->pClass == pFunc->pStackClasses[ pFunc->iStackClasses - 1 ] )
-                 ; /* Same class */
+			   {
+                  /* Same class */
+			   }
                else
-                 hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_TYPE, pVar->szName, ( char * ) szType );
+			   {
+                  hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_TYPE, pVar->szName, ( char * ) szType );
+			   }
             }
             else if( pVar->cType == 's' && pFunc->pStack[ pFunc->iStackIndex ] == 's' )
             {
                if( pFunc->iStackClasses && pVar->pClass == pFunc->pStackClasses[ pFunc->iStackClasses - 1 ] )
-                 ; /* Same class */
+			   {
+                  /* Same class */
+			   }
                else
-                 hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_TYPE, pVar->szName, ( char * ) szType );
+			   {
+                  hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ARRAY_ASSIGN_TYPE, pVar->szName, ( char * ) szType );
+			   }
             }
             else if( isupper( pVar->cType ) && pVar->cType != pFunc->pStack[ pFunc->iStackIndex ] )
-                hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_TYPE, pVar->szName, ( char * ) szType );
+			{
+               hb_compGenWarning( hb_comp_szWarnings, 'W', HB_COMP_WARN_ASSIGN_TYPE, pVar->szName, ( char * ) szType );
+			}
          }
        }
 
        /* Resetting */
        if( toupper( pFunc->pStack[ pFunc->iStackIndex ] ) == 'S' && pFunc->iStackClasses )
+	   {
          --pFunc->iStackClasses;
-
+	   }
        break;
 
      /* Macros Undefined Types */
@@ -2297,13 +2952,21 @@ void hb_compStrongType( int iSize )
      case HB_P_MPOPMEMVAR :
      case HB_P_MACROPOP :
      case HB_P_MACROPOPALIASED :
-        pFunc->iStackIndex--;
-        break;
+       pFunc->iStackIndex--;
+       break;
+
+	 case HB_P_SEQRECOVER :
+	   /* TODO: find type of BREAK() */
+       pFunc->pStack[ pFunc->iStackIndex++ ] = ' ';
+       break;
    }
 
    /* TODO Error or trace messages when completed. */
    if( pFunc->iStackIndex < 0 )
+   {
+	  printf( "\nStrongType Stack underflow!\n" );
       pFunc->iStackIndex = 0;
+   }
 }
 
 void hb_compGenPCode1( BYTE byte )