diff --git a/harbour/ChangeLog b/harbour/ChangeLog
index 3be30e6d8e..2ff6fd8dfd 100644
--- a/harbour/ChangeLog
+++ b/harbour/ChangeLog
@@ -17,6 +17,30 @@
    past entries belonging to author(s): Viktor Szakats.
 */
 
+2010-01-14 12:44 UTC+0100 Przemyslaw Czerpak (druzus/at/priv.onet.pl)
+  * harbour/include/hbpp.h
+  * harbour/src/pp/ppcore.c
+  * harbour/src/pp/pplib.c
+  * harbour/src/compiler/ppcomp.c
+    + added support for __pragma( <switchname> ) in #if expressions, i.e.:
+         #if __pragma( WARNINGLEVEL ) >= 3
+            #stdout Warnings set to level 3 or higher
+         #endif
+         #if !__pragma( z )
+            #stdout Shortcut optimization enabled
+         #else
+            #stdout Force complete boolean evaluation
+         #endif
+         #if __pragma( kj )
+            #stdout NO JUMP OPTIMIZATION
+         #endif
+         #if __pragma( km )
+            #stdout MACRO TEXT SUBSTITUTION DISABLED
+         #endif
+         #if __pragma( kh )
+            #stdout HARBOUR EXTENSIONS
+         #endif
+
 2010-01-14 12:36 UTC+0100 Viktor Szakats (harbour.01 syenar.hu)
   * contrib/xhb/hbcrypt.c
   * contrib/xhb/dbf2txt.c
diff --git a/harbour/include/hbpp.h b/harbour/include/hbpp.h
index 6982715150..d721f06c97 100644
--- a/harbour/include/hbpp.h
+++ b/harbour/include/hbpp.h
@@ -112,7 +112,7 @@ typedef HB_PP_INLINE_FUNC_( HB_PP_INLINE_FUNC );
 typedef HB_PP_INLINE_FUNC * PHB_PP_INLINE_FUNC;
 
 /* function for catching #pragma dump data */
-#define HB_PP_SWITCH_FUNC_( func ) BOOL func( void *, const char *, int )
+#define HB_PP_SWITCH_FUNC_( func ) BOOL func( void *, const char *, int *, BOOL )
 typedef HB_PP_SWITCH_FUNC_( HB_PP_SWITCH_FUNC );
 typedef HB_PP_SWITCH_FUNC * PHB_PP_SWITCH_FUNC;
 
diff --git a/harbour/src/compiler/ppcomp.c b/harbour/src/compiler/ppcomp.c
index 773133b061..f7c024382f 100644
--- a/harbour/src/compiler/ppcomp.c
+++ b/harbour/src/compiler/ppcomp.c
@@ -116,12 +116,15 @@ static void hb_pp_hb_inLine( void * cargo, char * szFunc,
 }
 
 static BOOL hb_pp_CompilerSwitch( void * cargo, const char * szSwitch,
-                                  int iValue )
+                                  int * piValue, BOOL fSet )
 {
    HB_COMP_DECL = ( HB_COMP_PTR ) cargo;
    BOOL fError = FALSE;
-   int i = strlen( szSwitch );
+   int iValue, i;
 
+   iValue = *piValue;
+
+   i = strlen( szSwitch );
    if( i > 1 && ( ( int ) ( szSwitch[ i - 1 ] - '0' ) ) == iValue )
       --i;
 
@@ -131,61 +134,97 @@ static BOOL hb_pp_CompilerSwitch( void * cargo, const char * szSwitch,
       {
          case 'a':
          case 'A':
-            HB_COMP_PARAM->fAutoMemvarAssume = iValue != 0;
+            if( fSet )
+               HB_COMP_PARAM->fAutoMemvarAssume = iValue != 0;
+            else
+               iValue = HB_COMP_PARAM->fAutoMemvarAssume ? 1 : 0;
             break;
 
          case 'b':
          case 'B':
-            HB_COMP_PARAM->fDebugInfo = iValue != 0;
+            if( fSet )
+               HB_COMP_PARAM->fDebugInfo = iValue != 0;
+            else
+               iValue = HB_COMP_PARAM->fDebugInfo ? 1 : 0;
             break;
 
          case 'j':
          case 'J':
-            HB_COMP_PARAM->fI18n = iValue != 0;
+            if( fSet )
+               HB_COMP_PARAM->fI18n = iValue != 0;
+            else
+               iValue = HB_COMP_PARAM->fI18n ? 1 : 0;
             break;
 
          case 'l':
          case 'L':
-            HB_COMP_PARAM->fLineNumbers = iValue != 0;
+            if( fSet )
+               HB_COMP_PARAM->fLineNumbers = iValue != 0;
+            else
+               iValue = HB_COMP_PARAM->fLineNumbers ? 1 : 0;
             break;
 
          case 'n':
          case 'N':
-            if( iValue >= 0 && iValue <= 2 )
-               HB_COMP_PARAM->iStartProc = iValue;
+            if( fSet )
+            {
+               if( iValue >= 0 && iValue <= 2 )
+                  HB_COMP_PARAM->iStartProc = iValue;
+               else
+                  fError = TRUE;
+            }
             else
-               fError = TRUE;
+               iValue = HB_COMP_PARAM->iStartProc;
             break;
 
          case 'p':
          case 'P':
-            HB_COMP_PARAM->fPPO = iValue != 0;
+            if( fSet )
+               HB_COMP_PARAM->fPPO = iValue != 0;
+            else
+               iValue = HB_COMP_PARAM->fPPO ? 1 : 0;
             break;
 
          case 'q':
          case 'Q':
-            HB_COMP_PARAM->fQuiet = iValue != 0;
+            if( fSet )
+               HB_COMP_PARAM->fQuiet = iValue != 0;
+            else
+               iValue = HB_COMP_PARAM->fQuiet ? 1 : 0;
             break;
 
          case 'v':
          case 'V':
-            HB_COMP_PARAM->fForceMemvars = iValue != 0;
+            if( fSet )
+               HB_COMP_PARAM->fForceMemvars = iValue != 0;
+            else
+               iValue = HB_COMP_PARAM->fForceMemvars ? 1 : 0;
             break;
 
          case 'w':
          case 'W':
-            if( iValue >= 0 && iValue <= 3 )
-               HB_COMP_PARAM->iWarnings = iValue;
+            if( fSet )
+            {
+               if( iValue >= 0 && iValue <= 3 )
+                  HB_COMP_PARAM->iWarnings = iValue;
+               else
+                  fError = TRUE;
+            }
             else
-               fError = TRUE;
+               iValue = HB_COMP_PARAM->iWarnings;
             break;
 
          case 'z':
          case 'Z':
-            if( iValue )
-               HB_COMP_PARAM->supported &= ~HB_COMPFLAG_SHORTCUTS;
+            if( fSet )
+            {
+               if( iValue )
+                  HB_COMP_PARAM->supported &= ~HB_COMPFLAG_SHORTCUTS;
+               else
+                  HB_COMP_PARAM->supported |= HB_COMPFLAG_SHORTCUTS;
+            }
             else
-               HB_COMP_PARAM->supported |= HB_COMPFLAG_SHORTCUTS;
+               iValue = ( HB_COMP_PARAM->supported & HB_COMPFLAG_SHORTCUTS ) ? 0 : 1;
             break;
 
          default:
@@ -200,12 +239,26 @@ static BOOL hb_pp_CompilerSwitch( void * cargo, const char * szSwitch,
          /* -k? parameters are case sensitive */
          switch( szSwitch[ 1 ] )
          {
+            case '?':
+               if( fSet )
+                  HB_COMP_PARAM->supported = iValue;
+               else
+                  iValue = HB_COMP_PARAM->supported;
+               break;
             case 'c':
             case 'C':
-               /* clear all flags - minimal set of features */
-               HB_COMP_PARAM->supported &= HB_COMPFLAG_SHORTCUTS;
-               HB_COMP_PARAM->supported |= HB_COMPFLAG_OPTJUMP |
-                                           HB_COMPFLAG_MACROTEXT;
+               if( fSet )
+               {
+                  /* clear all flags - minimal set of features */
+                  HB_COMP_PARAM->supported &= HB_COMPFLAG_SHORTCUTS;
+                  HB_COMP_PARAM->supported |= HB_COMPFLAG_OPTJUMP |
+                                              HB_COMPFLAG_MACROTEXT;
+               }
+               else
+               {
+                  iValue = ( HB_COMP_PARAM->supported & ~HB_COMPFLAG_SHORTCUTS ) ==
+                           ( HB_COMPFLAG_OPTJUMP | HB_COMPFLAG_MACROTEXT ) ? 1 : 0;
+               }
                break;
             case 'h':
             case 'H':
@@ -246,29 +299,60 @@ static BOOL hb_pp_CompilerSwitch( void * cargo, const char * szSwitch,
          }
          if( !fError && iFlag )
          {
-            if( iValue )
-               HB_COMP_PARAM->supported |= iFlag;
+            if( fSet )
+            {
+               if( iValue )
+                  HB_COMP_PARAM->supported |= iFlag;
+               else
+                  HB_COMP_PARAM->supported &= ~iFlag;
+            }
             else
-               HB_COMP_PARAM->supported &= ~iFlag;
+            {
+               if( iValue )
+                  iValue = HB_COMP_PARAM->supported & iFlag ? 0 : 1;
+               else
+                  iValue = HB_COMP_PARAM->supported & iFlag ? 1 : 0;
+            }
          }
       }
-      else if( hb_strnicmp( szSwitch, "es", 2 ) == 0 &&
-               ( iValue == HB_EXITLEVEL_DEFAULT ||
-                 iValue == HB_EXITLEVEL_SETEXIT ||
-                 iValue == HB_EXITLEVEL_DELTARGET ) )
-         HB_COMP_PARAM->iExitLevel = iValue;
+      else if( hb_strnicmp( szSwitch, "es", 2 ) == 0 )
+      {
+         if( fSet )
+         {
+            if( iValue == HB_EXITLEVEL_DEFAULT ||
+                iValue == HB_EXITLEVEL_SETEXIT ||
+                iValue == HB_EXITLEVEL_DELTARGET )
+               HB_COMP_PARAM->iExitLevel = iValue;
+         }
+         else
+            iValue = HB_COMP_PARAM->iExitLevel;
+      }
       else if( hb_stricmp( szSwitch, "p+" ) == 0 )
-         HB_COMP_PARAM->fPPT = iValue != 0;
+      {
+         if( fSet )
+            HB_COMP_PARAM->fPPT = iValue != 0;
+         else
+            iValue = HB_COMP_PARAM->fPPT ? 1 : 0;
+      }
       else
          fError = TRUE;
    }
    /* xHarbour extension */
-   else if( i >= 4 && hb_strnicmp( szSwitch, "TEXTHIDDEN", i ) == 0 &&
-            iValue >= 0 && iValue <= 1 )
-      HB_COMP_PARAM->iHidden = iValue;
+   else if( i >= 4 && hb_strnicmp( szSwitch, "TEXTHIDDEN", i ) == 0 )
+   {
+      if( fSet )
+      {
+         if( iValue >= 0 && iValue <= 1 )
+            HB_COMP_PARAM->iHidden = iValue;
+      }
+      else
+         iValue = HB_COMP_PARAM->iHidden;
+   }
    else
       fError = TRUE;
 
+   *piValue = iValue;
+
    return fError;
 }
 
diff --git a/harbour/src/pp/ppcore.c b/harbour/src/pp/ppcore.c
index 4df9cc6afe..1496a781b6 100644
--- a/harbour/src/pp/ppcore.c
+++ b/harbour/src/pp/ppcore.c
@@ -2270,7 +2270,44 @@ static BOOL hb_pp_setCompilerSwitch( PHB_PP_STATE pState, const char * szSwitch,
    }
 
    if( pState->pSwitchFunc )
-      fError = ( pState->pSwitchFunc )( pState->cargo, szSwitch, iValue );
+      fError = ( pState->pSwitchFunc )( pState->cargo, szSwitch, &iValue, TRUE );
+
+   return fError;
+}
+
+static BOOL hb_pp_getCompilerSwitch( PHB_PP_STATE pState, const char * szSwitch,
+                                     int * piValue )
+{
+   BOOL fError = TRUE;
+
+   if( pState->pSwitchFunc )
+      fError = ( pState->pSwitchFunc )( pState->cargo, szSwitch, piValue, FALSE );
+
+   if( fError ) switch( szSwitch[ 0 ] )
+   {
+      case 'p':
+      case 'P':
+         if( szSwitch[ 1 ] == '\0' )
+         {
+            *piValue = pState->fWritePreprocesed ? 1 : 0;
+            fError = FALSE;
+         }
+         else if( szSwitch[ 1 ] == '+' && szSwitch[ 2 ] == '\0' )
+         {
+            *piValue = pState->fWriteTrace ? 1 : 0;
+            fError = FALSE;
+         }
+         break;
+
+      case 'q':
+      case 'Q':
+         if( szSwitch[ 1 ] == '\0' )
+         {
+            *piValue = pState->fQuiet ? 1 : 0;
+            fError = FALSE;
+         }
+         break;
+   }
 
    return fError;
 }
@@ -4222,18 +4259,63 @@ static void hb_pp_processCondDefined( PHB_PP_STATE pState, PHB_PP_TOKEN pToken )
    {
       pNext = pToken->pNext;
       if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_KEYWORD &&
-          hb_pp_tokenValueCmp( pToken, "defined", HB_PP_CMP_CASE ) &&
+          ( hb_pp_tokenValueCmp( pToken, "defined", HB_PP_CMP_CASE ) ||
+            hb_pp_tokenValueCmp( pToken, "__pragma", HB_PP_CMP_CASE ) ) &&
           pNext && HB_PP_TOKEN_TYPE( pNext->type ) == HB_PP_TOKEN_LEFT_PB &&
           pNext->pNext && HB_PP_TOKEN_TYPE( pNext->pNext->type ) == HB_PP_TOKEN_KEYWORD &&
           pNext->pNext->pNext && HB_PP_TOKEN_TYPE( pNext->pNext->pNext->type ) == HB_PP_TOKEN_RIGHT_PB )
       {
-         BOOL fDefined = hb_pp_defineFind( pState, pNext->pNext ) != NULL;
+         const char * szValue = NULL;
+         char buffer[ 32 ];
 
-         hb_pp_tokenSetValue( pToken, fDefined ? "1" : "0", 1 );
-         HB_PP_TOKEN_SETTYPE( pToken, HB_PP_TOKEN_NUMBER );
-         pToken->pNext = pNext->pNext->pNext->pNext;
-         pNext->pNext->pNext->pNext = NULL;
-         hb_pp_tokenListFree( &pNext );
+         if( pToken->value[ 0 ] == '_' )
+         {
+            const char * szSwitch = NULL;
+
+            if( hb_pp_tokenValueCmp( pNext->pNext, "AUTOMEMVAR", HB_PP_CMP_DBASE ) )
+               szSwitch = "a";
+            else if( hb_pp_tokenValueCmp( pNext->pNext, "DEBUGINFO", HB_PP_CMP_DBASE ) )
+               szSwitch = "b";
+            else if( hb_pp_tokenValueCmp( pNext->pNext, "DYNAMICMEMVAR", HB_PP_CMP_DBASE ) )
+               szSwitch = "v";
+            else if( hb_pp_tokenValueCmp( pNext->pNext, "EXITSEVERITY", HB_PP_CMP_DBASE ) )
+               szSwitch = "es";
+            else if( hb_pp_tokenValueCmp( pNext->pNext, "LINENUMBER", HB_PP_CMP_DBASE ) )
+               szSwitch = "l";
+            else if( hb_pp_tokenValueCmp( pNext->pNext, "NOSTARTPROC", HB_PP_CMP_DBASE ) )
+               szSwitch = "n";
+            else if( hb_pp_tokenValueCmp( pNext->pNext, "PREPROCESSING", HB_PP_CMP_DBASE ) )
+               szSwitch = "p";
+            else if( hb_pp_tokenValueCmp( pNext->pNext, "SHORTCUT", HB_PP_CMP_DBASE ) )
+               szSwitch = "z";
+            else if( hb_pp_tokenValueCmp( pNext->pNext, "TEXTHIDDEN", HB_PP_CMP_DBASE ) )
+               szSwitch = "TEXTHIDDEN";
+            else if( hb_pp_tokenValueCmp( pNext->pNext, "TRACE", HB_PP_CMP_DBASE ) )
+               szSwitch = "p+";
+            else if( hb_pp_tokenValueCmp( pNext->pNext, "WARNINGLEVEL", HB_PP_CMP_DBASE ) )
+               szSwitch = "w";
+            else
+               szSwitch = pNext->pNext->value;
+
+            if( szSwitch )
+            {
+               int iValue = 0;
+               if( ! hb_pp_getCompilerSwitch( pState, szSwitch, &iValue ) )
+                  szValue = hb_numToStr( buffer, sizeof( buffer ), iValue );
+            }
+         }
+         else
+            szValue = hb_pp_defineFind( pState, pNext->pNext ) != NULL ?
+                      "1" : "0";
+
+         if( szValue )
+         {
+            hb_pp_tokenSetValue( pToken, szValue, ( ULONG ) strlen( szValue ) );
+            HB_PP_TOKEN_SETTYPE( pToken, HB_PP_TOKEN_NUMBER );
+            pToken->pNext = pNext->pNext->pNext->pNext;
+            pNext->pNext->pNext->pNext = NULL;
+            hb_pp_tokenListFree( &pNext );
+         }
       }
       pToken = pToken->pNext;
    }
diff --git a/harbour/src/pp/pplib.c b/harbour/src/pp/pplib.c
index 97f7f1ef0f..cbe6a83ab2 100644
--- a/harbour/src/pp/pplib.c
+++ b/harbour/src/pp/pplib.c
@@ -90,12 +90,13 @@ static void hb_pp_Disp( void * cargo, const char * szMessage )
 }
 
 static BOOL hb_pp_CompilerSwitch( void * cargo, const char * szSwitch,
-                                  int iValue )
+                                  int * piValue, BOOL fSet )
 {
    /* ignore all compiler switches */
    HB_SYMBOL_UNUSED( cargo );
    HB_SYMBOL_UNUSED( szSwitch );
-   HB_SYMBOL_UNUSED( iValue );
+   HB_SYMBOL_UNUSED( piValue );
+   HB_SYMBOL_UNUSED( fSet );
 
    return FALSE;
 }