diff --git a/harbour/ChangeLog b/harbour/ChangeLog
index 95624fb68a..33bda71e9e 100644
--- a/harbour/ChangeLog
+++ b/harbour/ChangeLog
@@ -8,6 +8,151 @@
    2002-12-01 13:30 UTC+0100 Foo Bar <foo.bar@foobar.org>
 */
 
+      to character not symbol item type.
+
+2006-11-08 13:40 UTC+0100 Przemyslaw Czerpak (druzus/at/priv.onet.pl)
+  * harbour/source/pp/ppcore.c
+    * cleaned two warnings generated by old GCC versions
+
+2006-11-08 12:55 UTC+0100 Przemyslaw Czerpak (druzus/at/priv.onet.pl)
+  * harbour/bin/hb-func.sh
+    + added linker parametrs to hbcc
+
+  * harbour/include/hbapi.h
+    + added hb_retclenAdoptRaw()
+
+  * harbour/include/hbapifs.h
+  * harbour/source/common/hbfsapi.c
+    * changed first parameters of hb_fsAddSearchPath() to const char *
+
+  * harbour/include/hbclass.ch
+    * update for new PP. I think that now we can try to create final
+      version of our OOP rules.
+
+  * harbour/include/hbdefs.h
+    + added UCHAR and SCHAR typedefs
+
+  * harbour/include/hbrddcdx.h
+    * indenting
+
+  * harbour/source/rdd/workarea.c
+    ! fixed minor typo
+
+  * harbour/source/common/hbdate.c
+  * harbour/source/rtl/dates.c
+    * moved hb_dateToday() and hb_dateTimeStr() from RTL to COMMON library
+
+  - harbour/include/hbpp.h
+  - harbour/source/pp/ppcomp.c
+  - harbour/source/pp/ppcore.c
+  - harbour/source/pp/pplib.c
+  - harbour/source/pp/pptable.c
+  - harbour/source/pp/pragma.c
+  * harbour/utils/hbpp/Makefile
+  * harbour/utils/hbpp/hbpp.c
+  + harbour/utils/hbpp/hbpp.h
+  + harbour/utils/hbpp/ppcomp.c
+  + harbour/utils/hbpp/ppcore.c
+  + harbour/utils/hbpp/pplib.c
+  + harbour/utils/hbpp/pptable.c
+  + harbour/utils/hbpp/pragma.c
+    * moved all PP code to harbour/utils/hbpp
+      It's interesting and working preprocessor and the code can be
+      usable for some other things so I do not want to remove it.
+      Probablly we should move it to contrib/hbpptext
+
+  * harbour/include/hbcomp.h
+  * harbour/include/hberrors.h
+  * harbour/include/hbsetup.ch
+  + harbour/include/hbpp.h
+  + harbour/include/hbstdgen.ch
+  * harbour/source/common/hbstr.c
+  * harbour/source/compiler/Makefile
+  * harbour/source/compiler/cmdcheck.c
+  * harbour/source/compiler/harbour.c
+  * harbour/source/compiler/harbour.l
+  * harbour/source/compiler/hbgenerr.c
+  + harbour/source/compiler/ppcomp.c
+  * harbour/source/pp/Makefile
+  + harbour/source/pp/ppcore.c
+  + harbour/source/pp/pplib.c
+  + harbour/source/pp/ppgen.c
+    + New PP code written from scratch. It works in similar way to
+      Clipper PP even the error codes are replicated. The code is MT
+      safe does not have any limitation on size of preprocessed code,
+      line, etc. It's also Clipper compatible lexer. It means that
+      we do not longer need FLEX or SIMPLEX which can be replaced
+      by new PP after some small modifications. Anyhow I haven't
+      decided to make it myself. I would like to agree with with the
+      rest of developers. I will be very happy if such modifications
+      will be done by someone else, Ryszard?
+      Meanwhile I h may no flush data in PreExt()
+
+  * harbour/source/rtl/gtwin/gtwin.c
+    ! fixed Init() code by adding missing SUPER_INIT()
+    * modified a little bit PreExt() and PostExt() methods
+
+2006-02-08 20:23 UTC+0100 Antonio Linares <alinares@fivetechsoft.com>
+  * makefile.nt
+  * makefile64.nt
+    * updated with recent changes
+
+         	./ppgen$(EXE_EXT) $(TOP)$(ROOT)include/hbstdgen.ch -opptable.c -q
+  * harbour/source/rtl/gtwin/gtwin.c
+    + added PreExt() and PostExt() methods
+
+2006-02-08 15:17 UTC+0100 PrzemyslawI chose
+      modified version of xHarbour extension with escaped strings e"<sting>"
+      so now FLEX understand such strings and decode them like C escaped
+      strings. It means that you can use them also in the .prg code f.e.:
+         outstd( e"Hello\n\rWorld" )
+      The new PP is also noticeable faster. You should see the difference
+      compiling long files. The build in PP rules are generated automatically
+      by ppgen program created from source/pp/ppgen.c
+      I had to add to GNU source/pp/Makefile these two lines:
+         pptable.c : ppgen$(EXE_EXT)
+            ./ppgen$(EXE_EXT) $(TOP)$(ROOT)include/hbstdgen.ch -opptable.c -q
+      Sth like that will have to be done also in non GNU make system.
+      Now Harbour can be compiled only using GNU make.
+      Marek can you update non GNU make files? I would like to leave this
+      modification to you or other developers who can test it.
+      It was quite big modification and I do not believe that I haven't
+      make any mistakes but I hope that in few weeks I'll fix any reported
+      bugs and it will resolve any PP problems.
+      TODO:
+         * error messages
+           create one common list of errors and warnings and keep it
+           in common library. PP and compiler can still generate different
+           errors with the same number. It can be confusing for the users
+           and hard to document and add i18n translations.
+           If possible we should also try to keep Clipper error numbers.
+           In new PP code I added Clipper error numbers but I cannot use
+           them until compiler code is not updated.
+           We should aslo remove the ctype passed to error functions and
+           hack with first character in warning messages and use only
+           error number. The codes from 1000 to 1999 should be warnings
+           where range 1000:1099 is activated by -w, 1100:1199 by -w1,
+           1200:1299 by -w2, etc. 2000:2999 are errors and 3000:3999
+           fatal errors. All compiler functions which generate an error
+           should expect that error function will not stop the compiler
+           but return and cleanly finished their job. It's necessary for
+           MT support in compiler and making compiler part of some other
+           programs which may still work and compile different source code.
+         * FLEX/SIMPLEX
+           remove them at all and add some final pass to PP to create
+           more precise tokens for grammar parser or at least add better
+           integration to remove some redundant code and existing limits.
+         * hb_inLine() support - it's broken in new PP but as I can see
+           it was never working correctly. I can add a hack to PP to support
+           hb_inLine() but I'm not sure it's worth to do. Maybe in few days.
+
+  + harbour/include/std.ch
+    + added new std.ch. It was created without using Clipper's std.ch.
+      It's quite possible that some rules are wrong and should be fixed
+      so please help. Anyhow I created a set of programs based on new PP
+      code generating all possible combinations of different commands I
+      collected from different source code, documentation and match patterns
+      of rules I was adding to new std.ch and then I was comparing .ppo
       files generated by Clipper and Harbour so I do not expect any bigger
       problems then some minor typos. I had to introduce some modifications
       in spacing as workaround for FLEX/SIMPLEX which cannot properly decode
diff --git a/harbour/bin/hb-func.sh b/harbour/bin/hb-func.sh
index 751e9436aa..8b74acd3cd 100644
--- a/harbour/bin/hb-func.sh
+++ b/harbour/bin/hb-func.sh
@@ -409,7 +409,7 @@ FOUTE="\${FOUTE%.[oc]}${hb_exesuf}"
 
 hb_cc()
 {
-    ${CCPREFIX}\${HB_CC} "\$@" \${CC_OPT} \${GCC_PATHS}
+    ${CCPREFIX}\${HB_CC} "\$@" \${CC_OPT} \${GCC_PATHS} \${HB_USRLPATH} \${HB_USRLIBS}
 }
 
 hb_cmp()
diff --git a/harbour/include/hbapi.h b/harbour/include/hbapi.h
index 58a0b89576..da0e50dbdf 100644
--- a/harbour/include/hbapi.h
+++ b/harbour/include/hbapi.h
@@ -448,6 +448,7 @@ extern HB_EXPORT void   hb_retnlllen( LONGLONG lNumber, int iWidth ); /* returns
 /* xHarbour compatible function */
 #define hb_retcAdopt( szText )               hb_retc_buffer( (szText) )
 #define hb_retclenAdopt( szText, ulLen )     hb_retclen_buffer( (szText), (ulLen) )
+#define hb_retclenAdoptRaw( szText, ulLen )  hb_retclen_buffer( (szText), (ulLen) )
 #define hb_retcStatic( szText )              hb_retc_const( (szText) )
 
 #ifdef HB_API_MACROS
diff --git a/harbour/include/hbapifs.h b/harbour/include/hbapifs.h
index 7016e5a343..6f69574742 100644
--- a/harbour/include/hbapifs.h
+++ b/harbour/include/hbapifs.h
@@ -178,7 +178,7 @@ typedef struct _HB_PATHNAMES
    BOOL   fFree;
 } HB_PATHNAMES;
 
-extern HB_EXPORT void    hb_fsAddSearchPath( char * szPath, HB_PATHNAMES ** pSearchList );
+extern HB_EXPORT void    hb_fsAddSearchPath( const char * szPath, HB_PATHNAMES ** pSearchList );
 extern HB_EXPORT void    hb_fsFreeSearchPath( HB_PATHNAMES * pSearchList );
        
 extern HB_EXPORT BOOL    hb_spFile( BYTE * pFilename, BYTE * pRetPath );
diff --git a/harbour/include/hbclass.ch b/harbour/include/hbclass.ch
index a1e0787881..f483a3289c 100644
--- a/harbour/include/hbclass.ch
+++ b/harbour/include/hbclass.ch
@@ -181,7 +181,7 @@
 #ifdef HB_CLS_NO_OO_ERR
    #xtranslate __HB_CLS_ERR([<msg,...>]) =>
 #else
-   #xtranslate __HB_CLS_ERR([<msg,...>]) => ;#error [<msg>] ; #undef _DUMMY_DEF_
+   #xtranslate __HB_CLS_ERR([<msg,...>]) => ;#error [ <msg>] ; #undef _DUMMY_DEF_
 #endif
 
 #xtranslate __HB_CLS_VARERR(<var>) => __HB_CLS_ERR( Invalid instance variable name: <var> )
@@ -221,8 +221,8 @@ DECLARE HBClass ;
 #xtranslate __HB_CLS_ASARGS( <FuncName>([<Args,...>]) )     => [<Args>]
 #xtranslate __HB_CLS_ASARGSOPT( <FuncName> )                =>
 #xtranslate __HB_CLS_ASARGSOPT( <FuncName>([<Args,...>]) )  => [, <Args>]
-#xtranslate __HB_CLS_ISVAR( <var> )                         =>
-#xtranslate __HB_CLS_ISVAR( <var>([<params,...>]) )         => __HB_CLS_VARERR(<var>([<params>]))
+#xtranslate __HB_CLS_ISVAR( <var> )                         => __HB_CLS_VARERR(<var>)
+#xtranslate __HB_CLS_ISVAR( <!var!> )                       =>
 #xcommand __HB_CLS_CHECKVAR( <param1> [,<paramN>] )         => __HB_CLS_ISVAR( <param1> ) [;__HB_CLS_ISVAR( <paramN> )]
 
 /* #xtranslate __HB_CLS_SCOPE( <export>, <protect>, <hidde> ) => ;
@@ -257,7 +257,7 @@ DECLARE HBClass ;
 
 #xcommand ENDCLASS => ;
          s_oClass:Create() ;;
-      endif ;;
+      end ;;
       return s_oClass:Instance() AS CLASS _CLASS_NAME_ ;;
    #undef  _CLASS_MODE_ ; #define _CLASS_MODE_ _CLASS_IMPLEMENTATION_
 
@@ -273,7 +273,7 @@ DECLARE HBClass ;
       #undef _DUMMY_DEF_
 #else
    #xcommand __HB_CLS_DECLARE_METHOD <MethodName> <ClassName> => ;
-      #xcommand METHOD \<type: FUNCTION, PROCEDURE> <MethodName>\[(\[<xparams,...>])] CLASS <ClassName> _CLASS_IMPLEMENTATION_ => ;
+      #xcommand METHOD \<type: FUNCTION, PROCEDURE> <MethodName>\[(\[\<xparams,...>])] CLASS <ClassName> _CLASS_IMPLEMENTATION_ => ;
          DECLARED METHOD \<type> <MethodName>\[(\<xparams>)] CLASS <ClassName>
 #endif
 
@@ -286,7 +286,7 @@ DECLARE HBClass ;
    __HB_CLS_DECLARE_METHOD __HB_CLS_PARAMS(<MethodName>) _CLASS_NAME_ ;;
    s_oClass:AddMethod( __HB_CLS_ASSTRING(<MethodName>), @__HB_CLS_ASID( __HB_CLS_MTHNAME _CLASS_NAME_ <MethodName> )(), __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ctor.>, HB_OO_CLSTP_CTOR, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ) )
 
-#xcommand ACCESS <AccessName>[()] [ AS <type> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [_CLASS_DECLARATION_] => ;
+#xcommand ACCESS <AccessName> [ AS <type> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [_CLASS_DECLARATION_] => ;
    METHOD <AccessName> [ AS <type> ] <export> <protect> <hidde> <persistent> _CLASS_DECLARATION_
 
 #xcommand ASSIGN <AssignName> [ AS <type> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [_CLASS_DECLARATION_] => ;
@@ -385,7 +385,7 @@ DECLARE HBClass ;
    MESSAGE <MessageName> [ AS <type> ] TO <oObject> <export> <protect> <hidde> <persistent>
 
 #xcommand ACCESS <MessageName> [ AS <type> ] [LOCAL <Locals,...>] INLINE <Code,...> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] => ;
-   MESSAGE __HB_CLS_ASID(<MessageName>) [ AS <type> ] [LOCAL <Locals>] INLINE <Code> <export> <protect> <hidde> <persistent>
+   MESSAGE <MessageName> [ AS <type> ] [LOCAL <Locals>] INLINE <Code> <export> <protect> <hidde> <persistent>
 
 #xcommand ASSIGN <MessageName> [ AS <type> ] [LOCAL <Locals,...>] INLINE <Code,...> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] => ;
    MESSAGE _<MessageName> [ AS <type> ] [LOCAL <Locals>] INLINE <Code> <export> <protect> <hidde> <persistent>
@@ -437,11 +437,11 @@ DECLARE HBClass ;
 
    /* The #xtranslate is wrongly used instead of #xcommand as
       workaround for some preprocessor problems */
-   #xtranslate    EXPORTED:   =>    nScope := HB_OO_CLSTP_EXPORTED
-   #xtranslate    EXPORT:     =>    nScope := HB_OO_CLSTP_EXPORTED
-   #xtranslate    VISIBLE:    =>    nScope := HB_OO_CLSTP_EXPORTED
-   #xtranslate    HIDDEN:     =>    nScope := HB_OO_CLSTP_HIDDEN
-   #xtranslate    PROTECTED:  =>    nScope := HB_OO_CLSTP_PROTECTED
+   #xcommand EXPORTED:   =>    nScope := HB_OO_CLSTP_EXPORTED
+   #xcommand EXPORT:     =>    nScope := HB_OO_CLSTP_EXPORTED
+   #xcommand VISIBLE:    =>    nScope := HB_OO_CLSTP_EXPORTED
+   #xcommand HIDDEN:     =>    nScope := HB_OO_CLSTP_HIDDEN
+   #xcommand PROTECTED:  =>    nScope := HB_OO_CLSTP_PROTECTED
 
 
    // Classy compatibility... Added By JF Lefebvre (mafact) 2006/11/07
@@ -456,30 +456,30 @@ DECLARE HBClass ;
 
    #xcommand VAR <DataNames,...> [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] => ;
       __HB_CLS_CHECKVAR(<DataNames>);;
-      _HB_MEMBER {[AS <type>] <DataNames>} ;;
+      _HB_MEMBER {[ AS <type>] <DataNames> } ;;
       s_oClass:AddMultiData( <(type)>, <uValue>, __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataNames)>}, __HB_CLS_NOINI )
 
    #xcommand VAR <DataName> [ AS <type> ] IN <SuperClass> => ;
       __HB_CLS_CHECKVAR(<DataName>);;
-      _HB_MEMBER {[AS <type>] <DataName>} ;;
+      _HB_MEMBER {[ AS <type>] <DataName> } ;;
       s_oClass:AddInline( <(DataName)>, {|Self| Self:<SuperClass>:<DataName> }, HB_OO_CLSTP_EXPORTED + HB_OO_CLSTP_READONLY ) ;;
       s_oClass:AddInline( "_" + <(DataName)>, {|Self, param| Self:<SuperClass>:<DataName> := param }, HB_OO_CLSTP_EXPORTED )
 
    #xcommand VAR <DataName> [ AS <type> ] IS <SprDataName> IN <SuperClass> => ;
       __HB_CLS_CHECKVAR(<DataName>);;
-      _HB_MEMBER {[AS <type>] <DataName>} ;;
+      _HB_MEMBER {[ AS <type>] <DataName> } ;;
       s_oClass:AddInline( <(DataName)>, {|Self| Self:<SuperClass>:<SprDataName> }, HB_OO_CLSTP_EXPORTED + HB_OO_CLSTP_READONLY ) ;;
       s_oClass:AddInline( "_" + <(DataName)>, {|Self, param| Self:<SuperClass>:<SprDataName> := param }, HB_OO_CLSTP_EXPORTED )
 
    #xcommand VAR <DataName1> [ AS <type> ] IS <DataName2> => ;
       __HB_CLS_CHECKVAR(<DataName1>);;
-      _HB_MEMBER {[AS <type>] <DataName1>} ;;
+      _HB_MEMBER {[ AS <type>] <DataName1> } ;;
       s_oClass:AddInline( <(DataName1)>, {|Self| Self:<DataName2> }, HB_OO_CLSTP_EXPORTED + HB_OO_CLSTP_READONLY ) ;;
       s_oClass:AddInline( "_" + <(DataName1)>, {|Self, param| Self:<DataName2> := param }, HB_OO_CLSTP_EXPORTED )
 
    #xcommand VAR <DataName1> [ AS <type> ] IS <DataName2> TO <oObject> => ;
       __HB_CLS_CHECKVAR(<DataName1>);;
-      _HB_MEMBER {[AS <type>] <DataName1>} ;;
+      _HB_MEMBER {[ AS <type>] <DataName1> } ;;
       s_oClass:AddInline( <(DataName1)>, {|Self| Self:<oObject>:<DataName2> }, HB_OO_CLSTP_EXPORTED + HB_OO_CLSTP_READONLY ) ;;
       s_oClass:AddInline( "_" + <(DataName1)>, {|Self, param| Self:<oObject>:<DataName2> := param }, HB_OO_CLSTP_EXPORTED )
 
@@ -490,13 +490,13 @@ DECLARE HBClass ;
 
    #xcommand DATA <DataNames,...> [ AS <type> ] [ INIT <uValue> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] => ;
       __HB_CLS_CHECKVAR(<DataNames>);;
-      _HB_MEMBER {[AS <type>] <DataNames>} ;;
+      _HB_MEMBER {[ AS <type>] <DataNames> } ;;
       s_oClass:AddMultiData( <(type)>, <uValue>, __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataNames)>}, __HB_CLS_NOINI )
 
    /* Warning! For backward compatibility this CLASSDATA ignores the
       SHARED clause and always create shared class variables */
    #xcommand CLASSDATA <DataNames,...> [ AS <type> ] [ INIT <uValue> ] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] [<share: SHARED>] [<persistent: PERSISTENT, PROPERTY>] => ;
-      _HB_MEMBER {[AS <type>] <DataNames>} ;;
+      _HB_MEMBER {[ AS <type>] <DataNames> } ;;
    s_oClass:AddMultiClsData( <(type)>, <uValue>, __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( /* <.share.> */ .T., HB_OO_CLSTP_SHARED, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataNames)>}, __HB_CLS_NOINI )
 
 #endif /* HB_CLS_FWO */
@@ -508,20 +508,17 @@ DECLARE HBClass ;
 #xtranslate  = <!name!>{ [<p,...>] }        =>  = <name>():New( <p> )
 #xtranslate  , <!name!>{ [<p,...>] }        =>  , <name>():New( <p> )
 
-#xcommand EXPORT <DataNames,...> [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] => ;
-   __HB_CLS_CHECKVAR(<DataNames>);;
-   _HB_MEMBER {[AS <type>] <DataNames>} ;;
-   s_oClass:AddMultiData( <(type)>, <uValue>, HB_OO_CLSTP_EXPORTED + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataNames)>}, __HB_CLS_NOINI )
+#xcommand EXPORT <!DataName1!> [, <!DataNameN!>] [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] => ;
+   _HB_MEMBER {[ AS <type>] <DataName1> [, <DataNameN>] } ;;
+   s_oClass:AddMultiData( <(type)>, <uValue>, HB_OO_CLSTP_EXPORTED + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataName1)> [, <(DataNameN)>]}, __HB_CLS_NOINI )
 
-#xcommand PROTECT <DataNames,...> [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] => ;
-   __HB_CLS_CHECKVAR(<DataNames>);;
-   _HB_MEMBER {[AS <type>] <DataNames>} ;;
-   s_oClass:AddMultiData( <(type)>, <uValue>, HB_OO_CLSTP_PROTECTED + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataNames)>}, __HB_CLS_NOINI )
+#xcommand PROTECT <!DataName1!> [, <!DataNameN!>] [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] => ;
+   _HB_MEMBER {[ AS <type>] <DataName1> [, <DataNameN>] } ;;
+   s_oClass:AddMultiData( <(type)>, <uValue>, HB_OO_CLSTP_PROTECTED + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataName1)> [, <(DataNameN)>]}, __HB_CLS_NOINI )
 
-#xcommand HIDDE <DataNames,...> [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] => ;
-   __HB_CLS_CHECKVAR(<DataNames>);;
-   _HB_MEMBER {[AS <type>] <DataNames>} ;;
-   s_oClass:AddMultiData( <(type)>, <uValue>, HB_OO_CLSTP_HIDDEN + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataNames)>}, __HB_CLS_NOINI )
+#xcommand HIDDE <!DataName1!> [, <!DataNameN!>] [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] => ;
+   _HB_MEMBER {[ AS <type>] <DataName1> [, <DataNameN>] } ;;
+   s_oClass:AddMultiData( <(type)>, <uValue>, HB_OO_CLSTP_HIDDEN + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataName1)> [, <(DataNameN)>]}, __HB_CLS_NOINI )
 
 #endif /* HB_CLS_VO */
 
@@ -533,9 +530,8 @@ DECLARE HBClass ;
    __HB_CLS_DECLARE_METHOD __HB_CLS_PARAMS(<MethodName>) _CLASS_NAME_ ;;
    s_oClass:AddClsMthds( __HB_CLS_ASSTRING(<MethodName>), @__HB_CLS_ASID( __HB_CLS_MTHNAME _CLASS_NAME_ <MethodName> )(), __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.share.>, HB_OO_CLSTP_SHARED, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ) )
 
-#xcommand CLASSVAR <DataNames,...> [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] [<share: SHARED>] [<persistent: PERSISTENT, PROPERTY>] => ;
-   __HB_CLS_CHECKVAR(<DataNames>);;
-   _HB_MEMBER {[AS <type>] <DataNames>} ;;
-   s_oClass:AddMultiClsData( <(type)>, <uValue>, __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.share.>, HB_OO_CLSTP_SHARED, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataNames)>}, __HB_CLS_NOINI )
+#xcommand CLASSVAR <!DataName1!> [, <!DataNameN!>] [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] [<share: SHARED>] [<persistent: PERSISTENT, PROPERTY>] => ;
+   _HB_MEMBER {[ AS <type>] <DataName1> [, <DataNameN>] } ;;
+   s_oClass:AddMultiClsData( <(type)>, <uValue>, __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.share.>, HB_OO_CLSTP_SHARED, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataName1)> [, <(DataNameN)>]}, __HB_CLS_NOINI )
 
 #endif /* HB_CLASS_CH_ */
diff --git a/harbour/include/hbcomp.h b/harbour/include/hbcomp.h
index b07fd1e8cd..7d35caeca2 100644
--- a/harbour/include/hbcomp.h
+++ b/harbour/include/hbcomp.h
@@ -470,8 +470,6 @@ extern void hb_compFileInfo( void );
 extern void hb_compPrintLogo( void );
 extern void hb_compPrintModes( void );
 
-extern int hb_compCompile( char * szPrg, int argc, char * argv[], BOOL bSingleFile );
-
 #endif    /* HB_MACRO_SUPPORT */
 
 /* Misc functions defined in harbour.c */
@@ -597,6 +595,25 @@ extern const BYTE     hb_comp_pcode_len[];
 /* error messages output */
 extern FILE           *hb_comp_errFile;
 
+/* Hide Strings */
+extern int            hb_comp_iHidden;
+
+/* compiler PP functions and variables */
+#define HB_PP_STR_SIZE  12288
+#define HB_PP_BUFF_SIZE 4096
+extern void hb_pp_SetRules( BOOL hb_comp_bQuiet, int argc, char * argv[] );
+extern void hb_pp_Init( void );
+extern void hb_pp_Free( void );
+extern void hb_pp_AddDefine( char *defname, char *value );
+extern void hb_pp_ParseDirective( char * );
+extern int  hb_pp_Internal( FILE *, char * );
+
+extern BOOL hb_pp_LiteralEscSeq;
+extern BOOL hb_pp_NestedLiteralString;
+extern int hb_pp_StreamBlock;
+extern unsigned int hb_pp_MaxTranslateCycles;
+
+
 /* /GC command line setting types */
 #define HB_COMPGENC_COMPACT     0
 #define HB_COMPGENC_NORMAL      1
diff --git a/harbour/include/hbdefs.h b/harbour/include/hbdefs.h
index d1e8b875a1..3a6725c8e8 100644
--- a/harbour/include/hbdefs.h
+++ b/harbour/include/hbdefs.h
@@ -165,6 +165,12 @@
    #undef UINT                            /* varies with platform */
    typedef unsigned int UINT;
 
+   #undef SCHAR                           /* 1 byte signed */
+   typedef signed char SCHAR;
+
+   #undef UCHAR                           /* 1 byte unsigned */
+   typedef unsigned char UCHAR;
+
    #undef BYTE                            /* 1 byte unsigned */
    typedef unsigned char BYTE;
 
diff --git a/harbour/include/hberrors.h b/harbour/include/hberrors.h
index 23ac50cd18..bc2db21c7e 100644
--- a/harbour/include/hberrors.h
+++ b/harbour/include/hberrors.h
@@ -120,6 +120,7 @@ HB_EXTERN_BEGIN
 #define HB_COMP_ERR_MEMOVERFLOW                 58
 #define HB_COMP_ERR_MEMCORRUPT                  59
 #define HB_COMP_ERR_WITHOBJECT                  60
+#define HB_COMP_ERR_BUFFER_OVERFLOW             61
 
 #define HB_COMP_WARN_AMBIGUOUS_VAR              1
 #define HB_COMP_WARN_MEMVAR_ASSUMED             2
@@ -153,34 +154,6 @@ HB_EXTERN_BEGIN
 #define HB_COMP_WARN_FORVAR_DUPL                30
 #define HB_COMP_WARN_ENUM_INVALID               31
 
-/*
- * Errors generated by Harbour preprocessor
- */
-#define HB_PP_ERR_CANNOT_OPEN                   1
-#define HB_PP_ERR_DIRECTIVE_ELSE                2
-#define HB_PP_ERR_DIRECTIVE_ENDIF               3
-#define HB_PP_ERR_WRONG_NAME                    4
-#define HB_PP_ERR_DEFINE_ABSENT                 5
-#define HB_PP_ERR_COMMAND_DEFINITION            6
-#define HB_PP_ERR_PATTERN_DEFINITION            7
-#define HB_PP_ERR_RECURSE                       8
-#define HB_PP_ERR_WRONG_DIRECTIVE               9
-#define HB_PP_ERR_EXPLICIT                      10
-#define HB_PP_ERR_MEMALLOC                      11
-#define HB_PP_ERR_MEMREALLOC                    12
-#define HB_PP_ERR_MEMFREE                       13
-#define HB_PP_ERR_PRAGMA_BAD_VALUE              14
-#define HB_PP_ERR_CANNOT_OPEN_RULES             15
-#define HB_PP_ERR_BAD_RULES_FILE_NAME           16
-#define HB_PP_ERR_TOO_MANY_INCLUDES             17
-#define HB_PP_ERR_BUFFER_OVERFLOW               18
-#define HB_PP_ERR_LABEL_MISSING_IN_DEFINE       19
-#define HB_PP_ERR_PARE_MISSING_IN_DEFINE        20
-#define HB_PP_ERR_LABEL_DUPL_IN_DEFINE          21
-
-#define HB_PP_WARN_DEFINE_REDEF                 1
-#define HB_PP_WARN_NO_DIRECTIVES                2
-
 extern void hb_compGenError( char * szErrors[], char cPrefix, int iError, const char * szError1, const char * szError2 ); /* generic parsing error management function */
 extern void hb_compGenWarning( char * szWarnings[], char cPrefix, int iWarning, const char * szWarning1, const char * szWarning2); /* generic parsing warning management function */
 
diff --git a/harbour/include/hbpp.h b/harbour/include/hbpp.h
index f915dd87d2..5118656a79 100644
--- a/harbour/include/hbpp.h
+++ b/harbour/include/hbpp.h
@@ -4,9 +4,9 @@
 
 /*
  * Harbour Project source code:
- * Header file for the Preprocesor
+ * 
  *
- * Copyright 1999 Alexander S.Kresin <alex@belacy.belgorod.su>
+ * Copyright 2006 Przemyslaw Czerpak <druzus / at / priv.onet.pl>
  * www - http://www.harbour-project.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -55,95 +55,553 @@
 
 #include "hbapi.h"
 #include "hbapifs.h"
-#include "hberrors.h"
 #include "hbver.h"
 
 HB_EXTERN_BEGIN
 
-struct _DEFINES;
-typedef struct _DEFINES
-{
-   char * name;
-   int namelen;
-   char * pars;
-   int    npars;
-   char * value;
-   struct _DEFINES * last;
-} DEFINES;
-
-struct _COMMANDS;
-typedef struct _COMMANDS
-{
-   int com_or_xcom;
-   char * name;
-   int namelen;
-   char * mpatt;
-   char * value;
-   struct _COMMANDS * last;
-} COMMANDS;
-
-#define HB_PP_STR_SIZE  12288
-#define HB_PP_BUFF_SIZE 4096
-
-#define HB_SKIPTABSPACES( sptr ) while( *( sptr ) == ' ' || *( sptr ) == '\t' ) ( sptr )++
-
-/* PPCORE.C exported functions and variables */
-
-#define HB_INCLUDE_FUNC_( hbFunc ) BOOL hbFunc( char *, HB_PATHNAMES * )
-typedef HB_INCLUDE_FUNC_( HB_INCLUDE_FUNC );
-typedef HB_INCLUDE_FUNC * HB_INCLUDE_FUNC_PTR;
-
-extern void   hb_pp_SetRules( HB_INCLUDE_FUNC_PTR hb_compInclude, BOOL hb_comp_bQuiet );
-extern int    hb_pp_ReadRules( void );
-extern void   hb_pp_Init( void );
-extern void   hb_pp_Free( void );
-extern void   hb_pp_CloseInclude( void );
-extern int    hb_pp_ParseDirective( char * ); /* Parsing preprocessor directives ( #... ) */
-extern int    hb_pp_ParseExpression( char *, char *, BOOL ); /* Parsing a line ( without preprocessor directive ) */
-extern int    hb_pp_WrStr( FILE *, char * );
-extern int    hb_pp_RdStr( FILE *, char *, int, BOOL, char *, int *, int * );
-extern void   hb_pp_Stuff( char *, char *, int, int, int );
-extern int    hb_pp_strocpy( char *, char * );
-extern DEFINES * hb_pp_AddDefine( char *, char * );         /* Add new #define to a linked list */
-
-extern int    hb_pp_lInclude;
-extern int *  hb_pp_aCondCompile;
-extern int    hb_pp_nCondCompile;
-extern char * hb_pp_szErrors[];
-extern char * hb_pp_szWarnings[];
-extern int    hb_pp_nEmptyStrings;
-extern int    hb_pp_LastOutLine;
-extern int    hb_pp_StreamBlock;
-extern BOOL   hb_pp_NestedLiteralString;
-extern BOOL   hb_pp_LiteralEscSeq;
-extern unsigned int  hb_pp_MaxTranslateCycles;
-
-/* PPCOMP.C exported functions */
-
-extern int    hb_pp_Internal( FILE *, char * );
-extern void   hb_pp_InternalFree( void );
-
-#define HB_PP_STREAM_DUMP_C   1 /* pragma BEGINDUMP */
-#define HB_PP_STREAM_CLIPPER  2 /* clipper compatible TEXT/ENDTEXT */
+/* #pragma {__text,__stream,__cstream}|functionOut|functionEnd|functionStart */
+#define HB_PP_STREAM_OFF      0 /* standard preprocessing */
+#define HB_PP_STREAM_COMMENT  1 /* multiline comment */
+#define HB_PP_STREAM_DUMP_C   2 /* pragma BEGINDUMP */
+#define HB_PP_STREAM_CLIPPER  3 /* clipper compatible TEXT/ENDTEXT */
 #define HB_PP_STREAM_PRG      4 /* TEXT/ENDTEXT lines joined with LF */
-#define HB_PP_STREAM_C        8 /* TEXT/ENDTEXT lines joined and ESC seq processed */
+#define HB_PP_STREAM_C        5 /* TEXT/ENDTEXT lines joined and ESC seq processed */
 
-extern BOOL   hb_pp_StreamBlockBegin( char *, int );
-extern void   hb_pp_BlockEnd( void );
 
-/* PPTABLE.C exported functions and variables */
+/* function to open included files */
+#define HB_PP_OPEN_FUNC_( func ) FILE * func( char *, BOOL, char * )
+typedef HB_PP_OPEN_FUNC_( HB_PP_OPEN_FUNC );
+typedef HB_PP_OPEN_FUNC * PHB_PP_OPEN_FUNC;
 
-extern void   hb_pp_Table( void );
+/* function to close included files */
+#define HB_PP_CLOSE_FUNC_( func ) void func( FILE * )
+typedef HB_PP_CLOSE_FUNC_( HB_PP_CLOSE_FUNC );
+typedef HB_PP_CLOSE_FUNC * PHB_PP_CLOSE_FUNC;
 
-extern DEFINES *  hb_pp_topDefine;
-extern COMMANDS * hb_pp_topCommand;
-extern COMMANDS * hb_pp_topTranslate;
+/* function to generate errors */
+#define HB_PP_ERROR_FUNC_( func ) void func( char **, char, int, const char *, const char * )
+typedef HB_PP_ERROR_FUNC_( HB_PP_ERROR_FUNC );
+typedef HB_PP_ERROR_FUNC * PHB_PP_ERROR_FUNC;
 
-/* PRAGMA.C exported functions */
+/* function to redirect stdout messages */
+#define HB_PP_DISP_FUNC_( func ) void func( const char * )
+typedef HB_PP_DISP_FUNC_( HB_PP_DISP_FUNC );
+typedef HB_PP_DISP_FUNC * PHB_PP_DISP_FUNC;
 
-extern BOOL hb_pp_ParsePragma( char * szline );
+/* function for catching #pragma dump data */
+#define HB_PP_DUMP_FUNC_( func ) void func( char *, ULONG, int )
+typedef HB_PP_DUMP_FUNC_( HB_PP_DUMP_FUNC );
+typedef HB_PP_DUMP_FUNC * PHB_PP_DUMP_FUNC;
+
+/* function for catching #pragma dump data */
+#define HB_PP_SWITCH_FUNC_( func ) BOOL func( const char *, int )
+typedef HB_PP_SWITCH_FUNC_( HB_PP_SWITCH_FUNC );
+typedef HB_PP_SWITCH_FUNC * PHB_PP_SWITCH_FUNC;
+
+
+#ifdef _HB_PP_INTERNAL
+
+/* default maximum number of translations */
+#define HB_PP_MAX_CYCLES      4096
+/* maximum number of single token translations, in Clipper it's 18 + number
+   of used rules, we will use also constant but increased by total number
+   of rules of given type: define, [x]translate, [x]command */
+#define HB_PP_MAX_REPATS      128
+
+/* Clipper allows only 16 nested includes */
+#define HB_PP_MAX_INCLUDED_FILES    64
+
+
+/* comparision modes */
+#define HB_PP_CMP_ADDR        0 /* compare token addresses */
+#define HB_PP_CMP_STD         1 /* standard comparison, ignore the case of the characters */
+#define HB_PP_CMP_DBASE       2 /* dbase keyword comparison (accepts at least four character shortcuts) ignore the case of the characters */
+#define HB_PP_CMP_CASE        3 /* case sensitive comparison */
+
+#define HB_PP_CMP_MODE(t)     ( (t) & 0xff )
+#define HB_PP_STD_RULE        0x8000
+
+
+/* conditional compilation */
+#define HB_PP_COND_ELSE       1     /* preprocessing and output stopped until corresponding #else */
+#define HB_PP_COND_DISABLE    2     /* preprocessing and output stopped until corresponding #endif(s) */
+
+/* operation precedence for #if calculation */
+#define HB_PP_PREC_NUL  0
+#define HB_PP_PREC_NOT  1
+#define HB_PP_PREC_LOG  2
+#define HB_PP_PREC_REL  3
+#define HB_PP_PREC_BIT  4
+#define HB_PP_PREC_PLUS 5
+#define HB_PP_PREC_MULT 6
+#define HB_PP_PREC_NEG  7
+
+
+/* preprocessor tokens */
+#define HB_PP_TOKEN_NUL          0
+
+#define HB_PP_MMARKER_REGULAR    1
+#define HB_PP_MMARKER_LIST       2
+#define HB_PP_MMARKER_RESTRICT   3
+#define HB_PP_MMARKER_WILD       4
+#define HB_PP_MMARKER_EXTEXP     5
+#define HB_PP_MMARKER_NAME       6
+#define HB_PP_MMARKER_OPTIONAL   7
+
+#define HB_PP_RMARKER_REGULAR    11
+#define HB_PP_RMARKER_STRDUMP    12
+#define HB_PP_RMARKER_STRSTD     13
+#define HB_PP_RMARKER_STRSMART   14
+#define HB_PP_RMARKER_BLOCK      15
+#define HB_PP_RMARKER_LOGICAL    16
+#define HB_PP_RMARKER_NUL        17
+#define HB_PP_RMARKER_OPTIONAL   18
+
+/* keywords, pseudo keywords and PP only tokens */
+#define HB_PP_TOKEN_KEYWORD      21
+#define HB_PP_TOKEN_MACRO        22
+#define HB_PP_TOKEN_TEXT         23
+#define HB_PP_TOKEN_OTHER        24   /* non keyword, text, or operator character */
+#define HB_PP_TOKEN_BACKSLASH    25   /* "\\" */
+#define HB_PP_TOKEN_PIPE         26   /* "|" */
+#define HB_PP_TOKEN_DOT          27   /* "." */
+#define HB_PP_TOKEN_COMMA        28   /* "," */
+#define HB_PP_TOKEN_EOC          29   /* ";" */
+#define HB_PP_TOKEN_EOL          30   /* "\n" */
+#define HB_PP_TOKEN_HASH         31   /* "\n" */
+#define HB_PP_TOKEN_DIRECTIVE    32   /* direct # directive first token */
+
+/* constant values */
+#define HB_PP_TOKEN_STRING       41
+#define HB_PP_TOKEN_NUMBER       42
+#define HB_PP_TOKEN_DATE         43
+#define HB_PP_TOKEN_LOGICAL      44
+
+/* operators */
+#define HB_PP_TOKEN_LEFT_PB      50
+#define HB_PP_TOKEN_RIGHT_PB     51
+#define HB_PP_TOKEN_LEFT_SB      52
+#define HB_PP_TOKEN_RIGHT_SB     53
+#define HB_PP_TOKEN_LEFT_CB      54
+#define HB_PP_TOKEN_RIGHT_CB     55
+#define HB_PP_TOKEN_REFERENCE    56
+#define HB_PP_TOKEN_AMPERSAND    57
+#define HB_PP_TOKEN_SEND         58
+#define HB_PP_TOKEN_ALIAS        59
+
+#define HB_PP_TOKEN_ASSIGN       60
+#define HB_PP_TOKEN_PLUSEQ       61
+#define HB_PP_TOKEN_MINUSEQ      62
+#define HB_PP_TOKEN_MULTEQ       63
+#define HB_PP_TOKEN_DIVEQ        64
+#define HB_PP_TOKEN_MODEQ        65
+#define HB_PP_TOKEN_EXPEQ        66
+
+#define HB_PP_TOKEN_INC          67
+#define HB_PP_TOKEN_DEC          68
+#define HB_PP_TOKEN_NOT          69
+#define HB_PP_TOKEN_OR           70
+#define HB_PP_TOKEN_AND          71
+#define HB_PP_TOKEN_EQUAL        72
+#define HB_PP_TOKEN_EQ           73
+#define HB_PP_TOKEN_LT           74
+#define HB_PP_TOKEN_GT           75
+#define HB_PP_TOKEN_LE           76
+#define HB_PP_TOKEN_GE           77
+#define HB_PP_TOKEN_NE           78
+#define HB_PP_TOKEN_IN           79
+#define HB_PP_TOKEN_PLUS         80
+#define HB_PP_TOKEN_MINUS        81
+#define HB_PP_TOKEN_MULT         82
+#define HB_PP_TOKEN_DIV          83
+#define HB_PP_TOKEN_MOD          84
+#define HB_PP_TOKEN_POWER        85
+
+
+/* bitfields */
+//#define HB_PP_TOKEN_UNARY        0x0100
+//#define HB_PP_TOKEN_BINARY       0x0200
+//#define HB_PP_TOKEN_JOINABLE     0x0400
+#define HB_PP_TOKEN_MATCHMARKER  0x2000
+#define HB_PP_TOKEN_STATIC       0x4000
+#define HB_PP_TOKEN_PREDEFINED   0x8000
+
+#define HB_PP_TOKEN_SETTYPE(t,n) do{ (t)->type = ( (t)->type & 0xff00 ) | (n); } while(0)
+
+#define HB_PP_TOKEN_TYPE(t)      ( (t) & 0xff )
+#define HB_PP_TOKEN_ALLOC(t)     ( ( (t) & HB_PP_TOKEN_STATIC ) == 0 )
+#define HB_PP_TOKEN_ISPREDEF(t)  ( ( (t)->type & HB_PP_TOKEN_PREDEFINED ) != 0 )
+
+/* These macros are very important for the PP behavior. They define what
+   and how will be translated. Their default definitions are not strictly
+   Clipper compatible to allow programmer using indirect # directive
+         EOL - end of line    => '\n' or NULL
+         EOC - end of command => EOL or ';'
+         EOS - end of subst   => EOL or ';' + '#'
+         EOP - end of pattern => EOL for direct and EOC for indirect
+ */
+
+/* End Of Line */
+#define HB_PP_TOKEN_ISEOL(t)     ( (t) == NULL || \
+                                   HB_PP_TOKEN_TYPE((t)->type) == HB_PP_TOKEN_EOL )
+/* End Of Command */
+#define HB_PP_TOKEN_ISEOC(t)     ( HB_PP_TOKEN_ISEOL(t) || \
+                                   HB_PP_TOKEN_TYPE((t)->type) == HB_PP_TOKEN_EOC )
+
+#ifdef HB_C52_STRICT
+#  define HB_PP_TOKEN_ISEOS(t)   HB_PP_TOKEN_ISEOL(t)
+#  define HB_PP_TOKEN_ISEOP(t,l) HB_PP_TOKEN_ISEOL(t)
+#else
+/* End Of Subst - define how mant tokens in line should be translated,
+                  Clipper translate whole line */
+#  define HB_PP_TOKEN_ISEOS(t)   ( HB_PP_TOKEN_ISEOL(t) || \
+                                   ( HB_PP_TOKEN_TYPE((t)->type) == HB_PP_TOKEN_EOC && \
+                                     (t)->pNext && \
+                                     ( HB_PP_TOKEN_TYPE((t)->pNext->type) == HB_PP_TOKEN_HASH || \
+                                       HB_PP_TOKEN_TYPE((t)->pNext->type) == HB_PP_TOKEN_DIRECTIVE ) ) )
+/* End Of Pattern - the second paramter define if it's direct or indirect
+                    pattern */
+#  define HB_PP_TOKEN_ISEOP(t,l) ( (l) ? HB_PP_TOKEN_ISEOL(t) : HB_PP_TOKEN_ISEOC(t) )
+#endif
+
+#define HB_PP_TOKEN_ISDIRECTIVE(t)  ( HB_PP_TOKEN_TYPE((t)->type) == HB_PP_TOKEN_DIRECTIVE || \
+                                      HB_PP_TOKEN_TYPE((t)->type) == HB_PP_TOKEN_HASH )
+
+#define HB_PP_TOKEN_CANJOIN(t)   ( ! HB_PP_TOKEN_CLOSE_BR(t) && \
+                                   HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_KEYWORD && \
+                                   HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_MACRO && \
+                                   HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_TEXT && \
+                                   HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_STRING && \
+                                   HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_NUMBER && \
+                                   HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_DATE && \
+                                   HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_LOGICAL )
+
+#define HB_PP_TOKEN_OPEN_BR(t)   ( HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_LEFT_PB || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_LEFT_SB || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_LEFT_CB )
+
+#define HB_PP_TOKEN_CLOSE_BR(t)  ( HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_RIGHT_PB || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_RIGHT_SB || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_RIGHT_CB )
+
+#define HB_PP_TOKEN_NEEDLEFT(t)  ( HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_ASSIGN || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_PLUSEQ || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_MINUSEQ || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_MULTEQ || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_DIVEQ || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_MODEQ || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_EXPEQ || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_EQUAL || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_EQ || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_LEFT_SB )
+
+/* I do not want to replicate exactly Clipper PP behavior and check if
+   expression is valid.
+   it's wrong and causes that potentially valid expressions are not
+   properly parsed, f.e:
+      ? 1 + + 2
+   does not work when
+      qout( 1 + + 2 )
+   perfectly does.
+   It this difference will be reason of some problems then please inform me
+   with a code example so I'll be able if it should be implemented or not.
+   Now I simply disabled HB_PP_TOKEN_NEEDRIGHT() macro.
+ */
+#ifndef HB_C52_STRICT
+#define HB_PP_TOKEN_NEEDRIGHT(t) ( FALSE )
+#else
+#define HB_PP_TOKEN_NEEDRIGHT(t) ( HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_PLUS || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_MINUS || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_MULT || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_DIV || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_MOD || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_POWER )
+#endif
+
+#ifdef HB_C52_STRICT
+#  define HB_PP_TOKEN_ISUNARY(t) ( HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_MINUS || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_DEC || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_INC || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_AMPERSAND )
+#else
+#  define HB_PP_TOKEN_ISUNARY(t) ( HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_MINUS || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_DEC || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_INC || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_AMPERSAND || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_PLUS || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_NOT || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_REFERENCE )
+#endif
+
+#define HB_PP_TOKEN_ISMATCH(t)   ( (t) && ( (t)->type & HB_PP_TOKEN_MATCHMARKER ) != 0 )
+
+#if 0
+#define HB_PP_TOKEN_ISRESULT(t)  ( HB_PP_TOKEN_TYPE(t) == HB_PP_RMARKER_REGULAR || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_RMARKER_STRDUMP || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_RMARKER_STRSTD || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_RMARKER_STRSMART || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_RMARKER_BLOCK || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_RMARKER_LOGICAL || \
+                                   HB_PP_TOKEN_TYPE(t) == HB_PP_RMARKER_NUL )
+#endif
+
+#define HB_PP_TOKEN_ISEXPVAL(t)     ( HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_KEYWORD || \
+                                      HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_MACRO || \
+                                      HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_STRING || \
+                                      HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_NUMBER || \
+                                      HB_PP_TOKEN_TYPE(t) == HB_PP_TOKEN_DATE )
+#define HB_PP_TOKEN_ISEXPTOKEN(t)   ( HB_PP_TOKEN_ISEXPVAL( (t)->type ) || \
+                                      ( (t)->pNext && HB_PP_TOKEN_ISUNARY( (t)->type ) && \
+                                        HB_PP_TOKEN_ISEXPVAL( (t)->pNext->type ) ) )
+
+#ifdef HB_C52_STRICT
+/* Clipper supports quoting by [] for 1-st token in the line so we 
+   are checking for HB_PP_TOKEN_NUL in this macro */
+#define HB_PP_TOKEN_CANQUOTE(t)     ( HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_NUL && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_KEYWORD && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_MACRO && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_RIGHT_PB && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_RIGHT_SB && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_RIGHT_CB )
+#else
+/* Disable string quoting by [] for next token if current one is
+   constant value - it's not Clipper compatible but we need it for
+   accessing string characters by array index operator or introduce
+   similar extensions in the future */
+#define HB_PP_TOKEN_CANQUOTE(t)     ( HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_NUL && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_KEYWORD && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_MACRO && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_RIGHT_PB && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_RIGHT_SB && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_RIGHT_CB && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_STRING && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_NUMBER && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_DATE && \
+                                      HB_PP_TOKEN_TYPE(t) != HB_PP_TOKEN_LOGICAL )
+#endif
+/* For platforms which does not use ASCII based character tables this macros
+   have to be changed to use valid C functions, f.e.:
+      isalpha(), isdigit(), ... */
+#ifdef HB_C52_STRICT
+#  define HB_PP_ISILLEGAL(c)     ( (c) < 32 || (c) >= 126 )
+#else
+#  define HB_PP_ISILLEGAL(c)     ( (c) < 32 || (c) == 127 )
+#endif
+#define HB_PP_ISTEXTCHAR(c)      ( (unsigned char) (c) >= 128 )
+#define HB_PP_ISBLANK(c)         ( (c) == ' ' || (c) == '\t' )
+#define HB_PP_ISDIGIT(c)         ( (c) >= '0' && (c) <= '9' )
+#define HB_PP_ISHEX(c)           ( HB_PP_ISDIGIT(c) || \
+                                   ( (c) >= 'A' && (c) <= 'F' ) || \
+                                   ( (c) >= 'a' && (c) <= 'f' ) )
+#define HB_PP_ISTRUE(c)          ( (c) == 'T' || (c) == 't' || \
+                                   (c) == 'Y' || (c) == 'y' )
+#define HB_PP_ISFALSE(c)         ( (c) == 'F' || (c) == 'f' || \
+                                   (c) == 'N' || (c) == 'n' )
+#define HB_PP_ISFIRSTIDCHAR(c)   ( ( (c) >= 'A' && (c) <= 'Z' ) || \
+                                   ( (c) >= 'a' && (c) <= 'z' ) || (c) == '_' )
+#define HB_PP_ISNEXTIDCHAR(c)    ( HB_PP_ISFIRSTIDCHAR(c) || HB_PP_ISDIGIT(c) )
+
+typedef struct _HB_PP_TOKEN
+{
+   struct _HB_PP_TOKEN * pNext;     /* next token pointer */
+   struct _HB_PP_TOKEN * pMTokens;  /* restrict or optional marker token(s) */
+
+   char * value;                    /* token value */
+   USHORT len;                      /* token value length */
+   USHORT spaces;                   /* leading spaces for stringify */
+   USHORT type;                     /* token type, see HB_PP_TOKEN_* */
+   USHORT index;                    /* index to match marker or 0 */
+}
+HB_PP_TOKEN, * PHB_PP_TOKEN;
+
+typedef struct _HB_PP_RESULT
+{
+   struct _HB_PP_RESULT * pNext;
+   PHB_PP_TOKEN   pFirstToken;
+   PHB_PP_TOKEN   pNextExpr;
+}
+HB_PP_RESULT, * PHB_PP_RESULT;
+
+typedef struct _HB_PP_MARKERPTR
+{
+   struct _HB_PP_MARKERPTR * pNext;
+   PHB_PP_TOKEN   pToken;
+   PHB_PP_TOKEN   pMTokens;
+   USHORT         type;
+}
+HB_PP_MARKERPTR, * PHB_PP_MARKERPTR;
+
+typedef struct _HB_PP_MARKERLST
+{
+   struct _HB_PP_MARKERLST * pNext;
+   PHB_PP_MARKERPTR  pMatchMarkers;
+   USHORT            canrepeat;
+   USHORT            index;
+}
+HB_PP_MARKERLST, * PHB_PP_MARKERLST;
+
+typedef struct
+{
+   USHORT   canrepeat;
+   /* filled when pattern matches for substitution, cleared after */
+   USHORT   matches;
+   PHB_PP_RESULT  pResult;
+}
+HB_PP_MARKER, * PHB_PP_MARKER;
+
+typedef struct _HB_PP_RULE
+{
+   struct _HB_PP_RULE * pPrev;      /* previous rule */
+   PHB_PP_TOKEN   pMatch;           /* match patern or NULL */
+   PHB_PP_TOKEN   pResult;          /* result patern or NULL */
+   USHORT         mode;             /* comparison mode HB_PP_CMP_* */
+   USHORT         markers;          /* number of markers in marker table */
+   /* filled when pattern matches for substitution, cleared after */
+   PHB_PP_MARKER  pMarkers;         /* marker table */
+   PHB_PP_TOKEN   pNextExpr;        /* next expression after match pattern */
+}
+HB_PP_RULE, * PHB_PP_RULE;
+
+typedef struct _HB_PP_DEFRULE
+{
+   PHB_PP_TOKEN   pMatch;
+   PHB_PP_TOKEN   pResult;
+   USHORT         mode;
+   USHORT         markers;
+   ULONG          repeatbits;
+}
+HB_PP_DEFRULE, * PHB_PP_DEFRULE;
+
+typedef struct
+{
+   char *   name;       /* input name */
+   ULONG    len;        /* input name length */
+   char *   value;      /* output name */
+   USHORT   type;       /* HB_PP_TOKEN_* */
+}
+HB_PP_OPERATOR, * PHB_PP_OPERATOR;
+
+typedef struct
+{
+   char *   pBufPtr;
+   ULONG    ulLen;
+   ULONG    ulAllocated;
+}
+HB_MEM_BUFFER, * PHB_MEM_BUFFER;
+
+typedef struct _HB_PP_FILE
+{
+   char *   szFileName;          /* input file name */
+   FILE *   file_in;             /* input file handle */
+   PHB_PP_TOKEN pTokenList;      /* current line decoded to tokens */
+   int      iCurrentLine;        /* current line in file */
+   int      iLastLine;           /* last non empty generated line */
+   int      iLastDisp;           /* last shown line number */
+   int      iTokens;             /* number of decoded tokens */
+   BOOL     fGenLineInfo;        /* #line information should be generated */
+   BOOL     fEof;                /* the end of file reached */
+
+   char *   pLineBuf;            /* buffer for parsing external lines */
+   ULONG    ulLineBufLen;        /* size of external line buffer */
+
+   struct _HB_PP_FILE * pPrev;   /* previous file, the one which included this file */
+}
+HB_PP_FILE, * PHB_PP_FILE;
+
+typedef struct
+{
+   /* common for all included files */
+   PHB_PP_OPERATOR pOperators;   /* user defined operators */
+   PHB_PP_RULE    pDefinitions;  /* #define table */
+   PHB_PP_RULE    pTranslations; /* #[x]translate table */
+   PHB_PP_RULE    pCommands;     /* #[x]command table */
+   int            iOperators;    /* number of user defined operators */
+   int            iDefinitions;  /* number of rules in pDefinitions */
+   int            iTranslations; /* number of rules in pTranslations */
+   int            iCommands;     /* number of rules in pCommands */
+
+   PHB_PP_TOKEN   pTokenOut;     /* preprocessed tokens */
+   PHB_PP_TOKEN * pNextTokenPtr; /* pointer to the last NULL pointer in token list */
+
+   PHB_MEM_BUFFER pDumpBuffer;   /* buffer for dump output */
+   PHB_MEM_BUFFER pOutputBuffer; /* buffer for preprocessed line */
+
+   int      iCycle;              /* translation counter */
+   int      iMaxCycles;          /* maximum number of translations */
+   int      iHideStrings;        /* hidden string mode */
+   BOOL     fTracePragmas;       /* display information about set pragmas */
+   BOOL     fWritePreprocesed;   /* write preprocessed data to file (.ppo) */
+
+   HB_PATHNAMES * pIncludePath;  /* search path(s) for included files */
+
+   char *   szOutFileName;       /* output file name */
+   FILE *   file_out;            /* output file handle */
+
+   BOOL     fError;              /* error during preprocessing */
+   BOOL     fQuiet;              /* do not show standard information */
+   int      iCondCompile;        /* current conditional compilation flag, when not 0 disable preprocessing and output */
+   int      iCondCount;          /* number of nested #if[n]def directive */
+   int      iCondStackSize;      /* size of conditional compilation stack */
+   int *    pCondStack;          /* conditional compilation stack */
+   FILE *   file_in;             /* file handle */
+
+   /* used to divide line per tokens and tokens manipulations */
+   PHB_MEM_BUFFER pBuffer;       /* buffer for input and output line */
+   int      iSpaces;             /* leading spaces for next token */
+   int      iSpacesNL;           /* leading spaces ';' token (fCanNextLine) if it will not be line concatenator */
+   int      iLastType;           /* last token type */
+   BOOL     fCanNextLine;        /* ';' token found and we do not know yet if it's command separator or line concatenator */
+   BOOL     fDirective;          /* # directives is parsed */
+   BOOL     fNewStatement;       /* set to TRUE at line begining or after each ';' token */
+   PHB_PP_TOKEN   pFuncOut;      /* function used for each line in HB_PP_STREAM_* dumping */
+   PHB_PP_TOKEN   pFuncEnd;      /* end function for HB_PP_STREAM_* dumping */
+   PHB_MEM_BUFFER pStreamBuffer; /* buffer for stream output */
+   int      iStreamDump;         /* stream output, see HB_PP_STREAM_* */
+   int      iDumpLine;           /* line where current dump output begins */
+
+   PHB_PP_FILE pFile;            /* currently preprocessed file structure */
+   int      iFiles;              /* number of open files */
+
+   PHB_PP_OPEN_FUNC  pOpenFunc;  /* function to open files */
+   PHB_PP_CLOSE_FUNC pCloseFunc; /* function to close files */
+   PHB_PP_ERROR_FUNC pErrorFunc; /* function to generate errors */
+   PHB_PP_DISP_FUNC  pDispFunc;  /* function to redirect stdout messages */
+   PHB_PP_DUMP_FUNC  pDumpFunc;  /* function for catching #pragma dump data */
+   PHB_PP_SWITCH_FUNC pSwitchFunc; /* function to compiler switches with #pragma ... */
+}
+HB_PP_STATE, * PHB_PP_STATE;
+
+extern void hb_pp_initRules( PHB_PP_RULE * pRulesPtr, int * piRules,
+                             const HB_PP_DEFRULE pDefRules[], int iDefRules );
+
+extern void hb_pp_initStaticRules( PHB_PP_STATE pState );
+
+#else
+
+typedef void * PHB_PP_STATE;
+
+#endif /* _HB_PP_INTERNAL */
+
+/* public functions */
+extern PHB_PP_STATE hb_pp_new( void );
+extern void   hb_pp_init( PHB_PP_STATE pState, char * szFileName, BOOL fQuiet,
+                          PHB_PP_OPEN_FUNC  pOpenFunc,  PHB_PP_CLOSE_FUNC pCloseFunc,
+                          PHB_PP_ERROR_FUNC pErrorFunc, PHB_PP_DISP_FUNC  pDispFunc,
+                          PHB_PP_DUMP_FUNC  pDumpFunc,  PHB_PP_SWITCH_FUNC pSwitchFunc );
+extern void   hb_pp_free( PHB_PP_STATE pState );
+extern void   hb_pp_reset( PHB_PP_STATE pState );
+extern void   hb_pp_setStdBase( PHB_PP_STATE pState );
+extern void   hb_pp_addSearchPath( PHB_PP_STATE pState, const char * szPath, BOOL fReplace );
+extern void   hb_pp_inFile( PHB_PP_STATE pState, char * szFileName, FILE * file_in );
+extern void   hb_pp_outFile( PHB_PP_STATE pState, char * szOutFileName, FILE * file_out );
+extern char * hb_pp_fileName( PHB_PP_STATE pState );
+extern int    hb_pp_line( PHB_PP_STATE pState );
+extern char * hb_pp_outFileName( PHB_PP_STATE pState );
+extern char * hb_pp_nextLine( PHB_PP_STATE pState, ULONG * pulLen );
+extern char * hb_pp_parseLine( PHB_PP_STATE pState, char * pLine, ULONG * pulLen );
+extern void   hb_pp_addDefine( PHB_PP_STATE pState, char * szDefName, char * szDefValue );
+extern void   hb_pp_delDefine( PHB_PP_STATE pState, char * szDefName );
 
 HB_EXTERN_END
 
 #endif /* HB_PP_H_ */
-
diff --git a/harbour/include/hbrddcdx.h b/harbour/include/hbrddcdx.h
index ade3020ba5..879d18c990 100644
--- a/harbour/include/hbrddcdx.h
+++ b/harbour/include/hbrddcdx.h
@@ -328,7 +328,7 @@ typedef struct _CDXTAG
 
    BOOL     UsrAscend;        /* user settable ascending/descending order flag */
    BOOL     UsrUnique;        /* user settable unique order flag */
-   
+
    BOOL     TagChanged;
    BOOL     TagBOF;
    BOOL     TagEOF;
diff --git a/harbour/include/hbsetup.ch b/harbour/include/hbsetup.ch
index 552f108174..432fb6e9fc 100644
--- a/harbour/include/hbsetup.ch
+++ b/harbour/include/hbsetup.ch
@@ -82,7 +82,4 @@
 
 /* #define HB_FILE_VER_STATIC */  /* Enable inclusion of file version strings */
 
-/*#define HB_CLS_ENFORCERO */     /* Activate the RO checking on OO DATA    */
-                                  /* when not called from a constructor     */
-
 #endif /* HB_SETUP_CH_ */
diff --git a/harbour/include/hbstdgen.ch b/harbour/include/hbstdgen.ch
new file mode 100644
index 0000000000..cdc8586c06
--- /dev/null
+++ b/harbour/include/hbstdgen.ch
@@ -0,0 +1,86 @@
+/*
+ * $Id$
+ */
+
+/*
+ * Harbour Project source code:
+ * 
+ *
+ * Copyright 2006 Przemyslaw Czerpak <druzus / at / priv.onet.pl>
+ * www - http://www.harbour-project.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this software; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
+ *
+ * As a special exception, the Harbour Project gives permission for
+ * additional uses of the text contained in its release of Harbour.
+ *
+ * The exception is that, if you link the Harbour libraries with other
+ * files to produce an executable, this does not by itself cause the
+ * resulting executable to be covered by the GNU General Public License.
+ * Your use of that executable is in no way restricted on account of
+ * linking the Harbour library code into it.
+ *
+ * This exception does not however invalidate any other reasons why
+ * the executable file might be covered by the GNU General Public License.
+ *
+ * This exception applies only to the code released by the Harbour
+ * Project under the name Harbour.  If you copy code from other
+ * Harbour Project or Free Software Foundation releases into a copy of
+ * Harbour, as the General Public License permits, the exception does
+ * not apply to the code that you add in this way.  To avoid misleading
+ * anyone as to the status of such modified files, you must delete
+ * this exception notice from them.
+ *
+ * If you write modifications of your own for Harbour, it is your choice
+ * whether to permit this exception to apply to your modifications.
+ * If you do not wish that, delete this exception notice.
+ *
+ */
+
+/* include hbsetup.ch to set default build settings */
+#include "hbsetup.ch"
+/* include std.ch to set default rules */
+#include "std.ch"
+
+/* undefine all rules which are not necessary in default PP tables */
+#undef HB_SETUP_CH_
+
+#undef HB_EXTENSION
+
+#undef HB_C52_UNDOC
+#undef HB_C52_STRICT
+
+#undef HB_COMPAT_C53
+#undef HB_COMPAT_XPP
+#undef HB_COMPAT_VO
+#undef HB_COMPAT_FLAGSHIP
+#undef HB_COMPAT_FOXPRO
+#undef HB_COMPAT_DBASE
+#undef HB_COMPAT_CLIP
+
+#undef HB_SHORTNAMES
+#undef HB_FILE_VER_STATIC
+
+#undef __HARBOUR__
+#undef __DATE__
+#undef __TIME__
+#undef __HB_MAIN__
+#undef __ARCH16BIT__
+#undef __ARCH32BIT__
+#undef __ARCH64BIT__
+#undef __LITTLE_ENDIAN__
+#undef __BIG_ENDIAN__
+#undef __PDP_ENDIAN__
diff --git a/harbour/include/std.ch b/harbour/include/std.ch
index 85aca14c9e..ffa25334cc 100644
--- a/harbour/include/std.ch
+++ b/harbour/include/std.ch
@@ -4,9 +4,9 @@
 
 /*
  * Harbour Project source code:
- * Header file for the standard command definitions.
+ * 
  *
- * Copyright 1999 {list of individual authors and e-mail addresses}
+ * Copyright 2006 Przemyslaw Czerpak <druzus / at / priv.onet.pl>
  * www - http://www.harbour-project.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -55,6 +55,605 @@
 
 #include "set.ch"
 
-/* TODO: Fill this file. */
+#command DO WHILE <exp>    => while <exp>
+#command END <x>           => end
+#command END SEQUENCE      => end
+#command ENDSEQUENCE       => end
+#command ENDDO <*x*>       => enddo
+#command ENDIF <*x*>       => endif
+#command ENDCASE <*x*>     => endcase
+#command ENDFOR [<*x*>]    => next
+#command NEXT <v> [TO <x>] [STEP <s>]  => next
+#command DO <proc>.prg [WITH <p,...>]  => do <proc> [ WITH <p>]
+#command CALL <proc>() [WITH <p,...>]  => call <proc> [ WITH <p>]
+#command STORE <v> TO <v1> [,<vN>]     => <v1> := [ <vN> :=] <v>
+
+#command SET ECHO <*x*>       =>
+#command SET HEADING <*x*>    =>
+#command SET MENU <*x*>       =>
+#command SET STATUS <*x*>     =>
+#command SET STEP <*x*>       =>
+#command SET SAFETY <*x*>     =>
+#command SET TALK <*x*>       =>
+#command SET PROCEDURE TO     =>
+#command SET PROCEDURE TO <f> => _ProcReq_( <(f)> )
+#command SET FORMAT TO <id>            => ;
+         _ProcReq_( <(id)> + ".fmt" ) ; __SetFormat( {|| <id>()} )
+#command SET FORMAT TO <id>.<ext>      => ;
+         _ProcReq_( <(id)> + "." + <(ext)> ) ; __SetFormat( {|| <id>()} )
+#command SET FORMAT TO <id:&>          => ;
+         if ( Empty(<(id)>) ) ; SET FORMAT TO ; else ;;
+         __SetFormat( &("{||" + <(id)> + "()}") ) ; end
+#command SET FORMAT TO                 => __SetFormat()
+
+#define _DFSET(x, y) Set( _SET_DATEFORMAT, if(__SetCentury(), x, y) )
+#command SET DATE [TO] AMERICAN        => _DFSET( "mm/dd/yyyy", "mm/dd/yy" )
+#command SET DATE [TO] ANSI            => _DFSET( "yyyy.mm.dd", "yy.mm.dd" )
+#command SET DATE [TO] BRITISH         => _DFSET( "dd/mm/yyyy", "dd/mm/yy" )
+#command SET DATE [TO] FRENCH          => _DFSET( "dd/mm/yyyy", "dd/mm/yy" )
+#command SET DATE [TO] GERMAN          => _DFSET( "dd.mm.yyyy", "dd.mm.yy" )
+#command SET DATE [TO] ITALIAN         => _DFSET( "dd-mm-yyyy", "dd-mm-yy" )
+#command SET DATE [TO] JAPANESE        => _DFSET( "yyyy/mm/dd", "yy/mm/dd" )
+#command SET DATE [TO] USA             => _DFSET( "mm-dd-yyyy", "mm-dd-yy" )
+
+#command SET CENTURY <x:ON,OFF,&>      => __SetCentury( <(x)> )
+#command SET CENTURY (<x>)             => __SetCentury( <x> )
+#command SET DATE FORMAT [TO] <f>      => Set( _SET_DATEFORMAT, <f> )
+#command SET EPOCH TO <y>              => Set( _SET_EPOCH, <y> )
+
+#command SET DECIMALS TO <x>           => Set( _SET_DECIMALS, <x> )
+#command SET DECIMALS TO               => Set( _SET_DECIMALS, 0 )
+#command SET DEFAULT TO <(path)>       => Set( _SET_DEFAULT, <(path)> )
+#command SET DEFAULT TO                => Set( _SET_DEFAULT, "" )
+#command SET PATH TO <*pth*>           => Set( _SET_PATH, <(pth)> )
+#command SET PATH TO                   => Set( _SET_PATH, "" )
+
+#command SET EXACT <x:ON,OFF,&>        => Set( _SET_EXACT, <(x)> )
+#command SET EXACT (<x>)               => Set( _SET_EXACT, <x> )
+#command SET FIXED <x:ON,OFF,&>        => Set( _SET_FIXED, <(x)> )
+#command SET FIXED (<x>)               => Set( _SET_FIXED, <x> )
+#command SET EXCLUSIVE <x:ON,OFF,&>    => Set( _SET_EXCLUSIVE, <(x)> )
+#command SET EXCLUSIVE (<x>)           => Set( _SET_EXCLUSIVE, <x> )
+#command SET SOFTSEEK <x:ON,OFF,&>     => Set( _SET_SOFTSEEK, <(x)> )
+#command SET SOFTSEEK (<x>)            => Set( _SET_SOFTSEEK, <x> )
+#command SET UNIQUE <x:ON,OFF,&>       => Set( _SET_UNIQUE, <(x)> )
+#command SET UNIQUE (<x>)              => Set( _SET_UNIQUE, <x> )
+#command SET DELETED <x:ON,OFF,&>      => Set( _SET_DELETED, <(x)> )
+#command SET DELETED (<x>)             => Set( _SET_DELETED, <x> )
+#command SET CONSOLE <x:ON,OFF,&>      => Set( _SET_CONSOLE, <(x)> )
+#command SET CONSOLE (<x>)             => Set( _SET_CONSOLE, <x> )
+#command SET BELL <x:ON,OFF,&>         => Set( _SET_BELL, <(x)> )
+#command SET BELL (<x>)                => Set( _SET_BELL, <x> )
+#command SET CONFIRM <x:ON,OFF,&>      => Set( _SET_CONFIRM, <(x)> )
+#command SET CONFIRM (<x>)             => Set( _SET_CONFIRM, <x> )
+#command SET ESCAPE <x:ON,OFF,&>       => Set( _SET_ESCAPE, <(x)> )
+#command SET ESCAPE (<x>)              => Set( _SET_ESCAPE, <x> )
+#command SET INTENSITY <x:ON,OFF,&>    => Set( _SET_INTENSITY, <(x)> )
+#command SET INTENSITY (<x>)           => Set( _SET_INTENSITY, <x> )
+#command SET SCOREBOARD <x:ON,OFF,&>   => Set( _SET_SCOREBOARD, <(x)> )
+#command SET SCOREBOARD (<x>)          => Set( _SET_SCOREBOARD, <x> )
+#command SET WRAP <x:ON,OFF,&>         => Set( _SET_WRAP, <(x)> )
+#command SET WRAP (<x>)                => Set( _SET_WRAP, <x> )
+#command SET DELIMITERS <x:ON,OFF,&>   => Set( _SET_DELIMITERS, <(x)> )
+#command SET DELIMITERS (<x>)          => Set( _SET_DELIMITERS, <x> )
+#command SET DELIMITERS TO <c>         => Set( _SET_DELIMCHARS, <c> )
+#command SET DELIMITERS TO [DEFAULT]   => Set( _SET_DELIMCHARS, "::" )
+#command SET ALTERNATE <x:ON,OFF,&>    => Set( _SET_ALTERNATE, <(x)> )
+#command SET ALTERNATE (<x>)           => Set( _SET_ALTERNATE, <x> )
+#command SET ALTERNATE TO              => Set( _SET_ALTFILE, "" )
+#command SET ALTERNATE TO <(file)> [<add: ADDITIVE>] => ;
+               Set( _SET_ALTFILE, <(file)>, <.add.> )
+#command SET PRINTER <x:ON,OFF,&>      => Set( _SET_PRINTER, <(x)> )
+#command SET PRINTER (<x>)             => Set( _SET_PRINTER, <x> )
+#command SET PRINTER TO                => Set( _SET_PRINTFILE, "" )
+#command SET PRINTER TO <(file)> [<add: ADDITIVE>]    => ;
+               Set( _SET_PRINTFILE, <(file)>, <.add.> )
+#command SET CURSOR <x:ON,OFF,&>       => ;
+               SetCursor( if(Upper(<(x)>) == "ON", 1, 0) )
+#command SET CURSOR (<x>)              => SetCursor( if(<x>, 1, 0) )
+#command SET MARGIN TO <x>             => Set( _SET_MARGIN, <x> )
+#command SET MARGIN TO                 => Set( _SET_MARGIN, 0 )
+#command SET DEVICE TO SCREEN          => Set( _SET_DEVICE, "SCREEN" )
+#command SET DEVICE TO PRINTER         => Set( _SET_DEVICE, "PRINTER" )
+#command SET COLOR TO [<*c*>]          => SetColor( #<c> )
+#command SET COLOR TO ( <c> )          => SetColor( <c> )
+#command SET COLOUR TO [<*c*>]         => SET COLOR TO [<c>]
+#command SET ORDER TO <tg> [IN <(bg)>] => ordSetFocus( <tg> [, <(bg)>] )
+#command SET ORDER TO TAG <(tg)> [IN <(bg)>] => ordSetFocus( <(tg)> [, <(bg)>] )
+#command SET INDEX TO [<(i1)> [,<(iN)>]] [<add: ADDITIVE>] => ;
+         if !<.add.> ; ordListClear() ; end ;
+         [ ; ordListAdd( <(i1)> )] [ ; ordListAdd( <(iN)> )]
+#command SET MESSAGE TO <n> [<cent: CENTER, CENTRE>] => ;
+            Set( _SET_MESSAGE, <n> ) ; Set( _SET_MCENTER, <.cent.> )
+#command SET MESSAGE TO                => Set( _SET_MESSAGE, 0 ) ;;
+                                          Set( _SET_MCENTER, .f. )
+#command SET TYPEAHEAD TO <x>          => Set( _SET_TYPEAHEAD, <x> )
+#command SET KEY <n> TO <f>            => SetKey( <n>, {|p, l, v| <f>(p, l, v)} )
+#command SET KEY <n> TO <f>([<p,...>]) => SET KEY <n> TO <f>
+#command SET KEY <n> TO <f:&>          => ;
+         if ( Empty(<(f)>) ) ; SetKey( <n>, NIL ) ; else ;;
+            SetKey( <n>, {|p, l, v| <f>(p, l, v)} ) ; end
+#command SET KEY <n> [TO]              => SetKey( <n>, NIL )
+#command SET FUNCTION <n> [TO] [<f>]   => __SetFunction( <n>, <f> )
+
+#ifdef HB_COMPAT_C53
+   #command SET EVENTMASK TO <x>       => Set( _SET_EVENTMASK, <x> )
+   #command SET VIDEOMODE TO <x>       => Set( _SET_VIDEOMODE, <x> )
+   #command SET SCOPETOP TO            => ordScope( 0, nil )
+   #command SET SCOPETOP TO <x>        => ordScope( 0, <x> )
+   #command SET SCOPEBOTTOM TO         => ordScope( 1, nil )
+   #command SET SCOPEBOTTOM TO <x>     => ordScope( 1, <x> )
+   #command SET SCOPE TO               => ordScope( 0, nil ) ; ordScope( 1, nil )
+   #command SET SCOPE TO <x>, <y>      => ordScope( 0, <x> ) ; ordScope( 1, <y> )
+   #command SET SCOPE TO <x>           => ordScope( 0, <x> ) ; ordScope( 1, <x> )
+   #command SET SCOPE TO , <x>         => ordScope( 1, <x> )
+   #command SET ORDER TO               => ordSetFocus( 0 )
+   #command SET DESCENDING ON          => ordDescend( ,, .T. )
+   #command SET DESCENDING OFF         => ordDescend( ,, .F. )
+   #command SET AUTORDER TO            => Set( _SET_AUTORDER, 0 )
+   #command SET AUTORDER TO <x>        => Set( _SET_AUTORDER, <x> )
+   #command SET AUTOSHARE TO           => Set( _SET_AUTOSHARE, 0 )
+   #command SET AUTOSHARE TO <x>       => Set( _SET_AUTOSHARE, <x> )
+   #command SET MBLOCKSIZE TO <x>      => Set( _SET_MBLOCKSIZE, <x> )
+   #command SET MEMOBLOCK TO <x>       => Set( _SET_MBLOCKSIZE, <x> )
+   #command SET MFILEEXT TO <x>        => Set( _SET_MFILEEXT, <x> )
+   #command SET STRICTREAD<x:ON,OFF,&> => Set( _SET_STRICTREAD, <(x)> )
+   #command SET STRICTREAD (<x>)       => Set( _SET_STRICTREAD, <x> )
+   #command SET OPTIMIZE <x:ON,OFF,&>  => Set( _SET_OPTIMIZE, <(x)> )
+   #command SET OPTIMIZE (<x>)         => Set( _SET_OPTIMIZE, <x> )
+   #command SET AUTOPEN <x:ON,OFF,&>   => Set( _SET_AUTOPEN, <(x)> )
+   #command SET AUTOPEN (<x>)          => Set( _SET_AUTOPEN, <x> )
+#endif
+
+#command ?  [<explist,...>]         => QOut( <explist> )
+#command ?? [<explist,...>]         => QQOut( <explist> )
+#command EJECT                      => __Eject()
+#command TEXT                       => text QOut, QQOut
+#command TEXT TO FILE <(f)>         => __TextSave( <(f)> ) ;;
+                                       text QOut, __TextRestore
+#command TEXT TO PRINTER            => __TextSave( "PRINTER" ) ;;
+                                       text QOut, __TextRestore
+#ifdef HB_COMPAT_C53
+   #xcommand TEXTBLOCK <*cText*>    =>
+#endif
+
+#command CLS                        => Scroll() ; SetPos(0,0)
+#command CLEAR SCREEN               => CLS
+#command SAVE SCREEN                => __XSaveScreen()
+#command RESTORE SCREEN             => __XRestScreen()
+#command SAVE SCREEN TO <v>         => <v> := SaveScreen( 0, 0, Maxrow(), Maxcol() )
+#command RESTORE SCREEN FROM <v>    => RestScreen( 0, 0, Maxrow(), Maxcol(), <v> )
+
+#command @ <row>, <col>             => Scroll( <row>, <col>, <row> ) ;;
+                                       SetPos( <row>, <col> )
+#command @ <top>, <left> CLEAR      => Scroll( <top>, <left> ) ;;
+                                       SetPos( <top>, <left> )
+#command @ <top>, <left> CLEAR TO <bottom>, <right>   => ;
+         Scroll( <top>, <left>, <bottom>, <right> ) ; SetPos( <top>, <left> )
+#command @ <top>, <left>, <bottom>, <right> BOX <string> [COLOR <clr>] => ;
+         DispBox( <top>, <left>, <bottom>, <right>, <string> [, <clr>] )
+#command @ <top>, <left> TO <bottom>, <right> [DOUBLE] [COLOR <clr>] => ;
+         DispBox( <top>, <left>, <bottom>, <right>, 2 [, <clr>] )
+#command @ <top>, <left> TO <bottom>, <right> [COLOR <clr>] => ;
+         DispBox( <top>, <left>, <bottom>, <right>, 1 [, <clr>] )
+#command @ <row>, <col> SAY <exp> [PICTURE <pic>] [COLOR <clr>] => ;
+         DevPos( <row>, <col> ) ; DevOutPict( <exp>, <pic> [, <clr>] )
+#command @ <row>, <col> SAY <exp> [COLOR <clr>] => ;
+         DevPos( <row>, <col> ) ; DevOut( <exp> [, <clr>] )
+#command @ <row>, <col> PROMPT <prompt> [MESSAGE <msg>] => ;
+         __AtPrompt( <row>, <col>, <prompt> , <msg> )
+#command MENU TO <v> => ;
+         <v> := __MenuTo( {|_1| if(PCount() == 0, <v>, <v> := _1)}, #<v> )
+
+#command WAIT [<msg>]                  => __Wait( <msg> )
+#command WAIT [<msg>] TO <v>           => <v> := __Wait( <msg> )
+#command ACCEPT [<msg>] TO <v>         => <v> := __Accept( <msg> )
+#command INPUT [<msg>] TO <v>          => ;
+         if ( !Empty(__Accept(<msg>)) ) ; <v> := &( __AcceptStr() ) ; end
+#command KEYBOARD <x>                  => __Keyboard( <x> )
+#command CLEAR TYPEAHEAD               => __Keyboard()
+#command CLEAR MEMORY                  => __MVClear()
+#command RELEASE <v,...>               => __MVXRelease( <"v"> )
+#command RELEASE ALL                   => __MVRelease( "*", .t. )
+#command RELEASE ALL LIKE <p>          => __MVRelease( #<p>, .t. )
+#command RELEASE ALL EXCEPT <p>        => __MVRelease( #<p>, .f. )
+#command RESTORE [FROM <(f)>] [<a:ADDITIVE>] => __MVRestore( <(f)>, <.a.> )
+#command SAVE TO <(f)> ALL LIKE <p>    => __MVSave( <(f)>, <(p)>, .t. )
+#command SAVE ALL LIKE <p> TO <(f)>    => __MVSave( <(f)>, <(p)>, .t. )
+#command SAVE ALL EXCEPT <p> TO <(f)>  => __MVSave( <(f)>, <(p)>, .f. )
+#command SAVE TO <(f)> ALL EXCEPT <p>  => __MVSave( <(f)>, <(p)>, .f. )
+#command SAVE [TO <(f)>] [ALL]         => __MVSave( <(f)>, "*", .t. )
+
+#command ERASE <(f)>                   => FErase( <(f)> )
+#command DELETE FILE <(f)>             => FErase( <(f)> )
+#command RENAME <(old)> TO <(new)>     => FRename( <(old)>, <(new)> )
+#command COPY FILE <(src)> TO <(dst)>  => __CopyFile( <(src)>, <(dst)> )
+#command DIR [<(mask)>]                => __Dir( <(mask)> )
+#command TYPE <(f)> [<prn:TO PRINTER>] [TO FILE <(dst)>] => ;
+         __TypeFile( <(f)>, <.prn.> ) [ ; COPY FILE <(f)> TO <(dst)> ]
+#command TYPE <(f)> [<prn:TO PRINTER>] => __TypeFile( <(f)>, <.prn.> )
+
+#command REQUEST <func,...>      => EXTERNAL <func>
+#command CANCEL                  => __Quit()
+#command QUIT                    => __Quit()
+#command RUN <*cmd*>             => __Run( #<cmd> )
+#command RUN ( <cmd> )           => __Run( <cmd> )
+#command ! <*cmd*>               => RUN <cmd>
+#command RUN = <xpr>             => ( run := <xpr> )
+#command RUN := <xpr>            => ( run := <xpr> )
+
+#command CLOSE <a>               => <a>->( dbCloseArea() )
+#command CLOSE                   => dbCloseArea()
+#command CLOSE DATABASES         => dbCloseAll()
+#command CLOSE ALTERNATE         => Set(_SET_ALTFILE, "")
+#command CLOSE FORMAT            => __SetFormat(NIL)
+#command CLOSE INDEXES           => dbClearIndex()
+#command CLOSE PROCEDURE         =>
+#command CLOSE ALL               => CLOSE DATABASES ; SELECT 1 ; CLOSE FORMAT
+#command CLEAR                   => CLEAR SCREEN ; CLEAR GETS
+#command CLEAR ALL               => CLOSE DATABASES ; CLOSE FORMAT ;;
+                                    CLEAR MEMORY ; CLEAR GETS ;;
+                                    SET ALTERNATE OFF ; SET ALTERNATE TO
+
+#command SELECT <area>           => dbSelectArea( <(area)> )
+#command SELECT <f>([<p,...>])   => dbSelectArea( <f>(<p>) )
+#command USE                     => dbCloseArea()
+#command USE <(db)> [VIA <rdd>] [ALIAS <a>] [<nw: NEW>] ;
+            [<ex: EXCLUSIVE>] [<sh: SHARED>] [<ro: READONLY>] ;
+            [CODEPAGE <cp>] [INDEX <(index1)> [, <(indexN)>]] => ;
+         dbUseArea( <.nw.>, <rdd>, <(db)>, <(a)>, ;
+                    if(<.sh.> .or. <.ex.>, !<.ex.>, NIL), <.ro.> [, <cp>] ) ;
+         [; dbSetIndex( <(index1)> )] ;
+         [; dbSetIndex( <(indexN)> )]
+
+#command APPEND BLANK            => dbAppend()
+#command PACK                    => __dbPack()
+#command ZAP                     => __dbZap()
+#command UNLOCK                  => dbUnlock()
+#command UNLOCK ALL              => dbUnlockAll()
+#command COMMIT                  => dbCommitAll()
+#command GOTO <x>                => dbGoto(<x>)
+#command GO <x>                  => dbGoto(<x>)
+#command GOTO TOP                => dbGoTop()
+#command GO TOP                  => dbGoTop()
+#command GOTO BOTTOM             => dbGoBottom()
+#command GO BOTTOM               => dbGoBottom()
+#command SKIP                    => dbSkip(1)
+#command SKIP <x>                => dbSkip( <x> )
+#command SKIP ALIAS <a>          => <a>->( dbSkip(1) )
+#command SKIP <x> ALIAS <a>      => <a>->( dbSkip(<x>) )
+#command FIND <*text*>           => dbSeek( <(text)> )
+#command FIND := <xpr>           => ( find := <xpr> )
+#command FIND = <xpr>            => ( find := <xpr> )
+#command CONTINUE                => __dbContinue()
+#ifdef HB_COMPAT_C53
+   #command SEEK <exp> [<soft: SOFTSEEK>] [<last: LAST>] => ;
+            dbSeek( <exp>, if( <.soft.>, .T., NIL ), if( <.last.>, .T., NIL ) )
+#else
+   #command SEEK <exp> [<soft: SOFTSEEK>] => ;
+            dbSeek( <exp>, if( <.soft.>, .T., NIL ) )
+#endif
+#command LOCATE [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+                [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         __dbLocate( <{for}>, <{while}>, <next>, <rec>, <.rest.> )
+
+#command SET RELATION TO         => dbClearRelation()
+#command SET RELATION [<add:ADDITIVE>] ;
+               [TO  <exp1> INTO <(alias1)> [<scp1:SCOPED>];
+            [, [TO] <expN> INTO <(aliasN)> [<scpN:SCOPED>]]] => ;
+         if ( !<.add.> ) ; dbClearRelation() ; end ;
+           ; dbSetRelation( <(alias1)>, <{exp1}>, <"exp1">, <.scp1.> ) ;
+         [ ; dbSetRelation( <(aliasN)>, <{expN}>, <"expN">, <.scpN.> )]
+
+#command SET FILTER TO           => dbClearFilter(NIL)
+#command SET FILTER TO <exp>     => dbSetFilter( <{exp}>, <"exp"> )
+#command SET FILTER TO <x:&>     => if ( Empty(<(x)>) ) ; dbClearFilter() ;;
+                                    else ; dbSetFilter( <{x}>, <(x)> ) ; end
+#command REPLACE [ <f1> WITH <x1> [, <fN> WITH <xN>] ] ;
+                 [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+                 [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         DBEval( {|| _FIELD-><f1> := <x1> [, _FIELD-><fN> := <xN>]}, ;
+                 <{for}>, <{while}>, <next>, <rec>, <.rest.> )
+#command REPLACE <f1> WITH <v1> [, <fN> WITH <vN> ] => ;
+         _FIELD-><f1> := <v1> [; _FIELD-><fN> := <vN>]
+
+#command DELETE [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+                [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         DBEval( {|| dbDelete()}, <{for}>, <{while}>, <next>, <rec>, <.rest.> )
+#command DELETE                  =>  dbDelete()
+
+#command RECALL [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+                [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         DBEval( {|| dbRecall()}, <{for}>, <{while}>, <next>, <rec>, <.rest.> )
+#command RECALL                  =>  dbRecall()
+
+#command CREATE <(db)> [FROM <(src)>] [VIA <rdd>] [ALIAS <a>] ;
+                [<new: NEW>] [CODEPAGE <cp>] => ;
+         __dbCreate( <(db)>, <(src)>, <rdd>, <.new.>, <(a)> [, <cp>] )
+
+#command COPY [STRUCTURE] [EXTENDED] [TO <(f)>] => __dbCopyXStruct( <(f)> )
+#command COPY [STRUCTURE] [TO <(f)>] [FIELDS <fields,...>] => ;
+         __dbCopyStruct( <(f)>, { <(fields)> } )
+
+#command COPY [TO <(f)>] [FIELDS <fields,...>] ;
+              [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+              [RECORD <rec>] [<rest:REST>] [ALL] ;
+              [DELIMITED [WITH <*delim*>]] => ;
+         __dbDelim( .T., <(f)>, <(delim)>, { <(fields)> }, ;
+                    <{for}>, <{while}>, <next>, <rec>, <.rest.> )
+
+#command COPY [TO <(f)>] [SDF] [FIELDS <fields,...>] ;
+              [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+              [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         __dbSDF( .T., <(f)>, { <(fields)> }, ;
+                  <{for}>, <{while}>, <next>, <rec>, <.rest.> )
+
+#command COPY [TO <(f)>] [FIELDS <fields,...>] ;
+              [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+              [RECORD <rec>] [<rest:REST>] [ALL] [VIA <rdd>] => ;
+         __dbCopy( <(f)>, { <(fields)> }, ;
+                   <{for}>, <{while}>, <next>, <rec>, <.rest.>, <rdd> )
+
+#command APPEND [FROM <(f)>] [FIELDS <fields,...>] ;
+                [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+                [RECORD <rec>] [<rest:REST>] [ALL] ;
+                [DELIMITED [WITH <*delim*>]] => ;
+         __dbDelim( .F., <(f)>, <(delim)>, { <(fields)> }, ;
+                    <{for}>, <{while}>, <next>, <rec>, <.rest.> )
+
+#command APPEND [FROM <(f)>] [SDF] [FIELDS <fields,...>] ;
+                [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+                [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         __dbSDF( .F., <(f)>, { <(fields)> }, ;
+                  <{for}>, <{while}>, <next>, <rec>, <.rest.> )
+
+#command APPEND [FROM <(f)>] [FIELDS <fields,...>] ;
+                [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+                [RECORD <rec>] [<rest:REST>] [ALL] [VIA <rdd>] => ;
+         __dbApp( <(f)>, { <(fields)> }, ;
+                  <{for}>, <{while}>, <next>, <rec>, <.rest.>, <rdd> )
+
+#command SORT [TO <(f)>] [ON <fields,...>] ;
+              [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+              [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         __dbSort( <(f)>, { <(fields)> }, ;
+                   <{for}>, <{while}>, <next>, <rec>, <.rest.> )
+
+#command TOTAL [TO <(f)>] [ON <key>] [FIELDS <fields,...>] ;
+               [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+               [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         __dbTotal( <(f)>, <{key}>, { <(fields)> }, ;
+                    <{for}>, <{while}>, <next>, <rec>, <.rest.> )
+
+#command UPDATE [FROM <(alias)>] [ON <key>] [<rand:RANDOM>] ;
+                [REPLACE <f1> WITH <x1> [, <fN> WITH <xN>]] => ;
+         __dbUpdate( <(alias)>, <{key}>, <.rand.>, ;
+                     {|| _FIELD-><f1> := <x1> [, _FIELD-><fN> := <xN>]} )
+
+#command JOIN [WITH <(alias)>] [TO <f>] [FIELDS <fields,...>] [FOR <for>] => ;
+         __dbJoin( <(alias)>, <(f)>, { <(fields)> }, ;
+                   if(EMPTY(#<for>), { || .T. }, <{for}> ) )
+
+#command COUNT [TO <v>] ;
+               [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+               [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         <v> := 0 ; DBEval( {|| <v> := <v> + 1}, ;
+                            <{for}>, <{while}>, <next>, <rec>, <.rest.> )
+
+#command SUM [ <x1> [, <xN>]  TO  <v1> [, <vN>] ] ;
+             [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+             [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         <v1> := [ <vN> := ] 0 ;;
+         DBEval( {|| <v1> := <v1> + <x1> [, <vN> := <vN> + <xN> ]}, ;
+                 <{for}>, <{while}>, <next>, <rec>, <.rest.> )
+
+#command AVERAGE [ <x1> [, <xN>]  TO  <v1> [, <vN>] ] ;
+                 [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+                 [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         M->__Avg := <v1> := [ <vN> := ] 0 ;;
+         DBEval( {|| M->__Avg := M->__Avg + 1, ;
+                 <v1> := <v1> + <x1> [, <vN> := <vN> + <xN>] }, ;
+                 <{for}>, <{while}>, <next>, <rec>, <.rest.> ) ;;
+         <v1> := <v1> / M->__Avg [ ; <vN> := <vN> / M->__Avg ]
+
+#command LIST [<v,...>] [<off:OFF>] [<prn:TO PRINTER>] [TO FILE <(f)>] ;
+              [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+              [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         __dbList( <.off.>, { <{v}> }, .t., ;
+                   <{for}>, <{while}>, <next>, <rec>, <.rest.>, <.prn.>, <(f)> )
+
+#command DISPLAY [<v,...>] [<off:OFF>] [<prn:TO PRINTER>] [TO FILE <(f)>] ;
+                 [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+                 [RECORD <rec>] [<rest:REST>] [<all:ALL>] => ;
+         __dbList( <.off.>, { <{v}> }, <.all.>, ;
+                   <{for}>, <{while}>, <next>, <rec>, <.rest.>, <.prn.>, <(f)> )
+
+#command REPORT FORM <frm> [HEADING <head>] [<plain:PLAIN>] [<noej:NOEJECT>] ;
+                           [<sum:SUMMARY>] [<nocon:NOCONSOLE>] ;
+                           [<prn:TO PRINTER>] [TO FILE <(f)>] ;
+                           [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+                           [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         __ReportForm( <(frm)>, <.prn.>, <(f)>, <.nocon.>, ;
+                       <{for}>, <{while}>, <next>, <rec>, <.rest.>, ;
+                       <.plain.>, <head>, <.noej.>, <.sum.> )
+
+#command LABEL FORM <lbl> [<smp:SAMPLE>] [<nocon:NOCONSOLE>] ;
+                          [<prn:TO PRINTER>] [TO FILE <(f)>] ;
+                          [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+                          [RECORD <rec>] [<rest:REST>] [ALL] => ;
+         __LabelForm( <(lbl)>, <.prn.>, <(f)>, <.nocon.>, ;
+                      <{for}>, <{while}>, <next>, <rec>, <.rest.>, <.smp.> )
+
+#command DELETE TAG <(tag1)> [IN <(bag1)>] [, <(tagN)> [IN <(bagN)>]] => ;
+         ordDestroy( <(tag1)>, <(bag1)> )[ ; ordDestroy( <(tagN)>, <(bagN)> ) ]
+
+#command INDEX ON <key> [TAG <(tag)>] TO <(bag)> ;
+               [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+               [RECORD <rec>] [<rest:REST>] [<all:ALL>] ;
+               [EVAL <eval>] [EVERY <every>] [<unique: UNIQUE>] ;
+               [<ascend: ASCENDING>] [<descend: DESCENDING>] ;
+               [<add: ADDITIVE>] [<cur: USECURRENT>] [<cust: CUSTOM>] ;
+               [<noopt: NOOPTIMIZE>] [<mem: MEMORY, TEMPORARY>] ;
+               [<filter: USEFILTER>] [<ex: EXCLUSIVE>] => ;
+         ordCondSet( <"for">, <{for}>, [<.all.>], <{while}>, ;
+                     <{eval}>, <every>, RECNO(), <next>, <rec>, ;
+                     [<.rest.>], [<.descend.>],, ;
+                     [<.add.>], [<.cur.>], [<.cust.>], [<.noopt.>], ;
+                     <"while">, [<.mem.>], [<.filter.>], [<.ex.>] ) ;;
+         ordCreate( <(bag)>, <(tag)>, <"key">, <{key}>, [<.unique.>] )
+
+#command INDEX ON <key> TAG <(tag)> [TO <(bag)>] ;
+               [FOR <for>] [WHILE <while>] [NEXT <next>] ;
+               [RECORD <rec>] [<rest:REST>] [<all:ALL>] ;
+               [EVAL <eval>] [EVERY <every>] [<unique: UNIQUE>] ;
+               [<ascend: ASCENDING>] [<descend: DESCENDING>] ;
+               [<add: ADDITIVE>] [<cur: USECURRENT>] [<cust: CUSTOM>] ;
+               [<noopt: NOOPTIMIZE>] [<mem: MEMORY, TEMPORARY>] ;
+               [<filter: USEFILTER>] [<ex: EXCLUSIVE>] => ;
+         ordCondSet( <"for">, <{for}>, [<.all.>], <{while}>, ;
+                     <{eval}>, <every>, RECNO(), <next>, <rec>, ;
+                     [<.rest.>], [<.descend.>],, ;
+                     [<.add.>], [<.cur.>], [<.cust.>], [<.noopt.>], ;
+                     <"while">, [<.mem.>], [<.filter.>], [<.ex.>] ) ;;
+         ordCreate( <(bag)>, <(tag)>, <"key">, <{key}>, [<.unique.>] )
+
+#command INDEX ON <key> TO <(file)> [<u: UNIQUE>] => ;
+            dbCreateIndex( <(file)>, <"key">, <{key}>, if( <.u.>, .t., NIL ) )
+
+#command REINDEX [EVAL <eval>] [EVERY <every>] [<lNoOpt: NOOPTIMIZE>] => ;
+            ordCondSet(,,,, <{eval}>, <every>,,,,,,,,,, <.lNoOpt.>) ;;
+            ordListRebuild()
+#command REINDEX        => ordListRebuild()
+
+
+#command READ           => ReadModal(GetList) ; GetList := {}
+#command READ SAVE      => ReadModal(GetList)
+#command CLEAR GETS     => ReadKill(.T.) ; GetList := {}
+
+#xcommand @ [<exp,...>] COLOUR [<nextexp,...>] => @ [ <exp>] COLOR [ <nextexp>]
+
+#command @ <row>, <col> SAY <say> [<sayexp,...>] GET <get> [<getexp,...>] => ;
+         @ <row>, <col> SAY <say> [ <sayexp>] ;;
+         @ Row(), Col() + 1 GET <get> [ <getexp>]
+
+#command @ <row>, <col> GET <v> [<exp,...>] RANGE <l>, <h> [<nextexp,...>] => ;
+         @ <row>, <col> GET <v> [ <exp>] ;
+                        VALID { |_1| RangeCheck( _1, , <l>, <h> ) } [ <nextexp>]
+
+#command @ <row>, <col> GET <v> [<exp,...>] COLOR <clr> [<nextexp,...>] => ;
+         @ <row>, <col> GET <v> [ <exp>] SEND colorDisp(<clr>) [ <nextexp>]
+
+#ifdef HB_COMPAT_C53
+
+   #command READ [MENU <oMenu>] ;
+                 [MSG AT <row>, <left>, <right> [MSG COLOR <color>]] => ;
+         ReadModal( GetList, NIL, <oMenu>, <row>, <left>, <right>, <color> ) ;;
+         GetList := {}
+
+   #command READ SAVE [MENU <oMenu>] ;
+                      [MSG AT <row>, <left>, <right> [MSG COLOR <color>]] => ;
+         ReadModal( GetList, NIL, <oMenu>, <row>, <left>, <right>, <color> )
+
+   #command @ <row>, <col> GET <v> [PICTURE <pic>] ;
+                           [VALID <valid>] [WHEN <when>] [SEND <snd>] ;
+                           [CAPTION <cap>] [MESSAGE <msg>] => ;
+         SetPos( <row>, <col> ) ;;
+         AAdd( GetList, _GET_( <v>, <"v">, <pic>, <{valid}>, <{when}> ) ) ;;
+       [ ATail(GetList):Caption := <cap> ;;
+         ATail(GetList):CapRow := ATail(Getlist):row ;;
+         ATail(GetList):CapCol := ATail(Getlist):col - __CapLength(<cap>) - 1 ;] ;
+       [ ATail(GetList):message := <msg> ;] [ ATail(GetList):<snd> ;] ;
+         ATail(GetList):Display()
+
+   #command @ <row>, <col> GET <v> CHECKBOX [VALID <valid>] [WHEN <when>] ;
+                           [CAPTION <cap>] [MESSAGE <msg>] [COLOR <clr>] ;
+                           [FOCUS <fb>] [STATE <sb>] [STYLE <stl>] ;
+                           [SEND <snd>] [GUISEND <gsnd>] [BITMAPS <bmaps>] => ;
+         SetPos( <row>, <col> ) ;;
+         AAdd( GetList, _GET_( <v>, <(v)>, NIL, <{valid}>, <{when}> ) ) ;;
+         ATail(GetList):Control := _CheckBox_( <v>, <cap>, ;
+                     <msg>, <clr>, <{fb}>, <{sb}>, <stl>, <bmaps> ) ;;
+         ATail(GetList):reader := { | a, b, c, d | GuiReader( a, b, c, d ) } ;;
+       [ ATail(GetList):<snd> ;] [ ATail(GetList):Control:<gsnd> ;] ;
+         ATail(GetList):Control:Display()
+
+   #command @ <top>, <left>, <bottom>, <right> GET <v> LISTBOX <items> ;
+                  [VALID <valid>] [WHEN <when>] ;
+                  [CAPTION <cap>] [MESSAGE <msg>] [COLOR <clr>] ;
+                  [FOCUS <fb>] [STATE <sb>] [<dd:DROPDOWN>] [<sbar:SCROLLBAR>] ;
+                  [SEND <snd>] [GUISEND <gsnd>] [BITMAP <bmap>] => ;
+         SetPos( <top>, <left> ) ;;
+         AAdd( GetList, _GET_( <v>, <(v)>, NIL, <{valid}>, <{when}> ) ) ;;
+         ATail(GetList):Control := _ListBox_( ATail(Getlist):row, ;
+               ATail(Getlist):col, <bottom>, <right>, <v>, <items>, <cap>, ;
+               <msg>, <clr>, <{fb}>, <{sb}>, <.dd.>, <.sbar.>, <bmap> ) ;;
+         ATail(GetList):reader := { | a, b, c, d | GuiReader( a, b, c, d ) } ;;
+       [ ATail(GetList):<snd> ;] [ ATail(GetList):Control:<gsnd> ;] ;
+         ATail(GetList):Control:Display()
+
+   #command @ <row>, <col> GET <v> PUSHBUTTON ;
+                  [VALID <valid>] [WHEN <when>] ;
+                  [CAPTION <cap>] [MESSAGE <msg>] [COLOR <clr>] ;
+                  [FOCUS <fb>] [STATE <sb>] [STYLE <stl>] ;
+                  [SEND <snd>] [GUISEND <gsnd>] [BITMAP <bmap>] ;
+                  [SIZE X <sX> Y <sY>] [CAPOFF X <cX> Y <cY> ] ;
+                  [BMPOFF X <bX> Y <bY>] => ;
+         SetPos( <row>, <col> ) ;;
+         AAdd( GetList, _GET_( <v>, <(v)>, NIL, <{valid}>, <{when}> ) ) ;;
+         ATail(GetList):Control := _PushButt_( <cap>, <msg>, <clr>, <{fb}>,;
+               <{sb}>, <stl>, <sX>, <sY>, <cX>, <cY>, <bmap>, <bX>, <bY> ) ;;
+         ATail(GetList):reader := { | a, b, c, d | GuiReader( a, b, c, d ) } ;;
+       [ ATail(GetList):<snd> ;] [ ATail(GetList):Control:<gsnd> ;] ;
+         ATail(GetList):Control:Display()
+
+   #command @ <top>, <left>, <bottom>, <right> GET <v> RADIOGROUP <buttons> ;
+                  [VALID <valid>] [WHEN <when>] ;
+                  [CAPTION <cap>] [MESSAGE <msg>] [COLOR <clr>] ;
+                  [FOCUS <fb>] [STYLE <stl>] ;
+                  [SEND <snd>] [GUISEND <gsnd>] => ;
+         SetPos( <top>, <left> ) ;;
+         AAdd( GetList, _GET_( <v>, <(v)>, NIL, <{valid}>, <{when}> ) ) ;;
+         ATail(GetList):Control := _RadioGrp_( ATail(Getlist):row, ;
+               ATail(Getlist):col, <bottom>, <right>, <v>, <buttons>, <cap>,;
+               <msg>, <clr>, <{fb}>, <stl> ) ;;
+         ATail(GetList):reader := { | a, b, c, d | GuiReader( a, b, c, d ) } ;;
+       [ ATail(GetList):<snd> ;] [ ATail(GetList):Control:<gsnd> ;] ;
+         ATail(GetList):Control:Display()
+
+   #command @ <top>, <left>, <bottom>, <right> GET <v> TBROWSE <oBrowse> ;
+                  [VALID <valid>] [WHEN <when>] ;
+                  [MESSAGE <msg>] [SEND <snd>] [GUISEND <gsnd>] => ;
+         SetPos( <top>, <left> ) ;;
+         AAdd( GetList, _GET_( <v>, <(v)>, NIL, <{valid}>, <{when}> ) ) ;;
+         <oBrowse>:ntop := ATail(Getlist):row ;;
+         <oBrowse>:nleft := ATail(Getlist):col ;;
+         <oBrowse>:nbottom := <bottom> ; <oBrowse>:nright := <right> ;;
+         <oBrowse>:Configure() ; ATail(GetList):Control := <oBrowse> ;;
+         ATail(GetList):reader := { | a, b, c, d | TBReader( a, b, c, d ) } ;
+     [ ; ATail(GetList):Control:Message := <msg>] ;
+     [ ; ATail(GetList):<snd>] [ ; ATail(GetList):Control:<gsnd>]
+
+   #command @ <top>, <left>, <bottom>, <right> GET <v> TBROWSE <oBrowse> ;
+                  ALIAS <a> [VALID <valid>] [WHEN <when>] ;
+                  [MESSAGE <msg>] [SEND <snd>] [GUISEND <gsnd>] => ;
+         SetPos( <top>, <left> ) ;;
+         AAdd( GetList, _GET_( <v>, <(v)>, NIL, <{valid}>, <{when}> ) ) ;;
+         <oBrowse>:ntop := ATail(Getlist):row ;;
+         <oBrowse>:nleft := ATail(Getlist):col ;;
+         <oBrowse>:nbottom := <bottom> ; <oBrowse>:nright := <right> ;;
+         <oBrowse>:Configure() ; ATail(GetList):Control := <oBrowse> ;;
+         ATail(GetList):reader := { | a, b, c, d | <a>->( TBReader( a, b, c, d ) ) } ;
+     [ ; ATail(GetList):Control:Message := <msg>] ;
+     [ ; ATail(GetList):<snd>] [ ; ATail(GetList):Control:<gsnd>]
+
+#else
+
+   #command @ <row>, <col> GET <v> [PICTURE <pic>] ;
+                           [VALID <valid>] [WHEN <when>] [SEND <snd>] => ;
+         SetPos( <row>, <col> ) ; AAdd( GetList, ;
+            _GET_( <v>, <"v">, <pic>, <{valid}>, <{when}> ):Display() ) ;
+      [; ATail(GetList):<snd>]
+
+#endif /* HB_COMPAT_C53 */
 
 #endif /* HB_STD_CH_ */
diff --git a/harbour/source/common/hbdate.c b/harbour/source/common/hbdate.c
index fac0d8bd62..abbd7028fa 100644
--- a/harbour/source/common/hbdate.c
+++ b/harbour/source/common/hbdate.c
@@ -60,10 +60,17 @@
  *    hb_dateStrPut()
  *    hb_dateStrGet()
  *
+ * Copyright 1999 Jose Lalin <dezac@corevia.com>
+ *    hb_dateDOW()
+ *
  * See doc/license.txt for licensing terms.
  *
  */
 
+#define HB_OS_WIN_32_USED
+
+#include <time.h>
+
 #include "hbapi.h"
 #include "hbdate.h"
 
@@ -237,3 +244,51 @@ HB_EXPORT int hb_dateDOW( int iYear, int iMonth, int iDay )
    return ( iDay + 26 * iMonth / 10 +
             iYear + iYear / 4 - iYear / 100 + iYear / 400 + 6 ) % 7 + 1;
 }
+
+HB_EXPORT void hb_dateToday( int * piYear, int * piMonth, int * piDay )
+{
+#if defined(HB_OS_WIN_32)
+
+   SYSTEMTIME st;
+   GetLocalTime( &st );
+
+   *piYear  = st.wYear;
+   *piMonth = st.wMonth;
+   *piDay   = st.wDay;
+
+#else
+
+   time_t t;
+   struct tm * oTime;
+
+   time( &t );
+   oTime = localtime( &t );
+
+   *piYear  = oTime->tm_year + 1900;
+   *piMonth = oTime->tm_mon + 1;
+   *piDay   = oTime->tm_mday;
+
+#endif
+}
+
+/* NOTE: The passed buffer must be at least 9 chars long */
+
+HB_EXPORT void hb_dateTimeStr( char * pszTime )
+{
+#if defined(HB_OS_WIN_32)
+   {
+      SYSTEMTIME st;
+      GetLocalTime( &st );
+      sprintf( pszTime, "%02d:%02d:%02d", st.wHour, st.wMinute, st.wSecond );
+   }
+#else
+   {
+      time_t t;
+      struct tm * oTime;
+
+      time( &t );
+      oTime = localtime( &t );
+      sprintf( pszTime, "%02d:%02d:%02d", oTime->tm_hour, oTime->tm_min, oTime->tm_sec );
+   }
+#endif
+}
diff --git a/harbour/source/common/hbfsapi.c b/harbour/source/common/hbfsapi.c
index a00e90cbe1..1778f13391 100644
--- a/harbour/source/common/hbfsapi.c
+++ b/harbour/source/common/hbfsapi.c
@@ -60,7 +60,7 @@ extern void hb_fhnd_ForceLink( void );
 /*
  * Function that adds zero or more paths to a list of pathnames to search
  */
-void hb_fsAddSearchPath( char * szPath, HB_PATHNAMES ** pSearchList )
+void hb_fsAddSearchPath( const char * szPath, HB_PATHNAMES ** pSearchList )
 {
    char * pPath;
    char * pDelim;
diff --git a/harbour/source/common/hbstr.c b/harbour/source/common/hbstr.c
index 005dca3047..0c79f1046b 100644
--- a/harbour/source/common/hbstr.c
+++ b/harbour/source/common/hbstr.c
@@ -667,7 +667,7 @@ HB_EXPORT HB_LONG hb_strValInt( const char * szText, int * iOverflow )
 
    HB_TRACE(HB_TR_DEBUG, ("hb_strValInt(%s)", szText));
 
-   if ( hb_str2number( FALSE, szText, strlen( szText ), &lVal, &dVal, NULL, NULL ) )
+   if ( hb_str2number( TRUE, szText, strlen( szText ), &lVal, &dVal, NULL, NULL ) )
    {
       *iOverflow = 1;
       return 0;
@@ -853,53 +853,55 @@ HB_EXPORT char * hb_strncpyTrim( char * pDest, const char * pSource, ULONG ulLen
 
 char * hb_strRemEscSeq( char *str, ULONG *pLen )
 {
-  char *ptr = str;
-  
-  while( *ptr )
-  {
-    if( *ptr == '\\' )
-    {
-      switch( *(ptr+1) )
+   char *ptr, *dst, ch;
+   ULONG ul = *pLen, ulStripped = 0;
+
+   ptr = dst = str;
+   while( ul )
+   {
+      if( *ptr == '\\' )
+         break;
+      ++ptr; ++dst;
+      --ul;
+   }
+
+   while( ul-- )
+   {
+      ch = *ptr++;
+      if( ch == '\\' )
       {
-        case '\\':
-        {
-          memmove( ptr, ptr+1, *pLen - (ptr - str) );
-          (*pLen)--;
-          break;
-        }
-        case 'r':
-        {
-          memmove( ptr, ptr+1, *pLen - (ptr - str) );
-          *ptr = '\r';
-          (*pLen)--;
-          break;
-        }
-        case 'n':
-        {
-          memmove( ptr, ptr+1, *pLen - (ptr - str) );
-          *ptr = '\n';
-          (*pLen)--;
-          break;
-        }
-        case 't':
-        {
-          memmove( ptr, ptr+1, *pLen - (ptr - str) );
-          *ptr = '\t';
-          (*pLen)--;
-          break;
-        }
-        case 'b':
-        {
-          memmove( ptr, ptr+1, *pLen - (ptr - str) );
-          *ptr = '\b';
-          (*pLen)--;
-          break;
-        }
-        default:
-          break;
+         ++ulStripped;
+         ch = *ptr++;
+         switch( ch )
+         {
+            case 'r':
+               ch = '\r';
+               break;
+            case 'n':
+               ch = '\n';
+               break;
+            case 't':
+               ch = '\t';
+               break;
+            case 'b':
+               ch = '\b';
+               break;
+            case 'q':
+               ch = '"';
+               break;
+            case '\\':
+            default:
+               break;
+         }
       }
-    }
-    ptr++;
-  }
-  return str;
+      *dst++ = ch;
+   }
+
+   if( ulStripped )
+   {
+      *dst = '\0';
+      *pLen -= ulStripped;
+   }
+
+   return str;
 }
diff --git a/harbour/source/compiler/Makefile b/harbour/source/compiler/Makefile
index 456cce1df5..5a2df74905 100644
--- a/harbour/source/compiler/Makefile
+++ b/harbour/source/compiler/Makefile
@@ -55,6 +55,7 @@ C_SOURCES=\
     hbstrong.c \
     hbusage.c \
     hbident.c \
+    ppcomp.c \
     expropta.c \
     exproptb.c \
     exproptc.c \
diff --git a/harbour/source/compiler/cmdcheck.c b/harbour/source/compiler/cmdcheck.c
index 0ecb89f342..9907954494 100644
--- a/harbour/source/compiler/cmdcheck.c
+++ b/harbour/source/compiler/cmdcheck.c
@@ -49,8 +49,6 @@
 
 #include "hbcomp.h"
 
-extern int hb_pp_ParseDefine( char * );
-
 /* TODO: Add support for this compiler switches
    -r -t || hb_getenv( "TMP" )
 */
@@ -908,7 +906,7 @@ static void hb_compChkDefineSwitch( char *pszSwitch )
    {
       if( pszSwitch[1] == 'd' || pszSwitch[1] == 'D' )
       {
-         char *szDefText = hb_strdup( pszSwitch + 2 ), *pAssign, *sDefLine;
+         char *szDefText = hb_strdup( pszSwitch + 2 ), *pAssign, *szDefLine;
          unsigned int i = 0;
 
          while( i < strlen( szDefText ) && !HB_ISOPTSEP( szDefText[i] ) )
@@ -926,10 +924,10 @@ static void hb_compChkDefineSwitch( char *pszSwitch )
                szDefText[pAssign - szDefText] = '\0';
 
                /* hb_pp_AddDefine( szDefText,  pAssign + 1 ); */
-               sDefLine = ( char * ) hb_xgrab( strlen( szDefText ) + 1 + strlen( pAssign + 1 ) + 1 );
-               sprintf( sDefLine, "%s %s", szDefText, pAssign + 1 );
-               hb_pp_ParseDefine( sDefLine );
-               hb_xfree( sDefLine );
+               szDefLine = ( char * ) hb_xgrab( strlen( szDefText ) + strlen( pAssign + 1 ) + 10 );
+               sprintf( szDefLine, "#define %s %s", szDefText, pAssign + 1 );
+               hb_pp_ParseDirective( szDefLine );
+               hb_xfree( szDefLine );
             }
          }
 
diff --git a/harbour/source/compiler/harbour.c b/harbour/source/compiler/harbour.c
index 5b614f420a..f008972dc2 100644
--- a/harbour/source/compiler/harbour.c
+++ b/harbour/source/compiler/harbour.c
@@ -73,6 +73,7 @@ static void hb_compGenOutput( int );
 static void hb_compOutputFile( void );
 static void hb_compPpoFile( void );
 static void hb_compCompileEnd( void );
+static int  hb_compCompile( char * szPrg, BOOL bSingleFile );
 
 
 int hb_compLocalGetPos( char * szVarName );   /* returns the order + 1 of a local variable */
@@ -86,7 +87,7 @@ static void hb_compGenVariablePCode( BYTE , char * );    /* generates the pcode
 static PFUNCTION hb_compFunctionNew( char *, HB_SYMBOLSCOPE );  /* creates and initialises the _FUNC structure */
 static PINLINE hb_compInlineNew( char * );  /* creates and initialises the _INLINE structure */
 static void hb_compCheckDuplVars( PVAR pVars, char * szVarName ); /*checks for duplicate variables definitions */
-static int hb_compProcessRSPFile( char *, int, char * argv[] ); /* process response file */
+static int hb_compProcessRSPFile( char * ); /* process response file */
 
 static void hb_compOptimizeJumps( void );
 static void hb_compOptimizeFrames( PFUNCTION pFunc );
@@ -163,6 +164,8 @@ ULONG          hb_comp_Supported;
 
 FILE *         hb_comp_errFile = NULL;
 
+int            hb_comp_iHidden;                 /* Hide Strings */
+
 
 /* EXTERNAL statement can be placed into any place in a function - this flag is
  * used to suppress error report generation
@@ -243,7 +246,7 @@ int main( int argc, char * argv[] )
    hb_compChkPaths();
 
    /* Set standard rules */
-   hb_pp_SetRules( hb_compInclude, hb_comp_bQuiet );
+   hb_pp_SetRules( hb_comp_bQuiet, argc, argv );
 
    /* Prepare the table of identifiers */
    hb_compIdentifierOpen();
@@ -276,9 +279,9 @@ int main( int argc, char * argv[] )
          }
 
          if( argv[ i ][ 0 ] == '@' )
-            iStatus = hb_compProcessRSPFile( argv[ i ] + 1, argc, argv );
+            iStatus = hb_compProcessRSPFile( argv[ i ] + 1 );
          else
-            iStatus = hb_compCompile( argv[ i ], argc, argv, TRUE );
+            iStatus = hb_compCompile( argv[ i ], TRUE );
 
          if( iStatus != EXIT_SUCCESS )
             break;
@@ -342,7 +345,7 @@ void hb_compMainExit( void )
    hb_xexit();
 }
 
-static int hb_compProcessRSPFile( char * szRspName, int argc, char * argv[] )
+static int hb_compProcessRSPFile( char * szRspName )
 {
    char szFile[ _POSIX_PATH_MAX + 1 ];
    int iStatus = EXIT_SUCCESS;
@@ -413,7 +416,7 @@ static int hb_compProcessRSPFile( char * szRspName, int argc, char * argv[] )
       hb_comp_bAutoOpen = bAutoOpen;
       
       hb_fsFNameMerge( szFile, pFileName );
-      hb_compCompile( szFile, argc, argv, FALSE );
+      hb_compCompile( szFile, FALSE );
    }
 
    hb_xfree( pFileName );
@@ -4622,7 +4625,7 @@ static void hb_compPpoFile( void )
          else
          */
       }
-            hb_comp_pFilePpo->szExtension = ".ppo";
+      hb_comp_pFilePpo->szExtension = ".ppo";
    }
 }
 
@@ -4648,7 +4651,7 @@ static void hb_compOutputFile( void )
    }
 }
 
-int hb_compCompile( char * szPrg, int argc, char * argv[], BOOL bSingleFile )
+int hb_compCompile( char * szPrg, BOOL bSingleFile )
 {
    int iStatus = EXIT_SUCCESS;
 
@@ -4684,7 +4687,7 @@ int hb_compCompile( char * szPrg, int argc, char * argv[], BOOL bSingleFile )
       if( iStatus == EXIT_SUCCESS )
       {
          /* Add /D command line or envvar defines */
-         hb_compChkDefines( argc, argv );
+         /* hb_compChkDefines( argc, argv ); */
 
          /* Initialize support variables */
          hb_compInitVars();
@@ -4721,12 +4724,14 @@ int hb_compCompile( char * szPrg, int argc, char * argv[], BOOL bSingleFile )
 
                yyparse();
 
-               if( hb_comp_bPPO && hb_comp_yyppo )
+               if( hb_comp_yyppo )
                {
                   fclose( hb_comp_yyppo );
                   hb_comp_yyppo = NULL;
-                  if( hb_comp_pFilePpo )
-                     hb_xfree( hb_comp_pFilePpo );
+               }
+               if( hb_comp_pFilePpo )
+               {
+                  hb_xfree( hb_comp_pFilePpo );
                   hb_comp_pFilePpo = NULL;
                }
             }
@@ -4892,7 +4897,7 @@ static void hb_compCompileEnd( void )
    
    if( hb_comp_pFileName )
    {
-      if( hb_comp_pFileName != hb_comp_pMainFileName && hb_comp_pFileName )
+      if( hb_comp_pFileName != hb_comp_pMainFileName && hb_comp_pMainFileName )
       {
          /* currently compiled file was autoopened - close also
           * the main module
@@ -4904,12 +4909,14 @@ static void hb_compCompileEnd( void )
       hb_comp_pFileName = NULL;
    }
 
-   if( hb_comp_bPPO && hb_comp_yyppo )
+   if( hb_comp_yyppo )
    {
       fclose( hb_comp_yyppo );
       hb_comp_yyppo = NULL;
-      if( hb_comp_pFilePpo )
-         hb_xfree( hb_comp_pFilePpo );
+   }
+   if( hb_comp_pFilePpo )
+   {
+      hb_xfree( hb_comp_pFilePpo );
       hb_comp_pFilePpo = NULL;
    }
 
@@ -5137,12 +5144,14 @@ int hb_compAutoOpen( char * szPrg, BOOL * pbSkipGen, BOOL bSingleFile )
 
                yyparse();
 
-               if( hb_comp_bPPO && hb_comp_yyppo )
+               if( hb_comp_yyppo )
                {
                   fclose( hb_comp_yyppo );
                   hb_comp_yyppo = NULL;
-                  if( hb_comp_pFilePpo )
-                     hb_xfree( hb_comp_pFilePpo );
+               }
+               if( hb_comp_pFilePpo )
+               {
+                  hb_xfree( hb_comp_pFilePpo );
                   hb_comp_pFilePpo = NULL;
                }
 
diff --git a/harbour/source/compiler/harbour.l b/harbour/source/compiler/harbour.l
index 6ecaea60c8..a56651e360 100644
--- a/harbour/source/compiler/harbour.l
+++ b/harbour/source/compiler/harbour.l
@@ -134,7 +134,7 @@ FalseValue    "."[f|n]"."
 
 Separator     {SpaceTab}
 
-%x            STRING1 STRING2 STRING3 STRING4START STRING4 STRING5
+%x            STRINGEXT STRING1 STRING2 STRING3 STRING4START STRING4 STRING5
 %x            NEXT_ BREAK_ CASE_ DO_ DOIDENT_ WHILE_ WITH_ END_ FIELD_
 %x            FOR_ FOREACH_ FUNCTION_ IIF_ IF_ IN_ INIT_
 %x            RETURN_ RECOVER_
@@ -146,36 +146,51 @@ Separator     {SpaceTab}
 
 "&"(\x27|\x22|\[) { hb_compGenError( hb_comp_szErrors, 'E', HB_COMP_ERR_SYNTAX, yytext, NULL ); }
 
-\x27             BEGIN STRING1;
-\x22             BEGIN STRING2;
+"e"\x22        BEGIN STRINGEXT;
+\x27           BEGIN STRING1;
+\x22           BEGIN STRING2;
 
 \[             {
-                    if( (hb_comp_iState == OPERATOR) ||
-                        (hb_comp_iState == LSEPARATOR) ||
-                        (hb_comp_iState == LARRAY) ||
-                        (hb_comp_iState == IF) ||
-                        (hb_comp_iState == ELSEIF) ||
-                        (hb_comp_iState == CASE) ||
-                        (hb_comp_iState == BREAK) ||
-                        (hb_comp_iState == RETURN) ||
-                        (hb_comp_iState == WITH) ||
-                        (hb_comp_iState == WHILE)
-                      )
-							 {
-							 	if( hb_pp_NestedLiteralString )
-                {
-                          yy_breakFlex();
-                        	BEGIN STRING5;
-                }
-								else
-                        	BEGIN STRING3;
-							 }
-                    else
-                    {
-                        hb_comp_iState = LINDEX;
-                        return '[';
-                    }
+                  if( (hb_comp_iState == OPERATOR) ||
+                      (hb_comp_iState == LSEPARATOR) ||
+                      (hb_comp_iState == LARRAY) ||
+                      (hb_comp_iState == IF) ||
+                      (hb_comp_iState == ELSEIF) ||
+                      (hb_comp_iState == CASE) ||
+                      (hb_comp_iState == BREAK) ||
+                      (hb_comp_iState == RETURN) ||
+                      (hb_comp_iState == WITH) ||
+                      (hb_comp_iState == WHILE)
+                    )
+                  {
+                     if( hb_pp_NestedLiteralString )
+                     {
+                        yy_breakFlex();
+                        BEGIN STRING5;
+                     }
+                     else
+                        BEGIN STRING3;
                   }
+                  else
+                  {
+                     hb_comp_iState = LINDEX;
+                     return '[';
+                  }
+               }
+
+<STRINGEXT>[^\x22\n]*\x22  { BEGIN 0;
+                        yytext[--yyleng] = '\0';
+                        {
+                           ULONG len = yyleng;
+                           hb_strRemEscSeq( yytext, &len );
+                           yyleng = len;
+                        }
+                        yylval.string = hb_compIdentifierNew( yytext, TRUE );
+                        hb_comp_iState = LITERAL;
+
+                        return LITERAL;
+                     }
+
 <STRING1>[^\x27\n]*\n  { BEGIN 0;
                       unput( '\n' );
                       yytext[--yyleng] = '\0';
@@ -331,11 +346,13 @@ Separator     {SpaceTab}
 \n           {
                 hb_comp_iState = LOOKUP;
 
+/*
                 if( ! hb_comp_bQuiet && ( hb_comp_iLine % 100 ) == 0 )
                 {
                    printf( "\r%i", hb_comp_iLine );
                    fflush( stdout );
                 }
+*/
                 return '\n';
              }
 %{
diff --git a/harbour/source/compiler/hbgenerr.c b/harbour/source/compiler/hbgenerr.c
index 97415b44ff..f02617a609 100644
--- a/harbour/source/compiler/hbgenerr.c
+++ b/harbour/source/compiler/hbgenerr.c
@@ -92,7 +92,8 @@ char * hb_comp_szErrors[] =
    "Invalid date constant \'%s\'",
    "Memory buffer overflow",
    "Memory corruption detected",
-   "Implicit send operator with no WITH OBJECT in sight"
+   "Implicit send operator with no WITH OBJECT in sight",
+   "Input buffer overflow"
 };
 
 /* Table with parse warnings */
diff --git a/harbour/source/compiler/ppcomp.c b/harbour/source/compiler/ppcomp.c
new file mode 100644
index 0000000000..fc4b62e4d4
--- /dev/null
+++ b/harbour/source/compiler/ppcomp.c
@@ -0,0 +1,375 @@
+/*
+ * $Id$
+ */
+
+/*
+ * Harbour Project source code:
+ * Compiler C source with real code generation
+ *
+ * Copyright 2006 Przemyslaw Czerpak < druzus /at/ priv.onet.pl >
+ * www - http://www.harbour-project.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA (or visit
+ * their web site at http://www.gnu.org/).
+ *
+ */
+
+
+#include "hbcomp.h"
+#include <errno.h>
+
+static PHB_PP_STATE s_pp_state = NULL;
+
+BOOL hb_pp_NestedLiteralString = FALSE;
+BOOL hb_pp_LiteralEscSeq = FALSE;
+int hb_pp_StreamBlock = 0;
+unsigned int hb_pp_MaxTranslateCycles = 1024;
+char *hb_pp_STD_CH = NULL;
+
+
+
+static void hb_pp_ErrorGen( char * szMsgTable[], char cPrefix, int iErrorCode,
+                            const char * szParam1, const char * szParam2 )
+{
+   int iLine = hb_comp_iLine;
+
+   /* I do not know why but compiler expect line number 1 bigger then
+      real line number */
+   hb_comp_iLine = hb_pp_line( s_pp_state ) + 1;
+   if( cPrefix == 'W' )
+      hb_compGenWarning( szMsgTable, cPrefix, iErrorCode, szParam1, szParam2 );
+   else
+      hb_compGenError( szMsgTable, cPrefix, iErrorCode, szParam1, szParam2 );
+   hb_comp_iLine = iLine;
+}
+
+static FILE * hb_pp_IncludeOpen( char *szFileName, BOOL fSysFile, char * szFNameBuf )
+{
+   PHB_FNAME pFileName;
+   FILE *file = NULL;
+   PFILE pFile;
+   BOOL fPath;
+
+   pFileName = hb_fsFNameSplit( szFileName );
+   fPath = pFileName->szPath && pFileName->szPath[ 0 ];
+   errno = 0;
+   if( !fSysFile )
+   {
+      if( !fPath && hb_comp_pFileName )
+         pFileName->szPath = hb_comp_pFileName->szPath;
+
+      hb_fsFNameMerge( szFNameBuf, pFileName );
+
+      file = fopen( szFNameBuf, "r" );
+   }
+
+   if( !file && errno != EMFILE && hb_comp_pIncludePath )
+   {
+      HB_PATHNAMES * pSearch = hb_comp_pIncludePath;
+
+      pFileName->szName = szFileName;
+      pFileName->szExtension = NULL;
+      while( pSearch && !file )
+      {
+         pFileName->szPath = pSearch->szPath;
+         hb_fsFNameMerge( szFNameBuf, pFileName );
+         file = fopen( szFNameBuf, "r" );
+         pSearch = pSearch->pNext;
+      }
+   }
+   hb_xfree( pFileName );
+
+   if( file )
+   {
+      pFile = ( PFILE ) hb_xgrab( sizeof( _FILE ) );
+      pFile->handle = file;
+      pFile->pBuffer = hb_xgrab( HB_PP_BUFF_SIZE );
+      pFile->iBuffer = pFile->lenBuffer = 10;
+      pFile->yyBuffer = NULL;
+      pFile->szFileName = hb_strdup( szFNameBuf );
+      if( hb_comp_files.pLast )
+         hb_comp_files.pLast->iLine = hb_comp_iLine;
+      hb_comp_iLine = 1;
+      pFile->iLine = 1;
+      pFile->pPrev = hb_comp_files.pLast;
+      hb_comp_files.pLast = pFile;
+      hb_comp_files.iFiles++;
+   }
+
+   return file;
+}
+
+static void hb_pp_IncludeClose( FILE * file )
+{
+   if( hb_comp_files.iFiles > 0 && hb_comp_files.pLast &&
+       file == hb_comp_files.pLast->handle )
+   {
+      PFILE pFile;
+      fclose( hb_comp_files.pLast->handle );
+      hb_xfree( hb_comp_files.pLast->pBuffer );
+      hb_xfree( hb_comp_files.pLast->szFileName );
+      pFile = ( PFILE ) ( ( PFILE ) hb_comp_files.pLast )->pPrev;
+#if 0
+      if( hb_comp_files.pLast->yyBuffer && hb_comp_files.iFiles == 1 )
+         hb_compParserStop(); /* uses hb_comp_files.pLast */
+#endif
+      hb_xfree( hb_comp_files.pLast );
+      hb_comp_files.pLast = pFile;
+      if( hb_comp_files.pLast )
+         hb_comp_iLine = hb_comp_files.pLast->iLine;
+      hb_comp_files.iFiles--;
+   }
+}
+
+static void hb_pp_PragmaDump( char * pBuffer, ULONG ulSize, int iLine )
+{
+   int iSaveLine = hb_comp_iLine;
+   PINLINE pInline;
+
+   /* I do not know why but compiler expect line number 1 bigger then
+      real line number */
+   hb_comp_iLine = iLine + 1;
+
+   pInline = hb_compInlineAdd( NULL );
+   pInline->pCode = ( BYTE * ) hb_xgrab( ulSize + 1 );
+   memcpy( pInline->pCode, pBuffer, ulSize );
+   pBuffer[ ulSize ] = '\0';
+   pInline->lPCodeSize = ulSize;
+
+   hb_comp_iLine = iSaveLine;
+}
+
+static BOOL hb_pp_CompilerSwitch( const char * szSwitch, int iValue )
+{
+   BOOL fError = FALSE;
+   int i = strlen( szSwitch );
+
+   if( i == 1 )
+   {
+      switch( szSwitch[ 0 ] )
+      {
+         case 'a':
+         case 'A':
+            hb_comp_bAutoMemvarAssume = iValue != 0;
+            break;
+
+         case 'b':
+         case 'B':
+            hb_comp_bDebugInfo = iValue != 0;
+            break;
+
+         case 'l':
+         case 'L':
+            hb_comp_bLineNumbers = iValue != 0;
+            break;
+
+         case 'n':
+         case 'N':
+            hb_comp_bStartProc = iValue != 0;
+            break;
+
+         case 'p':
+         case 'P':
+            hb_comp_bPPO = iValue != 0;
+            break;
+
+         case 'q':
+         case 'Q':
+            hb_comp_bQuiet = iValue != 0;
+            break;
+
+         case 'v':
+         case 'V':
+            hb_comp_bForceMemvars = iValue != 0;
+            break;
+
+         case 'w':
+         case 'W':
+            if( iValue >= 0 && iValue <= 3 )
+               hb_comp_iWarnings = iValue;
+            else
+               fError = TRUE;
+            break;
+
+         case 'z':
+         case 'Z':
+            hb_comp_bShortCuts = iValue != 0;
+            break;
+
+         default:
+            fError = TRUE;
+      }
+   }
+   else if( i == 2 )
+   {
+      if( szSwitch[ 1 ] - '0' == iValue && iValue >= 0 && iValue <= 3 &&
+          ( szSwitch[ 0 ] == 'w' || szSwitch[ 0 ] == 'W' ) &&
+          ( iValue >= 0 && iValue <= 3 ) )
+         hb_comp_iWarnings = iValue;
+      else if( hb_stricmp( szSwitch, "es" ) == 0 &&
+               ( iValue == HB_EXITLEVEL_DEFAULT ||
+                 iValue == HB_EXITLEVEL_SETEXIT ||
+                 iValue == HB_EXITLEVEL_DELTARGET ) )
+         hb_comp_iExitLevel = iValue;
+      else
+         fError = TRUE;
+   }
+   else if( i == 3 )
+   {
+      if( szSwitch[ 2 ] - '0' == iValue &&
+          hb_strnicmp( szSwitch, "es", 2 ) == 0 &&
+          ( iValue == HB_EXITLEVEL_DEFAULT ||
+            iValue == HB_EXITLEVEL_SETEXIT ||
+            iValue == HB_EXITLEVEL_DELTARGET ) )
+         hb_comp_iExitLevel = iValue;
+      else
+         fError = TRUE;
+   }
+   /* xHarbour extension */
+   else if( i >= 4 && hb_strnicmp( szSwitch, "TEXTHIDDEN", i ) == 0 &&
+            iValue >= 0 && iValue <= 1 )
+      hb_comp_iHidden = iValue;
+   else
+      fError = TRUE;
+
+   return fError;
+}
+
+
+void hb_pp_SetRules( BOOL fQuiet, int argc, char * argv[] )
+{
+   char * szStdCh = hb_pp_STD_CH;
+
+   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_SetRules()" ) );
+
+   if( szStdCh && * szStdCh <= ' ' )
+      szStdCh = "";
+
+   hb_pp_Free();
+   s_pp_state = hb_pp_new();
+   if( s_pp_state )
+   {
+      hb_pp_init( s_pp_state, szStdCh, fQuiet,
+                  hb_pp_IncludeOpen, hb_pp_IncludeClose,
+                  hb_pp_ErrorGen, NULL, hb_pp_PragmaDump,
+                  hb_pp_CompilerSwitch );
+
+      /* Add /D and /undef: command line or envvar defines */
+      hb_compChkDefines( argc, argv );
+
+      /* mark current rules as standard ones */
+      hb_pp_setStdBase( s_pp_state );
+   }
+
+   if( hb_comp_pFileName )
+   {
+      hb_xfree( ( void * ) hb_comp_pFileName );
+      hb_comp_pFileName = NULL;
+   }
+   if( hb_pp_STD_CH )
+   {
+      hb_xfree( hb_pp_STD_CH );
+      hb_pp_STD_CH = NULL;
+   }
+}
+
+void hb_pp_Init( void )
+{
+   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_Init()" ) );
+
+   if( s_pp_state )
+   {
+      hb_pp_reset( s_pp_state );
+   }
+}
+
+void hb_pp_Free( void )
+{
+   if( s_pp_state )
+   {
+      hb_pp_free( s_pp_state );
+      s_pp_state = NULL;
+   }
+}
+
+void hb_pp_AddDefine( char *defname, char *value )
+{
+   if( s_pp_state )
+      hb_pp_addDefine( s_pp_state, defname, value );
+}
+
+void hb_pp_ParseDirective( char * szLine )
+{
+   if( s_pp_state && szLine )
+      hb_pp_parseLine( s_pp_state, szLine, NULL );
+}
+
+int hb_pp_Internal( FILE * handl_o, char * sOut )
+{
+   ULONG ulLen = 0;
+
+   HB_TRACE(HB_TR_DEBUG, ("hb_pp_Internal(%p, %s)", handl_o, sOut));
+
+   hb_pp_StreamBlock = 0;
+   hb_pp_NestedLiteralString = FALSE;
+   hb_pp_LiteralEscSeq = FALSE;
+
+   if( s_pp_state && hb_comp_files.iFiles > 0 )
+   {
+      char * szLine;
+
+      if( ! hb_pp_fileName( s_pp_state ) )
+      {
+         hb_pp_inFile( s_pp_state, hb_comp_files.pLast->szFileName,
+                                   hb_comp_files.pLast->handle );
+      }
+      if( handl_o && ! hb_pp_outFileName( s_pp_state ) )
+      {
+         char szOutFileName[ _POSIX_PATH_MAX + 1 ];
+         if( hb_comp_pFilePpo )
+            hb_fsFNameMerge( szOutFileName, hb_comp_pFilePpo );
+         else
+            szOutFileName[ 0 ] = '\0';
+         hb_pp_outFile( s_pp_state, szOutFileName, handl_o );
+         /* dirty hack but works as workaround for pure PP and compiler
+            API integration */
+         if( handl_o == hb_comp_yyppo )
+            hb_comp_yyppo = NULL;
+      }
+
+      szLine = hb_pp_nextLine( s_pp_state, &ulLen );
+      /* I do not know why but compiler expect line number 1 bigger then
+         real line number */
+      hb_comp_iLine = hb_pp_line( s_pp_state ) + 1;
+
+      if( ulLen >= HB_PP_STR_SIZE )
+         hb_compGenError( hb_comp_szErrors, 'F', HB_COMP_ERR_BUFFER_OVERFLOW, NULL, NULL );
+      else if( szLine )
+         memcpy( sOut, szLine, ulLen + 1 );
+      else
+         * sOut = '\0';
+   }
+   else
+   {
+      * sOut = '\0';
+   }
+
+   if( hb_comp_iLineINLINE && hb_pp_StreamBlock == 0 )
+   {
+      hb_comp_iLineINLINE = 0;
+   }
+
+   return ulLen;
+}
diff --git a/harbour/source/pp/Makefile b/harbour/source/pp/Makefile
index 3935565ac9..f6683f0946 100644
--- a/harbour/source/pp/Makefile
+++ b/harbour/source/pp/Makefile
@@ -5,12 +5,16 @@
 ROOT = ../../
 
 C_SOURCES=\
-	ppcore.c \
-	ppcomp.c \
 	pplib.c \
 	pptable.c \
-	pragma.c \
+	ppcore.c \
 
 LIBNAME=pp
 
+LIBS=\
+	common \
+
 include $(TOP)$(ROOT)config/lib.cf
+
+pptable.c : ppgen$(EXE_EXT)
+	./ppgen$(EXE_EXT) $(TOP)$(ROOT)include/hbstdgen.ch -opptable.c -q
diff --git a/harbour/source/pp/ppcore.c b/harbour/source/pp/ppcore.c
index 422b5431a3..2ef387f0eb 100644
--- a/harbour/source/pp/ppcore.c
+++ b/harbour/source/pp/ppcore.c
@@ -4,9 +4,9 @@
 
 /*
  * Harbour Project source code:
- * Preprocessor core module
+ * 
  *
- * Copyright 1999 Alexander S.Kresin <alex@belacy.belgorod.su>
+ * Copyright 2006 Przemyslaw Czerpak <druzus / at / priv.onet.pl>
  * www - http://www.harbour-project.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -50,4764 +50,4582 @@
  *
  */
 
-/*
- * The following parts are Copyright of the individual authors.
- * www - http://www.harbour-project.org
- *
- * Copyright 1999-2001 Viktor Szakats <viktor.szakats@syenar.hu>
- *    __DATE__, __TIME__, __HB_MAIN__ support
- *
- * Copyright 2000 Ron Pinkas <Ron@Profit-Master.com>
- *
- * hb_pp_SetRules() and related code for supportting
- * replaceable rules with -w switch
- *
- * See doc/license.txt for licensing terms.
- *
- */
+/* #define HB_C52_STRICT */
+#define HB_PP_NO_LINEINFO_TOKEN
 
-/*
- * Avoid tracing in preprocessor/compiler.
- */
-#if ! defined(HB_TRACE_UTILS)
-#if defined(HB_TRACE_LEVEL)
-#undef HB_TRACE_LEVEL
-#endif
-#endif
-
-#include <time.h>
-#include <errno.h>
+#define _HB_PP_INTERNAL
 
 #include "hbpp.h"
-#include "hbcomp.h"
-
-#if defined( OS_UNIX_COMPATIBLE )
-#include <sys/timeb.h>
-#else
-#include <sys/timeb.h>
-#endif
-
-int hb_pp_ParseDefine( char * );        /* Process #define directive */
-
-static COMMANDS *AddCommand( char * );  /* Add new #command to an array  */
-static COMMANDS *AddTranslate( char * );        /* Add new #translate to an array  */
-static DEFINES *DefSearch( char *, int, BOOL * );
-static COMMANDS *ComSearch( char *, COMMANDS * );
-static COMMANDS *TraSearch( char *, COMMANDS * );
-
-static int ParseUndef( char * );        /* Process #undef directive */
-static int ParseIfdef( char *, int );   /* Process #ifdef directive */
-static void ParseCommand( char *, BOOL, BOOL ); /* Process #command or #translate directive */
-static void ConvertPatterns( char *, int, char *, int );        /* Converting result pattern in #command and #translate */
-static int WorkDefine( char **, char *, DEFINES * );    /* Replace fragment of code with a #defined result text */
-static int WorkPseudoF( char **, char *, DEFINES * );   /* Replace pseudofunction with a #defined result text */
-static int WorkCommand( char *, char *, COMMANDS * );
-static int WorkTranslate( char *, char *, COMMANDS *, int * );
-static int CommandStuff( char *, char *, char *, int *, BOOL, BOOL );
-static int RemoveSlash( char * );
-static int WorkMarkers( char **, char **, char *, int *, BOOL, BOOL );
-static int getExpReal( char *, char **, BOOL, int, BOOL, BOOL );
-static BOOL isExpres( char *, BOOL );
-static BOOL TestOptional( char *, char * );
-static BOOL CheckOptional( char *, char *, char *, int *, BOOL, BOOL );
-static void SkipOptional( char ** );
-
-static void SearnRep( char *, char *, int, char *, int * );
-static int ReplacePattern( char, char *, int, char *, int );
-static void pp_rQuotes( char *, char * );
-static int md_strAt( char *, int, char *, BOOL, BOOL, BOOL, int );
-
-#define MD_STR_AT_IGNORECASE  0 /* search ignoring case */
-#define MD_STR_AT_USESUBCASE  1 /* use case specified in search string (old) */
-static char *PrevSquare( char *, char *, int * );
-static int IsInStr( char, char * );
-static int stroncpy( char *, char *, int );
-static int strincpy( char *, char * );
-static BOOL truncmp( char **, char **, BOOL );
-static BOOL strincmp( char *, char **, BOOL );
-static int strotrim( char *, BOOL );    /* Ron Pinkas 2001-02-14 added 2nd parameter */
-static int NextWord( char **, char *, BOOL );
-static int NextName( char **, char * );
-static int NextParm( char **, char * );
-static BOOL OpenInclude( char *, HB_PATHNAMES *, PHB_FNAME, BOOL bStandardOnly, char * );
-static BOOL IsIdentifier( char *szProspect );
-static int IsMacroVar( char *szText, BOOL isCommand );
-static void RemoveOptional( char *cpatt );
-static int ConvertOptional( char *cpatt, int len, BOOL bLeft );
-
-#define ISNAME( c )  ( isalnum( c ) || ( c ) == '_' || ( c ) > 0x7E )
-#define MAX_NAME     255
-#define MAX_EXP      2048
-#define PATTERN_SIZE 2048
-
-#define STATE_INIT      0
-#define STATE_NORMAL    1
-#define STATE_COMMENT   2
-#define STATE_QUOTE1    3
-#define STATE_QUOTE2    4
-#define STATE_QUOTE3    5
-#define STATE_ID_END    6
-#define STATE_ID        7
-#define STATE_EXPRES    8
-#define STATE_EXPRES_ID 9
-#define STATE_BRACKET   10
-
-#define IT_EXPR       1
-#define IT_ID         2
-#define IT_COMMA      3
-#define IT_ID_OR_EXPR 4
-
-#define HB_PP_MAX_INCLUDES FOPEN_MAX - 5 - 1
-
-#define HB_PP_MATCH_MARK '\1'
-#define HB_PP_OPT_START  '\2'
-#define HB_PP_OPT_END    '\3'
-
-/* Ron Pinkas added 2000-01-24 */
-#define IS_2CHAR_OPERATOR( p ) ( p[0] && p[1] && ( strncmp( p, ":=", 2 ) == 0 || \
-                                                   strncmp( p, "+=", 2 ) == 0 || \
-                                                   strncmp( p, "-=", 2 ) == 0 || \
-                                                   strncmp( p, "*=", 2 ) == 0 || \
-                                                   strncmp( p, "/=", 2 ) == 0 || \
-                                                   strncmp( p, "^=", 2 ) == 0 || \
-                                                   strncmp( p, "==", 2 ) == 0 || \
-                                                   strncmp( p, "<>", 2 ) == 0 || \
-                                                   strncmp( p, "<=", 2 ) == 0 || \
-                                                   strncmp( p, ">=", 2 ) == 0 || \
-                                                   strncmp( p, "++", 2 ) == 0 || \
-                                                   strncmp( p, "--", 2 ) == 0 || \
-                                                   strncmp( p, "->", 2 ) == 0      ) )
-/* END, Ron Pinkas added 2000-01-24 */
+#include "hbdate.h"
+#include <errno.h>
 
 
-static int s_kolAddDefs = 0;
-static int s_kolAddComs = 0;
-static int s_kolAddTras = 0;
-static int s_ParseState;
-static int s_maxCondCompile;
-static int s_aIsRepeate[5];
-static int s_Repeate;
-static BOOL s_bReplacePat = TRUE;
-static int s_numBrackets;
-static char s_groupchar;
-static char s_prevchar;
-/* additional buffers for expressions */
-static char *s_expreal = NULL;   /* allocation inside WorkMarkers */
-static char *s_expcopy = NULL;   /* allocation inside SearnExp */
+#define HB_PP_WARN_DEFINE_REDEF                 1     /* C1005 */
 
-/* global variables */
-int *hb_pp_aCondCompile = NULL;
-int hb_pp_nCondCompile = 0;
-BOOL hb_pp_NestedLiteralString = FALSE;
-BOOL hb_pp_LiteralEscSeq = FALSE;
-unsigned int hb_pp_MaxTranslateCycles = 1024;
-int hb_pp_StreamBlock = 0;
-char *hb_pp_STD_CH = NULL;
+#define HB_PP_ERR_ILLEGAL_CHAR                  1     /* C2004 */
+#define HB_PP_ERR_STRING_TERMINATOR             2     /* C2007 */
+#define HB_PP_ERR_MISSING_ENDTEXT               3     /* C2033 */
+#define HB_PP_ERR_DEFINE_SYNTAX                 4     /* C2055 */
+#define HB_PP_ERR_LABEL_MISSING_IN_DEFINE       5     /* C2057 */
+#define HB_PP_ERR_PARE_MISSING_IN_DEFINE        6     /* C2058 */
+#define HB_PP_ERR_MISSING_PATTERN_SEP           7     /* C2059 */
+#define HB_PP_ERR_UNKNOWN_RESULT_MARKER         8     /* C2060 */
+#define HB_PP_ERR_WRONG_LABEL                   9     /* C2061 */
+#define HB_PP_ERR_BAD_MATCH_MARKER              10    /* C2062 */
+#define HB_PP_ERR_EMPTY_OPTIONAL                11    /* C2065 */
+#define HB_PP_ERR_UNCLOSED_OPTIONAL             12    /* C2066 */
+#define HB_PP_ERR_DIRECTIVE_IFDEF               13    /* C2068 */
+#define HB_PP_ERR_DIRECTIVE_ENDIF               14    /* C2069 */
+#define HB_PP_ERR_DIRECTIVE_ELSE                15    /* C2070 */
+#define HB_PP_ERR_DIRECTIVE_UNDEF               16    /* C2071 */
+#define HB_PP_ERR_AMBIGUOUS_MATCH_PATTERN       17    /* C2072 */
+#define HB_PP_ERR_NESTED_OPTIONAL               18    /* C2073 */
+#define HB_PP_ERR_EXPLICIT                      19    /* C2074 */
+#define HB_PP_ERR_CYCLIC_DEFINE                 20    /* C2078 */
+#define HB_PP_ERR_CYCLIC_TRANSLATE              21    /* C2079 */
+#define HB_PP_ERR_CYCLIC_COMMAND                22    /* C2080 */
+#define HB_PP_ERR_UNTERMINATED_COMMENT          23    /* C2083 */
+#define HB_PP_ERR_PRAGMA                        24    /* C20?? */
+#define HB_PP_ERR_DIRECTIVE_IF                  25    /* C20?? */
+#define HB_PP_ERR_CANNOT_OPEN_INPUT             26    /* C30?? */
+#define HB_PP_ERR_CANNOT_CREATE_FILE            27    /* C3006 */
+#define HB_PP_ERR_CANNOT_OPEN_FILE              28    /* C3007 */
+#define HB_PP_ERR_WRONG_FILE_NAME               29    /* C3008 */
+#define HB_PP_ERR_NESTED_INCLUDES               30    /* C3009 */
+#define HB_PP_ERR_INVALID_DIRECTIVE             31    /* C3010 */
+#define HB_PP_ERR_CANNOT_OPEN_RULES             32    /* C3011 */
 
-/* Ron Pinkas added 2000-11-21 */
-static BOOL s_bArray = FALSE;
 
-/* Table with parse errors */
-char *hb_pp_szErrors[] = {
-   "Can\'t open #include file: \'%s\'; %s",
-   "#else does not match #ifdef",
-   "#endif does not match #ifdef",
-   "Bad filename in #include",
-   "#define without parameters",
-   "Missing => in #translate/#command \'%s\' [%s]'",
-   "Error in pattern definition",
-   "Cycled #define",
-   "Invalid name follows #: \'%s\'",
-   "\'%s\'",
-   "Memory allocation error",
-   "Memory reallocation error",
-   "Freeing a NULL memory pointer",
-   "Value out of range in #pragma directive",
-   "Can\'t open command definitions file: \'%s\'",
-   "Invalid command definitions file name: \'%s\'",
-   "Too many nested #includes, can\'t open: \'%s\'",
-   "Input buffer overflow",
-   "Label missing in #define '%s'",
-   "Comma or right parenthesis missing in #define '%s'",
-   "Label duplicated in #define '%s(%s)'",
+/* warning messages */
+static char * hb_pp_szWarnings[] =
+{
+   "1Redefinition or duplicate definition of #define %s"                /* C1005 */
 };
 
-/* Table with warnings */
-char *hb_pp_szWarnings[] = {
-   "1Redefinition or duplicate definition of #define %s",
-   "1No directives in command definitions file"
+/* error messages */
+static char * hb_pp_szErrors[] =
+{
+   "Illegal character: '\\x%s'",                                        /* C2004 */
+   "Unterminated string: '%s'",                                         /* C2007 */
+   "Missing ENDTEXT",                                                   /* C2033 */
+   "Syntax error in #define",                                           /* C2055 */
+   "Label missing in #define",                                          /* C2057 */
+   "Comma or right parenthesis missing in #define",                     /* C2058 */
+   "Missing => in #translate/#command",                                 /* C2059 */
+   "Unknown result marker in #translate/#command",                      /* C2060 */
+   "Label error in #translate/#command",                                /* C2061 */
+   "Bad match marker in #translate/#command",                           /* C2062 */
+   "Empty optional clause in #translate/#command",                      /* C2065 */
+   "Unclosed optional clause in #translate/#command",                   /* C2066 */
+   "Error in #ifdef",                                                   /* C2068 */
+   "#endif does not match #endif",                                      /* C2069 */
+   "#else does not match #ifdef",                                       /* C2070 */
+   "Error in #undef",                                                   /* C2071 */
+   "Ambiguous match pattern in #translate/#command",                    /* C2072 */
+   "Result pattern contains nested clauses in #translate/#command",     /* C2073 */
+   "#error: '%s'",                                                      /* C2074 */
+   "Circularity detected in #define: '%s'",                             /* C2078 */
+   "Circularity detected in #translate: '%s'",                          /* C2079 */
+   "Circularity detected in #command: '%s'",                            /* C2080 */
+   "Unterminated /* */ comment",                                        /* C2083 */
+
+   "Error in #pragma",                                                  /* C20?? */
+   "Error in #if expression",                                           /* C20?? */
+
+   "Cannot open input file: %s'",                                       /* C30?? */
+
+   "Can't create preprocessed output file",                             /* C3006 */
+   "Can't open #include file: '%s'",                                    /* C3007 */
+   "Bad filename in #include",                                          /* C3008 */
+   "Too many nested #includes",                                         /* C3009 */
+   "Invalid name follows #",                                            /* C3010 */
+   "Can't open standard rule file: '%s'"                                /* C3011 */
 };
 
-void hb_pp_SetRules( HB_INCLUDE_FUNC_PTR pIncludeFunc, BOOL bQuiet )
+
+static const HB_PP_OPERATOR s_operators[] = 
 {
-   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_SetRules()" ) );
+   { ".NOT.", 5, "!"    , HB_PP_TOKEN_NOT       | HB_PP_TOKEN_STATIC },
+   { ".AND.", 5, ".AND.", HB_PP_TOKEN_AND       | HB_PP_TOKEN_STATIC },
+   { ".OR." , 4, ".OR." , HB_PP_TOKEN_OR        | HB_PP_TOKEN_STATIC },
+   { "**="  , 3, "^="   , HB_PP_TOKEN_EXPEQ     | HB_PP_TOKEN_STATIC },
+   { "**"   , 2, "^"    , HB_PP_TOKEN_POWER     | HB_PP_TOKEN_STATIC },
+   { "++"   , 2, "++"   , HB_PP_TOKEN_INC       | HB_PP_TOKEN_STATIC },
+   { "--"   , 2, "--"   , HB_PP_TOKEN_DEC       | HB_PP_TOKEN_STATIC },
+   { "=="   , 2, "=="   , HB_PP_TOKEN_EQUAL     | HB_PP_TOKEN_STATIC },
+   { ":="   , 2, ":="   , HB_PP_TOKEN_ASSIGN    | HB_PP_TOKEN_STATIC },
+   { "+="   , 2, "+="   , HB_PP_TOKEN_PLUSEQ    | HB_PP_TOKEN_STATIC },
+   { "-="   , 2, "-="   , HB_PP_TOKEN_MINUSEQ   | HB_PP_TOKEN_STATIC },
+   { "*="   , 2, "*="   , HB_PP_TOKEN_MULTEQ    | HB_PP_TOKEN_STATIC },
+   { "/="   , 2, "/="   , HB_PP_TOKEN_DIVEQ     | HB_PP_TOKEN_STATIC },
+   { "%="   , 2, "%="   , HB_PP_TOKEN_MODEQ     | HB_PP_TOKEN_STATIC },
+   { "^="   , 2, "^="   , HB_PP_TOKEN_EXPEQ     | HB_PP_TOKEN_STATIC },
+   { "<="   , 2, "<="   , HB_PP_TOKEN_LE        | HB_PP_TOKEN_STATIC },
+   { ">="   , 2, ">="   , HB_PP_TOKEN_GE        | HB_PP_TOKEN_STATIC },
+   { "!="   , 2, "<>"   , HB_PP_TOKEN_NE        | HB_PP_TOKEN_STATIC },
+   { "<>"   , 2, "<>"   , HB_PP_TOKEN_NE        | HB_PP_TOKEN_STATIC },
+   { "->"   , 2, "->"   , HB_PP_TOKEN_ALIAS     | HB_PP_TOKEN_STATIC },
+   { "@"    , 1, "@"    , HB_PP_TOKEN_REFERENCE | HB_PP_TOKEN_STATIC },
+   { "("    , 1, "("    , HB_PP_TOKEN_LEFT_PB   | HB_PP_TOKEN_STATIC },
+   { ")"    , 1, ")"    , HB_PP_TOKEN_RIGHT_PB  | HB_PP_TOKEN_STATIC },
+   { "["    , 1, "["    , HB_PP_TOKEN_LEFT_SB   | HB_PP_TOKEN_STATIC },
+   { "]"    , 1, "]"    , HB_PP_TOKEN_RIGHT_SB  | HB_PP_TOKEN_STATIC },
+   { "{"    , 1, "{"    , HB_PP_TOKEN_LEFT_CB   | HB_PP_TOKEN_STATIC },
+   { "}"    , 1, "}"    , HB_PP_TOKEN_RIGHT_CB  | HB_PP_TOKEN_STATIC },
+   { ","    , 1, ","    , HB_PP_TOKEN_COMMA     | HB_PP_TOKEN_STATIC },
+   { "\\"   , 1, "\\"   , HB_PP_TOKEN_BACKSLASH | HB_PP_TOKEN_STATIC },
+   { "|"    , 1, "|"    , HB_PP_TOKEN_PIPE      | HB_PP_TOKEN_STATIC },
+   { "."    , 1, "."    , HB_PP_TOKEN_DOT       | HB_PP_TOKEN_STATIC },
+   { "&"    , 1, "&"    , HB_PP_TOKEN_AMPERSAND | HB_PP_TOKEN_STATIC },
+   { ":"    , 1, ":"    , HB_PP_TOKEN_SEND      | HB_PP_TOKEN_STATIC },
+   { "!"    , 1, "!"    , HB_PP_TOKEN_NOT       | HB_PP_TOKEN_STATIC },
+   { "="    , 1, "="    , HB_PP_TOKEN_EQ        | HB_PP_TOKEN_STATIC },
+   { "<"    , 1, "<"    , HB_PP_TOKEN_LT        | HB_PP_TOKEN_STATIC },
+   { ">"    , 1, ">"    , HB_PP_TOKEN_GT        | HB_PP_TOKEN_STATIC },
+   { "#"    , 1, "#"    , HB_PP_TOKEN_HASH      | HB_PP_TOKEN_STATIC },
+   { "$"    , 1, "$"    , HB_PP_TOKEN_IN        | HB_PP_TOKEN_STATIC },
+   { "+"    , 1, "+"    , HB_PP_TOKEN_PLUS      | HB_PP_TOKEN_STATIC },
+   { "-"    , 1, "-"    , HB_PP_TOKEN_MINUS     | HB_PP_TOKEN_STATIC },
+   { "*"    , 1, "*"    , HB_PP_TOKEN_MULT      | HB_PP_TOKEN_STATIC },
+   { "/"    , 1, "/"    , HB_PP_TOKEN_DIV       | HB_PP_TOKEN_STATIC },
+   { "%"    , 1, "%"    , HB_PP_TOKEN_MOD       | HB_PP_TOKEN_STATIC },
+   { "^"    , 1, "^"    , HB_PP_TOKEN_POWER     | HB_PP_TOKEN_STATIC }
+/* unused: ? ~ " ' ` */
+/* not accesible: " ' `  */
+/* illegal in Clipper: ~ */
+};
 
-   if( hb_pp_STD_CH )
+static void hb_pp_disp( PHB_PP_STATE pState, const char * szMessage )
+{
+   if( !pState->pDispFunc )
    {
-      if( *hb_pp_STD_CH > ' ' )
+      printf( "%s", szMessage );
+      fflush( stdout );
+   }
+   else
+      ( pState->pDispFunc )( szMessage );
+}
+
+static void hb_pp_error( PHB_PP_STATE pState, char type, int iError, const char * szParam )
+{
+   char ** szMsgTable = type == 'W' ? hb_pp_szWarnings : hb_pp_szErrors;
+
+   if( pState->pErrorFunc )
+   {
+      if( !pState->fError )
       {
-         hb_comp_pFileName = hb_fsFNameSplit( hb_pp_STD_CH );
-
-         if( hb_comp_pFileName->szName )
-         {
-            char szFileName[_POSIX_PATH_MAX];
-
-            if( !hb_comp_pFileName->szExtension )
-               hb_comp_pFileName->szExtension = ".ch";
-
-            hb_fsFNameMerge( szFileName, hb_comp_pFileName );
-
-            if( ( *pIncludeFunc ) ( szFileName, hb_comp_pIncludePath ) )
-            {
-               hb_pp_Init(  );
-
-               hb_pp_ReadRules(  );
-
-               if( s_kolAddComs || s_kolAddTras || s_kolAddDefs > 3 )
-               {
-                  if( !bQuiet )
-                     printf( "Loaded: %i Commands, %i Translates, %i Defines from: %s\n", s_kolAddComs, s_kolAddTras, s_kolAddDefs - 3, szFileName );
-               }
-               else
-               {
-                  hb_compGenWarning( hb_pp_szWarnings, 'I', HB_PP_WARN_NO_DIRECTIVES, NULL /*szFileName */ , NULL );
-               }
-
-               fclose( hb_comp_files.pLast->handle );
-               hb_xfree( hb_comp_files.pLast->pBuffer );
-               hb_xfree( hb_comp_files.pLast->szFileName );
-               if( hb_comp_files.pLast->yyBuffer )
-               {
-                  hb_compParserStop(  );        /* uses hb_comp_files.pLast */
-               }
-               hb_xfree( hb_comp_files.pLast );
-               hb_comp_files.pLast = NULL;
-               hb_comp_files.iFiles = 0;
-
-               hb_xfree( ( void * ) hb_comp_pFileName );
-               hb_comp_pFileName = NULL;
-            }
-            else
-            {
-               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_CANNOT_OPEN_RULES, szFileName, NULL );
-            }
-         }
-         else
-         {
-            hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_BAD_RULES_FILE_NAME, hb_pp_STD_CH, NULL );
-         }
+         ( pState->pErrorFunc )( szMsgTable, type, iError, szParam, NULL );
+         if( type != 'W' )
+            pState->fError = TRUE;
       }
-      else
-      {
-         if( !bQuiet )
-            printf( "Standard command definitions excluded.\n" );
-
-         hb_pp_Init(  );
-      }
-      hb_xfree( hb_pp_STD_CH );
    }
    else
    {
-      hb_pp_Table(  );
-      hb_pp_Init(  );
+      if( pState->pFile )
+         fprintf( stderr, "(%d) ", pState->pFile->iCurrentLine );
+      fprintf( stderr, "%s: ", type == 'F' ? "Fatal" : type == 'W' ? "Warning" : "Error" );
+      fprintf( stderr, szMsgTable[ iError - 1 ], szParam );
+      fprintf( stderr, "\n" );
+      fflush( stderr );
    }
 }
 
-void hb_pp_Free( void )
+static void hb_pp_operatorsFree( PHB_PP_OPERATOR pOperators, int iOperators )
 {
-   DEFINES *stdef;
-   COMMANDS *stcmd;
-
-   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_Free()" ) );
-
-   while( s_kolAddDefs )
+   PHB_PP_OPERATOR pOperator = pOperators;
+   while( --iOperators >= 0 )
    {
-      stdef = hb_pp_topDefine;
-      if( stdef->pars )
-         hb_xfree( stdef->pars );
-      if( stdef->value )
-         hb_xfree( stdef->value );
-      if( stdef->name )
-         hb_xfree( stdef->name );
-      hb_pp_topDefine = stdef->last;
-      hb_xfree( stdef );
-      s_kolAddDefs--;
-   }
-   while( s_kolAddComs )
-   {
-      stcmd = hb_pp_topCommand;
-      if( stcmd->mpatt )
-         hb_xfree( stcmd->mpatt );
-      if( stcmd->value )
-         hb_xfree( stcmd->value );
-      hb_xfree( stcmd->name );
-      hb_pp_topCommand = stcmd->last;
-      hb_xfree( stcmd );
-      s_kolAddComs--;
-   }
-   while( s_kolAddTras )
-   {
-      stcmd = hb_pp_topTranslate;
-      if( stcmd->mpatt )
-         hb_xfree( stcmd->mpatt );
-      if( stcmd->value )
-         hb_xfree( stcmd->value );
-      hb_xfree( stcmd->name );
-      hb_pp_topTranslate = stcmd->last;
-      hb_xfree( stcmd );
-      s_kolAddTras--;
-   }
-   if( hb_pp_aCondCompile )
-   {
-      hb_xfree( ( void * ) hb_pp_aCondCompile );
-      hb_pp_aCondCompile = NULL;
-   }
-   hb_pp_InternalFree(  );
-   
-   if( s_expreal )
-   {
-      hb_xfree( ( void *) s_expreal );
-      s_expreal = NULL;
-   }
-   if( s_expcopy )
-   {
-      hb_xfree( ( void *) s_expcopy );
-      s_expcopy = NULL;
+      hb_xfree( pOperator->name );
+      hb_xfree( pOperator->value );
+      ++pOperator;
    }
+   hb_xfree( pOperators );
 }
 
-void hb_pp_Init( void )
+static PHB_PP_OPERATOR hb_pp_operatorFind( PHB_PP_STATE pState,
+                                           char * buffer, ULONG ulLen )
 {
-   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_Init()" ) );
-
-   hb_pp_Free(  );
-
-   s_ParseState = 0;
-   s_maxCondCompile = 5;
-   s_bReplacePat = TRUE;
-   s_prevchar = 'A';
-
-   if( !hb_pp_aCondCompile )
-      hb_pp_aCondCompile = ( int * ) hb_xgrab( sizeof( int ) * 5 );
-
-   hb_pp_nCondCompile = 0;
+   PHB_PP_OPERATOR pOperator = pState->pOperators;
+   int i = pState->iOperators;
 
+   while( --i >= 0 )
    {
-      char sOS[64];
-      char sVer[64];
-      char *pSrc, *pDst;
-      char *szPlatform = hb_verPlatform(  );
-      int n;
+      if( pOperator->len <= ulLen &&
+          hb_strnicmp( pOperator->name, buffer, pOperator->len ) == 0 )
+         return pOperator;
 
-      strcpy( sOS, "__PLATFORM__" );
-
-      pSrc = szPlatform;
-      n = strlen( sOS );
-      pDst = sOS;
-
-      while( *pSrc && *pSrc != ' ' && n < ( int ) sizeof( sOS ) - 1 )
-      {
-         if( *pSrc == '_' || ( *pSrc >= 'A' && *pSrc <= 'Z' ) || ( *pSrc >= 'a' && *pSrc <= 'z' ) || ( *pSrc >= '0' && *pSrc <= '9' ) )
-         {
-            pDst[n++] = *pSrc;
-         }
-         pSrc++;
-      }
-      pDst[n] = 0;
-
-      n = 0;
-      pDst = sVer;
-      pDst[n++] = '"';
-      if( *pSrc == ' ' )
-      {
-         while( *( ++pSrc ) && n < ( int ) sizeof( sVer ) - 2 )
-            pDst[n++] = *pSrc;
-      }
-      pDst[n++] = '"';
-      pDst[n] = 0;
-
-      hb_pp_AddDefine( sOS, sVer );
-#ifdef HB_OS_UNIX
-      strcpy( &sOS[12], "UNIX" );
-      hb_pp_AddDefine( sOS, sVer );
-#endif
-      hb_xfree( szPlatform );
+      ++pOperator;
    }
 
+   pOperator = ( PHB_PP_OPERATOR ) s_operators;
+   i = sizeof( s_operators ) / sizeof( HB_PP_OPERATOR );
+
+   do
    {
-      char szResult[6];
-      USHORT usHarbour = ( 256 * HB_VER_MAJOR ) + HB_VER_MINOR;
+      if( pOperator->len <= ulLen &&
+          hb_strnicmp( pOperator->name, buffer, pOperator->len ) == 0 )
+         return pOperator;
 
-      /*
-         This updates __HARBOUR__ on every change of HB_VER_MAJOR / HB_VER_MINOR
-         HIBYTE is the HB_VER_MAJOR value and the LOBYTE is the HB_VER_MINOR value.
-
-         The check below is to ensure that __HARBOUR__ gets the
-         value of 1 by default
-       */
-      sprintf( szResult, "%05d", ( usHarbour ? usHarbour : 1 ) );
-      hb_pp_AddDefine( "__HARBOUR__", szResult );
+      ++pOperator;
    }
+   while( --i > 0 );
 
-   {
-      char szResult[11];
-      time_t t;
-      struct tm *oTime;
-
-      time( &t );
-      oTime = localtime( &t );
-
-      sprintf( szResult, "\"%04d%02d%02d\"", oTime->tm_year + 1900, oTime->tm_mon + 1, oTime->tm_mday );
-      hb_pp_AddDefine( "__DATE__", szResult );
-
-      sprintf( szResult, "\"%02d:%02d:%02d\"", oTime->tm_hour, oTime->tm_min, oTime->tm_sec );
-      hb_pp_AddDefine( "__TIME__", szResult );
-   }
-
-   {
-      char szResult[11];
-
-      sprintf( szResult, "%d", ( int ) sizeof( void * ) );
-#if defined( HB_ARCH_16BIT )
-      hb_pp_AddDefine( "__ARCH16BIT__", szResult );
-#elif defined( HB_ARCH_32BIT )
-      hb_pp_AddDefine( "__ARCH32BIT__", szResult );
-#elif defined( HB_ARCH_64BIT )
-      hb_pp_AddDefine( "__ARCH64BIT__", szResult );
-#endif
-
-#if defined( HB_LITTLE_ENDIAN )
-      hb_pp_AddDefine( "__LITTLE_ENDIAN__", szResult );
-#elif defined( HB_BIG_ENDIAN )
-      hb_pp_AddDefine( "__BIG_ENDIAN__", szResult );
-#elif defined( HB_PDP_ENDIAN )
-      hb_pp_AddDefine( "__PDP_ENDIAN__", szResult );
-#endif
-   }
-
-#ifdef HARBOUR_START_PROCEDURE
-   hb_pp_AddDefine( "__HB_MAIN__", HARBOUR_START_PROCEDURE );
-#endif
-}
-
-/* Table with parse warnings */
-/* NOTE: The first character stores the warning's level that triggers this
- * warning. The warning's level is set by -w<n> command line option.
- */
-
-int hb_pp_ParseDirective( char *sLine )
-{
-   char sDirective[MAX_NAME];
-   char szInclude[_POSIX_PATH_MAX];
-   int i;
-   int bIgnore = 1;
-   char *sParse;
-
-   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_ParseDirective(%s)", sLine ) );
-
-   strotrim( sLine, TRUE );
-   hb_pp_strocpy( sLine, sLine + 1 );
-   sParse = sLine;
-
-   i = NextName( &sLine, sDirective );
-   hb_strupr( sDirective );
-
-   HB_SKIPTABSPACES( sLine );
-
-   if( i == 4 && memcmp( sDirective, "ELSE", 4 ) == 0 )
-   {                            /* ---  #else  --- */
-      if( hb_pp_nCondCompile == 0 )
-         hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_DIRECTIVE_ELSE, NULL, NULL );
-      else if( hb_pp_nCondCompile == 1 || hb_pp_aCondCompile[hb_pp_nCondCompile - 2] )
-         hb_pp_aCondCompile[hb_pp_nCondCompile - 1] = 1 - hb_pp_aCondCompile[hb_pp_nCondCompile - 1];
-   }
-
-   else if( i >= 4 && i <= 5 && memcmp( sDirective, "ENDIF", i ) == 0 )
-   {                            /* --- #endif  --- */
-      if( hb_pp_nCondCompile == 0 )
-         hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_DIRECTIVE_ENDIF, NULL, NULL );
-      else
-         hb_pp_nCondCompile--;
-   }
-
-   else if( i >= 4 && i <= 5 && memcmp( sDirective, "IFDEF", i ) == 0 )
-      ParseIfdef( sLine, TRUE );        /* --- #ifdef  --- */
-
-   else if( i >= 4 && i <= 6 && memcmp( sDirective, "IFNDEF", i ) == 0 )
-      ParseIfdef( sLine, FALSE );       /* --- #ifndef  --- */
-
-   else if( hb_pp_nCondCompile == 0 || hb_pp_aCondCompile[hb_pp_nCondCompile - 1] )
-   {
-      if( i >= 4 && i <= 7 && memcmp( sDirective, "INCLUDE", i ) == 0 )
-      {                         /* --- #include --- */
-         char cDelimChar;
-
-         if( *sLine != '\"' && *sLine != '\'' && *sLine != '<' )
-            hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_WRONG_NAME, NULL, NULL );
-
-         cDelimChar = *sLine;
-         if( cDelimChar == '<' )
-            cDelimChar = '>';
-         else if( cDelimChar == '`' )
-            cDelimChar = '\'';
-
-         sLine++;
-         i = 0;
-         while( *( sLine + i ) != '\0' && *( sLine + i ) != cDelimChar )
-            i++;
-         if( *( sLine + i ) != cDelimChar )
-            hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_WRONG_NAME, NULL, NULL );
-         *( sLine + i ) = '\0';
-
-         if( !OpenInclude( sLine, hb_comp_pIncludePath, hb_comp_pFileName, ( cDelimChar == '>' ), szInclude ) )
-         {
-            if( errno == 0 || errno == EMFILE )
-               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_TOO_MANY_INCLUDES, sLine, NULL );
-            else
-            {
-#if defined(__CYGWIN__) || defined(__IBMCPP__) || defined(__LCC__)
-               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_CANNOT_OPEN, sLine, "" );
-#else
-               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_CANNOT_OPEN, sLine, strerror( errno ) );
-#endif
-            }
-         }
-      }
-
-      else if( i >= 4 && i <= 6 && memcmp( sDirective, "DEFINE", i ) == 0 )
-         hb_pp_ParseDefine( sLine );    /* --- #define  --- */
-
-      else if( i >= 4 && i <= 5 && memcmp( sDirective, "UNDEF", i ) == 0 )
-         ParseUndef( sLine );   /* --- #undef  --- */
-
-      else if( ( i >= 4 && i <= 7 && memcmp( sDirective, "COMMAND", i ) == 0 ) || ( i >= 4 && i <= 8 && memcmp( sDirective, "XCOMMAND", i ) == 0 ) )
-         /* --- #command  --- */
-         ParseCommand( sLine, ( i == 7 ) ? FALSE : TRUE, TRUE );
-
-      else
-         if( ( i >= 4 && i <= 9 && memcmp( sDirective, "TRANSLATE", i ) == 0 )
-             || ( i >= 4 && i <= 10 && memcmp( sDirective, "XTRANSLATE", i ) == 0 ) )
-         /* --- #translate  --- */
-         ParseCommand( sLine, ( i == 9 ) ? FALSE : TRUE, FALSE );
-
-      else if( i >= 4 && i <= 6 && memcmp( sDirective, "STDOUT", i ) == 0 )
-         printf( "%s\n", sLine );       /* --- #stdout  --- */
-
-      else if( i >= 4 && i <= 5 && memcmp( sDirective, "ERROR", i ) == 0 )
-         /* --- #error  --- */
-         hb_compGenError( hb_pp_szErrors, 'E', HB_PP_ERR_EXPLICIT, sLine, NULL );
-
-      else if( i == 4 && memcmp( sDirective, "LINE", 4 ) == 0 )
-         return -1;
-
-      else if( i == 6 && memcmp( sDirective, "PRAGMA", 6 ) == 0 )
-      {
-         hb_pp_strocpy( sParse, sParse + 6 );
-         bIgnore = hb_pp_ParsePragma( sParse ); /* --- #pragma  --- */
-      }
-      else
-         hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_WRONG_DIRECTIVE, sDirective, NULL );
-   }
-   return bIgnore;
-}
-
-int hb_pp_ParseDefine( char *sLine )
-{
-   char defname[MAX_NAME], pars[MAX_NAME + 1];
-   int i, npars = -1;
-   DEFINES *lastdef;
-
-   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_ParseDefine(%s)", sLine ) );
-
-   HB_SKIPTABSPACES( sLine );
-   if( ISNAME( ( BYTE ) * sLine ) )
-   {
-      char *cParams = NULL;
-
-      NextName( &sLine, defname );
-      if( *sLine == '(' )       /* If pseudofunction was found */
-      {
-         int iParLen = 0;
-         int iLen;
-
-         sLine++;
-         HB_SKIPTABSPACES( sLine );
-
-         npars = 0;
-         while( *sLine && *sLine != ')' )
-         {
-            if( ISNAME( ( BYTE ) * sLine ) )
-            {
-               NextName( &sLine, pars );
-               iLen = strlen( pars );
-               if( cParams == NULL )
-               {
-                  /* 'xy0' -> '~xy0' */
-                  cParams = ( char * ) hb_xgrab( iLen + 2 );
-               }
-               else
-               {
-                  /* '~xy0' -> '~xy,~ab0' */
-                  char *cPos;
-
-                  cPos = strstr( cParams, pars );
-                  if( cPos && ( cPos[iLen] == ',' || cPos[iLen] == '\0' ) )
-                  {
-                     cPos--;
-                     if( *cPos == '\001' )
-                        hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_LABEL_DUPL_IN_DEFINE, defname, pars );
-                  }
-                  cParams = ( char * ) hb_xrealloc( cParams, iParLen + iLen + 3 );
-                  cParams[iParLen++] = ',';
-                  cParams[iParLen] = '\0';
-               }
-               cParams[iParLen] = '\001';
-               strcpy( cParams + iParLen + 1, pars );
-               iParLen += iLen + 1;
-               npars++;
-               HB_SKIPTABSPACES( sLine );
-            }
-            else
-               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_LABEL_MISSING_IN_DEFINE, defname, NULL );
-
-            if( *sLine == ',' )
-            {
-               sLine++;
-               HB_SKIPTABSPACES( sLine );
-               if( *sLine == ')' )
-                  hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_LABEL_MISSING_IN_DEFINE, defname, NULL );
-            }
-         }
-         HB_SKIPTABSPACES( sLine );
-         if( *sLine == '\0' )
-            hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_PARE_MISSING_IN_DEFINE, defname, NULL );
-
-         sLine++;
-      }
-
-      HB_SKIPTABSPACES( sLine );
-
-      if( cParams )
-      {
-         char *tmp = cParams;
-         char *cPos;
-         int iPar, iLen, iPos, iOldPos;
-
-         iLen = strlen( sLine );
-         for( i = 0; i < npars; i++ )
-         {
-            /*1z,1y */
-            cPos = strchr( tmp, ',' );
-            if( cPos )
-               iPar = cPos - tmp;
-            else
-               iPar = strlen( tmp );
-            memcpy( pars, tmp, iPar );
-            pars[iPar] = '\0';
-            iOldPos = 0;
-            while( ( iPos = md_strAt( pars + 1, iPar - 1, sLine + iOldPos, TRUE, FALSE, FALSE, MD_STR_AT_IGNORECASE ) ) != 0 )
-            {
-               if( sLine[iOldPos + iPos] != '\001' )
-               {
-                  hb_pp_Stuff( pars, sLine + iOldPos + iPos - 1, iPar, iPar - 1, iLen - iPos - iOldPos );
-                  iLen++;
-               }
-               iOldPos += iPos + iPar;
-            }
-            if( cPos )
-               tmp = cPos + 1;
-         }
-      }
-      lastdef = hb_pp_AddDefine( defname, ( *sLine == '\0' ) ? NULL : sLine );
-
-      if( lastdef )
-      {
-         lastdef->npars = npars;
-         lastdef->pars = cParams;
-      }
-      else if( cParams )
-         hb_xfree( cParams );
-   }
-   else
-      hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_DEFINE_ABSENT, NULL, NULL );
-
-   return 0;
-}
-
-DEFINES *hb_pp_AddDefine( char *defname, char *value )
-{
-   BOOL isNew;
-   DEFINES *stdef;
-   int len = strlen( defname );
-
-   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_AddDefine(%s, %s)", defname, value ) );
-
-   stdef = DefSearch( defname, len, &isNew );
-
-   if( stdef != NULL )
-   {
-      hb_compGenWarning( hb_pp_szWarnings, 'I', HB_PP_WARN_DEFINE_REDEF, defname, NULL );
-
-      if( isNew )
-      {
-         if( stdef->pars )
-            hb_xfree( stdef->pars );
-         if( stdef->value )
-            hb_xfree( stdef->value );
-      }
-      else
-         return NULL;
-   }
-   else
-   {
-      stdef = ( DEFINES * ) hb_xgrab( sizeof( DEFINES ) );
-      stdef->last = hb_pp_topDefine;
-      hb_pp_topDefine = stdef;
-      stdef->name = hb_strdup( defname );
-      stdef->namelen = len;
-      stdef->npars = -1;
-
-      s_kolAddDefs++;
-   }
-
-   stdef->value = ( value == NULL ) ? NULL : hb_strdup( value );
-   stdef->pars = NULL;
-
-   return stdef;
-}
-
-static int ParseUndef( char *sLine )
-{
-   char defname[MAX_NAME];
-   DEFINES *stdef;
-   BOOL isNew;
-   int len;
-
-   HB_TRACE( HB_TR_DEBUG, ( "ParseUndef(%s)", sLine ) );
-
-   NextWord( &sLine, defname, FALSE );
-
-   len = strlen( defname );
-   if( ( stdef = DefSearch( defname, len, &isNew ) ) != NULL )
-   {
-      if( isNew )
-      {
-         if( stdef->pars )
-            hb_xfree( stdef->pars );
-         if( stdef->value )
-            hb_xfree( stdef->value );
-         hb_xfree( stdef->name );
-      }
-      stdef->pars = NULL;
-      stdef->value = NULL;
-      stdef->name = NULL;
-      stdef->namelen = 0;
-   }
-
-   return 0;
-}
-
-static int ParseIfdef( char *sLine, int usl )
-{
-   char defname[MAX_NAME];
-   DEFINES *stdef;
-   int len = 0;
-
-   HB_TRACE( HB_TR_DEBUG, ( "ParseIfdef(%s, %d)", sLine, usl ) );
-
-   if( hb_pp_nCondCompile == 0 || hb_pp_aCondCompile[hb_pp_nCondCompile - 1] )
-   {
-      len = NextWord( &sLine, defname, FALSE );
-      if( *defname == '\0' )
-         hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_DEFINE_ABSENT, NULL, NULL );
-   }
-   if( hb_pp_nCondCompile == s_maxCondCompile )
-   {
-      s_maxCondCompile += 5;
-      hb_pp_aCondCompile = ( int * ) hb_xrealloc( hb_pp_aCondCompile, sizeof( int ) * s_maxCondCompile );
-   }
-   if( hb_pp_nCondCompile == 0 || hb_pp_aCondCompile[hb_pp_nCondCompile - 1] )
-   {
-      if( ( ( stdef = DefSearch( defname, len, NULL ) ) != NULL && usl ) || ( stdef == NULL && !usl ) )
-         hb_pp_aCondCompile[hb_pp_nCondCompile] = 1;
-      else
-         hb_pp_aCondCompile[hb_pp_nCondCompile] = 0;
-   }
-   else
-      hb_pp_aCondCompile[hb_pp_nCondCompile] = 0;
-
-   hb_pp_nCondCompile++;
-
-   return 0;
-}
-
-static DEFINES *DefSearch( char *defname, int len, BOOL * isNew )
-{
-   int kol = 0, j;
-   DEFINES *stdef = hb_pp_topDefine;
-
-   HB_TRACE( HB_TR_DEBUG, ( "DefSearch(%s)", defname ) );
-
-   while( stdef != NULL )
-   {
-      kol++;
-      if( stdef->name != NULL && stdef->namelen == len )
-      {
-         for( j = 0; *( stdef->name + j ) == *( defname + j ) && *( stdef->name + j ) != '\0'; j++ ) ;
-         if( *( stdef->name + j ) == *( defname + j ) )
-         {
-            if( isNew )
-               *isNew = ( s_kolAddDefs >= kol );
-            return stdef;
-         }
-      }
-      stdef = stdef->last;
-   }
    return NULL;
 }
 
-static COMMANDS *ComSearch( char *cmdname, COMMANDS * stcmdStart )
+#define HB_MEMBUF_DEFAULT_SIZE      256
+
+static PHB_MEM_BUFFER hb_membufNew( void )
 {
-   COMMANDS *stcmd = ( stcmdStart ) ? stcmdStart : hb_pp_topCommand;
+   PHB_MEM_BUFFER pBuffer = ( PHB_MEM_BUFFER ) hb_xgrab( sizeof( HB_MEM_BUFFER ) );
 
-   HB_TRACE( HB_TR_DEBUG, ( "ComSearch(%s, %p)", cmdname, stcmdStart ) );
+   pBuffer->ulLen = 0;
+   pBuffer->ulAllocated = HB_MEMBUF_DEFAULT_SIZE;
+   pBuffer->pBufPtr = ( char * ) hb_xgrab( pBuffer->ulAllocated );
 
-   while( stcmd != NULL )
-   {
-      int j;
-
-      for( j = 0; ( *( stcmd->name + j ) == toupper( *( cmdname + j ) ) ) &&
-           ( *( stcmd->name + j ) != '\0' ) && ( ( stcmd->com_or_xcom ) ? 1 : ( j < 4 || ISNAME( ( BYTE ) * ( cmdname + j + 1 ) ) ) ); j++ ) ;
-      if( ( *( stcmd->name + j ) == toupper( *( cmdname + j ) ) )
-          || ( !stcmd->com_or_xcom && j >= 4 && *( stcmd->name + j ) != '\0' && *( cmdname + j ) == '\0' ) )
-         break;
-
-      stcmd = stcmd->last;
-   }
-
-   return stcmd;
+   return pBuffer;
 }
 
-static COMMANDS *TraSearch( char *cmdname, COMMANDS * sttraStart )
+static void hb_membufFree( PHB_MEM_BUFFER pBuffer )
 {
-   int j;
-   COMMANDS *sttra = ( sttraStart ) ? sttraStart : hb_pp_topTranslate;
-
-   HB_TRACE( HB_TR_DEBUG, ( "TraSearch(%s, %p)", cmdname, sttraStart ) );
-
-   while( sttra != NULL )
-   {
-      for( j = 0; *( sttra->name + j ) == toupper( *( cmdname + j ) ) &&
-           *( sttra->name + j ) != '\0' && ( ( sttra->com_or_xcom ) ? 1 : ( j < 4 || ISNAME( ( BYTE ) * ( cmdname + j + 1 ) ) ) ); j++ ) ;
-      if( *( sttra->name + j ) == toupper( *( cmdname + j ) )
-          || ( !sttra->com_or_xcom && j >= 4 && *( sttra->name + j ) != '\0' && *( cmdname + j ) == '\0' ) )
-         break;
-      sttra = sttra->last;
-   }
-   return sttra;
+   hb_xfree( pBuffer->pBufPtr );
+   hb_xfree( pBuffer );
 }
 
-static void ParseCommand( char *sLine, BOOL com_or_xcom, BOOL com_or_tra )
+static void hb_membufFlush( PHB_MEM_BUFFER pBuffer )
 {
-#if !defined(HB_PP_DEBUG_MEMORY)
-   static char mpatt[PATTERN_SIZE];
-#else
-   char *mpatt = ( char * ) hb_xgrab( PATTERN_SIZE );
-#endif
-   char *rpatt;
-
-   char cmdname[MAX_NAME];
-   COMMANDS *stcmd;
-   int mlen, rlen;
-   int ipos;
-
-   /* Ron Pinkas added 2000-12-03 */
-   BOOL bOk = FALSE;
-
-   HB_TRACE( HB_TR_DEBUG, ( "ParseCommand(%s, %d, %d)", sLine, com_or_xcom, com_or_tra ) );
-
-   HB_SKIPTABSPACES( sLine );
-   ipos = 0;
-
-   /* JFL 2000-09-19 */
-   /* This was the original line as Alexander wrote it */
-   /* while( *sLine != '\0' && *sLine != ' ' && *sLine != '\t' && *sLine != '<' && *sLine != '=' && ( *sLine != '(' || ipos == 0 ) ) */
-   /* Now the line #xtranslate = name(.. => will be allowed */
-
-   /* I changed it to the following to allow < and = to be the first char within a translate or xtranslate */
-   while( *sLine != '\0' && *sLine != ' ' && *sLine != '\t'
-          && ( *sLine != '<' || ipos == 0 ) && ( *sLine != '=' || ipos == 0 ) && ( *sLine != '(' || ipos == 0 ) )
-   {
-      /* Ron Pinkas added 2000-01-24 */
-      if( !ISNAME( ( BYTE ) * sLine ) )
-      {
-         if( *sLine == '[' && ipos )
-            break;
-
-         if( IS_2CHAR_OPERATOR( sLine ) )
-         {
-            *( cmdname + ipos++ ) = *sLine++;
-            *( cmdname + ipos++ ) = *sLine++;
-            break;
-         }
-         else
-         {
-            *( cmdname + ipos++ ) = *sLine++;
-            break;
-         }
-      }
-      /* END, Ron Pinkas added 2000-01-24 */
-
-      *( cmdname + ipos++ ) = *sLine++;
-   }
-   *( cmdname + ipos ) = '\0';
-
-   if( !ipos )
-   {
-#if defined(HB_PP_DEBUG_MEMORY)
-      hb_xfree( ( void * ) mpatt );
-#endif
-      return;
-   }
-
-   hb_strupr( cmdname );
-   HB_SKIPTABSPACES( sLine );
-
-   /* Ron Pinkas added 2000-12-03 */
-   ipos = 0;
-   while( *sLine )
-   {
-      mpatt[ipos++] = *sLine;
-
-      if( *sLine == '=' )
-      {
-         int i = ipos;
-
-         sLine++;
-         mpatt[i++] = *sLine;
-
-         while( *sLine && ( *sLine == ' ' || *sLine == '\t' ) )
-         {
-            sLine++;
-            mpatt[i++] = *sLine;
-         }
-
-         if( *sLine == '>' )
-         {
-            ipos = ipos - 2;
-            while( mpatt[ipos] == ' ' || mpatt[ipos] == '\t' )
-            {
-               ipos--;
-            }
-
-            mpatt[ipos + 1] = '\0';
-            sLine++;
-            bOk = TRUE;
-            break;
-         }
-
-         ipos = i;
-      }
-
-      sLine++;
-   }
-   /* End - Ron Pinkas added 2000-12-03 */
-
-   /* Ron Pinkas modified 2000-12-03
-      if( (ipos = hb_strAt( "=>", 2, sLine, strlen(sLine) )) > 0 ) */
-   if( bOk )
-   {
-      /* Ron Pinkas removed 2000-12-03
-         stroncpy( mpatt, sLine, ipos-1 ); */
-
-      mlen = strotrim( mpatt, TRUE );
-
-      /* Ron Pinkas removed 2000-12-03
-         sLine += ipos + 1; */
-
-      HB_SKIPTABSPACES( sLine );
-      /* hb_pp_strocpy( rpatt, sLine ); */
-      rpatt = sLine;
-      rlen = strotrim( rpatt, TRUE );
-
-      ConvertPatterns( mpatt, mlen, rpatt, rlen );
-      RemoveSlash( mpatt );
-      rlen = RemoveSlash( rpatt );
-
-      if( com_or_tra )
-         stcmd = AddCommand( cmdname );
-      else
-         stcmd = AddTranslate( cmdname );
-
-      stcmd->com_or_xcom = com_or_xcom;
-      stcmd->mpatt = hb_strdup( mpatt );
-      stcmd->value = ( rlen > 0 ) ? hb_strdup( rpatt ) : NULL;
-   }
-   else
-   {
-      sLine -= ( ipos + 1 );
-      hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_COMMAND_DEFINITION, cmdname, sLine );
-   }
-#if defined(HB_PP_DEBUG_MEMORY)
-   hb_xfree( ( void * ) mpatt );
-#endif
+   pBuffer->ulLen = 0;
 }
 
-/* Remove escape characters and check '[' optional markers
-*/
-static int ConvertOptional( char *cpatt, int len, BOOL bLeft )
+static ULONG hb_membufLen( PHB_MEM_BUFFER pBuffer )
 {
-   int i = 0;
-
-   while( cpatt[i] != '\0' )
-   {
-      if( cpatt[i] == '"' || cpatt[i] == '\'' )
-      {
-         char c = cpatt[i];
-
-         i++;
-         while( cpatt[i] && cpatt[i] != c )
-         {
-            i++;
-         }
-         i++;
-         continue;              /* skip "strings" */
-      }
-
-      if( cpatt[i] == '[' )
-      {
-         if( i && cpatt[i - 1] == '\\' )
-         {
-            hb_pp_Stuff( "", cpatt + i - 1, 0, 1, len - i + 1 );
-            len--;
-            continue;
-         }
-         else
-         {
-            int j = i + 1;
-            int iOpenBrackets = 1;
-            BOOL bOption = FALSE;
-
-            while( cpatt[j] && iOpenBrackets )
-            {
-               if( cpatt[j] == '[' && cpatt[j - 1] != '\\' )
-                  iOpenBrackets++;
-               else if( cpatt[j] == ']' && cpatt[j - 1] != '\\' )
-               {
-                  if( --iOpenBrackets == 0 && ( bOption || bLeft ) )
-                  {
-                     cpatt[i] = HB_PP_OPT_START;
-                     cpatt[j] = HB_PP_OPT_END;
-                  }
-               }
-               else if( cpatt[j] == '<' )
-               {
-                  j++;
-                  while( cpatt[j] == ' ' || cpatt[j] == '\t' )
-                     j++;
-                  if( strchr( "*(!-{.\"", cpatt[j] ) || ISNAME( ( BYTE ) cpatt[j] ) )
-                  {
-                     bOption = TRUE;
-                     continue;
-                  }
-               }
-               else if( cpatt[j] == '"' || cpatt[j] == '\'' )
-               {
-                  char c = cpatt[j];
-
-                  j++;
-                  while( cpatt[j] && cpatt[j] != c )
-                  {
-                     j++;
-                  }
-               }
-               j++;
-            }
-
-            if( iOpenBrackets )
-            {
-               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_PATTERN_DEFINITION, cpatt + i, NULL );
-            }
-         }
-      }
-      else if( cpatt[i] == ']' )
-      {
-         if( i && cpatt[i - 1] == '\\' )
-         {
-            hb_pp_Stuff( "", cpatt + i - 1, 0, 1, len - i + 1 );
-            len--;
-            continue;
-         }
-      }
-      i++;
-   }
-
-   return len;
+   return pBuffer->ulLen;
 }
 
-static void RemoveOptional( char *cpatt )
+static char * hb_membufPtr( PHB_MEM_BUFFER pBuffer )
 {
-   int i = 0;
-   int len = strlen( cpatt );
-   int iOpenBra = 0;
-
-   while( cpatt[i] != '\0' )
-   {
-      if( cpatt[i] == '"' || cpatt[i] == '\'' )
-      {
-         char c = cpatt[i++];
-
-         while( cpatt[i] && cpatt[i] != c )
-         {
-            i++;
-         }
-         if( cpatt[i] )
-            i++;
-         continue;              /* skip "strings" */
-      }
-      if( cpatt[i] == '[' )
-      {
-         i++;
-         iOpenBra++;
-         while( cpatt[i] && iOpenBra )
-         {
-            if( cpatt[i] == '[' )
-               iOpenBra++;
-            else if( cpatt[i] == ']' )
-               iOpenBra--;
-            i++;
-         }
-         continue;              /* skip [strings] */
-      }
-
-      if( cpatt[i] == HB_PP_OPT_START || cpatt[i] == HB_PP_OPT_END )
-      {
-         hb_pp_Stuff( "", cpatt + i, 0, 1, len - i + 1 );
-         len--;
-      }
-      else
-         i++;
-   }
+   return pBuffer->pBufPtr;
 }
 
-
-/* ConvertPatterns()
- * Converts result pattern in #command and #translate to inner format
- */
-
-static void ConvertPatterns( char *mpatt, int mlen, char *rpatt, int rlen )
+static void hb_membufAddCh( PHB_MEM_BUFFER pBuffer, char ch )
 {
-   int i = 0, ipos, ifou;
-   int explen, rmlen;
-   char exppatt[MAX_NAME], expreal[5] = "   0";
-   char lastchar = '@', exptype;
-   char *ptr, *ptrtmp;
-
-   HB_TRACE( HB_TR_DEBUG, ( "ConvertPatterns(%s, %d, %s, %d)", mpatt, mlen, rpatt, rlen ) );
-
-   expreal[0] = HB_PP_MATCH_MARK;
-   mlen = ConvertOptional( mpatt, mlen, TRUE ); /* left pattern */
-   rlen = ConvertOptional( rpatt, rlen, FALSE );        /* right pattern */
-
-   while( *( mpatt + i ) != '\0' )
+   if( pBuffer->ulLen == pBuffer->ulAllocated )
    {
-      if( mpatt[i] == '"' || mpatt[i] == '\'' )
-      {
-         char c = mpatt[i];
-
-         i++;
-         while( mpatt[i] && mpatt[i] != c )
-         {
-            i++;
-         }
-         i++;
-         continue;              /* skip "strings" */
-      }
-
-      if( *( mpatt + i ) == '<' )
-      {
-         if( i && mpatt[ i-1 ] == '\\' )
-         {
-            i++;
-            continue;
-         }
-         
-         /* Drag match marker, determine it type */
-         explen = 0;
-         ipos = i;
-         i++;
-         exptype = '0';
-         while( *( mpatt + i ) == ' ' || *( mpatt + i ) == '\t' )
-            i++;
-         if( *( mpatt + i ) == '*' )    /* Wild match marker */
-         {
-            exptype = '3';
-            i++;
-         }
-         else if( *( mpatt + i ) == '(' )       /* Extended expression match marker */
-         {
-            exptype = '4';
-            i++;
-         }
-         else if( *( mpatt + i ) == '!' )       /* Minimal expression match marker */
-         {
-            exptype = '5';
-            i++;
-         }
-         ptr = mpatt + i;
-         while( *ptr != '>' )
-         {
-            if( *ptr == '\0' || *ptr == '<' || *ptr == '[' || *ptr == ']' )
-            {
-               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_PATTERN_DEFINITION, NULL, NULL );
-               return;
-            }
-            ptr++;
-         }
-
-         while( *( mpatt + i ) != '>' )
-         {
-            if( *( mpatt + i ) == ',' ) /* List match marker */
-            {
-               exptype = '1';
-               while( *( mpatt + i ) != '>' )
-                  i++;
-               break;
-            }
-            else if( *( mpatt + i ) == ':' )    /* Restricted match marker */
-            {
-               exptype = '2';
-               *( mpatt + i-- ) = ' ';
-               break;
-            }
-            if( *( mpatt + i ) != ' ' && *( mpatt + i ) != '\t' )
-               *( exppatt + explen++ ) = *( mpatt + i );
-            i++;
-         }
-
-         if( exptype == '3' )
-         {
-            if( *( exppatt + explen - 1 ) == '*' )
-               explen--;
-            else
-               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_PATTERN_DEFINITION, NULL, NULL );
-         }
-         else if( exptype == '4' )
-         {
-            if( *( exppatt + explen - 1 ) == ')' )
-               explen--;
-            else
-               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_PATTERN_DEFINITION, NULL, NULL );
-         }
-         else if( exptype == '5' )
-         {
-            if( *( exppatt + explen - 1 ) == '!' )
-               explen--;
-            else
-               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_PATTERN_DEFINITION, NULL, NULL );
-         }
-
-         rmlen = i - ipos + 1;
-         /* Convert match marker into inner format */
-         lastchar = ( lastchar != 'Z' ) ? ( ( char ) ( ( unsigned int ) lastchar + 1 ) ) : 'a';
-         expreal[1] = lastchar;
-         expreal[2] = exptype;
-         hb_pp_Stuff( expreal, mpatt + ipos, 4, rmlen, mlen - ipos );
-         mlen += 4 - rmlen;
-         i += 4 - rmlen;
-
-         /* Look for appropriate result markers */
-         ptr = rpatt;
-         while( ( ifou = hb_strAt( exppatt, explen, ptr, rlen - ( ptr - rpatt ) ) ) > 0 )
-         {
-            /* Convert result marker into inner format */
-            ifou--;
-            ptr += ifou;
-            ptrtmp = ptr + 1;
-            rmlen = explen;
-            exptype = '0';      /* regular result marker */
-            do
-            {
-               ptr--;
-               rmlen++;
-               ifou--;
-               if( *ptr == '<' )
-                  continue;
-               else if( *ptr == '\"' )
-                  exptype = '2';        /* normal stringify result marker */
-               else if( *ptr == '(' )
-                  exptype = '3';        /* Smart stringify result marker */
-               else if( *ptr == '{' )
-                  exptype = '4';        /* Blockify result marker */
-               else if( *ptr == '.' )
-                  exptype = '5';        /* Logify result marker */
-               else if( *ptr == '-' )
-                  exptype = '6';        /* ommit (remove) result marker */
-               else if( *ptr == ' ' || *ptr == '\t' )
-                  continue;
-               else
-                  ifou = -1;
-            }
-            while( ifou >= 0 && *ptr != '<' && *( ptr - 1 ) != '\\' );
-
-            if( ifou >= 0 && *ptr == '<' )
-            {
-               ptr += rmlen++;
-               while( *ptr != '\0' && *ptr != '>' && *( ptr - 1 ) != '\\' )
-               {
-                  if( *ptr != ' ' && *ptr != '\t' && *ptr != '\"' && *ptr != ')' && *ptr != '}' && *ptr != '.' && *ptr != '-' )
-                  {
-                     ifou = -1;
-                     break;
-                  }
-                  rmlen++;
-                  ptr++;
-               }
-               if( ifou >= 0 && *ptr == '>' )
-               {
-                  ptr -= rmlen;
-                  ptr++;
-                  if( exptype == '0' && *( ptr - 1 ) == '#' && *( ptr - 2 ) != '\\' )
-                  {
-                     exptype = '1';     /* dumb stringify result marker */
-                     ptr--;
-                     rmlen++;
-                  }
-                  expreal[2] = exptype;
-                  hb_pp_Stuff( expreal, ptr, 4, rmlen, rlen + ( rpatt - ptr ) );
-                  rlen += 4 - rmlen;
-               }
-               else
-                  ptr = ptrtmp;
-            }
-            else
-               ptr = ptrtmp;
-         }
-      }
-      i++;
+      pBuffer->ulAllocated <<= 1;
+      pBuffer->pBufPtr = ( char * ) hb_xrealloc( pBuffer->pBufPtr, pBuffer->ulAllocated );
    }
+   pBuffer->pBufPtr[ pBuffer->ulLen++ ] = ch;
 }
 
-static COMMANDS *AddCommand( char *cmdname )
+static void hb_membufAddData( PHB_MEM_BUFFER pBuffer, char * data, ULONG ulLen )
 {
-   COMMANDS *stcmd;
-
-   HB_TRACE( HB_TR_DEBUG, ( "AddCommand(%s)", cmdname ) );
-
-   stcmd = ( COMMANDS * ) hb_xgrab( sizeof( COMMANDS ) );
-   stcmd->last = hb_pp_topCommand;
-   hb_pp_topCommand = stcmd;
-   stcmd->name = hb_strdup( cmdname );
-   stcmd->namelen = strlen( cmdname );
-   s_kolAddComs++;
-   return stcmd;
-}
-
-static COMMANDS *AddTranslate( char *traname )
-{
-   COMMANDS *sttra;
-
-   HB_TRACE( HB_TR_DEBUG, ( "AddTranslate(%s)", traname ) );
-
-   sttra = ( COMMANDS * ) hb_xgrab( sizeof( COMMANDS ) );
-   sttra->last = hb_pp_topTranslate;
-   hb_pp_topTranslate = sttra;
-   sttra->name = hb_strdup( traname );
-   sttra->namelen = strlen( traname );
-   s_kolAddTras++;
-   return sttra;
-}
-
-int hb_pp_ParseExpression( char *sLine, char *sOutLine, BOOL bSplitLines )
-{
-#if !defined(HB_PP_DEBUG_MEMORY)
-   static char rpatt[PATTERN_SIZE];
-#else
-   char *rpatt = ( char * ) hb_xgrab( PATTERN_SIZE );
-#endif
-   char sToken[MAX_NAME];
-   char *ptri, *ptro, *ptrb;
-   int lenToken, i, ipos, isdvig, lens;
-   int ifou;
-   int rezDef, rezTra, rezCom;
-   unsigned int kolpass = 0;
-   DEFINES *stdef;
-   COMMANDS *stcmd;
-
-   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_ParseExpression(%s, %s)", sLine, sOutLine ) );
-
-   do
-   {
-      strotrim( sLine, FALSE );
-
-      rezDef = 0;
-      rezTra = 0;
-      rezCom = 0;
-      isdvig = 0;
-
-      do
-      {
-         ptro = sOutLine;
-         ptri = sLine + isdvig;
-         if( bSplitLines )
-            ipos = md_strAt( ";", 1, ptri, TRUE, FALSE, FALSE, MD_STR_AT_IGNORECASE );
-         else
-            ipos = 0;
-
-         if( ipos > 0 )
-         {
-            *( ptri + ipos - 1 ) = '\0';
-         }
-
-         HB_SKIPTABSPACES( ptri );
-
-         if( *ptri == '#' )
-         {
-            int bIgnore;
-
-            strcpy( rpatt, ptri );
-            bIgnore = hb_pp_ParseDirective( rpatt );
-
-            if( ipos > 0 )
-            {
-               ipos--;
-               *( sLine + isdvig + ipos - 1 ) = ';';
-               *( sLine + isdvig + ipos ) = ' ';
-            }
-
-            lens = strlen( sLine + isdvig );
-            if( bIgnore )
-               hb_pp_Stuff( " ", sLine + isdvig, 0, ( ipos ) ? ipos : lens, lens );
-            else
-               hb_pp_Stuff( rpatt, sLine + isdvig, strlen( rpatt ), ( ipos ) ? ipos : lens, lens );
-
-            if( ipos > 0 )
-            {
-               ipos = 1;
-            }
-         }
-         else
-         {                      /* Look for macros from #define      */
-            while( ( lenToken = NextName( &ptri, sToken ) ) > 0 )
-            {
-#if 0
-               printf( "Token: >%s< Line: >%s<\n", sToken, sLine );
-#endif
-
-               if( ( stdef = DefSearch( sToken, lenToken, NULL ) ) != NULL )
-               {
-                  ptrb = ptri - lenToken;
-
-                  if( ( i = WorkDefine( &ptri, ptro, stdef ) ) >= 0 )
-                  {
-                     rezDef++;
-                     lens = strlen( ptrb );
-
-                     if( ipos > 0 )
-                     {
-                        *( ptrb + lens ) = ';';
-                        lens += strlen( ptrb + lens + 1 );
-                     }
-
-                     hb_pp_Stuff( ptro, ptrb, i, ptri - ptrb, lens + 1 );
-                     if( ipos > 0 )
-                     {
-                        ipos += i - ( ptri - ptrb );
-                        *( sLine + isdvig + ipos - 1 ) = '\0';
-                     }
-                     ptri += i - ( ptri - ptrb );
-                  }
-               }
-            }
-
-            if( rezDef == 0 )
-            {
-               /* Look for definitions from #translate    */
-               stcmd = hb_pp_topTranslate;
-               while( stcmd != NULL )
-               {
-                  ptri = sLine + isdvig;
-                  lenToken = stcmd->namelen;
-
-                  while( ( ifou = md_strAt( stcmd->name, lenToken, ptri, TRUE, FALSE, FALSE, MD_STR_AT_USESUBCASE ) ) > 0 )
-                  {
-                     ptri += ifou - 1;
-
-                     if( ( i = WorkTranslate( ptri + lenToken, ptro, stcmd, &lens ) ) >= 0 )
-                     {
-                        lens += lenToken;
-                        while( lens > 0 && ( *( ptri + lens - 1 ) == ' ' || *( ptri + lens - 1 ) == '\t' ) )
-                        {
-                           lens--;
-                        }
-
-                        if( ipos > 0 )
-                        {
-                           *( sLine + isdvig + ipos - 1 ) = ';';
-                        }
-
-                        hb_pp_Stuff( ptro, ptri, i, lens, strlen( ptri ) );
-                        rezTra = 1;
-
-                        if( ipos > 0 )
-                        {
-                           ipos += i - lens;
-                           *( sLine + isdvig + ipos - 1 ) = '\0';
-                        }
-
-                        ptri += i;
-                     }
-                     else
-                     {
-                        ptri += lenToken;
-                     }
-                  }
-
-                  stcmd = stcmd->last;
-               }
-            }                   /* rezDef == 0 */
-
-            /* Look for definitions from #command      */
-            /* JFL ! Was 3 but insufficient in most cases */
-            /* I know this is a new hardcoded limit ... any better idea's welcome */
-            if( rezDef == 0 && rezTra == 0 && kolpass < 20 )
-            {
-               ptri = sLine + isdvig;
-               HB_SKIPTABSPACES( ptri );
-
-               if( ISNAME( ( BYTE ) * ptri ) )
-               {
-                  NextName( &ptri, sToken );
-               }
-               else
-               {
-                  /* Ron Pinkas commented 2000-01-24
-                     i = 0;
-                     while( *ptri != ' ' && *ptri != '\t' && *ptri != '\0' && *ptri != '\"' && *ptri != '\'' && *ptri != '('  && !ISNAME( ( BYTE ) *ptri ) )
-                     {
-                     *(sToken+i) = *ptri++;
-                     i++;
-                     }
-                     *(sToken+i) = '\0';
-                   */
-
-                  /* Ron Pinkas added 2000-01-24 */
-                  if( IS_2CHAR_OPERATOR( ptri ) )
-                  {
-                     sToken[0] = *ptri++;
-                     sToken[1] = *ptri++;
-                     sToken[2] = '\0';
-                  }
-                  else
-                  {
-                     sToken[0] = *ptri++;
-                     sToken[1] = '\0';
-                  }
-                  /* END, Ron Pinkas added 2000-01-24 */
-               }
-
-               HB_SKIPTABSPACES( ptri );
-
-               if( ( *ptri == '\0'
-                     || ( *ptri != '='
-                          && ( !IsInStr( *ptri, ":/+*-%^" )
-                               || *( ptri + 1 ) != '=' ) && ( *ptri != '-'
-                                                              || *( ptri + 1 ) != '>' ) ) ) && ( stcmd = ComSearch( sToken, NULL ) ) != NULL )
-               {
-                  ptro = sOutLine;
-
-                  i = WorkCommand( ptri, ptro, stcmd );
-                  ptri = sLine + isdvig;
-
-                  if( ipos > 0 )
-                  {
-                     *( ptri + ipos - 1 ) = ';';
-                  }
-
-                  if( i >= 0 )
-                  {
-                     if( isdvig + ipos > 0 )
-                     {
-                        lens = strlen( sLine + isdvig );
-                        hb_pp_Stuff( ptro, sLine + isdvig, i, ( ipos ) ? ipos - 1 : lens, lens );
-
-                        if( ipos > 0 )
-                        {
-                           ipos = i + 1;
-                        }
-                     }
-                     else
-                     {
-                        memcpy( sLine, sOutLine, i + 1 );
-                     }
-                  }
-
-                  rezCom = 1;
-               }
-               else if( ipos > 0 )
-               {
-                  *( sLine + isdvig + ipos - 1 ) = ';';
-               }
-            }
-            else if( ipos > 0 )
-            {
-               *( sLine + isdvig + ipos - 1 ) = ';';
-            }
-         }
-
-         isdvig += ipos;
-      }
-      while( ipos != 0 );
-
-      kolpass++;
-
-      if( kolpass > hb_pp_MaxTranslateCycles && ( rezDef || rezTra || rezCom ) )
-      {
-         hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_RECURSE, NULL, NULL );
-         break;
-      }
-   }
-   while( rezDef || rezTra || rezCom );
-
-   RemoveOptional( sLine );
-   if( *sOutLine )
-   {
-      RemoveOptional( sOutLine );
-   }
-
-#if defined(HB_PP_DEBUG_MEMORY)
-   hb_xfree( ( void * ) rpatt );
-#endif
-   return 0;
-}
-
-static int WorkDefine( char **ptri, char *ptro, DEFINES * stdef )
-{
-   int npars, lens;
-   char *ptr;
-
-   HB_TRACE( HB_TR_DEBUG, ( "WorkDefine(%p, %s, %p)", ptri, ptro, stdef ) );
-
-   if( stdef->npars < 0 )
-   {
-      lens = hb_pp_strocpy( ptro, stdef->value );
-   }
-   else
-   {
-      HB_SKIPTABSPACES( *ptri );
-
-      if( **ptri == '(' )
-      {
-         npars = 0;
-         ptr = *ptri;
-
-         do
-         {
-            ptr++;
-
-            if( NextParm( &ptr, NULL ) > 0 )
-            {
-               npars++;
-            }
-         }
-         while( *ptr != ')' && *ptr != '\0' );
-
-         if( *ptr == ')' && stdef->npars == npars )
-         {
-            /* Ron Pinkas added 2000-11-21 */
-            char *pTmp = ptr + 1;
-
-            while( *pTmp && ( *pTmp == ' ' || *pTmp == '\t' ) )
-            {
-               pTmp++;
-            }
-            if( *pTmp == '[' )
-            {
-               s_bArray = TRUE;
-            }
-            /* END - Ron Pinkas added 2000-11-21 */
-
-            lens = WorkPseudoF( ptri, ptro, stdef );
-         }
-         else
-         {
-            return -1;
-         }
-      }
-      else
-      {
-         return -1;
-      }
-   }
-
-   return lens;
-}
-
-static int WorkPseudoF( char **ptri, char *ptro, DEFINES * stdef )
-{
-   char parfict[MAX_NAME], *ptrreal;
-   char *ptrb;
-   int ipos, ifou, ibeg;
-   int lenfict, lenreal, lenres;
-
-   HB_TRACE( HB_TR_DEBUG, ( "WorkPseudoF(%p, %s, %p)", ptri, ptro, stdef ) );
-
-   lenres = hb_pp_strocpy( ptro, stdef->value );        /* Copying value of macro to destination string  */
-
-   if( stdef->pars )
-   {
-      ipos = 0;
-      ibeg = 0;
-      do                        /* Parsing through parameters */
-      {                         /* in macro definition        */
-         if( *( stdef->pars + ipos ) == ',' || *( stdef->pars + ipos ) == '\0' )
-         {
-            *( parfict + ipos - ibeg ) = '\0';
-            lenfict = ipos - ibeg;
-
-            if( **ptri != ')' )
-            {
-               ( *ptri )++;     /* Get next real parameter */
-               HB_SKIPTABSPACES( *ptri );
-               ptrreal = *ptri;
-               lenreal = NextParm( ptri, NULL );
-
-               ptrb = ptro;
-               while( ( ifou = hb_strAt( parfict, lenfict, ptrb, lenres - ( ptrb - ptro ) ) ) > 0 )
-               {
-                  ptrb = ptrb + ifou - 1;
-                  if( !ISNAME( ( BYTE ) * ( ptrb - 1 ) ) && !ISNAME( ( BYTE ) * ( ptrb + lenfict ) ) )
-                  {
-                     hb_pp_Stuff( ptrreal, ptrb, lenreal, lenfict, lenres + ( ptro - ptrb ) );
-                     lenres += lenreal - lenfict;
-                     ptrb += lenreal;
-                  }
-                  else
-                  {
-                     ptrb++;
-                  }
-               }
-
-               ibeg = ipos + 1;
-            }
-         }
-         else
-         {
-            *( parfict + ipos - ibeg ) = *( stdef->pars + ipos );
-         }
-
-         if( *( stdef->pars + ipos ) == '\0' )
-         {
-            break;
-         }
-
-         ipos++;
-      }
-      while( 1 );
-   }
-   else
-   {
-      while( **ptri != ')' )
-      {
-         ( *ptri )++;
-      }
-   }
-
-   ( *ptri )++;
-
-   return lenres;
-}
-
-static int WorkCommand( char *ptri, char *ptro, COMMANDS * stcmd )
-{
-   int rez;
-   int lenres;
-   char *ptrmp;
-   char *sToken = stcmd->name;
-
-   HB_TRACE( HB_TR_DEBUG, ( "WorkCommand(%s, %s, %p)", ptri, ptro, stcmd ) );
-
-   do
-   {
-      lenres = hb_pp_strocpy( ptro, stcmd->value );     /* Copying result pattern */
-      ptrmp = stcmd->mpatt;     /* Pointer to a match pattern */
-      s_Repeate = 0;
-      s_groupchar = '@';
-      rez = CommandStuff( ptrmp, ptri, ptro, &lenres, TRUE, stcmd->com_or_xcom );
-
-      stcmd = stcmd->last;
-      if( rez < 0 && stcmd != NULL )
-         stcmd = ComSearch( sToken, stcmd );
-   }
-   while( rez < 0 && stcmd != NULL );
-
-   *( ptro + lenres ) = '\0';
-   if( rez >= 0 )
-   {
-      return lenres;
-   }
-   return -1;
-}
-
-static int WorkTranslate( char *ptri, char *ptro, COMMANDS * sttra, int *lens )
-{
-   int rez;
-   int lenres;
-   char *ptrmp;
-   char *sToken = sttra->name;
-
-   HB_TRACE( HB_TR_DEBUG, ( "WorkTranslate(%s, %s, %p, %p)", ptri, ptro, sttra, lens ) );
-
-   do
-   {
-      lenres = hb_pp_strocpy( ptro, sttra->value );
-      ptrmp = sttra->mpatt;
-      s_Repeate = 0;
-      s_groupchar = '@';
-      rez = CommandStuff( ptrmp, ptri, ptro, &lenres, FALSE, sttra->com_or_xcom );
-
-      sttra = sttra->last;
-
-      if( rez < 0 && sttra != NULL )
-      {
-         sttra = TraSearch( sToken, sttra );
-      }
-   }
-   while( rez < 0 && sttra != NULL );
-
-   *( ptro + lenres ) = '\0';
-
-   if( rez >= 0 )
-   {
-      *lens = rez;
-      return lenres;
-   }
-
-   return -1;
-}
-
-#define MAX_OPTIONALS 64
-
-static int CommandStuff( char *ptrmp, char *inputLine, char *ptro, int *lenres, BOOL com_or_tra, BOOL com_or_xcom )
-{
-   BOOL endTranslation = FALSE;
-   int ipos;
-   char *lastopti[MAX_OPTIONALS], *strtopti = NULL, *strtptri = NULL;
-   char *ptri = inputLine, *ptr, tmpname[MAX_NAME];
-   int isWordInside = 0;
-   char szMatch[2];
-   char *cSkipped[MAX_OPTIONALS];
-   int iSkipped = 0;
-
-   /*
-      printf( "MP: >%s<\nIn: >%s<\n", ptrmp, ptri );
-    */
-
-   HB_TRACE( HB_TR_DEBUG, ( "CommandStuff(%s, %s, %s, %p, %d, %d)", ptrmp, inputLine, ptro, lenres, com_or_tra, com_or_xcom ) );
-
-   s_numBrackets = 0;
-   HB_SKIPTABSPACES( ptri );
-   if( ptrmp == NULL )
-   {
-      if( *ptri != '\0' )
-         return -1;
-   }
-   else
-   {
-      while( *ptri != '\0' && !endTranslation )
-      {
-         HB_SKIPTABSPACES( ptrmp );
-         if( *ptrmp == HB_PP_OPT_START && !s_numBrackets && !strtopti )
-         {
-            /* Store start position of outermost optional in pattern */
-            strtopti = ptrmp;
-         }
-         if( !s_numBrackets && strtopti && strtptri != ptri && 
-             ( ISNAME( ( BYTE ) * ptri ) || *ptri == '&' ) )
-         {
-            /* Input stream starts with a word or macro -store the position
-             * which matches the outermost optional in pattern
-             */
-            strtptri = ptri;
-            ptrmp = strtopti;
-            ptr = ptri;
-            ipos = NextName( &ptr, tmpname );   /* get starting keyword */
-            ipos = md_strAt( tmpname, ipos, strtopti, TRUE, TRUE, TRUE, MD_STR_AT_USESUBCASE );
-            if( ipos && TestOptional( strtopti, strtopti + ipos - 2 ) )
-            {
-               /* the keyword from input is found in the pattern */
-               ptr = PrevSquare( strtopti + ipos - 2, strtopti, NULL );
-               if( ptr )
-                  ptrmp = ptr;
-               if( ptr != strtopti )
-               {
-                  cSkipped[ iSkipped++ ] = strtopti;
-               }
-            }
-         }
-
-         switch ( *ptrmp )
-         {
-            case HB_PP_OPT_START:
-               if( !s_numBrackets )
-                  isWordInside = 0;
-               s_numBrackets++;
-               s_aIsRepeate[s_Repeate] = 0;
-               lastopti[s_Repeate++] = ptrmp;
-               ptrmp++;
-               if( !CheckOptional( ptrmp, ptri, ptro, lenres, com_or_tra, com_or_xcom ) )
-               {
-                  SkipOptional( &ptrmp );
-               }
-               break;
-
-            case HB_PP_OPT_END:
-               if( s_Repeate )
-               {
-                  s_Repeate--;
-                  if( s_aIsRepeate[s_Repeate] )
-                  {
-                     if( ISNAME( ( BYTE ) * ptri ) )
-                     {
-                        ptr = ptri;
-                        ipos = NextName( &ptr, tmpname );
-                        ipos = md_strAt( tmpname, ipos, ptrmp, TRUE, TRUE, TRUE, MD_STR_AT_USESUBCASE );
-                        if( ipos && TestOptional( ptrmp + 1, ptrmp + ipos - 2 ) )
-                        {
-                           ptr = PrevSquare( ptrmp + ipos - 2, ptrmp + 1, NULL );
-                           if( !ptr || CheckOptional( ptrmp + 1, ptri, ptro, lenres, com_or_tra, com_or_xcom ) )
-                           {
-                              ptrmp = lastopti[s_Repeate];
-                              ptrmp++;
-                              s_Repeate++;
-                              SkipOptional( &ptrmp );
-                              s_numBrackets++;
-                              ptrmp++;
-                              strtptri = ptri;
-                           }
-                           else
-                              ptrmp = lastopti[s_Repeate];
-                        }
-                        else
-                        {
-                           ptrmp = lastopti[s_Repeate];
-                        }
-                     }
-                     else
-                     {
-                        ptrmp = lastopti[s_Repeate];
-                     }
-                  }
-                  else
-                  {
-                     if( !isWordInside )
-                        strtopti = NULL;
-                     ptrmp++;
-                  }
-                  s_numBrackets--;
-               }
-               else
-               {
-                  if( !isWordInside )
-                     strtopti = NULL;
-                  s_numBrackets--;
-                  ptrmp++;
-               }
-               break;
-
-            case ',':
-               if( s_numBrackets == 1 )
-                  isWordInside = 1;
-               if( !s_numBrackets )
-                  strtopti = NULL;
-               if( *ptri == ',' )
-               {
-                  ptrmp++;
-                  ptri++;
-               }
-               else
-               {
-                  if( s_numBrackets )
-                  {
-                     SkipOptional( &ptrmp );
-                  }
-                  else
-                     return -1;
-               }
-               break;
-
-            case HB_PP_MATCH_MARK:     /*  Match marker */
-               if( !s_numBrackets )
-                  strtopti = NULL;
-               if( s_numBrackets == 1 && *( ptrmp + 2 ) == '2' )
-                  isWordInside = 1;     /*  restricted match marker  */
-               if( ! WorkMarkers( &ptrmp, &ptri, ptro, lenres, com_or_tra, com_or_xcom ) )
-               {
-                  if( s_numBrackets )
-                  {
-                     SkipOptional( &ptrmp );
-                  }
-                  else
-                     return -1;
-               }
-               break;
-
-            case '\0':
-               if( iSkipped )
-               {
-                  ptrmp = cSkipped[ --iSkipped ];
-                  break;
-               }
-               if( com_or_tra )
-                  return -1;
-               else
-                  endTranslation = TRUE;
-               break;
-
-            default:           /*   Key word    */
-               if( s_numBrackets == 1 )
-                  isWordInside = 1;
-               if( !s_numBrackets )
-                  strtopti = NULL;
-               ptr = ptri;
-               if( *ptri == ',' || truncmp( &ptri, &ptrmp, !com_or_xcom ) )
-               {
-                  ptri = ptr;
-                  if( s_numBrackets )
-                  {
-                     SkipOptional( &ptrmp );
-                  }
-                  else 
-                     return -1;
-               }
-         }
-         HB_SKIPTABSPACES( ptri );
-      };
-   }
-
-   if( *ptrmp != '\0' )
-   {
-      if( s_Repeate )
-      {
-         s_Repeate = 0;
-         ptrmp = lastopti[0];
-      }
-      s_numBrackets = 0;
-      do
-      {
-         HB_SKIPTABSPACES( ptrmp );
-         if( *ptrmp != '\0' )
-            switch ( *ptrmp )
-            {
-               case HB_PP_OPT_START:
-                  ptrmp++;
-                  SkipOptional( &ptrmp );
-                  ptrmp++;
-                  break;
-               case HB_PP_OPT_END:
-                  ptrmp++;
-                  break;
-               default:
-                  return -1;
-            }
-      }
-      while( *ptrmp != '\0' );
-   }
-
-   szMatch[0] = HB_PP_MATCH_MARK;
-   szMatch[1] = '\0';
-   SearnRep( szMatch, "", 0, ptro, lenres );
-   *( ptro + *lenres ) = '\0';
-
-   if( com_or_tra )
-      return 1;
-   else
-      return ( ptri - inputLine );
-}
-
-static int RemoveSlash( char *cpatt )
-{
-   int i = 0;
-   int lenres = strlen( cpatt );
-
-   while( cpatt[i] != '\0' )
-   {
-      if( cpatt[i] == '"' || cpatt[i] == '\'' )
-      {
-         char c = cpatt[i];
-
-         i++;
-         while( cpatt[i] && cpatt[i] != c )
-         {
-            i++;
-         }
-         i++;
-         continue;              /* skip "strings" */
-      }
-      if( cpatt[i] == '[' )
-      {
-         i++;
-         while( cpatt[i] && cpatt[i] != ']' )
-         {
-            i++;
-         }
-         i++;
-         continue;              /* skip [strings] */
-      }
-
-      if( cpatt[i] == '\\' )
-      {
-         hb_pp_Stuff( "", cpatt + i, 0, 1, lenres - i + 1 );
-         lenres--;
-         i++;
-      }
-      else
-         i++;
-   }
-   return lenres;
-}
-
-static int WorkMarkers( char **ptrmp, char **ptri, char *ptro, int *lenres, BOOL com_or_tra, BOOL com_or_xcom )
-{
-#if ! defined(HB_PP_DEBUG_MEMORY)
-   char exppatt[MAX_NAME];
-#else
-   char *exppatt = ( char * ) hb_xgrab( MAX_NAME );
-#endif
-   int lenreal = 0, maxlenreal, lenpatt;
-   int rezrestr, ipos, nBra;
-   char *ptr, *ptrtemp;
-
-   HB_TRACE( HB_TR_DEBUG, ( "WorkMarkers(%p, %p, %s, %p)", ptrmp, ptri, ptro, lenres ) );
-
-   
-   maxlenreal = HB_PP_STR_SIZE;
-   if( s_expreal == NULL )
-      s_expreal = ( char * ) hb_xgrab( maxlenreal );
-      
-   /* Copying a match pattern to 'exppatt' */
-   lenpatt = stroncpy( exppatt, *ptrmp, 4 );
-   *ptrmp += 4;
-
-   HB_SKIPTABSPACES( *ptrmp );
-
-   /* JFL removed 12/11/2001 to allow param like (,,3) as allowed by clipper */
-   /*
-      if( **ptri == ',' )
-      {
-      if( s_numBrackets )
-      {
-      return 0;
-      }
-      } */
-
-   ptrtemp = *ptrmp;
-
-   if( *( exppatt + 2 ) != '2' && *ptrtemp == HB_PP_OPT_END )
-   {
-      ptrtemp++;
-      HB_SKIPTABSPACES( ptrtemp );
-
-      while( *ptrtemp == HB_PP_OPT_START )
-      {
-         nBra = 0;
-         ptrtemp++;
-
-         while( ( *ptrtemp != HB_PP_OPT_END || nBra ) && *ptrtemp != '\0' )
-         {
-            if( *ptrtemp == HB_PP_OPT_START )
-            {
-               nBra++;
-            }
-            else if( *ptrtemp == HB_PP_OPT_END )
-            {
-               nBra--;
-            }
-            ptrtemp++;
-         }
-         ptrtemp++;
-
-         HB_SKIPTABSPACES( ptrtemp );
-      }
-   }
-
-   if( *( exppatt + 2 ) != '2' && *ptrtemp != HB_PP_MATCH_MARK
-       && *ptrtemp != ',' && *ptrtemp != HB_PP_OPT_START && *ptrtemp != HB_PP_OPT_END && *ptrtemp != '\0' )
-   {
-      lenreal = strincpy( s_expreal, ptrtemp );
-
-      if( ( ipos = md_strAt( s_expreal, lenreal, *ptri, TRUE, TRUE, FALSE, MD_STR_AT_USESUBCASE ) ) > 0 )
-      {
-         if( ptrtemp > *ptrmp )
-         {
-            if( ipos == 1 )
-            {
-               if( s_numBrackets )
-               {
-#if defined(HB_PP_DEBUG_MEMORY)
-                  hb_xfree( ( void * ) exppatt );
-#endif
-                  return 0;
-               }
-            }
-            else
-            {
-               maxlenreal = ipos;
-               lenreal = 0;
-            }
-         }
-         else
-         {
-            /*
-               printf( "\nFound: '%s' Len: %i In: '%s' At: %i \n", s_expreal, lenreal, *ptri, ipos );
-             */
-
-            lenreal = stroncpy( s_expreal, *ptri, ipos - 1 );
-
-            if( ipos > 1 )
-            {
-               if( *( exppatt + 2 ) == '5' )    /*  ----  Minimal match marker  */
-               {
-                  if( IsIdentifier( s_expreal ) )
-                  {
-                     *ptri += lenreal;
-                  }
-               }
-               else if( isExpres( s_expreal, *( exppatt + 2 ) == '1' ) )
-               {
-                  *ptri += lenreal;
-               }
-            }
-            else
-            {
-               if( s_numBrackets )
-               {
-#if defined(HB_PP_DEBUG_MEMORY)
-                  hb_xfree( ( void * ) exppatt );
-#endif
-                  return 0;
-               }
-               else
-               {
-                  lenreal = 0;
-               }
-            }
-         }
-      }
-      else
-      {
-         if( s_numBrackets )
-         {
-#if defined(HB_PP_DEBUG_MEMORY)
-            hb_xfree( ( void * ) exppatt );
-#endif
-            return 0;
-         }
-         else
-         {
-            lenreal = 0;
-         }
-      }
-   }
-
-   if( *( exppatt + 2 ) == '4' )        /*  ----  extended match marker  */
-   {
-      if( !lenreal )
-         lenreal = getExpReal( s_expreal, ptri, FALSE, maxlenreal, FALSE, FALSE );
-      {
-         SearnRep( exppatt, s_expreal, lenreal, ptro, lenres );
-      }
-   }
-   else if( *( exppatt + 2 ) == '3' )   /*  ----  wild match marker  */
-   {
-      lenreal = hb_pp_strocpy( s_expreal, *ptri );
-      *ptri += lenreal;
-      SearnRep( exppatt, s_expreal, lenreal, ptro, lenres );
-   }
-   else if( *( exppatt + 2 ) == '2' )   /*  ---- restricted match marker  */
-   {
-      while( **ptrmp != '>' )
-      {
-         *( exppatt + lenpatt++ ) = *( ( *ptrmp )++ );
-      }
-      *( exppatt + lenpatt ) = '\0';
-      ( *ptrmp )++;
-
-      ptr = exppatt + 4;
-      rezrestr = 0;
-      while( *ptr != '\0' )
-      {
-         if( *ptr == '&' )
-         {
-            /* rglab: Thu Sep  2 21:30:07 2004
-             * Special Clipper undocumented restricted match marker: 
-             * <x:&>
-             * Clipper accepts the macro variable only here.
-             * eg.
-             * SET FILTER TO &var. 
-             * SET FILTER TO &var.foo
-             * SET FILTER TO &(var) 
-             *
-             * Notice that any expression that starts from the macro
-             * variable is not valid for this marker
-             * eg.
-             * SET FILTER TO &var+1
-             *  the above command is preprocessed by a general rule
-             * that is using smart match marker <(x)>
-             */
-            if( **ptri == '&' )
-            {
-               char * ptrmacro = *ptri; /* save current position */
-               
-               *ptri += 1;
-               HB_SKIPTABSPACES( *ptri );
-               if( **ptri == '(' )      /* macro expression &( expr )  */
-               {
-                  lenreal = getExpReal( s_expreal + 2, ptri, TRUE, maxlenreal, FALSE, TRUE );
-                  if( !( **ptri == '\0' || **ptri == ' ' ) && com_or_tra )
-                     break;
-                  s_expreal[0] = '&';
-                  s_expreal[1] = '(';
-                  lenreal +=3;
-                  s_expreal[lenreal-1] = ')';
-                  SearnRep( exppatt, s_expreal, lenreal, ptro, lenres );
-                  rezrestr = 1;
-               }
-               else
-               {
-                  lenreal = IsMacroVar( *ptri, com_or_tra );
-                  if( lenreal > 0 )
-                  {
-                     if( ! com_or_tra )
-                     {
-                        /* translate */
-                           strncpy( s_expreal + 1, *ptri, lenreal );
-                           s_expreal[0] = '&';
-                           s_expreal[lenreal + 1] = '\0';
-                           *ptri += lenreal;
-                           SearnRep( exppatt, s_expreal, lenreal + 1, ptro, lenres );
-                           rezrestr = 1;
-                           break;
-                     }
-                     else
-                     {
-                        char * ptmp = *ptri + lenreal;
-                        HB_SKIPTABSPACES( ptmp );
-                        if( ! IsInStr( *ptmp, ":/+*-%^=<>[{.," ) || 
-                            (*ptmp && ptmp[0]=='+' && ptmp[1]=='+') ||
-                           (*ptmp && ptmp[0]=='-' && ptmp[1]=='-') )
-                        {
-                        /* NOTE:
-                         * Clipper usually bounds to left the '++' and '--'
-                         * operators which means that the following code:
-                         * #command XCALL <x> <y> => <x>( <y> )
-                         *  XCALL &a ++b
-                         * is preprocessed into:
-                         * &a( ++b )
-                         * However if used with restricted macro match marker:
-                         * #command MCALL <x:&> <y> => <x>( <y> )
-                         * then
-                         *  MCALL &a ++b
-                         * is preprocessed into:
-                         * &a ++( b )
-                        */
-                           strncpy( s_expreal + 1, *ptri, lenreal );
-                           s_expreal[0] = '&';
-                           s_expreal[lenreal + 1] = '\0';
-                           *ptri += lenreal;
-                           SearnRep( exppatt, s_expreal, lenreal + 1, ptro, lenres );
-                           rezrestr = 1;
-                           break;
-                        }
-                        else
-                        {
-#if defined(HB_PP_DEBUG_MEMORY)
-                           hb_xfree( ( void * ) exppatt );
-#endif
-                           *ptri = ptrmacro; /* restore '&' char */
-                           return 0;
-                        }
-                     }
-                  }
-                  else
-                  {
-#if defined(HB_PP_DEBUG_MEMORY)
-                     hb_xfree( ( void * ) exppatt );
-#endif
-                     *ptri -= 1; /* restore '&' char */
-                     return 0;
-                  }
-               }
-               break;
-            }
-            else
-            {
-               ptr++;
-            }
-         }
-         else
-         {
-            HB_SKIPTABSPACES( ptr );
-            /* Comparing real parameter and restriction value */
-            ptrtemp = ptr;
-            if( !strincmp( *ptri, &ptr, !com_or_xcom ) )
-            {
-               lenreal = stroncpy( s_expreal, *ptri, ( ptr - ptrtemp ) );
-               *ptri += lenreal;
-               SearnRep( exppatt, s_expreal, lenreal, ptro, lenres );
-               rezrestr = 1;
-               break;
-            }
-            else
-            {
-               while( *ptr != ',' && *ptr != '\0' )
-               {
-                  ptr++;
-               }
-               if( *ptr == ',' )
-               {
-                  ptr++;
-               }
-            }
-         }
-      }
-      if( rezrestr == 0 )
-      {
-         /* If restricted match marker doesn't correspond to real parameter */
-#if defined(HB_PP_DEBUG_MEMORY)
-         hb_xfree( ( void * ) exppatt );
-#endif
-         return 0;
-      }
-   }
-   else if( *( exppatt + 2 ) == '1' )   /*  ---- list match marker  */
-   {
-      if( !lenreal )
-      {
-         lenreal = getExpReal( s_expreal, ptri, TRUE, maxlenreal, FALSE, FALSE );
-      }
-
-      if( lenreal )
-      {
-         SearnRep( exppatt, s_expreal, lenreal, ptro, lenres );
-      }
-      else
-      {
-#if defined(HB_PP_DEBUG_MEMORY)
-         hb_xfree( ( void * ) exppatt );
-#endif
-         return 0;
-      }
-   }
-   else                         /*  ---- regular match marker  */
-   {
-      /* Copying a real expression to 's_expreal' */
-      if( !lenreal )
-      {
-         lenreal = getExpReal( s_expreal, ptri, FALSE, maxlenreal, FALSE, FALSE );
-      }
-
-      /*
-         printf("Len: %i Pat: %s Exp: %s\n", lenreal, exppatt, s_expreal );
-       */
-
-      if( lenreal )
-      {
-         SearnRep( exppatt, s_expreal, lenreal, ptro, lenres );
-      }
-      else
-      {
-#if defined(HB_PP_DEBUG_MEMORY)
-         hb_xfree( ( void * ) exppatt );
-#endif
-         return 0;
-      }
-   }
-
-#if defined(HB_PP_DEBUG_MEMORY)
-   hb_xfree( ( void * ) exppatt );
-#endif
-   return 1;
-}
-
-static int getExpReal( char *expreal, char **ptri, BOOL prlist, int maxrez, BOOL bStrict, BOOL bInBrackets )
-{
-   int lens = 0;
-   char *sZnaki = "+-=><*/$.:#%!^";
-   int State;
-   int StBr1 = 0, StBr2 = 0, StBr3 = 0;
-   BOOL rez = FALSE;
-   BOOL bMacro = FALSE;
-   BOOL bBrackets = FALSE;
-   char *cStart = expreal;
-   char cLastSep = '\0';
-   char cLastChar = '\0';
-
-   HB_TRACE( HB_TR_DEBUG, ( "getExpReal(%s, %p, %d, %d, %d, %d)", expreal, ptri, prlist, maxrez, bStrict, bInBrackets ) );
-
-   HB_SKIPTABSPACES( *ptri );
-
-   if( **ptri == '(' && bInBrackets )
-   {
-      /* scan expression including start and end brackets */
-      bBrackets = TRUE;
-      ( * ptri )++;
-      prlist = TRUE;
-   }
-   State = ( **ptri == '\'' || **ptri == '\"' || **ptri == '[' ) ? STATE_EXPRES : STATE_ID;
-      
-   while( **ptri != '\0' && !rez && lens < maxrez )
-   {
-      if( State == STATE_EXPRES || ( cLastChar && strchr( "({[.|,$!#=<>^%*/+-", cLastChar ) ) )
-         /* Ron Pinkas added if on State 2001-05-02 to avoid 
-            multiple strings concatination. 
-          */
-      {
-         if( **ptri == '"' )
-         {
-            if( expreal != NULL )
-            {
-               *expreal++ = **ptri;
-            }
-
-            ( *ptri )++;
-            lens++;
-
-            while( **ptri != '\0' && lens < maxrez )
-            {
-               if( expreal != NULL )
-               {
-                  *expreal++ = **ptri;
-               }
-
-               if( **ptri == '"' )
-               {
-                  break;
-               }
-
-               ( *ptri )++;
-               lens++;
-            }
-
-            ( *ptri )++;
-            lens++;
-
-            cLastChar = '"';
-            State = ( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 ) ? STATE_ID_END : STATE_BRACKET;
-            continue;
-         }
-         else if( **ptri == '\'' )
-         {
-            char *pString;
-
-            if( expreal != NULL )
-            {
-               *expreal++ = **ptri;
-            }
-
-            ( *ptri )++;
-            lens++;
-
-            pString = expreal;
-
-            while( **ptri != '\0' && lens < maxrez )
-            {
-               if( expreal != NULL )
-               {
-                  *expreal++ = **ptri;
-               }
-
-               if( **ptri == '\'' )
-               {
-                  break;
-               }
-
-               ( *ptri )++;
-               lens++;
-            }
-
-            if( expreal != NULL )
-            {
-               *( expreal - 1 ) = '\0';
-               if( strchr( pString, '"' ) == NULL )
-               {
-                  *( pString - 1 ) = '"';
-                  *( expreal - 1 ) = '"';
-               }
-               else
-               {
-                  *( expreal - 1 ) = '\'';
-               }
-            }
-
-            ( *ptri )++;
-            lens++;
-
-            cLastChar = '\'';
-            State = ( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 ) ? STATE_ID_END : STATE_BRACKET;
-            continue;
-         }
-         else if( **ptri == '[' )
-            /* ( see below 5-2-2001 
-               && ( State == STATE_EXPRES || ( strchr( ")]}.", cLastChar ) == NULL 
-               && ! ISNAME( ( BYTE ) cLastChar ) ) )
-             */
-         {
-            char *pString;
-
-            if( expreal != NULL )
-            {
-               *expreal++ = **ptri;
-            }
-
-            ( *ptri )++;
-            lens++;
-
-            pString = expreal;
-
-            while( **ptri != '\0' && lens < maxrez )
-            {
-               if( expreal != NULL )
-               {
-                  *expreal++ = **ptri;
-               }
-
-               if( **ptri == ']' )
-               {
-                  break;
-               }
-
-               ( *ptri )++;
-               lens++;
-            }
-
-            if( expreal != NULL )
-            {
-               *( expreal - 1 ) = '\0';
-               if( strchr( pString, '"' ) == NULL )
-               {
-                  *( pString - 1 ) = '"';
-                  *( expreal - 1 ) = '"';
-               }
-               else if( strchr( pString, '\'' ) == NULL )
-               {
-                  *( pString - 1 ) = '\'';
-                  *( expreal - 1 ) = '\'';
-               }
-               else
-               {
-                  *( expreal - 1 ) = ']';
-               }
-            }
-
-            ( *ptri )++;
-            lens++;
-
-            cLastChar = ']';
-            State = ( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 ) ? STATE_ID_END : STATE_BRACKET;
-            continue;
-         }
-         /* Added by Ron Pinkas 2001-05-02 
-            ( removed lots of related scattered logic below! 
-          */
-      }
-      else if( strchr( "'\"", **ptri ) )
-      {
-         /* New String, can't belong to extracted expression. */
-         break;
-      }
-      else if( **ptri == '[' && ( strchr( ")]}.", cLastChar ) == NULL && !ISNAME( ( BYTE ) cLastChar ) ) )      /* New String, can't belong to extracted expression. */
-      {
-         break;
-      }
-      /* End - END - Added by Ron Pinkas 2000-11-05 */
-
-#if 0
-      printf( "State: %i Char:%c\n", State, **ptri );
-#endif
-
-      switch ( State )
-      {
-         case STATE_BRACKET:
-         {
-            if( **ptri == '(' )
-            {
-               StBr1++;
-            }
-            else if( **ptri == '[' )
-            {
-               StBr2++;
-            }
-            else if( **ptri == '{' )
-            {
-               StBr3++;
-            }
-            else if( **ptri == ')' )
-            {
-               StBr1--;
-               if( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 )
-               {
-                     State = STATE_ID_END;
-               }
-            }
-            else if( **ptri == ']' )
-            {
-               StBr2--;
-               if( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 )
-               {
-                  State = STATE_ID_END;
-               }
-            }
-            else if( **ptri == '}' )
-            {
-               StBr3--;
-               if( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 )
-               {
-                  State = STATE_ID_END;
-               }
-            }
-
-            break;
-         }
-
-         case STATE_ID:
-         case STATE_ID_END:
-         {
-            if( ( ( ISNAME( ( BYTE ) ** ptri ) || **ptri == '\\' || **ptri == '&' ) && State == STATE_ID_END ) || **ptri == ',' )
-            {
-               if( **ptri == ',' )
-               {
-                  if( !prlist )
-                  {
-                     rez = TRUE;
-                  }
-                  else
-                  {
-                     State = STATE_EXPRES;
-                  }
-                  cLastSep = ',';
-               }
-               else
-               {
-                  rez = TRUE;
-               }
-            }
-            else if( ( **ptri == '+' && *( *ptri + 1 ) == '+' ) || ( **ptri == '-' && *( *ptri + 1 ) == '-' ) )
-            {
-               cLastChar = **ptri;
-
-               if( expreal )
-               {
-                  *expreal++ = **ptri;
-               }
-               (*ptri)++;
-               lens++;
-
-               if( expreal )
-               {
-                  *expreal++ = **ptri;
-               }
-               (*ptri)++;
-               lens++;
-
-               if( State == STATE_ID )
-               {
-                  // Prefix ONLY when lens == 0 (2) oterwise MUST be a postfix.
-                  if( lens == 2 )
-                  {
-                     while( **ptri == ' ' && lens < maxrez )
-                     {
-                        if( expreal )
-                        {
-                           *expreal++ = **ptri;
-                        }
-                        (*ptri)++;
-                        lens++;
-                     }
-                  }
-                  else
-                  {
-                     State = ( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 )? STATE_ID_END: STATE_BRACKET;
-                  }
-               }
-               continue;
-            }
-            else if( IsInStr( **ptri, sZnaki ) )
-            {
-               cLastSep = ',';
-               /* Ron Pinkas added 2000-06-02 */
-               if( **ptri == '.' && bMacro )
-               {
-                  /* Macro terminator '.' */
-                  if( *( *ptri + 1 ) == ' ' )
-                  {
-                     State = STATE_ID_END;
-                  }
-
-                  bMacro = FALSE;
-
-                  /* Ron Pinkas added 2000-05-03 */
-                  /* Macro terminator is NOT a coninutation char unlike '.' of logical operators, so we don't want it recorded as cLastChar! */
-                  if( expreal != NULL )
-                  {
-                     *expreal++ = **ptri;
-                  }
-                  ( *ptri )++;
-                  lens++;
-                  continue;
-                  /* END - Ron Pinkas added 2000-05-03 */
-               }
-               else if( **ptri == '*' && *( *ptri + 1 ) == '*' )
-               {
-                  /* Clipper replaces ** with ^ operator */
-                  if( expreal != NULL )
-                  {
-                     *expreal++ = '^';
-                  }
-                  ( *ptri ) += 2;
-                  lens++;
-                  cLastChar = '^';
-                  State = STATE_EXPRES;
-                  continue;
-               }
-               else
-                  /* Ron Pinkas end 2000-06-02 */
-                  State = STATE_EXPRES;
-            }
-            else if( **ptri == '(' )
-            {
-               State = STATE_BRACKET;
-               StBr1 = 1;
-            }
-            else if( **ptri == '[' )
-            {
-               StBr2++;
-               State = STATE_BRACKET;
-            }
-            else if( **ptri == '{' )
-            {
-               State = STATE_BRACKET;
-               StBr3 = 1;
-            }
-            else if( **ptri == ')' && StBr1 == 0 )
-            {
-               if( bBrackets )
-               {
-                  ( *ptri )++;
-               }
-               rez = TRUE;
-            }
-            else if( **ptri == ']' && StBr2 == 0 )
-            {
-               rez = TRUE;
-            }
-            else if( **ptri == '}' && StBr3 == 0 )
-            {
-               rez = TRUE;
-            }
-            else if( **ptri == '&' )
-            {
-               bMacro = TRUE;
-            }
-            else if( **ptri == ' ' )
-            {
-               State = STATE_ID_END;
-               bMacro = FALSE;
-            }
-
-            break;
-         }
-
-         case STATE_EXPRES:
-         case STATE_EXPRES_ID:
-         {
-            if( **ptri == '[' )
-            {
-               StBr2++;
-               State = STATE_BRACKET;
-            }
-            else if( ISNAME( ( BYTE ) ** ptri ) )
-            {
-               if( prlist && cLastSep == ' ' )
-               {
-                  State = STATE_ID_END;
-                  rez = TRUE;
-               }
-               else
-                  State = STATE_EXPRES_ID;
-               cLastSep = **ptri;
-            }
-            else if( **ptri == ' ' )
-            {
-               if( !prlist )
-               {
-                  if( State == STATE_EXPRES_ID )
-                  {
-                     State = STATE_ID_END;
-                  }
-                  else if( lens > 2 && ( ( *( *ptri - 2 ) == '+' && *( *ptri - 1 ) == '+' ) || ( *( *ptri - 2 ) == '-' && *( *ptri - 1 ) == '-' ) ) )
-                  {
-                     State = STATE_ID_END;
-                  }
-               }
-               if( cLastSep != ',' )
-                  cLastSep = ' ';
-            }
-            /* Ron Pinkas added 2000-06-14 */
-            else if( **ptri == ')' && StBr1 == 0 )
-            {
-               rez = TRUE;
-            }
-            /* Ron Pinkas end 2000-06-14 */
-            else if( **ptri == '(' )
-            {
-               StBr1++;
-               State = STATE_BRACKET;
-            }
-            else if( **ptri == '{' )
-            {
-               StBr3++;
-               State = STATE_BRACKET;
-            }
-            else if( **ptri == '}' && StBr3 == 0 )
-            {
-               rez = TRUE;
-            }
-            else if( **ptri == ',' )
-            {
-               if( !prlist )
-               {
-                  rez = TRUE;
-                  State = STATE_EXPRES;
-               }
-               cLastSep = ',';
-            }
-            else if( **ptri == '.' && *( *ptri - 2 ) == '.' &&
-                     ( *( *ptri - 1 ) == 'T' || *( *ptri - 1 ) == 'F' || *( *ptri - 1 ) == 't' || *( *ptri - 1 ) == 'f' ) )
-            {
-               State = STATE_ID_END;
-            }
-            else if( **ptri == '&' )
-            {
-               State = STATE_ID;
-               continue;
-            }
-            else
-            {
-               State = STATE_EXPRES;
-               cLastSep = ',';
-            }
-
-            break;
-         }
-      }
-
-      if( !rez )
-      {
-         /* Ron Pinkas added 2000-06-17 */
-         if( **ptri != ' ' && **ptri != '\t' )
-         {
-            cLastChar = **ptri;
-         }
-         /* Ron Pinkas end 2000-06-17 */
-
-         if( expreal != NULL )
-            *expreal++ = **ptri;
-
-         ( *ptri )++;
-         lens++;
-      }
-   }
-   if( !rez && lens >= maxrez )
-   {
-      hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_BUFFER_OVERFLOW, NULL, NULL );
-   }
-
-   if( expreal != NULL && expreal > cStart )
-   {
-      while( *( expreal - 1 ) == ' ' && expreal > cStart )
-      {
-         expreal--;
-         lens--;
-      }
-
-      *expreal = '\0';
-   }
-
-   /* Ron Pinkas added 2000-06-21 */
-   if( bStrict )
-   {
-      if( State == STATE_QUOTE1 || State == STATE_QUOTE2 || State == STATE_QUOTE3 || State == STATE_BRACKET || StBr1 || StBr2 || StBr3 )
-      {
-         /* Alexander should we include this???
-            expreal = NULL;
-          */
-         lens = 0;
-      }
-   }
-   /* Ron Pinkas end 2000-06-21 */
-
-   return lens;
-}
-
-static BOOL isExpres( char *stroka, BOOL prlist )
-{
-   int l1, l2;
-
-   HB_TRACE( HB_TR_DEBUG, ( "isExpres(%s)", stroka ) );
-
-#if 0
-   printf( "Exp: >%s<\n", stroka );
-#endif
-
-   l1 = strlen( stroka );
-   l2 = getExpReal( NULL, &stroka, prlist, HB_PP_STR_SIZE, TRUE, FALSE );
-
-#if 0
-   printf( "Len1: %i Len2: %i RealExp: >%s< Last: %c\n", l1, l2, stroka - l2, ( stroka - l2 )[l1 - 1] );
-#endif
-
-   /* Ron Pinkas modified 2000-06-17 Expression can't be valid if last charcter is one of these: ":/+*-%^=(<>"
-      return ( l1 <= l2 );
-    */
-
-   return ( l1 <= l2 /*&& ! IsInStr( ( stroka - l2 )[l1-1], ":/+*-%^=(<>[{" ) */  );
-}
-
-static BOOL TestOptional( char *ptr1, char *ptr2 )
-{
-   int nbr = 0;
-   BOOL flagname = FALSE;
-   int statevar = 0;
-
-   HB_TRACE( HB_TR_DEBUG, ( "TestOptional(%s, %s)", ptr1, ptr2 ) );
-
-   while( ptr1 <= ptr2 )
-   {
-      if( *ptr1 == HB_PP_OPT_START )
-      {
-         nbr++;
-      }
-      else if( *ptr1 == HB_PP_OPT_END )
-      {
-         if( nbr )
-         {
-            nbr--;
-            flagname = FALSE;
-         }
-         else
-            return 0;
-      }
-      else if( *ptr1 == HB_PP_MATCH_MARK && *( ptr1 + 2 ) == '2' && nbr )
-         statevar = 1;
-      else if( *ptr1 == '>' && statevar )
-         statevar = 0;
-      else if( *ptr1 != ' ' && *ptr1 != '\t' && !statevar )
-      {
-         if( nbr )
-            flagname = TRUE;
-         else
-            return 0;
-      }
-      ptr1++;
-   }
-   /*   if( !flagname )
-      while( *ptr1 != ']' )
-      {
-      if( *ptr1 == '[' || *ptr1 == '\0' ) return 0;
-      ptr1++;
-      } */
-   return !flagname;
-}
-
-static BOOL CheckOptional( char *ptrmp, char *ptri, char *ptro, int *lenres, BOOL com_or_tra, BOOL com_or_xcom )
-{
-   int save_numBr = s_numBrackets, save_Repeate = s_Repeate;
-   BOOL endTranslation = FALSE;
-   BOOL bResult = TRUE;
-   char *lastInputptr[5];
-   char *lastopti[3], *ptr;
-
-   HB_SYMBOL_UNUSED( com_or_tra );
-
-   HB_TRACE( HB_TR_DEBUG, ( "CheckOptional(%s, %s, %s, %p, %d, %d)", ptrmp, ptri, ptro, lenres, com_or_tra, com_or_xcom ) );
-
-   s_bReplacePat = FALSE;
-   lastInputptr[s_Repeate] = ptri;
-   while( *ptri != '\0' && !endTranslation && bResult )
-   {
-      HB_SKIPTABSPACES( ptrmp );
-      switch ( *ptrmp )
-      {
-         case HB_PP_OPT_START:
-            s_numBrackets++;
-            s_aIsRepeate[s_Repeate] = 0;
-            lastInputptr[s_Repeate] = ptri;
-            lastopti[s_Repeate++] = ptrmp;
-            ptrmp++;
-            break;
-
-         case HB_PP_OPT_END:
-            if( s_numBrackets == save_numBr )
-               endTranslation = TRUE;
-            else
-            {
-               if( s_Repeate )
-               {
-                  s_Repeate--;
-                  ptrmp = lastopti[s_Repeate];
-               }
-               else
-                  ptrmp++;
-               s_numBrackets--;
-            }
-            break;
-
-         case ',':
-            if( *ptri == ',' )
-            {
-               ptrmp++;
-               ptri++;
-            }
-            else
-            {
-               if( s_numBrackets - save_numBr > 0 )
-               {
-                  SkipOptional( &ptrmp );
-                  ptri = lastInputptr[s_Repeate];
-               }
-               else
-                  bResult = FALSE;
-            }
-            break;
-
-         case HB_PP_MATCH_MARK:        /*  Match marker */
-            if( !WorkMarkers( &ptrmp, &ptri, ptro, lenres, com_or_tra, com_or_xcom ) )
-            {
-               if( s_numBrackets - save_numBr > 0 )
-               {
-                  SkipOptional( &ptrmp );
-                  ptri = lastInputptr[s_Repeate];
-               }
-               else
-                  bResult = FALSE;
-            }
-            break;
-
-         case '\0':
-            bResult = FALSE;
-
-         default:              /*   Key word    */
-            ptr = ptri;
-            if( *ptri == ',' || truncmp( &ptri, &ptrmp, !com_or_xcom ) )
-            {
-               ptri = ptr;
-               if( s_numBrackets - save_numBr > 0 )
-               {
-                  SkipOptional( &ptrmp );
-                  ptri = lastInputptr[s_Repeate];
-               }
-               else
-                  bResult = FALSE;
-            }
-      }
-      HB_SKIPTABSPACES( ptri );
-   };
-
-   if( *ptri == '\0' )
+   if( pBuffer->ulLen + ulLen > pBuffer->ulAllocated )
    {
       do
       {
-         HB_SKIPTABSPACES( ptrmp );
-         if( *ptrmp == HB_PP_OPT_START )
-         {
-            ptrmp++;
-            SkipOptional( &ptrmp );
-         }
-         else if( *ptrmp == HB_PP_OPT_END )
-            break;
-         else
-         {
-            bResult = 0;
-            break;
-         }
+         pBuffer->ulAllocated <<= 1;
       }
-      while( 1 );
+      while( pBuffer->ulLen + ulLen > pBuffer->ulAllocated );
+      pBuffer->pBufPtr = ( char * ) hb_xrealloc( pBuffer->pBufPtr, pBuffer->ulAllocated );
    }
-   s_Repeate = save_Repeate;
-   s_numBrackets = save_numBr;
-   s_bReplacePat = TRUE;
-   return bResult;
+
+   memcpy( &pBuffer->pBufPtr[ pBuffer->ulLen ], data, ulLen );
+   pBuffer->ulLen += ulLen;
 }
 
-static void SkipOptional( char **ptri )
+static void hb_membufAddStr( PHB_MEM_BUFFER pBuffer, char * szText )
 {
-   int nbr = 0;
+   hb_membufAddData( pBuffer, szText, strlen( szText ) );
+}
 
-   HB_TRACE( HB_TR_DEBUG, ( "SkipOptional(%p)", ptri ) );
-
-   while( **ptri != HB_PP_OPT_END || nbr )
+static void hb_pp_tokenFree( PHB_PP_TOKEN pToken )
+{
+   if( HB_PP_TOKEN_ALLOC( pToken->type ) )
+      hb_xfree( pToken->value );
+   if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_MMARKER_RESTRICT ||
+       HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_MMARKER_OPTIONAL ||
+       HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_RMARKER_OPTIONAL )
    {
-      switch ( **ptri )
+      while( pToken->pMTokens )
       {
-         case HB_PP_OPT_START:
-            nbr++;
-            break;
-         case HB_PP_OPT_END:
-            nbr--;
-            break;
-         case HB_PP_MATCH_MARK:
-            ( *ptri ) += 3;
-            if( *( *ptri - 1 ) == '2' )
-               while( **ptri != '>' )
-                  ( *ptri )++;
-            break;
+         PHB_PP_TOKEN pMTokens = pToken->pMTokens;
+         pToken->pMTokens = pMTokens->pNext;
+         hb_pp_tokenFree( pMTokens );
       }
-      ( *ptri )++;
    }
-   if( **ptri == HB_PP_OPT_END && s_numBrackets > 0 )
+   hb_xfree( pToken );
+}
+
+static void hb_pp_tokenListFree( PHB_PP_TOKEN * pTokenPtr )
+{
+   if( *pTokenPtr && !HB_PP_TOKEN_ISPREDEF( *pTokenPtr ) )
    {
-      if( s_Repeate )
-         s_Repeate--;
-      s_numBrackets--;
-      ( *ptri )++;
+      do
+      {
+         PHB_PP_TOKEN pToken = *pTokenPtr;
+         *pTokenPtr = pToken->pNext;
+         hb_pp_tokenFree( pToken );
+      }
+      while( *pTokenPtr );
    }
 }
 
-static void SearnRep( char *exppatt, char *expreal, int lenreal, char *ptro, int *lenres )
+static void hb_pp_tokenListFreeCmd( PHB_PP_TOKEN * pTokenPtr )
 {
-   int ifou, isdvig = 0;
-   BOOL rezs, bFound = FALSE;
-   int kolmarkers;
-   int lennew, i;
-   char lastchar = '0';
-   char *ptr, *ptr2, *ptrOut = ptro;
+   PHB_PP_TOKEN pToken;
+   BOOL fStop = FALSE;
 
-   HB_TRACE( HB_TR_DEBUG, ( "SearnRep(%s, %s, %d, %s, %p)", exppatt, expreal, lenreal, ptro, lenres ) );
-
-   if( s_expcopy == NULL )
-      s_expcopy = ( char * ) hb_xgrab( HB_PP_STR_SIZE );
-   
-   if( *( exppatt + 1 ) == '\0' )
-      *( ptro + *lenres ) = '\0';
-
-   while( ( ifou = md_strAt( exppatt, ( *( exppatt + 1 ) ) ? 2 : 1, ptrOut, FALSE, FALSE, TRUE, MD_STR_AT_USESUBCASE ) ) > 0 )
+   while( *pTokenPtr && !fStop )
    {
-      bFound = TRUE;
-      rezs = FALSE;
-      ptr = ptrOut + ifou - 1;
-      kolmarkers = 0;
-      ptr = PrevSquare( ptr, ptro, &kolmarkers );
-      if( ptr )
+      pToken = *pTokenPtr;
+      *pTokenPtr = pToken->pNext;
+      fStop = HB_PP_TOKEN_ISEOC( pToken );
+      hb_pp_tokenFree( pToken );
+   }
+}
+
+static int hb_pp_tokenMoveCommand( PHB_PP_TOKEN * pDestPtr, PHB_PP_TOKEN * pSrcPtr )
+{
+   PHB_PP_TOKEN pToken;
+   int iLines = 0;
+
+   while( *pSrcPtr )
+   {
+      pToken = *pSrcPtr;
+      *pSrcPtr = pToken->pNext;
+      *pDestPtr = pToken;
+      pDestPtr = &pToken->pNext;
+      if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_EOL )
+         ++iLines;
+      if( HB_PP_TOKEN_ISEOC( pToken ) )
       {
-         if( s_Repeate )
-            s_aIsRepeate[s_Repeate - 1]++;
-         if( !s_bReplacePat )
-            return;
+         break;
+      }
+   }
+   *pDestPtr = NULL;
 
-         ptr2 = ptrOut + ifou + 3;
-         while( *ptr2 != HB_PP_OPT_END || *( ptr2 - 1 ) == '\\' )
-         {
-            if( *ptr2 == HB_PP_MATCH_MARK )
-               kolmarkers++;
-            ptr2++;
-         }
+   return iLines;
+}
 
-         if( s_Repeate && lenreal && kolmarkers && lastchar != '0' && *( ptrOut + ifou + 2 ) == '0' )
-         {
-            isdvig += ifou;
-            rezs = TRUE;
-         }
-         else if( s_Repeate )
-         {
-            if( lenreal == 0 )
-            {
-               if( s_numBrackets >= 2 )
-               {
-                  isdvig += ifou;
-                  continue;
-               }
-               else
-               {
-                  hb_pp_Stuff( "", ptr, 0, ptr2 - ptr + 1, *lenres - ( ptr - ptro ) );
-                  *lenres -= ptr2 - ptr + 1;
-                  isdvig = ptr - ptro;
-                  rezs = TRUE;
-               }
-            }
-            else
-            {
-               lennew = ptr2 - ptr - 1;
+static PHB_PP_TOKEN hb_pp_tokenResultEnd( PHB_PP_TOKEN * pTokenPtr, BOOL fDirect )
+{
+   PHB_PP_TOKEN pNext = NULL;
 
-               if( lennew < HB_PP_STR_SIZE-2 )
-               {
-                  memcpy( s_expcopy, ptr + 1, lennew );
-               }
-               else
-               {
-                  hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_BUFFER_OVERFLOW, NULL, NULL );
-                  return;
-               }
-               *( s_expcopy + lennew++ ) = ' ';
-               *( s_expcopy + lennew ) = '\0';
-               while( ( i = hb_strAt( exppatt, 2, s_expcopy, lennew ) ) > 0 )
-                  lennew += ReplacePattern( exppatt[2], expreal, lenreal, s_expcopy + i - 1, lennew );
-               if( kolmarkers )
-               {
-                  s_groupchar = ( char ) ( ( unsigned int ) s_groupchar + 1 );
-                  for( i = 0; i < lennew; i++ )
-                     if( *( s_expcopy + i ) == HB_PP_MATCH_MARK )
-                     {
-                        *( s_expcopy + i + 3 ) = s_groupchar;
-                        i += 4;
-                     }
-               }
-               hb_pp_Stuff( s_expcopy, ptr, lennew, 0, *lenres - ( ptr - ptro ) );
-               *lenres += lennew;
-               isdvig = ptr - ptro + ( ptr2 - ptr - 1 ) + lennew;
-               rezs = TRUE;
-            }
-         }
-         else if( exppatt[0] == '\001' && exppatt[1] == '\000' )
+#ifdef HB_C52_STRICT
+   HB_SYMBOL_UNUSED( fDirect );
+#endif
+
+   while( *pTokenPtr )
+   {
+      if( HB_PP_TOKEN_ISEOP( * pTokenPtr, fDirect ) )
+      {
+         pNext = *pTokenPtr;
+         *pTokenPtr = NULL;
+         break;
+      }
+      pTokenPtr = &( *pTokenPtr )->pNext;
+   }
+
+   return pNext;
+}
+
+static PHB_PP_TOKEN hb_pp_tokenNew( const char * value, ULONG ulLen,
+                                    int iSpaces, USHORT type )
+{
+   PHB_PP_TOKEN pToken = ( PHB_PP_TOKEN ) hb_xgrab( sizeof( HB_PP_TOKEN ) );
+
+   /* TODO: error on overflow: ulLen >= USHRT_MAX */
+
+   if( HB_PP_TOKEN_ALLOC( type ) )
+   {
+      pToken->value = ( char * ) hb_xgrab( ulLen + 1 );
+      memcpy( pToken->value, value, ulLen );
+      pToken->value[ ulLen ] = '\0';
+   }
+   else
+      pToken->value = ( char * ) value;
+
+   pToken->len    = ( USHORT ) ulLen;
+   pToken->spaces = ( USHORT ) iSpaces;
+   pToken->type   = type;
+   pToken->index  = 0;
+   pToken->pNext  = NULL;
+   pToken->pMTokens = NULL;
+
+   return pToken;
+}
+
+static void hb_pp_tokenSetValue( PHB_PP_TOKEN pToken,
+                                 const char * value, ULONG ulLen )
+{
+   if( HB_PP_TOKEN_ALLOC( pToken->type ) )
+      hb_xfree( pToken->value );
+   pToken->type &= ~HB_PP_TOKEN_STATIC;
+   pToken->value = ( char * ) hb_xgrab( ulLen + 1 );
+   memcpy( pToken->value, value, ulLen );
+   pToken->value[ ulLen ] = '\0';
+   pToken->len = ( USHORT ) ulLen;
+}
+
+static PHB_PP_TOKEN hb_pp_tokenClone( PHB_PP_TOKEN pSource )
+{
+   PHB_PP_TOKEN pDest = ( PHB_PP_TOKEN ) hb_xgrab( sizeof( HB_PP_TOKEN ) );
+
+   memcpy( pDest, pSource, sizeof( HB_PP_TOKEN ) );
+   if( HB_PP_TOKEN_ALLOC( pDest->type ) )
+   {
+      pDest->value = ( char * ) hb_xgrab( pDest->len + 1 );
+      memcpy( pDest->value, pSource->value, pDest->len );
+      pDest->value[ pDest->len ] = '\0';
+   }
+   pDest->pNext  = NULL;
+
+   return pDest;
+}
+
+static void hb_pp_tokenAdd( PHB_PP_TOKEN ** pTokenPtr,
+                            const char * value, ULONG ulLen,
+                            int iSpaces, USHORT type )
+{
+   PHB_PP_TOKEN pToken = hb_pp_tokenNew( value, ulLen, iSpaces, type );
+   ** pTokenPtr = pToken;
+   * pTokenPtr = &pToken->pNext;
+}
+
+static void hb_pp_tokenAddCmdSep( PHB_PP_STATE pState )
+{
+   hb_pp_tokenAdd( &pState->pNextTokenPtr, ";", 1, pState->iSpacesNL, HB_PP_TOKEN_EOC | HB_PP_TOKEN_STATIC );
+   pState->pFile->iTokens++;
+   pState->fNewStatement = TRUE;
+   pState->fCanNextLine = FALSE;
+}
+
+static void hb_pp_tokenAddNext( PHB_PP_STATE pState, const char * value, ULONG ulLen,
+                                USHORT type )
+{
+   if( pState->fCanNextLine )
+      hb_pp_tokenAddCmdSep( pState );
+
+   if( !pState->fDirective && pState->fNewStatement &&
+       ulLen == 1 && * value == '#' )
+   {
+      pState->fDirective = TRUE;
+      value = "#";
+      type = HB_PP_TOKEN_DIRECTIVE | HB_PP_TOKEN_STATIC;
+   }
+
+   hb_pp_tokenAdd( &pState->pNextTokenPtr, value, ulLen, pState->iSpaces, type );
+   pState->pFile->iTokens++;
+   pState->fNewStatement = FALSE;
+
+   pState->iSpaces = 0;
+   pState->iLastType = HB_PP_TOKEN_TYPE( type );
+}
+
+static void hb_pp_tokenAddStreamFunc( PHB_PP_STATE pState, PHB_PP_TOKEN pToken,
+                                      const char * value, ULONG ulLen )
+{
+   while( pToken )
+   {
+      if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_RMARKER_STRDUMP )
+      {
+         if( value )
          {
-            /* final pass to remove optional markers */
-            hb_pp_Stuff( "", ptr, 0, ptr2 - ptr + 1, *lenres - ( ptr - ptro ) );
-            *lenres -= ptr2 - ptr + 1;
-            isdvig = ptr - ptro;
-            rezs = TRUE;
+            hb_pp_tokenAdd( &pState->pNextTokenPtr, value, ulLen, pToken->spaces, HB_PP_TOKEN_STRING );
+            pState->pFile->iTokens++;
          }
       }
-
-      if( !rezs && s_bReplacePat )
+      else
       {
-         if( *( ptrOut + ifou + 2 ) != '0' && *( exppatt + 1 ) )
+         * pState->pNextTokenPtr = hb_pp_tokenClone( pToken );
+         pState->pNextTokenPtr = &( * pState->pNextTokenPtr )->pNext;
+         pState->pFile->iTokens++;
+      }
+      pToken = pToken->pNext;
+   }
+   pState->fNewStatement = TRUE;
+}
+
+static void hb_pp_readLine( PHB_PP_STATE pState )
+{
+   int ch, iLine;
+
+   hb_membufFlush( pState->pBuffer );
+
+   while( TRUE )
+   {
+      if( pState->pFile->pLineBuf )
+      {
+         if( pState->pFile->ulLineBufLen )
          {
-            isdvig = ptrOut - ptro + ifou;
-            do
-            {
-               if( lastchar == '0' )
-                  lastchar = *( ptrOut + ifou + 2 );
-               if( lastchar != *( ptrOut + ifou + 2 ) )
-               {
-                  ifou +=3;
-                  ptrOut = ptrOut + ifou;
-                  continue;
-               }
-               
-               *lenres += ReplacePattern( exppatt[2], expreal, lenreal, ptrOut + ifou - 1, *lenres - ifou + 1 );
-               ptrOut = ptrOut + ifou;
-            }
-            while( ( ifou = md_strAt( exppatt, ( *( exppatt + 1 ) ) ? 2 : 1, ptrOut, FALSE, FALSE, TRUE, MD_STR_AT_USESUBCASE ) ) > 0 );
-            if( ! s_Repeate )
-            {
-               lastchar++;
-               ptrOut = ptro + isdvig;
-               isdvig = 0;
-               continue;
-            }
-            return;
-         }
-         else if( lastchar == '0' )
-         {
-            *lenres += ReplacePattern( (exppatt[1]?exppatt[2]:exppatt[1]), expreal, lenreal, ptrOut + ifou - 1, *lenres - isdvig - ifou + 1 );
-            isdvig += ifou - 1;
+            ch = pState->pFile->pLineBuf[ 0 ];
+            pState->pFile->pLineBuf++;
+            pState->pFile->ulLineBufLen--;
          }
          else
-         {
-            ptrOut += ifou + 1;
-            continue;
-         }
+            break;
+      }
+      else
+         ch = fgetc( pState->pFile->file_in );
+      if( ch == EOF )
+      {
+         pState->pFile->fEof = TRUE;
+         break;
+      }
+      /* In Clipper ^Z works like \n */
+      else if( ch == '\n' || ch == '\x1a' )
+      {
+         break;
+      }
+      /* Clipper strips \r characters even from quoted strings */
+      else if( ch != '\r' )
+      {
+         hb_membufAddCh( pState->pBuffer, ch );
       }
-      else if( !s_bReplacePat )
-         isdvig += ifou;
-      ptrOut = ptro + isdvig;
    }
-   if( !bFound && s_Repeate )
-      s_aIsRepeate[s_Repeate - 1]++;
+   iLine = ++pState->pFile->iCurrentLine / 100;
+   if( !pState->fQuiet &&
+       iLine != pState->pFile->iLastDisp )
+   {
+      char szLine[ 12 ];
+
+      pState->pFile->iLastDisp = iLine;
+      sprintf( szLine, "\r%i00", iLine );
+      hb_pp_disp( pState, szLine );
+   }
 }
 
-static BOOL ScanMacro( char *expreal, int lenitem, int *pNewLen )
+static BOOL hb_pp_hasChar( char ch, char * pBuffer, ULONG ulLen, ULONG * pulAt )
 {
+   ULONG ul = 0;
+   while( ul < ulLen )
+   {
+      if( pBuffer[ ul ] == ch )
+      {
+         * pulAt = ul;
+         return TRUE;
+      }
+      ++ul;
+   }
+   return FALSE;
+}
+
+static BOOL hb_pp_hasCommand( char * pBuffer, ULONG ulLen, ULONG * pulAt, int iCmds, ... )
+{
+   ULONG ul = 0, u;
+   char * cmd;
+   va_list va;
    int i;
 
-   HB_TRACE( HB_TR_DEBUG, ( "ScanMacro(%s, %d, %p)", expreal, lenitem, pNewLen ) );
-
-   expreal++;                   /* skip '&' character */
-   i = 0;
-
-   while( expreal[i] == ' ' || expreal[i] == '\t' )
+   va_start( va, iCmds );
+   for( i = 0; i < iCmds && ul < ulLen; ++i )
    {
-      i++;
+      cmd = va_arg( va, char * );
+      u = strlen( cmd );
+      while( ul < ulLen && HB_PP_ISBLANK( pBuffer[ ul ] ) )
+         ++ul;
+      if( ul + u > ulLen || hb_strnicmp( cmd, pBuffer + ul, u ) != 0 )
+         break;
+      ul += u;
+      if( ul < ulLen && ( HB_PP_ISNEXTIDCHAR( cmd[ u - 1 ] ) ||
+                          HB_PP_ISTEXTCHAR( cmd[ u - 1 ] ) ) &&
+                        ( HB_PP_ISNEXTIDCHAR( pBuffer[ ul ] ) ||
+                          HB_PP_ISTEXTCHAR( pBuffer[ ul ] ) ) )
+         break;
    }
-   if( expreal[i] == '(' )
+   va_end( va );
+
+   if( i == iCmds )
    {
-      *pNewLen = lenitem - 1;
-      return TRUE;
-   }
-   else if( isalpha( ( BYTE ) expreal[i] ) || expreal[i] == '_' )
-   {
-      i++;
-      while( ISNAME( ( BYTE ) expreal[i] ) )
-      {
-         i++;
-      }
-      *pNewLen = i;
-      if( expreal[i] == '.' )
-      {
-         i++;
-      }
-      while( expreal[i] == ' ' || expreal[i] == '\t' )
-      {
-         i++;
-      }
-      if( expreal[i] == '\0' || expreal[i] == ',' || expreal[i] == ')' )   /* || expreal[i] == ' ' )*/
+      while( ul < ulLen && HB_PP_ISBLANK( pBuffer[ ul ] ) )
+         ++ul;
+      if( ul == ulLen || pBuffer[ ul ] == ';' )
       {
+         * pulAt = ul;
          return TRUE;
       }
    }
-   *pNewLen = lenitem;
    return FALSE;
 }
 
-static int pp_Stringify( BOOL bSmart, char **ptro, int *lenres, char *expr, int lenitem )
+static void hb_pp_dumpEnd( PHB_PP_STATE pState )
 {
-   int rmlen = 0;
-   int lenTrim = lenitem;
-   int iAdd = 0;
-   char sQuotes[3] = "\"\"";
-   BOOL bComma = expr[lenitem] == ',';
+   pState->iStreamDump = HB_PP_STREAM_OFF;
+   if( pState->pDumpFunc )
+   {
+      ( pState->pDumpFunc )( hb_membufPtr( pState->pDumpBuffer ),
+                             hb_membufLen( pState->pDumpBuffer ),
+                             pState->iDumpLine );
 
-   while( *expr == ' ' && lenTrim )
-   {
-      expr++;
-      lenTrim--;
-   }
-   while( lenTrim && expr[lenTrim - 1] == ' ' )
-   {
-      lenTrim--;
-   }
-
-   if( !lenTrim )
-   {
-      /* empty string - do nothing unless the comma is required */
-   }
-   else if( *expr == '&' )
-   {
-      /* macro operator */
-      BOOL bSmartMacro;
-      int lennew;
-
-      lennew = lenTrim;
-      bSmartMacro = ScanMacro( expr, lenTrim, &lennew );
-      if( bSmartMacro )
+      /* I do not like it - dump data should be separated from
+         preprocessed .prg code. What is inside DUMP area and
+         how it will be interpreted depends on backend not on
+         PP itself */
+      if( pState->fWritePreprocesed )
       {
-         /* remove macro operator '&' */
-         lenTrim = lennew;
-         hb_pp_Stuff( expr + 1, *ptro, lenTrim, 0, *lenres );
-      }
-      else
-      {
-         /* enclose expression in string markers */
-         iAdd = 2;
-         pp_rQuotes( expr, sQuotes );
-         hb_pp_Stuff( sQuotes, *ptro, iAdd, 0, *lenres );
-         hb_pp_Stuff( expr, *ptro + 1, lenTrim, 0, *lenres + iAdd );
-      }
-   }
-   else if( bSmart && ( *expr == '('
-                        || ( *expr == '\"' && *( expr + lenTrim - 1 ) == '\"' )
-                        || ( *expr == '[' && *( expr + lenTrim - 1 ) == ']' ) || ( *expr == '\'' && *( expr + lenTrim - 1 ) == '\'' ) ) )
-   {
-      /* items enclosed in () "" '' [] leave unchanged */
-      hb_pp_Stuff( expr, *ptro, lenTrim, 0, *lenres );
-   }
-   else
-   {
-      /* enclose expression in string markers */
-      iAdd = 2;
-      pp_rQuotes( expr, sQuotes );
-      hb_pp_Stuff( sQuotes, *ptro, iAdd, 0, *lenres );
-      hb_pp_Stuff( expr, *ptro + 1, lenTrim, 0, *lenres + iAdd );
-   }
-   ( *ptro ) += lenTrim + iAdd;
-   ( *lenres ) += lenTrim + iAdd;
+         int iLines = 0;
+         char * pBuffer;
+         ULONG ulLen;
 
-   if( bComma )
-   {
-      hb_pp_Stuff( ",", *ptro, 1, 0, *lenres );
-      ( *lenres )++;
-      ( *ptro )++;
-      rmlen++;
-   }
-   rmlen += lenTrim + iAdd;
-
-   return rmlen;
-}
-
-static int ReplacePattern( char patttype, char *expreal, int lenreal, char *ptro, int lenres )
-{
-   int rmlen = lenreal, ifou, lenitem;
-   char sQuotes[4] = "\"\",";
-
-   HB_TRACE( HB_TR_DEBUG, ( "ReplacePattern(%c, %s, %d, %s, %p)", patttype, expreal, lenreal, ptro, lenres ) );
-
-   switch ( *( ptro + 2 ) )
-   {
-      case '0':                /* Regular result marker  */
-         hb_pp_Stuff( expreal, ptro, lenreal, 4, lenres );
-         break;
-
-      case '1':                /* Dumb stringify result marker  */
-         pp_rQuotes( expreal, sQuotes );
-         hb_pp_Stuff( sQuotes, ptro, 2, 4, lenres );
-         if( lenreal )
-            hb_pp_Stuff( expreal, ptro + 1, lenreal, 0, lenres );
-         rmlen = lenreal + 2;
-         if( *sQuotes == '[' )
-            hb_pp_NestedLiteralString = TRUE;
-         break;
-
-      case '2':                /* Normal stringify result marker  */
-         hb_pp_Stuff( "", ptro, 0, 4, lenres ); /* remove match marker */
-         lenres -= 4;
-         if( patttype == '1' )  /* list match marker */
+         if( pState->pFile->fGenLineInfo )
+         {
+            fprintf( pState->file_out, "#line %d", pState->iDumpLine );
+            if( pState->pFile->szFileName )
+            {
+               fprintf( pState->file_out, " \"%s\"", pState->pFile->szFileName );
+            }
+            fputc( '\n', pState->file_out );
+            pState->pFile->fGenLineInfo = FALSE;
+         }
+         else if( pState->pFile->iLastLine < pState->iDumpLine )
          {
-            rmlen = 0;
             do
-            {
-               ifou = md_strAt( ",", 1, expreal, FALSE, TRUE, FALSE, MD_STR_AT_IGNORECASE );
-               if( *expreal != '\0' )
-               {
-                  rmlen += pp_Stringify( FALSE, &ptro, &lenres, expreal, ( ( ifou ) ? ifou - 1 : lenreal ) );
-               }
-               expreal += ifou;
-               lenreal -= ifou;
-            }
-            while( ifou > 0 );
+               fputc( '\n', pState->file_out );
+            while( ++pState->pFile->iLastLine < pState->iDumpLine );
          }
-         else
+         pBuffer = hb_membufPtr( pState->pDumpBuffer );
+         ulLen = hb_membufLen( pState->pDumpBuffer );
+         fputs( "#pragma BEGINDUMP\n", pState->file_out );
+         fwrite( pBuffer, sizeof( char ), ulLen, pState->file_out );
+         fputs( "#pragma ENDDUMP\n", pState->file_out );
+
+         while( ulLen-- )
          {
-            rmlen = pp_Stringify( FALSE, &ptro, &lenres, expreal, lenreal );
+            if( *pBuffer++ == '\n' )
+               ++iLines;
          }
-         break;
-
-      case '3':                /* Smart stringify result marker  */
-         hb_pp_Stuff( "", ptro, 0, 4, lenres ); /* remove match marker */
-         lenres -= 4;
-         if( patttype == '1' )  /* list match marker */
-         {
-            rmlen = 0;
-            do
-            {
-               ifou = md_strAt( ",", 1, expreal, FALSE, TRUE, FALSE, MD_STR_AT_IGNORECASE );
-               if( *expreal != '\0' )
-               {
-                  rmlen += pp_Stringify( TRUE, &ptro, &lenres, expreal, ( ( ifou ) ? ifou - 1 : lenreal ) );
-               }
-               expreal += ifou;
-               lenreal -= ifou;
-            }
-            while( ifou > 0 );
-         }
-         else
-         {
-            rmlen = pp_Stringify( TRUE, &ptro, &lenres, expreal, lenreal );
-         }
-         break;
-
-      case '4':                /* Blockify result marker  */
-         if( !lenreal )
-            hb_pp_Stuff( expreal, ptro, lenreal, 4, lenres );
-         else if( patttype == '1' )     /* list match marker */
-         {
-            hb_pp_Stuff( "", ptro, 0, 4, lenres );
-            lenres -= 4;
-            rmlen = 0;
-            do
-            {
-               ifou = md_strAt( ",", 1, expreal, FALSE, TRUE, FALSE, MD_STR_AT_IGNORECASE );
-               lenitem = ( ifou ) ? ifou - 1 : lenreal;
-               if( *expreal != '\0' )
-               {
-                  int i;
-                  
-                  i = ( ifou ) ? 6 : 5;
-                  hb_pp_Stuff( "{|| },", ptro, i, 0, lenres );
-                  hb_pp_Stuff( expreal, ptro + 4, lenitem, 0, lenres + i );
-                  ptro += i + lenitem;
-                  rmlen += i + lenitem;
-               }
-               expreal += ifou;
-               lenreal -= ifou;
-            }
-            while( ifou > 0 );
-         }
-         else if( lenreal && *expreal == '{' )
-         {
-            hb_pp_Stuff( expreal, ptro, lenreal, 4, lenres );
-         }
-         else
-         {
-            hb_pp_Stuff( "{|| }", ptro, 5, 4, lenres );
-            hb_pp_Stuff( expreal, ptro + 4, lenreal, 0, lenres );
-            rmlen = lenreal + 5;
-         }
-         break;
-
-      case '5':                /* Logify result marker  */
-         rmlen = 3;
-         if( !lenreal )
-         {
-            hb_pp_Stuff( ".F.", ptro, 3, 4, lenres );
-         }
-         else
-            hb_pp_Stuff( ".T.", ptro, 3, 4, lenres );
-         break;
-
-      case '6':                /* Ommit result marker  */
-         rmlen = 1;
-         hb_pp_Stuff( " ", ptro, 1, 4, lenres );
-         break;
-   }
-   return rmlen - 4;
-}
-
-static void pp_rQuotes( char *expreal, char *sQuotes )
-{
-   BOOL lQuote1 = FALSE;
-   BOOL lQuote2 = FALSE;
-
-   HB_TRACE( HB_TR_DEBUG, ( "pp_rQuotes(%s, %s)", expreal, sQuotes ) );
-
-   /*
-      printf( "String: >%s< Delim: %s\n", expreal, sQuotes );
-    */
-
-   while( *expreal != '\0' )
-   {
-      if( *expreal == '\"' )
-         lQuote2 = TRUE;
-      else if( *expreal == '\'' )
-         lQuote1 = TRUE;
-      expreal++;
-   }
-   if( lQuote2 )
-   {
-      if( lQuote1 )
-      {
-         *sQuotes = '[';
-         *( sQuotes + 1 ) = ']';
+         pState->pFile->iLastLine = pState->iDumpLine + iLines + 2;
       }
-      else
-      {
-         *sQuotes = '\'';
-         *( sQuotes + 1 ) = '\'';
-      }
-   }
-   else
-   {
-      *sQuotes = '\"';
-      *( sQuotes + 1 ) = '\"';
+      hb_membufFlush( pState->pDumpBuffer );
    }
 }
 
-int hb_pp_RdStr( FILE * handl_i, char *buffer, int maxlen, BOOL lContinue, char *sBuffer, int *lenBuffer, int *iBuffer )
+static void hb_pp_getLine( PHB_PP_STATE pState )
 {
-   int readed = 0;
-   int State = 0;
-   char cha, cLast = '\0', symbLast = '\0';
-   BOOL lDropSpaces = lContinue;
+   char * pBuffer, ch;
+   ULONG ulLen, ul;
+   BOOL fDump = FALSE;
 
-   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_RdStr(%p, %s, %d, %d, %s, %p, %p)", handl_i, buffer, maxlen, lDropSpaces, sBuffer, lenBuffer, iBuffer ) );
+   hb_pp_tokenListFree( &pState->pFile->pTokenList );
+   pState->pNextTokenPtr = &pState->pFile->pTokenList;
+   pState->pFile->iTokens = pState->iSpaces = 0;
+   pState->fCanNextLine = pState->fDirective = FALSE;
+   pState->fNewStatement = TRUE;
+   pState->iLastType = HB_PP_TOKEN_NUL;
 
-   if( *lenBuffer == 0 )
+   do
    {
-      return -1;
-   }
-
-   while( 1 )
-   {
-      if( *iBuffer == *lenBuffer )
+      hb_pp_readLine( pState );
+      pBuffer = hb_membufPtr( pState->pBuffer );
+      ulLen = hb_membufLen( pState->pBuffer );
+      if( pState->fCanNextLine )
       {
-         if( ( *lenBuffer = fread( sBuffer, 1, HB_PP_BUFF_SIZE, handl_i ) ) < 1 )
+         pState->iSpaces = pState->iSpacesNL;
+         pState->fCanNextLine = FALSE;
+         /* Clipper left only last leading blank character from
+            concatenated lines */
+         if( ulLen > 1 && HB_PP_ISBLANK( pBuffer[ 0 ] ) )
          {
-            sBuffer[0] = '\n';
-         }
-         *iBuffer = 0;
-      }
-
-      cha = sBuffer[*iBuffer];
-      ( *iBuffer )++;
-
-      if( cha == '\r' )
-      {
-         cha = ' ';
-      }
-
-      if( cha == '\n' )
-      {
-         if( ( hb_pp_StreamBlock != HB_PP_STREAM_DUMP_C ) && s_ParseState == STATE_COMMENT && symbLast == ';' )
-         {
-            buffer[readed++] = ';';
-         }
-         break;
-      }
-      else
-      {
-         if( hb_pp_StreamBlock == HB_PP_STREAM_DUMP_C )
-         {
-            buffer[readed++] = cha;
-            continue;
+            while( ulLen > 1 && HB_PP_ISBLANK( pBuffer[ 1 ] ) )
+            {
+               --ulLen;
+               ++pBuffer;
+            }
          }
       }
-
-      if( maxlen > 0 )
+      else if( pState->iStreamDump && ulLen == 0 )
       {
-         switch ( s_ParseState )
-         {
-            case STATE_COMMENT:
-               if( cha == '/' && cLast == '*' )
-               {
-                  s_ParseState = STATE_NORMAL;
-                  cha = ' ';
-               }
-
-               cLast = cha;
-
-               if( cha != ' ' && cha != '\t' )
-               {
-                  symbLast = cha;
-               }
-               break;
-
-            case STATE_QUOTE1:
-               if( cha == '\'' )
-                  s_ParseState = STATE_NORMAL;
-               break;
-
-            case STATE_QUOTE2:
-               if( cha == '\"' )
-                  s_ParseState = STATE_NORMAL;
-               break;
-
-            case STATE_QUOTE3:
-               if( cha == ']' )
-                  s_ParseState = STATE_NORMAL;
-               break;
-
-            default:
-               switch ( cha )
-               {
-                  case '[':
-                     /* Ron Pinkas modified 2000-06-17
-                        if( ISNAME(( BYTE ) s_prevchar) || s_prevchar == ']' )
-                      */
-                     if( ISNAME( ( BYTE ) s_prevchar ) || strchr( ")]}.", s_prevchar ) )
-                     {
-                        s_ParseState = STATE_BRACKET;
-                     }
-                     else
-                     {
-                        s_ParseState = STATE_QUOTE3;
-                     }
-                     break;
-
-                  case ']':
-                     s_ParseState = STATE_NORMAL;
-                     break;
-
-                  case '\"':
-                     if( s_ParseState != STATE_BRACKET )
-                     {
-                        s_ParseState = STATE_QUOTE2;
-                     }
-                     break;
-
-                  case '\'':
-                     if( s_ParseState != STATE_BRACKET )
-                     {
-                        s_ParseState = STATE_QUOTE1;
-                     }
-                     break;
-
-                  case '&':
-                     if( readed > 0 && buffer[readed - 1] == '&' )
-                     {
-                        maxlen = 0;
-                        readed--;
-                     }
-                     break;
-
-                  case '/':
-                     if( readed > 0 && buffer[readed - 1] == '/' && !hb_pp_StreamBlock )
-                     {
-                        maxlen = 0;
-                        readed--;
-                     }
-                     break;
-
-                  case '*':
-                     if( readed > 0 && buffer[readed - 1] == '/' && !hb_pp_StreamBlock )
-                     {
-                        s_ParseState = STATE_COMMENT;
-                        readed--;
-                     }
-                     else if( !State && !lContinue )
-                     {
-                        maxlen = readed = 0;
-                     }
-                     break;
-               }
-
-               if( cha != ' ' && cha != ';' )
-               {
-                  s_prevchar = cha;
-               }
-         }
-
-         if( cha != ' ' && cha != '\t' )
-         {
-            State = 1;
-         }
-
-         if( lDropSpaces && State )
-         {
-            lDropSpaces = 0;
-         }
-
-         if( readed < maxlen && ( !lDropSpaces || readed == 0 ) && s_ParseState != STATE_COMMENT )
-         {
-            buffer[readed++] = cha;
-         }
+         pBuffer[ 0 ] = '\0';
+         fDump = TRUE;
       }
-   }
-
-   while( --readed >= 0 && ( buffer[readed] == ' ' || buffer[readed] == '\t' ) ) ;
-
-   if( buffer[readed] != ';' && s_ParseState != STATE_COMMENT )
-   {
-      s_ParseState = STATE_NORMAL;
-   }
-
-   if( maxlen )
-   {
-      if( readed < maxlen )
-         readed++;
-   }
-   else
-      readed++;
-   buffer[readed] = '\0';
-
-#if 0
-   printf( "%s\n", buffer );
-#endif
-
-   return readed;
-}
-
-int hb_pp_WrStr( FILE * handl_o, char *buffer )
-{
-   int lens = strlen( buffer );
-
-   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_WrStr(%p, %s)", handl_o, buffer ) );
-
-   /* Ron Pinkas added 2001-01-20 */
-   if( hb_comp_files.iFiles == 1 )
-   {
-      for( ; hb_pp_LastOutLine < hb_comp_iLine - 1; hb_pp_LastOutLine++ )
+      ul = 0;
+      while( ul < ulLen || fDump )
       {
-         fwrite( "\n", 1, 1, handl_o );
-      }
-      hb_pp_LastOutLine = hb_comp_iLine;
-   }
-   /* END Ron Pinkas added 2001-01-20 */
-
-   fwrite( buffer, lens, 1, handl_o );
-
-   if( *( buffer + lens - 1 ) != '\n' )
-   {
-      fwrite( "\n", 1, 1, handl_o );
-   }
-
-   return 0;
-}
-
-static int md_strAt( char *szSub, int lSubLen, char *szText, BOOL checkword, BOOL checkPrth, BOOL bRule, int iCaseOption )
-{
-   int State = STATE_NORMAL;
-   long lPos = 0, lSubPos = 0;
-   int kolPrth = 0, kolSquare = 0, kolFig = 0;
-   int lCase;
-   int iNestedQuote3 = 0;
-   char cLastChar = '\0';
-
-   HB_TRACE( HB_TR_DEBUG, ( "md_strAt(%s, %d, %s, %d, %d, %d)", szSub, lSubLen, szText, checkword, checkPrth, iCaseOption ) );
-
-   if( iCaseOption == MD_STR_AT_IGNORECASE )
-   {
-      lCase = 0;
-   }
-   else
-   {
-      lCase = ( *szSub == HB_PP_MATCH_MARK ) ? 0 : 1;
-   }
-
-   while( *( szText + lPos ) != '\0' && lSubPos < lSubLen )
-   {
-      if( State == STATE_QUOTE1 )
-      {
-         if( *( szText + lPos ) == '\'' )
+         ch = pBuffer[ 0 ];
+         if( pState->iStreamDump )
          {
-            State = STATE_NORMAL;
-         }
-         lPos++;
-      }
-      else if( State == STATE_QUOTE2 )
-      {
-         if( *( szText + lPos ) == '\"' )
-         {
-            State = STATE_NORMAL;
-         }
-         lPos++;
-      }
-      else if( State == STATE_QUOTE3 )
-      {
-         if( *( szText + lPos ) == ']' )
-         {
-            if( --iNestedQuote3 == 0 )
-               State = STATE_NORMAL;
-         }
-         else if( *( szText + lPos ) == '[' )
-            iNestedQuote3++;
-         lPos++;
-      }
-      else
-      {
-         if( State == STATE_BRACKET )
-         {
-            if( *( szText + lPos ) == ']' && ( lPos == 0 || *( szText + lPos - 1 ) != '\\' ) )
+            fDump = FALSE;
+            if( pState->iStreamDump == HB_PP_STREAM_COMMENT )
             {
-               kolSquare--;
-               if( kolSquare == 0 )
+               if( ulLen > 0 )
                {
-                  State = STATE_NORMAL;
+                  ++ul;
+                  if( ulLen > 1 && ch == '*' && pBuffer[ 1 ] == '/' )
+                  {
+                     pState->iStreamDump = HB_PP_STREAM_OFF;
+                     /* Clipper clear number of leading spaces when multiline
+                        comment ends */
+                     pState->iSpaces = 0;
+                     ++ul;
+                  }
                }
-
-               cLastChar = ']';
-               lPos++;
-               continue;
             }
-            else if( *( szText + lPos ) == '[' && ( lPos == 0 || *( szText + lPos - 1 ) != '\\' ) )
+            else if( pState->iStreamDump == HB_PP_STREAM_DUMP_C )
             {
-               kolSquare++;
-               cLastChar = '[';
-               lPos++;
-               continue;
-            }
-            else if( *( szText + lPos ) == ',' )
-            {
-               cLastChar = ',';
-               lPos++;
-               continue;
-            }
-         }
-         else
-         {
-            if( ( *( szText + lPos ) == '\'' || *( szText + lPos ) == '`' ) && ( lPos == 0 || *( szText + lPos - 1 ) != '\\' ) )
-            {
-               State = STATE_QUOTE1;
-               lPos++;
-               continue;
-            }
-            else if( *( szText + lPos ) == '\"' && ( lPos == 0 || *( szText + lPos - 1 ) != '\\' ) )
-            {
-               State = STATE_QUOTE2;
-               lPos++;
-               continue;
-            }
-            else if( bRule == FALSE && *( szText + lPos ) == '[' && strchr( ")]}.", cLastChar ) == NULL && !ISNAME( ( BYTE ) cLastChar ) )
-            {
-               State = STATE_QUOTE3;
-               iNestedQuote3++;
-               lPos++;
-               continue;
-            }
-            else if( *( szText + lPos ) == '[' && ( lPos == 0 || *( szText + lPos - 1 ) != '\\' ) )
-            {
-               State = STATE_BRACKET;
-               kolSquare++;
-               cLastChar = '[';
-               lPos++;
-               continue;
-            }
-            else if( *( szText + lPos ) == '(' )
-            {
-               kolPrth++;
-            }
-            else if( *( szText + lPos ) == ')' )
-            {
-               kolPrth--;
-            }
-            else if( *( szText + lPos ) == '{' )
-            {
-               kolFig++;
-            }
-            else if( *( szText + lPos ) == '}' )
-            {
-               kolFig--;
-            }
-            else if( szText[lPos] == '.' && szSub[0] != '.' )
-            {
-               if( toupper( szText[lPos + 1] ) == 'T' && szText[lPos + 2] == '.' )
+               if( hb_pp_hasCommand( pBuffer, ulLen, &ul, 3, "#", "pragma", "enddump" ) )
                {
-                  lPos += 3;
-               }
-               else if( toupper( szText[lPos + 1] ) == 'F' && szText[lPos + 2] == '.' )
-               {
-                  lPos += 3;
-               }
-               else if( toupper( szText[lPos + 1] ) == 'O' && toupper( szText[lPos + 2] ) == 'R' && szText[lPos + 4] == '.' )
-               {
-                  lPos += 4;
-               }
-               else if( toupper( szText[lPos + 1] ) == 'A'
-                        && toupper( szText[lPos + 2] ) == 'N' && toupper( szText[lPos + 3] ) == 'D' && szText[lPos + 4] == '.' )
-               {
-                  lPos += 5;
-               }
-               else if( toupper( szText[lPos + 1] ) == 'N'
-                        && toupper( szText[lPos + 2] ) == 'O' && toupper( szText[lPos + 3] ) == 'T' && szText[lPos + 4] == '.' )
-               {
-                  lPos += 5;
+                  hb_pp_dumpEnd( pState );
                }
                else
                {
-                  lPos++;
+                  ul = ulLen;
+                  hb_membufAddData( pState->pDumpBuffer, pBuffer, ul );
+                  hb_membufAddCh( pState->pDumpBuffer, '\n' );
                }
-
-               lSubPos = 0;
-               continue;
             }
-         }
-
-         if( !lSubPos && checkPrth &&
-             ( ( ( kolPrth > 1 )
-                 || ( kolPrth == 1 && *( szText + lPos ) != '(' )
-                 || ( kolPrth == 0 && *( szText + lPos ) == ')' ) )
-               || ( ( kolFig > 1 ) || ( kolFig == 1 && *( szText + lPos ) != '{' ) || ( kolFig == 0 && *( szText + lPos ) == '}' ) ) ) )
-         {
-            cLastChar = *( szText + lPos );
-            lPos++;
-            continue;
-         }
-
-         if( lSubPos && checkPrth && ( kolPrth > 0 || kolFig > 0 ) )
-         {
-            cLastChar = *( szText + lPos );
-            lPos++;
-            lSubPos = 0;
-            continue;
-         }
-
-         if( ( lCase
-               && toupper( *( szText + lPos ) ) == toupper( *( szSub + lSubPos ) ) ) || ( !lCase && *( szText + lPos ) == *( szSub + lSubPos ) ) )
-         {
-            lSubPos++;
-            cLastChar = *( szText + lPos );
-            lPos++;
-
-            if( lSubPos >= lSubLen && checkword &&
-                ( ( ISNAME( ( BYTE ) * szSub ) && lPos > lSubPos
-                    && ISNAME( ( BYTE ) * ( szText + lPos - lSubPos - 1 ) ) )
-                  || ( ISNAME( ( BYTE ) * ( szSub + lSubLen - 1 ) ) && ISNAME( ( BYTE ) * ( szText + lPos ) ) ) ) )
+            else if( hb_pp_hasCommand( pBuffer, ulLen, &ul, 1, "ENDTEXT" ) ||
+                     hb_pp_hasCommand( pBuffer, ulLen, &ul, 3, "#", "pragma", "__endtext" ) )
             {
-               lSubPos = 0;
+               if( pState->iStreamDump != HB_PP_STREAM_CLIPPER )
+               {
+                  /* HB_PP_STREAM_PRG, HB_PP_STREAM_C */
+                  hb_pp_tokenAddStreamFunc( pState, pState->pFuncOut,
+                                            hb_membufPtr( pState->pStreamBuffer ),
+                                            hb_membufLen( pState->pStreamBuffer ) );
+                  hb_membufFlush( pState->pStreamBuffer );
+               }
+               if( pState->pFuncEnd )
+                  hb_pp_tokenAddStreamFunc( pState, pState->pFuncEnd, NULL, 0 );
+
+               hb_pp_tokenListFree( &pState->pFuncOut );
+               hb_pp_tokenListFree( &pState->pFuncEnd );
+               pState->iStreamDump = HB_PP_STREAM_OFF;
+            }
+            else if( pState->iStreamDump == HB_PP_STREAM_CLIPPER )
+            {
+               ul = ulLen;
+               hb_pp_tokenAddStreamFunc( pState, pState->pFuncOut, pBuffer, ul );
+            }
+            else /* HB_PP_STREAM_PRG, HB_PP_STREAM_C */
+            {
+               ul = ulLen;
+               if( pState->iStreamDump == HB_PP_STREAM_C )
+                  hb_strRemEscSeq( pBuffer, &ul );
+               hb_membufAddData( pState->pStreamBuffer, pBuffer, ul );
+               hb_membufAddCh( pState->pStreamBuffer, '\n' );
+               ul = ulLen; /* hb_strRemEscSeq() above could change ul */
             }
          }
-         else if( lSubPos )
+         else if( ch == '"' || ch == '\'' || ch == '`' )
          {
-            lSubPos = 0;
+            if( ch == '`' )
+               ch = '\'';
+            while( ++ul < ulLen && pBuffer[ ul ] != ch );
+
+            hb_pp_tokenAddNext( pState, pBuffer + 1, ul - 1,
+                                HB_PP_TOKEN_STRING );
+
+            if( ul == ulLen )
+            {
+               hb_membufAddCh( pState->pBuffer, '\0' );
+               hb_pp_error( pState, 'E', HB_PP_ERR_STRING_TERMINATOR, pBuffer );
+            }
+            else
+               ++ul;
+         }
+         else if( ch == '[' && !pState->fDirective &&
+                  /* Clipper supports quoting by [] for 1-st token in the line */
+                  ( pState->fCanNextLine ||
+                    HB_PP_TOKEN_CANQUOTE( pState->iLastType ) ) &&
+                  hb_pp_hasChar( ']', pBuffer + 1, ulLen - 1, &ul ) )
+         {
+            hb_pp_tokenAddNext( pState, pBuffer + 1, ul, HB_PP_TOKEN_STRING );
+            ul += 2;
+         }
+         else if( ( ch == '/' || ch == '&' ) && ulLen > 1 && pBuffer[ 1 ] == ch )
+         {
+            /* strip the rest of line with // or && comment */
+            ul = ulLen;
+         }
+         else if( ch == '*' && pState->pFile->iTokens == 0 )
+	   {
+            /* strip the rest of line with // or && comment */
+            ul = ulLen;
+	   }
+         else if( ch == '/' && ulLen > 1 && pBuffer[ 1 ] == '*' )
+         {
+#ifdef HB_C52_STRICT
+            /* In Clipper multiline comments used after ';' flushes
+               the EOC token what causes that ';' is always command
+               separator and cannot be used as line concatenator just
+               before multiline comments */
+            if( pState->fCanNextLine )
+               hb_pp_tokenAddCmdSep( pState );
+#endif
+            pState->iStreamDump = HB_PP_STREAM_COMMENT;
+         }
+         else if( ch == ' ' || ch == '\t' )
+         {
+            do
+            {
+               if( pBuffer[ ul ] == ' ' )
+                  pState->iSpaces++;
+               else if( pBuffer[ ul ] == '\t' )
+                  pState->iSpaces += 4;
+               else
+                  break;
+            }
+            while( ++ul < ulLen );
+         }
+         else if( ch == ';' )
+         {
+            if( pState->fCanNextLine )
+               hb_pp_tokenAddCmdSep( pState );
+            pState->fCanNextLine = TRUE;
+            pState->iSpacesNL = pState->iSpaces;
+            pState->iSpaces = 0;
+            ++ul;
+         }
+         else if( HB_PP_ISFIRSTIDCHAR( ch ) )
+         {
+            while( ++ul < ulLen && HB_PP_ISNEXTIDCHAR( pBuffer[ ul ] ) );
+
+            /*
+             * In Clipper note can be used only as 1-st token and after 
+             * statement separator ';' it does not work like a single line
+             * comment.
+             */
+#ifdef HB_C52_STRICT
+            if( pState->pFile->iTokens == 0 &&
+#else
+            if( pState->fNewStatement &&
+#endif
+                ul == 4 && hb_stricmp( "NOTE", pBuffer ) == 0 )
+            {
+               /* strip the rest of line */
+               ul = ulLen;
+            }
+            /* TODO: hb_inline support, it should be here to not preprocess
+                     the C code, anyhow so far we were living with broken
+                     implementation so probably we can leave with it yet some
+                     time longer */
+            else
+            {
+               hb_pp_tokenAddNext( pState, pBuffer, ul, HB_PP_TOKEN_KEYWORD );
+            }
+         }
+         /* This is Clipper incompatible token - such characters are illegal
+            and error message generated, to replicate this behavior is enough
+            to change HB_PP_ISILLEGAL() macro */
+         else if( HB_PP_ISTEXTCHAR( ch ) )
+         {
+            while( ++ul < ulLen && HB_PP_ISTEXTCHAR( pBuffer[ ul ] ) );
+
+            hb_pp_tokenAddNext( pState, pBuffer, ul, HB_PP_TOKEN_TEXT );
+         }
+         else if( HB_PP_ISILLEGAL( ch ) )
+         {
+            char szCh[3];
+
+            hb_pp_tokenAddNext( pState, pBuffer, ++ul, HB_PP_TOKEN_NUL );
+            sprintf( szCh, "%02x", ch & 0xff );
+            hb_pp_error( pState, 'E', HB_PP_ERR_ILLEGAL_CHAR, szCh );
+         }
+         else if( HB_PP_ISDIGIT( ch ) )
+         {
+            if( ulLen >= 3 && pBuffer[ 0 ] == '0' &&
+                ( pBuffer[ 1 ] == 'x' || pBuffer[ 1 ] == 'X' ) &&
+                HB_PP_ISHEX( pBuffer[ 2 ] ) )
+            {
+               ul = 2;
+               while( ++ul < ulLen && HB_PP_ISHEX( pBuffer[ ul ] ) );
+
+               /* (LEX: mark token as hex?) */
+               hb_pp_tokenAddNext( pState, pBuffer, ul, HB_PP_TOKEN_NUMBER );
+            }
+            else if( ulLen >= 3 && pBuffer[ 0 ] == '0' &&
+                     ( pBuffer[ 1 ] == 'd' || pBuffer[ 1 ] == 'D' ) &&
+                     HB_PP_ISDIGIT( pBuffer[ 2 ] ) )
+            {
+               ul = 2;
+               while( ++ul < ulLen && HB_PP_ISDIGIT( pBuffer[ ul ] ) );
+
+               hb_pp_tokenAddNext( pState, pBuffer, ul, HB_PP_TOKEN_DATE );
+            }
+            else
+            {
+               while( ++ul < ulLen && HB_PP_ISDIGIT( pBuffer[ ul ] ) );
+               if( ulLen - ul > 1 && pBuffer[ ul ] == '.' &&
+                                     HB_PP_ISDIGIT( pBuffer[ ul + 1 ] ) )
+               {
+                  ++ul;
+                  while( ++ul < ulLen && HB_PP_ISDIGIT( pBuffer[ ul ] ) );
+               }
+               hb_pp_tokenAddNext( pState, pBuffer, ul, HB_PP_TOKEN_NUMBER );
+            }
+         }
+         else if( ch == '.' && ulLen > 1 && HB_PP_ISDIGIT( pBuffer[ 1 ] ) )
+         {
+            while( ++ul < ulLen && HB_PP_ISDIGIT( pBuffer[ ul ] ) );
+
+            hb_pp_tokenAddNext( pState, pBuffer, ul, HB_PP_TOKEN_NUMBER );
+         }
+         else if( ch == '.' && ulLen >= 3 && pBuffer[ 2 ] == '.' &&
+                  ( HB_PP_ISTRUE( pBuffer[ 1 ] ) || HB_PP_ISFALSE( pBuffer[ 1 ] ) ) )
+         {
+            const char * value = HB_PP_ISTRUE( pBuffer[ 1 ] ) ? ".T." : ".F.";
+
+            ul = 3;
+            hb_pp_tokenAddNext( pState, value, ul, HB_PP_TOKEN_LOGICAL | HB_PP_TOKEN_STATIC );
+         }
+         else if( ch == '&' && ulLen > 1 && HB_PP_ISFIRSTIDCHAR( pBuffer[ 1 ] ) )
+         {
+            /*
+             * [&<keyword>[.[<nextidchars>]]]+ is a single token in Clipper
+             * and this fact is important in later preprocessing so we have
+             * to replicate it
+             */
+            while( ulLen - ul > 1 && pBuffer[ ul ] == '&' &&
+                   HB_PP_ISFIRSTIDCHAR( pBuffer[ ul + 1 ] ) )
+            {
+               while( ++ul < ulLen && HB_PP_ISNEXTIDCHAR( pBuffer[ ul ] ) );
+               if( ul < ulLen && pBuffer[ ul ] == '.' )
+                  while( ++ul < ulLen && HB_PP_ISNEXTIDCHAR( pBuffer[ ul ] ) );
+            }
+            if( ul < ulLen && pBuffer[ ul ] == '&' )
+               ++ul;
+            hb_pp_tokenAddNext( pState, pBuffer, ul, HB_PP_TOKEN_MACRO );
          }
          else
          {
-            cLastChar = *( szText + lPos );
-            lPos++;
+            PHB_PP_OPERATOR pOperator = hb_pp_operatorFind( pState, pBuffer, ulLen );
+
+            if( pOperator )
+            {
+               hb_pp_tokenAddNext( pState, pOperator->value,
+					     strlen( pOperator->value ),
+                                   pOperator->type );
+               ul = pOperator->len;
+            }
+            else
+            {
+               hb_pp_tokenAddNext( pState, pBuffer, ++ul, HB_PP_TOKEN_OTHER );
+            }
          }
+         pBuffer += ul;
+         ulLen -= ul;
+         ul = 0;
       }
    }
+   while( ( pState->pFile->pLineBuf ? pState->pFile->ulLineBufLen :
+                                      !pState->pFile->fEof ) &&
+          ( pState->fCanNextLine || 
+            ( pState->iStreamDump && pState->iStreamDump != HB_PP_STREAM_CLIPPER ) ) );
 
-#if 0
-   if( bRule == 0 && szSub[0] != ';' )
+   if( pState->iStreamDump )
    {
-      printf( "Rule: %i Find: >%s< In: >%s<\n", bRule, szSub, szText );
-      printf( "Pos: %i Len: %i At: >%s<\n", lPos, lSubLen, ( szText + lPos - lSubLen ) );
+      if( pState->iStreamDump == HB_PP_STREAM_COMMENT )
+         hb_pp_error( pState, 'E', HB_PP_ERR_UNTERMINATED_COMMENT, NULL );
+      else if( pState->iStreamDump == HB_PP_STREAM_DUMP_C )
+         hb_pp_dumpEnd( pState );
+      else if( pState->pFile->pLineBuf ? !pState->pFile->ulLineBufLen :
+                                         pState->pFile->fEof )
+         hb_pp_error( pState, 'E', HB_PP_ERR_MISSING_ENDTEXT, NULL );
+   }
+   if( pState->pFile->iTokens != 0 )
+   {
+      hb_pp_tokenAdd( &pState->pNextTokenPtr, "\n", 1, 0, HB_PP_TOKEN_EOL | HB_PP_TOKEN_STATIC );
+      pState->pFile->iTokens++;
    }
-#endif
-
-   return ( lSubPos < lSubLen ? 0 : lPos - lSubLen + 1 );
 }
 
-static char *PrevSquare( char *ptr, char *bound, int *kolmark )
+static int hb_pp_tokenStr( PHB_PP_TOKEN pToken, PHB_MEM_BUFFER pBuffer,
+                           BOOL fSpaces, BOOL fQuote, USHORT ltype )
 {
-   HB_TRACE( HB_TR_DEBUG, ( "PrevSquare(%s, %s, %d)", ptr, bound, kolmark == NULL ? 0 : *kolmark ) );
-   while( ptr > bound )
+   int iLines = 0, iSpace = fSpaces ? pToken->spaces : 0;
+
+   /* This is workaround for stringify token list and later decoding by
+      FLEX/SIMPLEX which breaks Clipper compatible code */
+   if( iSpace == 0 && fQuote && ltype &&
+       ltype >= HB_PP_TOKEN_ASSIGN &&
+       HB_PP_TOKEN_TYPE( pToken->type ) >= HB_PP_TOKEN_ASSIGN )
+      iSpace = 1;
+
+   if( iSpace > 0 )
    {
-      if( kolmark && *ptr == HB_PP_MATCH_MARK )
+      do
+         hb_membufAddCh( pBuffer, ' ' );
+      while( --iSpace );
+   }
+
+   if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_STRING )
+   {
+      int iq = 7, i;
+      char ch;
+
+      for( i = 0; iq && i < pToken->len; ++i )
       {
-         ( *kolmark )++;
+         if( pToken->value[ i ] == '"' )
+            iq &= ~1;
+         else if( pToken->value[ i ] == '\'' )
+            iq &= ~2;
+         else if( pToken->value[ i ] == ']' )
+            iq &= ~4;
+         else if( pToken->value[ i ] == '\n' )
+            iq = 0;
       }
-      else if( *ptr == HB_PP_OPT_START || *ptr == HB_PP_OPT_END )
+      if( iq == 0 && fQuote )
       {
-         break;
-      }
-      ptr--;
-   }
-   return ( *ptr == HB_PP_OPT_START ) ? ptr : NULL;
-}
+         /* generate string with 'e' prefix before opening '"' and quote
+            control characters inside, f.e.:
+               e"line1\nline2"
+          */
 
-static int IsInStr( char symb, char *s )
-{
-   HB_TRACE( HB_TR_DEBUG, ( "IsInStr(%c, %s)", symb, s ) );
-
-   while( *s != '\0' )
-      if( *s++ == symb )
-         return 1;
-   return 0;
-}
-
-/* ptri = string for inserting
-	ptro = output string
-	len1 = length of ptri string
-	len2 = length of ptro string that will be replaced
-	lenres = length of ptro string
-*/
-void hb_pp_Stuff( char *ptri, char *ptro, int len1, int len2, int lenres )
-{
-   char *ptr1, *ptr2;
-   int i;
-
-   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_Stuff(%s, %s, %d, %d, %d)", ptri, ptro, len1, len2, lenres ) );
-
-   if( len1 > len2 )
-   {
-      ptr1 = ptro + lenres + 1;
-      ptr2 = ptro + lenres + len1 - len2;
-      /* This is a static buffer - current inserting can erase the null char
-         than we need set it again.
-       */
-      ptr2[1] = '\0';
-      for( i = 0; i <= lenres; ptr2--, i++ )
-      {
-         ptr1--;
-         *ptr2 = *ptr1;
-      }
-   }
-   else
-   {
-      ptr1 = ptro + len2;
-      ptr2 = ptro + len1;
-      for( ; ptr1 <= ptro + lenres; ptr1++, ptr2++ )
-         *ptr2 = *ptr1;
-   }
-   ptr2 = ptro;
-   for( i = 0; i < len1; i++ )
-      *ptr2++ = *( ptri + i );
-}
-
-int hb_pp_strocpy( char *ptro, char *ptri )
-{
-   int lens = 0;
-
-   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_strocpy(%s, %s)", ptro, ptri ) );
-
-   if( ptri != NULL )
-      while( *ptri != '\0' )
-      {
-         *ptro++ = *ptri++;
-         lens++;
-      }
-   *ptro = '\0';
-   return lens;
-}
-
-static int stroncpy( char *ptro, char *ptri, int lens )
-{
-   int i = 0;
-
-   HB_TRACE( HB_TR_DEBUG, ( "stroncpy(%s, %s, %d)", ptro, ptri, lens ) );
-
-   for( ; i < lens; i++ )
-      *( ptro + i ) = *ptri++;
-   i--;
-   while( i > 0 && *( ptro + i ) == ' ' )
-      i--;
-   i++;
-   *( ptro + i ) = '\0';
-   return i;
-}
-
-static BOOL truncmp( char **ptro, char **ptri, BOOL lTrunc )
-{
-   char *ptrb = *ptro, co, ci;
-   
-   HB_TRACE( HB_TR_DEBUG, ( "truncmp(%p, %p, %d)", ptro, ptri, lTrunc ) );
-
-      
-   for( ;
-        **ptri != ' ' && **ptri != '\t' && **ptri != ','
-        && **ptri != HB_PP_OPT_START && **ptri != HB_PP_OPT_END
-        && **ptri != HB_PP_MATCH_MARK && **ptri != '\0' && toupper( **ptri ) == toupper( **ptro ); ( *ptro )++, ( *ptri )++ ) ;
-   co = *( *ptro - 1 );
-   ci = **ptri;
-   
-   if( ( ( ci == ' ' || ci == ',' || ci == HB_PP_OPT_START ||
-           ci == HB_PP_OPT_END || ci == HB_PP_MATCH_MARK || ci == '\0' ) &&
-         ( ( !ISNAME( ( BYTE ) ** ptro ) && ISNAME( ( BYTE ) co ) ) || 
-         ( !ISNAME( ( BYTE ) co ) ) ) ) )
-      return FALSE;
-   else if( lTrunc && *ptro - ptrb >= 4 && ISNAME( ( BYTE ) ci ) && !ISNAME( ( BYTE ) ** ptro ) && ISNAME( ( BYTE ) co ) )
-   {
-      while( ISNAME( ( BYTE ) ** ptri ) )
-         ( *ptri )++;
-      return FALSE;
-   }
-   return TRUE;
-}
-
-static BOOL strincmp( char *ptro, char **ptri, BOOL lTrunc )
-{
-   char *ptrb = ptro, co, ci;
-
-   HB_TRACE( HB_TR_DEBUG, ( "strincmp(%s, %p)", ptro, ptri ) );
-
-   for( ;
-        **ptri != ',' && **ptri != HB_PP_OPT_START && **ptri != HB_PP_OPT_END
-        && **ptri != HB_PP_MATCH_MARK && **ptri != '\0' && toupper( **ptri ) == toupper( *ptro ); ptro++, ( *ptri )++ ) ;
-   co = *( ptro - 1 );
-   ci = **ptri;
-   if( ( ( ci == ' ' || ci == ',' || ci == HB_PP_OPT_START ||
-           ci == HB_PP_OPT_END || ci == HB_PP_MATCH_MARK || ci == '\0' ) &&
-         ( ( !ISNAME( ( BYTE ) * ptro ) && ISNAME( ( BYTE ) co ) ) || ( !ISNAME( ( BYTE ) co ) ) ) ) )
-      return FALSE;
-   else if( lTrunc && ptro - ptrb >= 4 && ISNAME( ( BYTE ) ci ) && !ISNAME( ( BYTE ) * ptro ) && ISNAME( ( BYTE ) co ) )
-   {
-      /*      while( ISNAME(( BYTE ) **ptri) ) (*ptri)++; */
-      return FALSE;
-   }
-   return TRUE;
-}
-
-static int strincpy( char *ptro, char *ptri )
-{
-   int lens = 0;
-
-   HB_TRACE( HB_TR_DEBUG, ( "strincpy(%s, %s)", ptro, ptri ) );
-
-   for( ;
-        *ptri != ' ' && *ptri != ',' && *ptri != HB_PP_OPT_START
-        && *ptri != HB_PP_OPT_END && *ptri != HB_PP_MATCH_MARK && *ptri != '\0'; ptro++, ptri++, lens++ )
-      *ptro = *ptri;
-   return lens;
-}
-
-static int strotrim( char *stroka, BOOL bRule )
-{
-   char *ptr = stroka, lastc = '0', curc;
-   int lens = 0, State = STATE_NORMAL;
-
-   HB_TRACE( HB_TR_DEBUG, ( "strotrim(%s)", stroka ) );
-
-   while( ( curc = *stroka ) != '\0' )
-   {
-      if( State == STATE_QUOTE1 )
-      {
-         if( curc == '\'' )
+         hb_membufAddCh( pBuffer, 'e' );
+         hb_membufAddCh( pBuffer, '"' );
+         for( i = 0; i < pToken->len; ++i )
          {
-            State = STATE_NORMAL;
-         }
-      }
-      else if( State == STATE_QUOTE2 )
-      {
-         if( curc == '\"' )
-         {
-            State = STATE_NORMAL;
-         }
-      }
-      else if( State == STATE_QUOTE3 )
-      {
-         if( curc == ']' )
-         {
-            State = STATE_NORMAL;
+            ch = pToken->value[ i ];
+            switch( ch )
+            {
+               case '\r':
+                  iq = ch = 'r';
+                  break;
+               case '\n':
+                  iq = ch = 'n';
+                  break;
+               case '\t':
+                  iq = ch = 't';
+                  break;
+               case '\b':
+                  iq = ch = 'b';
+                  break;
+               case '"':
+                  iq = ch = 'q';
+                  break;
+               case '\\':
+                  iq = 1;
+                  break;
+               default:
+                  iq = 0;
+                  break;
+            }
+            if( iq )
+               hb_membufAddCh( pBuffer, '\\' );
+            hb_membufAddCh( pBuffer, ch );
          }
+         hb_membufAddCh( pBuffer, '"' );
       }
       else
       {
-         if( curc == '\'' )
-         {
-            State = STATE_QUOTE1;
-         }
-         else if( curc == '\"' )
-         {
-            State = STATE_QUOTE2;
-         }
-         /* Ron Pinkas added 2000-11-05 */
-         /* Ron Pinkas 2001-02-14 added bRule logic  (removed array logic). */
-         else if( curc == '[' && bRule == FALSE )       /* && ( strchr( ")]}.", cLastChar ) == NULL && ! ISNAME( ( BYTE ) cLastChar ) ) ) */
-         {
-            State = STATE_QUOTE3;
-         }
-         /* END - Ron Pinkas added 2000-11-05 */
-         else if( curc == '\t' )
-         {
-            curc = ' ';
-         }
-      }
+         if( iq & 1 )
+            ch = '"';
+         else if( iq & 2 )
+            ch = '\'';
+         else
+            ch = '[';
 
-      if( State != STATE_NORMAL || curc != ' ' ||
-          ( curc == ' ' && !bRule ) ||
-          ( curc == ' ' && lastc != ' ' && lastc != ',' && lastc != '(' && *( stroka + 1 ) != ',' && *( stroka + 1 ) != ' ' && *( stroka + 1 ) ) )
-      {
-         *ptr++ = curc;
-         lastc = curc;
-         lens++;
+         hb_membufAddCh( pBuffer, ch );
+         hb_membufAddData( pBuffer, pToken->value, pToken->len );
+         hb_membufAddCh( pBuffer, ch == '[' ? ']' : ch );
       }
-
-      stroka++;
    }
-
-   *ptr = '\0';
-
-   return lens;
-}
-
-static int NextWord( char **sSource, char *sDest, BOOL lLower )
-{
-   int i = 0;
-
-   HB_TRACE( HB_TR_DEBUG, ( "NextWord(%p, %s, %d)", sSource, sDest, lLower ) );
-
-   HB_SKIPTABSPACES( ( *sSource ) );
-
-   while( **sSource != '\0' && **sSource != ' ' && **sSource != '\t' && **sSource != '(' )
-   {
-      *sDest++ = ( lLower ) ? tolower( **sSource ) : **sSource;
-      ( *sSource )++;
-      i++;
-   }
-
-   *sDest = '\0';
-
-   return i;
-}
-
-static int NextName( char **sSource, char *sDest )
-{
-   /* Ron Pinkas added 2000-11-08 */
-   char cLastChar = '\0', *pString = NULL, *pTmp;
-
-   /* END - Ron Pinkas added 2000-11-08 */
-
-   int lenName = 0, State = STATE_NORMAL;
-
-   HB_TRACE( HB_TR_DEBUG, ( "NextName(%p, %s)", sSource, sDest ) );
-
-#if 0
-   printf( "In: >%s<\n", *sSource );
-#endif
-
-   while( **sSource != '\0' && ( !ISNAME( ( BYTE ) ** sSource ) || State != STATE_NORMAL ) )
-   {
-      if( State == STATE_QUOTE1 )
-      {
-         if( **sSource == '\'' )
-         {
-            State = STATE_NORMAL;
-
-            /* Ron Pinkas added 2000-11-08 */
-            **sSource = '\0';
-            if( strchr( pString, '"' ) == NULL )
-            {
-               *pString = '"';
-               **sSource = '"';
-            }
-            else
-            {
-               **sSource = '\'';
-            }
-            /* END - Ron Pinkas added 2000-11-08 */
-         }
-      }
-      else if( State == STATE_QUOTE2 )
-      {
-         if( **sSource == '\"' )
-         {
-            State = STATE_NORMAL;
-         }
-      }
-      else if( State == STATE_QUOTE3 )
-      {
-         if( **sSource == ']' )
-         {
-            State = STATE_NORMAL;
-
-            /* Ron Pinkas added 2000-11-08 */
-            **sSource = '\0';
-            if( strchr( pString, '"' ) == NULL )
-            {
-               *pString = '"';
-               **sSource = '"';
-            }
-            else if( strchr( pString, '\'' ) == NULL )
-            {
-               *pString = '\'';
-               **sSource = '\'';
-            }
-            else
-            {
-               **sSource = ']';
-            }
-            /* END - Ron Pinkas added 2000-11-08 */
-         }
-      }
-      else if( ( *sSource )[0] == HB_PP_OPT_START || ( *sSource )[0] == HB_PP_OPT_END )
-      {
-         State = STATE_NORMAL;
-      }
-      /* Ron Pinkas added 2001-02-21 */
-      else if( ( *sSource )[0] == '.' && toupper( ( *sSource )[1] ) == 'A'
-               && toupper( ( *sSource )[2] ) == 'N' && toupper( ( *sSource )[3] ) == 'D' && ( *sSource )[4] == '.' )
-      {
-         ( *sSource ) += 5;
-         cLastChar = ' ';
-         continue;
-      }
-      else if( ( *sSource )[0] == '.' && toupper( ( *sSource )[1] ) == 'N'
-               && toupper( ( *sSource )[2] ) == 'O' && toupper( ( *sSource )[3] ) == 'T' && ( *sSource )[4] == '.' )
-      {
-         ( *sSource ) += 5;
-         cLastChar = ' ';
-         continue;
-      }
-      else if( ( *sSource )[0] == '.' && toupper( ( *sSource )[1] ) == 'O' && toupper( ( *sSource )[2] ) == 'R' && ( *sSource )[3] == '.' )
-      {
-         ( *sSource ) += 4;
-         cLastChar = ' ';
-         continue;
-      }
-      /* End - Ron Pinkas added 2001-02-21 */
-      else if( ( *sSource )[0] == '.' && toupper( ( *sSource )[1] ) == 'T' && ( *sSource )[2] == '.' )
-      {
-         ( *sSource ) += 3;
-         cLastChar = ' ';
-         continue;
-      }
-      else if( ( *sSource )[0] == '.' && toupper( ( *sSource )[1] ) == 'F' && ( *sSource )[2] == '.' )
-      {
-         ( *sSource ) += 3;
-         cLastChar = ' ';
-         continue;
-      }
-      else if( **sSource == '\'' )
-      {
-         /* Ron Pinkas added 2000-11-08 */
-         pString = *sSource;
-         State = STATE_QUOTE1;
-      }
-      else if( **sSource == '\"' )
-      {
-         /* Ron Pinkas added 2000-11-08 */
-         pString = *sSource;
-         State = STATE_QUOTE2;
-      }
-      /* Ron Pinkas added 2000-11-08 */
-      else if( **sSource == '[' && s_bArray == FALSE && strchr( ")]}.\"\'", cLastChar ) == NULL && !ISNAME( ( BYTE ) cLastChar ) )
-      {
-         /* Ron Pinkas added 2000-11-08 */
-         pString = *sSource;
-         State = STATE_QUOTE3;
-      }
-      /* END - Ron Pinkas added 2000-11-08 */
-
-      /* Ron Pinkas added 2000-11-08 */
-      if( State == STATE_NORMAL && **sSource != ' ' && **sSource != '\t' )
-      {
-         cLastChar = **sSource;
-      }
-      /* END - Ron Pinkas added 2000-11-08 */
-
-      ( *sSource )++;
-   }
-
-   while( **sSource != '\0' && ISNAME( ( BYTE ) ** sSource ) )
-   {
-      *sDest++ = *( *sSource )++;
-      lenName++;
-   }
-
-   *sDest = '\0';
-
-   /* Ron Pinkas added 2000-11-08 - Prepare for next run. */
-   pTmp = *sSource;
-   while( *pTmp && ( *pTmp == ' ' || *pTmp == '\t' || *pTmp == HB_PP_OPT_END || *pTmp == HB_PP_OPT_START ) )
-   {
-      pTmp++;
-   }
-
-   s_bArray = ( *pTmp == '[' );
-   /* END - Ron Pinkas added 2000-11-08 */
-
-#if 0
-   printf( "NextName: >%s<\n", sDest - lenName );
-   printf( "Rest: >%s<\n", *sSource );
-#endif
-
-   return lenName;
-}
-
-static int NextParm( char **sSource, char *sDest )
-{
-   int lenName = 0, State = STATE_NORMAL, StBr = 0;
-   char cLastChar = '\0';
-
-   HB_TRACE( HB_TR_DEBUG, ( "NextParm(%p, %s)", sSource, sDest ) );
-
-   HB_SKIPTABSPACES( ( *sSource ) );
-
-   while( **sSource != '\0' )
-   {
-      if( State == STATE_QUOTE1 )
-      {
-         if( **sSource == '\'' )
-         {
-            State = STATE_NORMAL;
-         }
-      }
-      else if( State == STATE_QUOTE2 )
-      {
-         if( **sSource == '\"' )
-         {
-            State = STATE_NORMAL;
-         }
-      }
-      else if( State == STATE_QUOTE3 )
-      {
-         if( **sSource == ']' )
-         {
-            State = STATE_NORMAL;
-         }
-      }
-      else if( **sSource == '\'' )
-      {
-         State = STATE_QUOTE1;
-      }
-      else if( **sSource == '\"' )
-      {
-         State = STATE_QUOTE2;
-      }
-      else if( **sSource == '[' && strchr( ")]}.", cLastChar ) == NULL && !ISNAME( ( BYTE ) cLastChar ) )
-      {
-         State = STATE_QUOTE3;
-      }
-      /* Ron Pinkas added 2000-11-26 */
-      else if( **sSource == '[' )
-      {
-         StBr++;
-      }
-      else if( **sSource == ']' )
-      {
-         StBr--;
-      }
-      /* END - Ron Pinkas added 2000-11-26 */
-      else if( **sSource == '{' )
-      {
-         StBr++;
-      }
-      else if( **sSource == '}' )
-      {
-         StBr--;
-      }
-      else if( **sSource == '(' )
-      {
-         StBr++;
-      }
-      else if( **sSource == ')' || **sSource == ',' )
-      {
-         if( StBr == 0 )
-         {
-            break;
-         }
-
-         if( **sSource == ')' )
-         {
-            StBr--;
-         }
-      }
-
-      if( sDest != NULL )
-      {
-         *sDest++ = **sSource;
-      }
-
-      if( State == STATE_NORMAL && **sSource != ' ' && **sSource != '\t' )
-      {
-         cLastChar = **sSource;
-      }
-
-      ( *sSource )++;
-      lenName++;
-   }
-
-   if( sDest )
-   {
-      *sDest = '\0';
-   }
-
-#if 0
-   if( sDest )
-      printf( "NextParm: >%s<\n", sDest - lenName );
    else
-      printf( "NextParm Len: %i\n", lenName );
-#endif
-
-   return lenName;
-}
-
-static BOOL IsIdentifier( char *szProspect )
-{
-   if( isalpha( ( BYTE ) szProspect[0] ) || szProspect[0] == '_' )
    {
-      int i = 1;
-
-      while( ISNAME( ( BYTE ) szProspect[i] ) )
-      {
-         i++;
-      }
-      while( szProspect[i] == ' ' )
-      {
-         i++;
-      }
-
-      return ( szProspect[i] == '\0' );
+      if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_EOL )
+         ++iLines;
+      hb_membufAddData( pBuffer, pToken->value, pToken->len );
    }
 
+   return iLines;
+}
+
+static BOOL hb_pp_tokenValueCmp( PHB_PP_TOKEN pToken, char * szValue, USHORT mode )
+{
+   if( pToken->len )
+   {
+      if( mode == HB_PP_CMP_CASE )
+         return memcmp( szValue, pToken->value, pToken->len ) == 0;
+      if( mode == HB_PP_CMP_DBASE && pToken->len >= 4 &&
+          ( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_KEYWORD ||
+            HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_STRING ||
+            HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_TEXT ) )
+         return hb_strnicmp( szValue, pToken->value, pToken->len < 4 ? 4 : pToken->len ) == 0;
+      else
+         return hb_stricmp( szValue, pToken->value ) == 0;
+   }
    return FALSE;
 }
 
-
-static int IsMacroVar( char *szText, BOOL isCommand )
+static BOOL hb_pp_tokenEqual( PHB_PP_TOKEN pToken, PHB_PP_TOKEN pMatch,
+                              USHORT mode )
 {
-   int len = 0;
-
-   if( isalpha( ( BYTE ) szText[0] ) || szText[0] == '_' )
-   {
-      int i = 1;
-
-      while( ISNAME( ( BYTE ) szText[i] ) || isdigit( ( BYTE ) szText[i] ) || szText[i] == '&' || szText[i] == '.' )
-      {
-         i++;
-      }
-/*         
-      while( ISNAME( ( BYTE ) szText[i] ) || szText[i] == '&' )
-      {
-         i++;
-      }
-      if( szText[i] == '.' || szText[i] == '&' )
-      {
-         i++;
-         while( ISNAME(( BYTE ) szText[i]) || isdigit( ( BYTE ) szText[i] ) || szText[i] == '&' || szText[i] == '.' )
-         {
-            i++;
-         }
-      }
-*/
-      len = i;
-      if( !( szText[i] == '\0' || szText[i] == ' ' || szText[i] == ')' ) && isCommand )
-      {
-         return 0;
-      }
-   }
-   return len;
+   return pToken == pMatch ||
+         ( mode != HB_PP_CMP_ADDR && 
+           HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_TYPE( pMatch->type ) &&
+           ( pToken->len == pMatch->len ||
+             ( mode == HB_PP_CMP_DBASE && pMatch->len > 4 &&
+               pToken->len >= 4 && pMatch->len > pToken->len ) ) &&
+           hb_pp_tokenValueCmp( pToken, pMatch->value, mode ) );
 }
 
-
-static BOOL OpenInclude( char *szFileName, HB_PATHNAMES * pSearch, PHB_FNAME pMainFileName, BOOL bStandardOnly, char *szInclude )
+static void hb_pp_patternClearResults( PHB_PP_RULE pRule )
 {
-   FILE *fptr;
-   PHB_FNAME pFileName;
-   PFILE pFile;
+   PHB_PP_MARKER pMarker = pRule->pMarkers;
+   int i = pRule->markers;
 
-   HB_TRACE( HB_TR_DEBUG, ( "OpenInclude(%s, %p, %p, %d, %s)", szFileName, pSearch, pMainFileName, ( int ) bStandardOnly, szInclude ) );
-
-   errno = 0;
-   if( bStandardOnly )
+   while( --i >= 0 )
    {
-      fptr = 0;
-      szInclude[0] = '\0';
-   }
-   else
-   {
-      pFileName = hb_fsFNameSplit( szFileName );
-
-      if( ( pFileName->szPath == NULL || *( pFileName->szPath ) == '\0' ) && pMainFileName )
-         pFileName->szPath = pMainFileName->szPath;
-
-      hb_fsFNameMerge( szInclude, pFileName );
-
-      fptr = fopen( szInclude, "r" );
-      hb_xfree( pFileName );
-   }
-
-   if( !fptr && pSearch && errno != EMFILE )
-   {
-      pFileName = hb_fsFNameSplit( szFileName );
-      pFileName->szName = szFileName;
-      pFileName->szExtension = NULL;
-      while( pSearch && !fptr )
+      pMarker->matches = 0;
+      while( pMarker->pResult )
       {
-         pFileName->szPath = pSearch->szPath;
-         hb_fsFNameMerge( szInclude, pFileName );
-         fptr = fopen( szInclude, "r" );
-         pSearch = pSearch->pNext;
+         PHB_PP_RESULT pResult = pMarker->pResult;
+         pMarker->pResult = pResult->pNext;
+         hb_xfree( pResult );
       }
-      hb_xfree( pFileName );
+      ++pMarker;
    }
+   pRule->pNextExpr = NULL;
+}
 
-   if( fptr )
+static BOOL hb_pp_patternAddResult( PHB_PP_RULE pRule, USHORT marker,
+                                    PHB_PP_TOKEN pFirst, PHB_PP_TOKEN pNext )
+{
+   PHB_PP_MARKER pMarker = &pRule->pMarkers[ marker - 1 ];
+
+   if( pMarker->matches == 0 || pMarker->canrepeat )
    {
-      pFile = ( PFILE ) hb_xgrab( sizeof( _FILE ) );
-      pFile->handle = fptr;
-      pFile->pBuffer = hb_xgrab( HB_PP_BUFF_SIZE );
-      pFile->iBuffer = pFile->lenBuffer = 10;
-      pFile->yyBuffer = NULL;
-      pFile->szFileName = hb_strdup( szFileName );
-
-      if( hb_comp_files.pLast )
-         hb_comp_files.pLast->iLine = hb_comp_iLine;
-      hb_comp_iLine = 1;
-
-      pFile->iLine = 1;
-      pFile->pPrev = hb_comp_files.pLast;
-      hb_comp_files.pLast = pFile;
-      hb_comp_files.iFiles++;
+      PHB_PP_RESULT * pResultPtr,
+               pResult = ( PHB_PP_RESULT ) hb_xgrab( sizeof( HB_PP_RESULT ) );
+      pMarker->matches++;
+      pResult->pFirstToken = pFirst;
+      pResult->pNextExpr = pNext;
+      pResult->pNext = NULL;
+      pResultPtr = &pMarker->pResult;
+      while( * pResultPtr )
+         pResultPtr = &( * pResultPtr )->pNext;
+      * pResultPtr = pResult;
+      ++pMarker;
       return TRUE;
    }
 
    return FALSE;
 }
 
-
-void hb_pp_CloseInclude( void )
+static PHB_PP_RULE hb_pp_ruleNew( PHB_PP_TOKEN pMatch, PHB_PP_TOKEN pResult,
+                                  USHORT mode, USHORT markers,
+                                  PHB_PP_MARKER pMarkers )
 {
-   PFILE pFile;
+   PHB_PP_RULE pRule = ( PHB_PP_RULE ) hb_xgrab( sizeof( HB_PP_RULE ) );
 
-   /* we close the currently include file and continue */
-   fclose( hb_comp_files.pLast->handle );
-   hb_xfree( hb_comp_files.pLast->pBuffer );
-   hb_xfree( hb_comp_files.pLast->szFileName );
-   pFile = ( PFILE ) ( ( PFILE ) hb_comp_files.pLast )->pPrev;
-   hb_xfree( hb_comp_files.pLast );
-   hb_comp_files.pLast = pFile;
-   if( hb_comp_files.pLast )
-      hb_comp_iLine = hb_comp_files.pLast->iLine;
-   hb_comp_files.iFiles--;
+   pRule->pPrev = NULL;
+   pRule->mode = mode;
+   pRule->pMatch = pMatch;
+   pRule->pResult = pResult;
+   pRule->markers = markers;
+   pRule->pMarkers = pMarkers;
+   pRule->pNextExpr = NULL;
+
+   return pRule;
+}
+
+static void hb_pp_ruleFree( PHB_PP_RULE pRule )
+{
+   hb_pp_tokenListFree( &pRule->pMatch );
+   hb_pp_tokenListFree( &pRule->pResult );
+   hb_pp_patternClearResults( pRule );
+   if( pRule->pMarkers )
+      hb_xfree( pRule->pMarkers );
+   hb_xfree( pRule );
+}
+
+static void hb_pp_ruleListFree( PHB_PP_RULE * pRulePtr )
+{
+   PHB_PP_RULE pRule;
+
+   while( *pRulePtr )
+   {
+      pRule = *pRulePtr;
+      *pRulePtr = pRule->pPrev;
+      hb_pp_ruleFree( pRule );
+   }
+}
+
+static void hb_pp_ruleNonStdFree( PHB_PP_RULE * pRulePtr )
+{
+   PHB_PP_RULE pRule;
+
+   while( *pRulePtr )
+   {
+      pRule = *pRulePtr;
+      if( ( pRule->mode & HB_PP_STD_RULE ) != 0 )
+      {
+         pRulePtr = &pRule->pPrev;
+      }
+      else
+      {
+         * pRulePtr = pRule->pPrev;
+         hb_pp_ruleFree( pRule );
+      }
+   }
+}
+
+static void hb_pp_ruleSetStd( PHB_PP_RULE pRule )
+{
+   while( pRule )
+   {
+      pRule->mode |= HB_PP_STD_RULE;
+      pRule = pRule->pPrev;
+   }
+}
+
+static PHB_PP_RULE hb_pp_defineFind( PHB_PP_STATE pState, PHB_PP_TOKEN pToken )
+{
+   PHB_PP_RULE pRule = pState->pDefinitions;
+
+   /* TODO: create binary tree or hash table - the #define keyword token has
+            to be unique so it's not necessary to keep the stack list,
+            it will increase the speed when there is a lot of #define values */
+
+   while( pRule && ! hb_pp_tokenEqual( pToken, pRule->pMatch, HB_PP_CMP_CASE ) )
+      pRule = pRule->pPrev;
+
+   return pRule;
+}
+
+static void hb_pp_defineAdd( PHB_PP_STATE pState, USHORT mode,
+                             USHORT markers, PHB_PP_MARKER pMarkers,
+                             PHB_PP_TOKEN pMatch, PHB_PP_TOKEN pResult )
+{
+   PHB_PP_RULE pRule = hb_pp_defineFind( pState, pMatch );
+
+   if( pRule )
+   {
+      hb_pp_tokenListFree( &pRule->pMatch );
+      hb_pp_tokenListFree( &pRule->pResult );
+      hb_pp_patternClearResults( pRule );
+      if( pRule->pMarkers )
+         hb_xfree( pRule->pMarkers );
+      pRule->pMatch = pMatch;
+      pRule->pResult = pResult;
+      pRule->pMarkers = pMarkers;
+      pRule->markers = markers;
+      pRule->mode = mode;
+      hb_pp_error( pState, 'W', HB_PP_WARN_DEFINE_REDEF, pMatch->value );
+   }
+   else
+   {
+      pRule = hb_pp_ruleNew( pMatch, pResult, mode, markers, pMarkers );
+      pRule->pPrev = pState->pDefinitions;
+      pState->pDefinitions = pRule;
+      pState->iDefinitions++;
+   }
+}
+
+static void hb_pp_defineDel( PHB_PP_STATE pState, PHB_PP_TOKEN pToken )
+{
+   PHB_PP_RULE * pRulePtr = &pState->pDefinitions, pRule;
+
+   while( * pRulePtr )
+   {
+      pRule = *pRulePtr;
+      if( hb_pp_tokenEqual( pToken, pRule->pMatch, HB_PP_CMP_CASE ) )
+      {
+         * pRulePtr = pRule->pPrev;
+         hb_pp_ruleFree( pRule );
+         pState->iDefinitions--;
+         return;
+      }
+      pRulePtr = &pRule->pPrev;
+   }
+}
+
+static PHB_PP_FILE hb_pp_FileNew( PHB_PP_STATE pState, char * szFileName,
+                                  BOOL fSysFile, FILE * file_in,
+                                  PHB_PP_OPEN_FUNC pOpenFunc )
+{
+   char szFileNameBuf[ _POSIX_PATH_MAX + 1 ];
+   PHB_PP_FILE pFile;
+
+   if( ! file_in )
+   {
+      if( pOpenFunc )
+      {
+         file_in = ( pOpenFunc )( szFileName, fSysFile, szFileNameBuf );
+         szFileName = szFileNameBuf;
+      }
+      else
+      {
+         PHB_FNAME pFileName = hb_fsFNameSplit( szFileName );
+
+         pFileName->szName = szFileName;
+         pFileName->szExtension = NULL;
+         errno = 0;
+         if( !fSysFile )
+         {
+            if( !pFileName->szPath || !pFileName->szPath[ 0 ] )
+            {
+               char * szFirstFName = NULL;
+               pFile = pState->pFile;
+               while( pFile )
+               {
+                  if( pFile->szFileName )
+                     szFirstFName = pFile->szFileName;
+                  pFile = pFile->pPrev;
+               }
+               if( szFirstFName )
+               {
+                  PHB_FNAME pFirstFName = hb_fsFNameSplit( szFirstFName );
+                  pFileName->szPath = pFirstFName->szPath;
+                  hb_fsFNameMerge( szFileNameBuf, pFileName );
+                  szFileName = szFileNameBuf;
+                  hb_xfree( pFirstFName );
+               }
+            }
+
+            file_in = fopen( szFileName, "r" );
+         }
+
+         if( !file_in && errno != EMFILE && pState->pIncludePath )
+         {
+            HB_PATHNAMES * pPath = pState->pIncludePath;
+
+            while( pPath && !file_in )
+            {
+               pFileName->szPath = pPath->szPath;
+               hb_fsFNameMerge( szFileNameBuf, pFileName );
+               file_in = fopen( szFileNameBuf, "r" );
+               pPath = pPath->pNext;
+            }
+         }
+         hb_xfree( pFileName );
+      }
+
+      if( ! file_in )
+         return NULL;
+   }
+
+   pFile = ( PHB_PP_FILE ) hb_xgrab( sizeof( HB_PP_FILE ) );
+   memset( pFile, '\0', sizeof( HB_PP_FILE ) );
+
+   pFile->szFileName = hb_strdup( szFileName );
+   pFile->file_in = file_in;
+   pFile->iLastLine = 1;
+
+   return pFile;
+}
+
+static PHB_PP_FILE hb_pp_FileBufNew( char * pLineBuf, ULONG ulLineBufLen )
+{
+   PHB_PP_FILE pFile;
+
+   pFile = ( PHB_PP_FILE ) hb_xgrab( sizeof( HB_PP_FILE ) );
+   memset( pFile, '\0', sizeof( HB_PP_FILE ) );
+
+   pFile->pLineBuf = pLineBuf;
+   pFile->ulLineBufLen = ulLineBufLen;
+
+   return pFile;
+}
+
+static void hb_pp_FileFree( PHB_PP_FILE pFile, PHB_PP_CLOSE_FUNC pCloseFunc )
+{
+   if( pFile->file_in )
+   {
+      if( pCloseFunc )
+         ( pCloseFunc )( pFile->file_in );
+      else
+         fclose( pFile->file_in );
+   }
+
+   if( pFile->szFileName )
+      hb_xfree( pFile->szFileName );
+
+   hb_pp_tokenListFree( &pFile->pTokenList );
+   hb_xfree( pFile );
+}
+
+static void hb_pp_OutFileFree( PHB_PP_STATE pState )
+{
+   if( pState->file_out )
+   {
+      fclose( pState->file_out );
+      pState->file_out = NULL;
+   }
+   if( pState->szOutFileName )
+   {
+      hb_xfree( pState->szOutFileName );
+      pState->szOutFileName = NULL;
+   }
+   pState->fWritePreprocesed = FALSE;
+}
+
+static void hb_pp_InFileFree( PHB_PP_STATE pState )
+{
+   while( pState->pFile )
+   {
+      PHB_PP_FILE pFile = pState->pFile;
+      pState->pFile = pFile->pPrev;
+      hb_pp_FileFree( pFile, pState->pCloseFunc );
+   }
+}
+
+static PHB_PP_STATE hb_pp_stateNew( void )
+{
+   PHB_PP_STATE pState = ( PHB_PP_STATE ) hb_xgrab( sizeof( HB_PP_STATE ) );
+
+   memset( pState, '\0', sizeof( HB_PP_STATE ) );
+
+   /* create new line buffer */
+   pState->pBuffer = hb_membufNew();
+
+   /* set default maximum number of translations */
+   pState->iMaxCycles = HB_PP_MAX_CYCLES;
+
+   return pState;
+}
+
+static void hb_pp_stateFree( PHB_PP_STATE pState )
+{
+   hb_pp_InFileFree( pState );
+   hb_pp_OutFileFree( pState );
+
+   if( pState->pIncludePath )
+      hb_fsFreeSearchPath( pState->pIncludePath );
+
+   if( pState->iOperators > 0 )
+      hb_pp_operatorsFree( pState->pOperators, pState->iOperators );
+
+   hb_pp_ruleListFree( &pState->pDefinitions );
+   hb_pp_ruleListFree( &pState->pTranslations );
+   hb_pp_ruleListFree( &pState->pCommands );
+
+   hb_pp_tokenListFree( &pState->pTokenOut );
+
+   hb_membufFree( pState->pBuffer );
+   if( pState->pDumpBuffer )
+      hb_membufFree( pState->pDumpBuffer );
+   if( pState->pOutputBuffer )
+      hb_membufFree( pState->pOutputBuffer );
+   if( pState->pStreamBuffer )
+      hb_membufFree( pState->pStreamBuffer );
+
+   if( pState->pCondStack )
+      hb_xfree( pState->pCondStack );
+
+   hb_pp_tokenListFree( &pState->pFuncOut );
+   hb_pp_tokenListFree( &pState->pFuncEnd );
+
+   hb_xfree( pState );
+}
+
+static void hb_pp_includeFile( PHB_PP_STATE pState, char * szFileName, BOOL fSysFile )
+{
+   if( pState->iFiles >= HB_PP_MAX_INCLUDED_FILES )
+   {
+      hb_pp_error( pState, 'F', HB_PP_ERR_NESTED_INCLUDES, NULL );
+   }
+   else
+   {
+      PHB_PP_FILE pFile = hb_pp_FileNew( pState, szFileName, fSysFile, NULL, pState->pOpenFunc );
+      if( pFile )
+      {
+         pFile->pPrev = pState->pFile;
+         pState->pFile = pFile;
+         pState->iFiles++;
+         pFile->fGenLineInfo = TRUE;
+      }
+      else if( errno == EMFILE )
+         hb_pp_error( pState, 'F', HB_PP_ERR_NESTED_INCLUDES, NULL );
+      else
+         hb_pp_error( pState, 'F', HB_PP_ERR_CANNOT_OPEN_FILE, szFileName );
+   }
+}
+
+static void hb_pp_includeClose( PHB_PP_STATE pState )
+{
+   PHB_PP_FILE pFile = pState->pFile;
+
+   pState->pFile = pFile->pPrev;
+   pState->iFiles--;
+   if( pState->pFile )
+      pState->pFile->fGenLineInfo = TRUE;
+
+   hb_pp_FileFree( pFile, pState->pCloseFunc );
+}
+
+static PHB_PP_TOKEN hb_pp_streamFuncGet( PHB_PP_TOKEN pToken, PHB_PP_TOKEN * pFuncPtr )
+{
+   hb_pp_tokenListFree( pFuncPtr );
+
+   if( pToken && HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_PIPE &&
+       !HB_PP_TOKEN_ISEOC( pToken->pNext ) )
+   {
+      PHB_PP_TOKEN * pStartPtr, * pEndPtr, pStart, pNext;
+      pStartPtr = pEndPtr = &pToken->pNext;
+      while( !HB_PP_TOKEN_ISEOC( * pEndPtr ) &&
+             HB_PP_TOKEN_TYPE( ( * pEndPtr )->type ) != HB_PP_TOKEN_PIPE )
+         pEndPtr = &( * pEndPtr )->pNext;
+
+      pToken = * pEndPtr;
+      * pEndPtr = NULL;
+      * pFuncPtr = pStart = * pStartPtr;
+      * pStartPtr = pToken;
+      /* replace %s with HB_PP_RMARKER_STRDUMP marker */
+      while( pStart && pStart->pNext )
+      {
+         pNext = pStart->pNext;
+         if( HB_PP_TOKEN_TYPE( pStart->type ) == HB_PP_TOKEN_MOD &&
+             HB_PP_TOKEN_TYPE( pNext->type ) == HB_PP_TOKEN_KEYWORD &&
+             pNext->len == 1 && pNext->value[0] == 's' )
+         {
+            HB_PP_TOKEN_SETTYPE( pStart, HB_PP_RMARKER_STRDUMP );
+            pStart->pNext = pNext->pNext;
+            hb_pp_tokenFree( pNext );
+            pNext = pStart->pNext;
+         }
+         pStart = pNext;
+      }
+   }
+   return pToken;
+}
+
+/* #pragma {__text,__stream,__cstream}|functionOut|functionEnd|functionStart */
+static BOOL hb_pp_pragmaStream( PHB_PP_STATE pState, PHB_PP_TOKEN pToken )
+{
+   BOOL fError = FALSE;
+
+   pToken = hb_pp_streamFuncGet( pToken, &pState->pFuncOut );
+   pToken = hb_pp_streamFuncGet( pToken, &pState->pFuncEnd );
+
+   return fError;
+}
+
+static BOOL hb_pp_pragmaOperatorNew( PHB_PP_STATE pState, PHB_PP_TOKEN pToken )
+{
+   BOOL fError = TRUE;
+
+   if( !HB_PP_TOKEN_ISEOC( pToken ) && HB_PP_TOKEN_CANJOIN( pToken->type ) )
+   {
+      ULONG ulLen;
+
+      hb_membufFlush( pState->pBuffer );
+      do
+      {
+         hb_membufAddData( pState->pBuffer, pToken->value, pToken->len );
+         pToken = pToken->pNext;
+      }
+      while( !HB_PP_TOKEN_ISEOC( pToken ) && pToken->spaces == 0 );
+      ulLen = hb_membufLen( pState->pBuffer );
+      if( !HB_PP_TOKEN_ISEOC( pToken ) )
+      {
+         do
+         {
+            hb_membufAddData( pState->pBuffer, pToken->value, pToken->len );
+            pToken = pToken->pNext;
+         }
+         while( !HB_PP_TOKEN_ISEOC( pToken ) && pToken->spaces == 0 );
+      }
+      if( HB_PP_TOKEN_ISEOC( pToken ) && ulLen > 0 )
+      {
+         PHB_PP_OPERATOR pOperator;
+         char * pBuffer = hb_membufPtr( pState->pBuffer ), * pDstBuffer;
+         ULONG ulDstLen = hb_membufLen( pState->pBuffer ) - ulLen;
+
+         if( ulDstLen )
+            pDstBuffer = pBuffer + ulLen;
+         else
+         {
+            pDstBuffer = pBuffer;
+            ulDstLen = ulLen;
+         }
+         if( pState->iOperators )
+            pState->pOperators = ( PHB_PP_OPERATOR ) hb_xrealloc(
+                     pState->pOperators,
+                     sizeof( HB_PP_OPERATOR ) * ( pState->iOperators + 1 ) );
+         else
+            pState->pOperators = ( PHB_PP_OPERATOR ) hb_xgrab( 
+                     sizeof( HB_PP_OPERATOR ) * ( pState->iOperators + 1 ) );
+         pOperator = &pState->pOperators[ pState->iOperators++ ];
+         pOperator->name  = hb_strndup( pBuffer, ulLen );
+         pOperator->len   = ulLen;
+         pOperator->value = hb_strndup( pDstBuffer, ulDstLen );
+         pOperator->type  = HB_PP_TOKEN_OTHER;
+         fError = FALSE;
+      }
+   }
+   return fError;
+}
+
+static BOOL hb_pp_setCompilerSwitch( PHB_PP_STATE pState, char * szSwitch,
+                                     int iValue )
+{
+   BOOL fError = TRUE;
+
+   if( strlen( szSwitch ) == 1 )
+   {
+      switch( szSwitch[ 0 ] )
+      {
+         case 'p':
+         case 'P':
+            pState->fWritePreprocesed = pState->file_out != NULL && iValue != 0;
+            fError = FALSE;
+            break;
+
+         case 'q':
+         case 'Q':
+            pState->fQuiet = iValue != 0;
+            fError = FALSE;
+            break;
+      }
+   }
+
+   if( pState->pSwitchFunc )
+      fError = ( pState->pSwitchFunc )( szSwitch, iValue );
+
+   return fError;
+}
+
+static PHB_PP_TOKEN hb_pp_pragmaGetLogical( PHB_PP_TOKEN pToken, BOOL * pfValue )
+{
+   PHB_PP_TOKEN pValue = NULL;
+
+   if( pToken && pToken->pNext &&
+       HB_PP_TOKEN_TYPE( pToken->pNext->type ) == HB_PP_TOKEN_KEYWORD )
+   {
+      if( ( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_EQ &&
+            HB_PP_TOKEN_ISEOC( pToken->pNext->pNext ) ) ||
+          ( pToken->pNext->pNext &&
+            HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_LEFT_PB &&
+            HB_PP_TOKEN_TYPE( pToken->pNext->pNext->type ) == HB_PP_TOKEN_RIGHT_PB &&
+            HB_PP_TOKEN_ISEOC( pToken->pNext->pNext->pNext ) ) )
+      {
+         pValue = pToken->pNext;
+         if( hb_stricmp( pValue->value, "ON" ) == 0 )
+            * pfValue = TRUE;
+         else if( hb_stricmp( pValue->value, "OFF" ) == 0 )
+            * pfValue = FALSE;
+         else
+            pValue = NULL;
+      }
+   }
+   return pValue;
+}
+
+static PHB_PP_TOKEN hb_pp_pragmaGetInt( PHB_PP_TOKEN pToken, int * piValue )
+{
+   PHB_PP_TOKEN pValue = NULL;
+
+   if( pToken && pToken->pNext &&
+       HB_PP_TOKEN_TYPE( pToken->pNext->type ) == HB_PP_TOKEN_NUMBER )
+   {
+      if( ( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_EQ &&
+            HB_PP_TOKEN_ISEOC( pToken->pNext->pNext ) ) ||
+          ( pToken->pNext->pNext &&
+            HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_LEFT_PB &&
+            HB_PP_TOKEN_TYPE( pToken->pNext->pNext->type ) == HB_PP_TOKEN_RIGHT_PB &&
+            HB_PP_TOKEN_ISEOC( pToken->pNext->pNext->pNext ) ) )
+      {
+         pValue = pToken->pNext;
+         * piValue = atoi( pValue->value );
+      }
+   }
+   return pValue;
+}
+
+static PHB_PP_TOKEN hb_pp_pragmaGetSwitch( PHB_PP_TOKEN pToken, int * piValue )
+{
+   PHB_PP_TOKEN pValue = NULL;
+
+   if( pToken && HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_KEYWORD )
+   {
+      if( HB_PP_TOKEN_ISEOC( pToken->pNext ) )
+      {
+         if( pToken->len > 1 && HB_PP_ISDIGIT( pToken->value[ pToken->len - 1 ] ) )
+         {
+            pValue = pToken;
+            * piValue = pValue->value[ pToken->len - 1 ] - '0';
+         }
+      }
+      else if( HB_PP_TOKEN_ISEOC( pToken->pNext->pNext ) )
+      {
+         if( HB_PP_TOKEN_TYPE( pToken->pNext->type ) == HB_PP_TOKEN_MINUS )
+         {
+            pValue = pToken->pNext;
+            * piValue = 0;
+         }
+         else if( HB_PP_TOKEN_TYPE( pToken->pNext->type ) == HB_PP_TOKEN_PLUS )
+         {
+            pValue = pToken->pNext;
+            * piValue = 1;
+         }
+         else if( HB_PP_TOKEN_TYPE( pToken->pNext->type ) == HB_PP_TOKEN_NUMBER )
+         {
+            pValue = pToken->pNext;
+            * piValue = atoi( pValue->value );
+         }
+      }
+   }
+   return pValue;
+}
+
+static void hb_pp_pragmaNew( PHB_PP_STATE pState, PHB_PP_TOKEN pToken )
+{
+   PHB_PP_TOKEN pValue = NULL;
+   BOOL fError = FALSE, fValue = FALSE;
+   int iValue = 0;
+
+   if( !pToken )
+      fError = TRUE;
+   else if( pToken->len == 1 && HB_ISOPTSEP( pToken->value[ 0 ] ) )
+   {
+      pValue = hb_pp_pragmaGetSwitch( pToken->pNext, &iValue );
+      if( pValue )
+         fError = hb_pp_setCompilerSwitch( pState, pValue->value, iValue );
+      else
+         fError = TRUE;
+   }
+   else if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_KEYWORD )
+   {
+      if( hb_pp_tokenValueCmp( pToken, "begindump", HB_PP_CMP_DBASE ) )
+      {
+         pState->iStreamDump = HB_PP_STREAM_DUMP_C;
+         pState->iDumpLine = pState->pFile->iCurrentLine;
+         if( ! pState->pDumpBuffer )
+            pState->pDumpBuffer = hb_membufNew();
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "enddump", HB_PP_CMP_DBASE ) )
+      {
+         pState->iStreamDump = HB_PP_STREAM_OFF;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "__text", HB_PP_CMP_DBASE ) )
+      {
+         fError = hb_pp_pragmaStream( pState, pToken->pNext );
+         if( !fError )
+            pState->iStreamDump = HB_PP_STREAM_CLIPPER;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "__stream", HB_PP_CMP_DBASE ) )
+      {
+         fError = hb_pp_pragmaStream( pState, pToken->pNext );
+         if( !fError )
+         {
+            pState->iStreamDump = HB_PP_STREAM_PRG;
+            if( ! pState->pStreamBuffer )
+               pState->pStreamBuffer = hb_membufNew();
+         }
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "__cstream", HB_PP_CMP_DBASE ) )
+      {
+         fError = hb_pp_pragmaStream( pState, pToken->pNext );
+         if( !fError )
+         {
+            pState->iStreamDump = HB_PP_STREAM_C;
+            if( ! pState->pStreamBuffer )
+               pState->pStreamBuffer = hb_membufNew();
+         }
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "__endtext", HB_PP_CMP_DBASE ) )
+      {
+         pState->iStreamDump = HB_PP_STREAM_OFF;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "AUTOMEMVAR", HB_PP_CMP_DBASE ) )
+      {
+         pValue = hb_pp_pragmaGetLogical( pToken->pNext, &fValue );
+         if( pValue )
+            fError = hb_pp_setCompilerSwitch( pState, "a", ( int ) fValue );
+         else
+            fError = TRUE;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "DEBUGINFO", HB_PP_CMP_DBASE ) )
+      {
+         pValue = hb_pp_pragmaGetLogical( pToken->pNext, &fValue );
+         if( pValue )
+            fError = hb_pp_setCompilerSwitch( pState, "b", ( int ) fValue );
+         else
+            fError = TRUE;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "DYNAMICMEMVAR", HB_PP_CMP_DBASE ) )
+      {
+         pValue = hb_pp_pragmaGetLogical( pToken->pNext, &fValue );
+         if( pValue )
+            fError = hb_pp_setCompilerSwitch( pState, "v", ( int ) fValue );
+         else
+            fError = TRUE;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "ENABLEWARNINGS", HB_PP_CMP_DBASE ) )
+      {
+         pValue = hb_pp_pragmaGetLogical( pToken->pNext, &fValue );
+         if( pValue )
+            fError = hb_pp_setCompilerSwitch( pState, "w", fValue ? 1 : 0 );
+         else
+            fError = TRUE;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "EXITSEVERITY", HB_PP_CMP_DBASE ) )
+      {
+         pValue = hb_pp_pragmaGetLogical( pToken->pNext, &iValue );
+         if( pValue )
+            fError = hb_pp_setCompilerSwitch( pState, "es", iValue );
+         else
+            fError = TRUE;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "LINENUMBER", HB_PP_CMP_DBASE ) )
+      {
+         pValue = hb_pp_pragmaGetLogical( pToken->pNext, &fValue );
+         if( pValue )
+            fError = hb_pp_setCompilerSwitch( pState, "l", fValue );
+         else
+            fError = TRUE;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "NOSTARTPROC", HB_PP_CMP_DBASE ) )
+      {
+         pValue = hb_pp_pragmaGetLogical( pToken->pNext, &fValue );
+         if( pValue )
+            fError = hb_pp_setCompilerSwitch( pState, "n", fValue );
+         else
+            fError = TRUE;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "OPERATOR", HB_PP_CMP_DBASE ) )
+      {
+         fError = hb_pp_pragmaOperatorNew( pState, pToken->pNext );
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "PREPROCESSING", HB_PP_CMP_DBASE ) )
+      {
+         pValue = hb_pp_pragmaGetLogical( pToken->pNext, &fValue );
+         if( pValue )
+            fError = hb_pp_setCompilerSwitch( pState, "p", fValue );
+         else
+            fError = TRUE;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "SHORTCUT", HB_PP_CMP_DBASE ) )
+      {
+         pValue = hb_pp_pragmaGetLogical( pToken->pNext, &fValue );
+         if( pValue )
+            fError = hb_pp_setCompilerSwitch( pState, "z", fValue );
+         else
+            fError = TRUE;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "RECURSELEVEL", HB_PP_CMP_DBASE ) )
+      {
+         pValue = hb_pp_pragmaGetInt( pToken->pNext, &pState->iMaxCycles );
+         fError = pValue == NULL;
+      }
+      /* xHarbour extension */
+      else if( hb_pp_tokenValueCmp( pToken, "TEXTHIDDEN", HB_PP_CMP_DBASE ) )
+      {
+         pValue = hb_pp_pragmaGetInt( pToken->pNext, &pState->iHideStrings );
+         if( pValue )
+            fError = hb_pp_setCompilerSwitch( pState, pToken->value, pState->iHideStrings );
+         else
+            fError = TRUE;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "TRACEPRAGMAS", HB_PP_CMP_DBASE ) )
+      {
+         pValue = hb_pp_pragmaGetLogical( pToken->pNext, &pState->fTracePragmas );
+         fError = pValue == NULL;
+      }
+      else if( hb_pp_tokenValueCmp( pToken, "WARNINGLEVEL", HB_PP_CMP_DBASE ) )
+      {
+         pValue = hb_pp_pragmaGetLogical( pToken->pNext, &iValue );
+         if( pValue )
+            fError = hb_pp_setCompilerSwitch( pState, "w", iValue );
+         else
+            fError = TRUE;
+      }
+      else
+         fError = TRUE;
+   }
+   else
+      fError = TRUE;
+
+   if( fError )
+   {
+      hb_pp_error( pState, 'E', HB_PP_ERR_PRAGMA, NULL );
+   }
+   else if( pState->fTracePragmas )
+   {
+      char szLine[ 12 ];
+
+      sprintf( szLine, "%d", pState->pFile->iCurrentLine );
+      hb_membufFlush( pState->pBuffer );
+      hb_membufAddCh( pState->pBuffer, '(' );
+      hb_membufAddStr( pState->pBuffer, szLine );
+      hb_membufAddStr( pState->pBuffer, ") #pragma " );
+      hb_membufAddStr( pState->pBuffer, pToken->value );
+      if( pValue && pValue != pToken )
+      {
+         hb_membufAddStr( pState->pBuffer, " set to '" );
+         hb_membufAddStr( pState->pBuffer, pValue->value );
+         hb_membufAddCh( pState->pBuffer, '\'' );
+      }
+      hb_membufAddCh( pState->pBuffer, '\n' );
+      hb_membufAddCh( pState->pBuffer, '\0' );
+
+      hb_pp_disp( pState, hb_membufPtr( pState->pBuffer ) );
+   }
+}
+
+static void hb_pp_defineNew( PHB_PP_STATE pState, PHB_PP_TOKEN pToken, BOOL fDirect )
+{
+   PHB_PP_TOKEN pMatch = pToken ? pToken->pNext : NULL;
+
+   if( !pMatch || HB_PP_TOKEN_TYPE( pMatch->type ) != HB_PP_TOKEN_KEYWORD )
+   {
+      hb_pp_error( pState, 'E', HB_PP_ERR_DEFINE_SYNTAX, NULL );
+   }
+   else
+   {
+      PHB_PP_TOKEN pResult, pLast = pMatch->pNext, pParam;
+      PHB_PP_MARKER pMarkers = NULL;
+      USHORT usPCount = 0, usParam;
+
+      /* pseudo function? */
+      if( pLast && HB_PP_TOKEN_TYPE( pLast->type ) == HB_PP_TOKEN_LEFT_PB &&
+          pLast->spaces == 0 )
+      {
+         USHORT type = HB_PP_TOKEN_KEYWORD;
+         while( TRUE )
+         {
+            pLast = pLast->pNext;
+            if( pLast && ( usPCount == 0 || type == HB_PP_TOKEN_COMMA ) &&
+                HB_PP_TOKEN_TYPE( pLast->type ) == HB_PP_TOKEN_RIGHT_PB )
+               break;
+            if( !pLast || type != HB_PP_TOKEN_TYPE( pLast->type ) )
+            {
+               if( type == HB_PP_TOKEN_KEYWORD )
+                  hb_pp_error( pState, 'E', HB_PP_ERR_LABEL_MISSING_IN_DEFINE, NULL );
+               else
+                  hb_pp_error( pState, 'E', HB_PP_ERR_PARE_MISSING_IN_DEFINE, NULL );
+               return;
+            }
+            else if( type == HB_PP_TOKEN_KEYWORD )
+            {
+               ++usPCount;
+               type = HB_PP_TOKEN_COMMA;
+            }
+            else
+               type = HB_PP_TOKEN_KEYWORD;
+         }
+      }
+      else  /* simple keyword define */
+         pLast = pMatch;
+      pResult = pLast->pNext;
+      pLast->pNext = NULL;
+      pToken->pNext = hb_pp_tokenResultEnd( &pResult, fDirect );
+      if( usPCount )
+      {
+         usPCount = 0;
+         pParam = pMatch->pNext->pNext;
+         while( HB_PP_TOKEN_TYPE( pParam->type ) == HB_PP_TOKEN_KEYWORD )
+         {
+            usParam = 0;
+            /* Check if it's not repeated ID */
+            pLast = pMatch->pNext->pNext;
+            while( pLast != pParam && ! hb_pp_tokenEqual( pParam, pLast, HB_PP_CMP_CASE ) )
+            {
+               pLast = pLast->pNext;
+            }
+            if( pLast == pParam )
+            {
+               pLast = pResult;
+               /* replace parameter tokens in result pattern with regular
+                  result markers */
+               while( pLast )
+               {
+                  if( hb_pp_tokenEqual( pParam, pLast, HB_PP_CMP_CASE ) )
+                  {
+                     HB_PP_TOKEN_SETTYPE( pLast, HB_PP_RMARKER_REGULAR );
+                     if( usParam == 0 )
+                        usParam = ++usPCount;
+                     pLast->index = usParam;
+                  }
+                  pLast = pLast->pNext;
+               }
+            }
+            HB_PP_TOKEN_SETTYPE( pParam, HB_PP_MMARKER_REGULAR );
+            pParam->index = usParam;
+            pParam = pParam->pNext;
+            if( HB_PP_TOKEN_TYPE( pParam->type ) == HB_PP_TOKEN_COMMA )
+               pParam = pParam->pNext;
+         }
+         if( usPCount )
+         {
+            /* create regular match and result markers from parameters */
+            pMarkers = ( PHB_PP_MARKER ) hb_xgrab( usPCount * sizeof( HB_PP_MARKER ) );
+            memset( pMarkers, '\0', usPCount * sizeof( HB_PP_MARKER ) );
+         }
+      }
+      hb_pp_defineAdd( pState, HB_PP_CMP_CASE, usPCount, pMarkers, pMatch, pResult );
+   }
+}
+
+static BOOL hb_pp_tokenUnQuotedGet( PHB_PP_TOKEN ** pTokenPtr, BOOL * pfQuoted,
+                                    BOOL fFree )
+{
+   PHB_PP_TOKEN pToken = **pTokenPtr;
+
+   * pfQuoted = FALSE;
+   if( pToken )
+   {
+      if( fFree )
+      {
+         ** pTokenPtr = pToken->pNext;
+         hb_pp_tokenFree( pToken );
+      }
+      else
+      {
+         * pTokenPtr = &pToken->pNext;
+      }
+      pToken = **pTokenPtr;
+      if( pToken )
+      {
+         if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_BACKSLASH )
+         {
+            * pfQuoted = TRUE;
+            pToken->pNext->spaces = pToken->spaces;
+            ** pTokenPtr = pToken->pNext;
+            hb_pp_tokenFree( pToken );
+            pToken = ** pTokenPtr;
+         }
+      }
+   }
+
+   return pToken != NULL;
+}
+
+static BOOL hb_pp_matchMarkerNew( PHB_PP_TOKEN * pTokenPtr,
+                                  PHB_PP_MARKERLST * pMarkerListPtr )
+{
+   USHORT type = HB_PP_TOKEN_NUL;
+   PHB_PP_TOKEN pMarkerId = NULL, pMTokens = NULL;
+   BOOL fQuoted;
+
+   /* At start pTokenPtr points to '<' token */
+
+   if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted )
+   {
+      if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_KEYWORD )
+      {
+         pMarkerId = * pTokenPtr;
+         if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, FALSE ) && !fQuoted )
+         {
+            if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_GT )
+               type = HB_PP_MMARKER_REGULAR;
+            else if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_COMMA )
+            {
+               int i = 3;
+               do
+               {
+                  if( !hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) || fQuoted ||
+                      HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) != HB_PP_TOKEN_DOT )
+                     break;
+               }
+               while( --i > 0 );
+               if( i == 0 && hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) &&
+                   !fQuoted && HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_GT )
+                  type = HB_PP_MMARKER_LIST;
+            }
+            else if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_SEND )
+            {
+               if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) )
+               {
+                  PHB_PP_TOKEN pLast = NULL;
+                  do
+                  {
+                     if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_GT && !fQuoted )
+                     {
+                        if( pLast )
+                        {
+                           pMTokens = pMarkerId->pNext;
+                           pMarkerId->pNext = * pTokenPtr;
+                           pTokenPtr = &pMarkerId->pNext;
+                           pLast->pNext = NULL;
+                        }
+                        type = HB_PP_MMARKER_RESTRICT;
+                        break;
+                     }
+                     pLast = * pTokenPtr;
+                  }
+                  while( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, FALSE ) );
+               }
+            }
+         }
+      }
+      else if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_MULT )
+      {
+         if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+             HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_KEYWORD )
+         {
+            pMarkerId = * pTokenPtr;
+            if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, FALSE ) && !fQuoted &&
+                HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_MULT &&
+                hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+                HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_GT )
+               type = HB_PP_MMARKER_WILD;
+         }
+      }
+      else if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_LEFT_PB )
+      {
+         if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+             HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_KEYWORD )
+         {
+            pMarkerId = * pTokenPtr;
+            if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, FALSE ) && !fQuoted &&
+                HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_RIGHT_PB &&
+                hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+                HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_GT )
+               type = HB_PP_MMARKER_EXTEXP;
+         }
+      }
+      else if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_NOT )
+      {
+         if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+             HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_KEYWORD )
+         {
+            pMarkerId = * pTokenPtr;
+            if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, FALSE ) && !fQuoted &&
+                HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_NOT &&
+                hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+                HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_GT )
+               type = HB_PP_MMARKER_NAME;
+         }
+      }
+   }
+
+   if( type != HB_PP_TOKEN_NUL )
+   {
+      PHB_PP_MARKERLST pMrkLst = * pMarkerListPtr, pMrkPrev = NULL;
+      PHB_PP_MARKERPTR pMrkPtr;
+
+      while( pMrkLst && !hb_pp_tokenEqual( pMrkLst->pMatchMarkers->pToken,
+                                           pMarkerId, HB_PP_CMP_CASE ) )
+      {
+         pMrkPrev = pMrkLst;
+         pMrkLst = pMrkLst->pNext;
+      }
+      if( !pMrkLst )
+      {
+         pMrkLst = ( PHB_PP_MARKERLST ) hb_xgrab( sizeof( HB_PP_MARKERLST ) );
+         if( pMrkPrev )
+            pMrkPrev->pNext = pMrkLst;
+         else
+            * pMarkerListPtr = pMrkLst;
+         pMrkLst->pNext = NULL;
+         pMrkLst->pMatchMarkers = NULL;
+         pMrkLst->canrepeat = TRUE;
+         pMrkLst->index = 0;
+      }
+      pMrkPtr = ( PHB_PP_MARKERPTR ) hb_xgrab( sizeof( HB_PP_MARKERPTR ) );
+      pMrkPtr->pNext = pMrkLst->pMatchMarkers;
+      pMrkLst->pMatchMarkers = pMrkPtr;
+      pMrkPtr->pToken = pMarkerId;
+      pMrkPtr->pMTokens = pMTokens;
+      pMrkPtr->type = type;
+      /* mark non restricted markers for later detection two consecutive
+         optional match markers */
+      if( type != HB_PP_MMARKER_RESTRICT )
+         pMarkerId->type |= HB_PP_TOKEN_MATCHMARKER;
+      /* free the trailing '>' marker token */
+      pMTokens = *pTokenPtr;
+      * pTokenPtr = pMTokens->pNext;
+      hb_pp_tokenFree( pMTokens );
+      return TRUE;
+   }
+   return FALSE;
+}
+
+static BOOL hb_pp_matchHasKeywords( PHB_PP_TOKEN pToken )
+{
+   /* Now we are strictly Clipper compatible here though the nested
+      optional markers which have keywords on deeper levels are not
+      recognized. Exactly the same makes Clipper PP */
+   while( HB_PP_TOKEN_ISMATCH( pToken ) )
+      pToken = pToken->pNext;
+   return pToken != NULL;
+}
+
+static BOOL hb_pp_matchPatternNew( PHB_PP_STATE pState, PHB_PP_TOKEN * pTokenPtr,
+                                   PHB_PP_MARKERLST * pMarkerListPtr,
+                                   PHB_PP_TOKEN ** pOptional )
+{
+   PHB_PP_TOKEN * pLastPtr = NULL;
+   BOOL fQuoted = FALSE;
+
+   if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_BACKSLASH )
+   {
+      PHB_PP_TOKEN pToken = * pTokenPtr;
+      * pTokenPtr = pToken->pNext;
+      hb_pp_tokenFree( pToken );
+      fQuoted = TRUE;
+   }
+
+   do
+   {
+      if( !fQuoted )
+      {
+         if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_LT )
+         {
+            if( !hb_pp_matchMarkerNew( pTokenPtr, pMarkerListPtr ) )
+            {
+               hb_pp_error( pState, 'E', HB_PP_ERR_BAD_MATCH_MARKER, NULL );
+               return FALSE;
+            }
+            /* now pTokenPtr points to marker keyword, all other tokens
+               have been stripped */
+         }
+         else if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_RIGHT_SB )
+         {
+            if( pOptional )
+            {
+               * pOptional = pTokenPtr;
+               return TRUE;
+            }
+         }
+         else if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_LEFT_SB )
+         {
+            PHB_PP_TOKEN * pStopOptPtr = NULL;
+            if( ! ( * pTokenPtr )->pNext )
+            {
+               /* assign pOptional only to force error below */
+               pOptional = &pTokenPtr;
+               break;
+            }
+            else if( ! hb_pp_matchPatternNew( pState, &( * pTokenPtr )->pNext,
+                                              pMarkerListPtr, &pStopOptPtr ) )
+               return FALSE;
+            else if( * pStopOptPtr == ( * pTokenPtr )->pNext )
+            {
+               hb_pp_error( pState, 'E', HB_PP_ERR_EMPTY_OPTIONAL, NULL );
+               return FALSE;
+            }
+            else
+            {
+               PHB_PP_TOKEN pToken, pOptional = ( * pTokenPtr )->pNext;
+               pToken = * pStopOptPtr;
+               * pStopOptPtr = NULL;
+               ( * pTokenPtr )->pNext = pToken->pNext;
+               hb_pp_tokenFree( pToken );
+               /* create new optional match marker */
+               HB_PP_TOKEN_SETTYPE( * pTokenPtr, HB_PP_MMARKER_OPTIONAL );
+               if( ( * pTokenPtr )->spaces > 1 )
+                  ( * pTokenPtr )->spaces = 1;
+               ( * pTokenPtr )->type |= HB_PP_TOKEN_MATCHMARKER;
+               ( * pTokenPtr )->pMTokens = pOptional;
+               if( pLastPtr && !hb_pp_matchHasKeywords( * pLastPtr ) )
+               {
+                  if( !hb_pp_matchHasKeywords( pOptional ) )
+                  {
+                     hb_pp_error( pState, 'E', HB_PP_ERR_AMBIGUOUS_MATCH_PATTERN, NULL );
+                     return FALSE;
+                  }
+                  /* replace the order for these optional tokens to keep
+                     the ones with keywords 1-st */
+                  ( * pTokenPtr )->pMTokens = * pLastPtr;
+                  * pLastPtr = pOptional;
+               }
+               pLastPtr = &( * pTokenPtr )->pMTokens;
+               /* to skip resetting pLastPtr below */
+               continue;
+            }
+         }
+      }
+      pLastPtr = NULL;
+   }
+   while( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, FALSE ) );
+
+   if( pOptional )
+   {
+      hb_pp_error( pState, 'E', HB_PP_ERR_UNCLOSED_OPTIONAL, NULL );
+      return FALSE;
+   }
+
+   return TRUE;
+}
+
+static BOOL hb_pp_resultMarkerNew( PHB_PP_STATE pState,
+                                   PHB_PP_TOKEN * pTokenPtr,
+                                   PHB_PP_MARKERLST * pMarkerListPtr,
+                                   BOOL fDump, BOOL fOptional,
+                                   USHORT * pusPCount, USHORT spaces )
+{
+   USHORT type = HB_PP_TOKEN_NUL, rtype;
+   PHB_PP_TOKEN pMarkerId = NULL, pToken;
+   BOOL fQuoted;
+
+   /* At start pTokenPtr points to '<' token */
+   if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted )
+   {
+      rtype = HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type );
+      if( rtype == HB_PP_TOKEN_KEYWORD || rtype == HB_PP_TOKEN_STRING )
+      {
+         pMarkerId = * pTokenPtr;
+         if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, FALSE ) && !fQuoted &&
+             HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_GT )
+         {
+            if( rtype == HB_PP_TOKEN_STRING )
+            {
+               type = HB_PP_RMARKER_STRSTD;
+               HB_PP_TOKEN_SETTYPE( pMarkerId, HB_PP_TOKEN_KEYWORD );
+            }
+            else
+               type = fDump ? HB_PP_RMARKER_STRDUMP : HB_PP_RMARKER_REGULAR;
+         }
+      }
+      else if( rtype == HB_PP_TOKEN_LEFT_PB )
+      {
+         if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+             HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_KEYWORD )
+         {
+            pMarkerId = * pTokenPtr;
+            if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, FALSE ) && !fQuoted &&
+                HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_RIGHT_PB &&
+                hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+                HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_GT )
+               type = HB_PP_RMARKER_STRSMART;
+         }
+      }
+      else if( rtype == HB_PP_TOKEN_LEFT_CB )
+      {
+         if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+             HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_KEYWORD )
+         {
+            pMarkerId = * pTokenPtr;
+            if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, FALSE ) && !fQuoted &&
+                HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_RIGHT_CB &&
+                hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+                HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_GT )
+               type = HB_PP_RMARKER_BLOCK;
+         }
+      }
+      else if( rtype == HB_PP_TOKEN_DOT )
+      {
+         if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+             HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_KEYWORD )
+         {
+            pMarkerId = * pTokenPtr;
+            if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, FALSE ) && !fQuoted &&
+                HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_DOT &&
+                hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+                HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_GT )
+               type = HB_PP_RMARKER_LOGICAL;
+         }
+      }
+      else if( rtype == HB_PP_TOKEN_MINUS )
+      {
+         if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+             HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_KEYWORD )
+         {
+            pMarkerId = * pTokenPtr;
+            if( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, FALSE ) && !fQuoted )
+            {
+               /* <-id-> was bad choice for marker type because -> is single
+                  ALIAS token so we have to add workaround for it now */
+               if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_ALIAS ||
+                   ( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_MINUS &&
+                     hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, TRUE ) && !fQuoted &&
+                     HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_GT ) )
+                  type = HB_PP_RMARKER_NUL;
+            }
+         }
+      }
+   }
+
+   if( type == HB_PP_TOKEN_NUL )
+   {
+      hb_pp_error( pState, 'E', HB_PP_ERR_WRONG_LABEL, NULL );
+   }
+   else
+   {
+      PHB_PP_MARKERLST pMrkLst = * pMarkerListPtr;
+
+      while( pMrkLst && !hb_pp_tokenEqual( pMrkLst->pMatchMarkers->pToken,
+                                           pMarkerId, HB_PP_CMP_CASE ) )
+      {
+         pMrkLst = pMrkLst->pNext;
+      }
+
+      if( !pMrkLst )
+      {
+         hb_pp_error( pState, 'E', HB_PP_ERR_UNKNOWN_RESULT_MARKER, NULL );
+      }
+      else
+      {
+         if( !pMrkLst->index )
+            pMrkLst->index = ++( *pusPCount );
+         if( !fOptional )
+            pMrkLst->canrepeat = FALSE;
+         HB_PP_TOKEN_SETTYPE( pMarkerId, type );
+         pMarkerId->index = pMrkLst->index;
+         pMarkerId->spaces = spaces;
+         /* free the trailing '>' marker token */
+         pToken = *pTokenPtr;
+         * pTokenPtr = pToken->pNext;
+         hb_pp_tokenFree( pToken );
+         return TRUE;
+      }
+   }
+   return FALSE;
+}
+
+static BOOL hb_pp_patternCompare( PHB_PP_TOKEN pToken1, PHB_PP_TOKEN pToken2 )
+{
+   while( pToken1 && pToken2 )
+   {
+      if( !hb_pp_tokenEqual( pToken1, pToken2, HB_PP_CMP_STD ) )
+         break;
+      if( HB_PP_TOKEN_TYPE( pToken1->type ) == HB_PP_MMARKER_RESTRICT ||
+          HB_PP_TOKEN_TYPE( pToken1->type ) == HB_PP_MMARKER_OPTIONAL ||
+          HB_PP_TOKEN_TYPE( pToken1->type ) == HB_PP_RMARKER_OPTIONAL )
+      {
+         if( !hb_pp_patternCompare( pToken1->pMTokens, pToken2->pMTokens ) )
+            break;
+      }
+      pToken1 = pToken1->pNext;
+      pToken2 = pToken2->pNext;
+   }
+   return !pToken1 && !pToken2;
+}
+
+static void hb_pp_directiveDel( PHB_PP_STATE pState, PHB_PP_TOKEN pMatch,
+                                USHORT markers, PHB_PP_MARKER pMarkers,
+                                USHORT mode, BOOL fCommand )
+{
+   PHB_PP_RULE pRule, * pRulePtr = fCommand ? &pState->pCommands :
+                                              &pState->pTranslations;
+   while( * pRulePtr )
+   {
+      pRule = * pRulePtr;
+      if( HB_PP_CMP_MODE( pRule->mode ) == mode && pRule->markers == markers )
+      {
+         USHORT u;
+         for( u = 0; u < markers; ++u )
+         {
+            if( pRule->pMarkers[ u ].canrepeat != pMarkers[ u ].canrepeat )
+               break;
+         }
+         if( u == markers && hb_pp_patternCompare( pRule->pMatch, pMatch ) )
+         {
+            * pRulePtr = pRule->pPrev;
+            hb_pp_ruleFree( pRule );
+            if( fCommand )
+               pState->iCommands--;
+            else
+               pState->iTranslations--;
+            return;
+         }
+      }
+      pRulePtr = &pRule->pPrev;
+   }
+}
+
+static void hb_pp_directiveNew( PHB_PP_STATE pState, PHB_PP_TOKEN pToken,
+                                USHORT mode, BOOL fCommand, BOOL fDirect,
+                                BOOL fDelete )
+{
+   PHB_PP_TOKEN pResult, pMatch, pStart, pLast;
+   BOOL fValid = FALSE;
+
+#ifdef HB_C52_STRICT
+   HB_SYMBOL_UNUSED( fDirect );
+#endif
+
+   pMatch = pResult = pLast = NULL;
+   if( pToken->pNext )
+   {
+      pStart = pToken->pNext;
+      while( !HB_PP_TOKEN_ISEOP( pStart, fDirect ) )
+      {
+         if( pMatch )
+         {
+            /* Clipper PP makes sth like that for result pattern of
+               #[x]translate and #[x]command */
+            if( pStart->spaces > 1 )
+               pStart->spaces = 1;
+         }
+         else if( pStart->pNext &&
+                  HB_PP_TOKEN_TYPE( pStart->type ) == HB_PP_TOKEN_EQ &&
+                  HB_PP_TOKEN_TYPE( pStart->pNext->type ) == HB_PP_TOKEN_GT )
+         {
+            fValid = TRUE;
+            if( !pLast )
+               break;
+
+            pLast->pNext = NULL;
+            pMatch = pToken->pNext;
+            pToken->pNext = pStart;
+            pToken = pStart = pStart->pNext;
+         }
+         pLast = pStart;
+         pStart = pStart->pNext;
+      }
+      if( pMatch && pLast != pToken )
+      {
+         pLast->pNext = NULL;
+         pResult = pToken->pNext;
+         pToken->pNext = pStart;
+      }
+   }
+
+   if( !fValid )
+   {
+      hb_pp_error( pState, 'E', HB_PP_ERR_MISSING_PATTERN_SEP, NULL );
+   }
+   else if( pMatch ) /* isn't dummy directive? */
+   {
+      PHB_PP_MARKERLST pMarkerList = NULL, pMrkLst;
+      PHB_PP_MARKERPTR pMrkPtr;
+      PHB_PP_MARKER pMarkers = NULL;
+      USHORT usPCount = 0;
+
+      fValid = hb_pp_matchPatternNew( pState, &pMatch, &pMarkerList, NULL );
+      if( fValid )
+      {
+         if( pResult )
+         {
+            PHB_PP_TOKEN * pTokenPtr, * pDumpPtr = NULL, * pOptStart = NULL;
+            BOOL fQuoted = FALSE;
+
+            if( HB_PP_TOKEN_TYPE( pResult->type ) == HB_PP_TOKEN_BACKSLASH )
+            {
+               fQuoted = TRUE;
+               pLast = pResult;
+               pResult = pResult->pNext;
+               hb_pp_tokenFree( pLast );
+            }
+            pTokenPtr = &pResult;
+            do
+            {
+               if( !fQuoted )
+               {
+                  if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_HASH )
+                  {
+                     pDumpPtr = pTokenPtr;
+                     /* to skip pDumpPtr reseting below */
+                     continue;
+                  }
+                  else if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_LT )
+                  {
+                     USHORT spaces = ( * pTokenPtr )->spaces;
+                     /* Free the string dump token: '#'. Clipper PP always
+                        does it without checking type of next marker */
+                     if( pDumpPtr )
+                     {
+                        pLast = * pDumpPtr;
+                        spaces = pLast->spaces;
+                        * pDumpPtr = pLast->pNext;
+                        hb_pp_tokenFree( pLast );
+                        pTokenPtr = pDumpPtr;
+                     }
+
+                     if( !hb_pp_resultMarkerNew( pState, pTokenPtr, &pMarkerList,
+                                                 pDumpPtr != NULL, pOptStart != NULL,
+                                                 &usPCount, spaces ) )
+                     {
+                        fValid = FALSE;
+                        break;
+                     }
+                     /* now pTokenPtr points to marker keyword, all other tokens
+                        have been stripped */
+                  }
+                  else if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_LEFT_SB )
+                  {
+                     if( pOptStart )
+                     {
+                        fValid = FALSE;
+                        hb_pp_error( pState, 'E', HB_PP_ERR_NESTED_OPTIONAL, NULL );
+                        break;
+                     }
+                     pOptStart = pTokenPtr;
+                  }
+                  else if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_RIGHT_SB && pOptStart )
+                  {
+                     pLast = * pTokenPtr;
+                     * pTokenPtr = NULL;
+                     ( * pOptStart )->pMTokens = ( * pOptStart )->pNext;
+                     ( * pOptStart )->pNext = pLast->pNext;
+                     HB_PP_TOKEN_SETTYPE( * pOptStart, HB_PP_RMARKER_OPTIONAL );
+#ifndef HB_C52_STRICT
+                     /* This is not Clipper compatible but we have word
+                        concatenation and without this modification we
+                        will introduce very serious bug */
+                     if( ( * pOptStart )->pMTokens &&
+                         ( * pOptStart )->pMTokens->spaces == 0 &&
+                         ( * pOptStart )->spaces > 0 &&
+                         HB_PP_TOKEN_TYPE( ( * pOptStart )->pMTokens->type ) !=
+                                                            HB_PP_TOKEN_COMMA )
+                        ( * pOptStart )->pMTokens->spaces = 1;
+#endif
+                     pTokenPtr = pOptStart;
+                     pOptStart = NULL;
+                     hb_pp_tokenFree( pLast );
+                  }
+               }
+               /* reset pDumpPtr */
+               pDumpPtr = NULL;
+            }
+            while( hb_pp_tokenUnQuotedGet( &pTokenPtr, &fQuoted, FALSE ) );
+
+            if( fValid && pOptStart )
+            {
+               fValid = FALSE;
+               hb_pp_error( pState, 'E', HB_PP_ERR_UNKNOWN_RESULT_MARKER, NULL );
+            }
+         }
+      }
+
+      if( fValid && usPCount )
+      {
+         /* create regular match and result markers from parameters */
+         pMarkers = ( PHB_PP_MARKER ) hb_xgrab( usPCount * sizeof( HB_PP_MARKER ) );
+         memset( pMarkers, '\0', usPCount * sizeof( HB_PP_MARKER ) );
+      }
+
+      /* free marker index list */
+      while( pMarkerList )
+      {
+         pMrkLst = pMarkerList;
+         while( pMrkLst->pMatchMarkers )
+         {
+            pMrkPtr = pMrkLst->pMatchMarkers;
+            pMrkLst->pMatchMarkers = pMrkPtr->pNext;
+            /* set match token type and parameters */
+            if( pMarkers && pMrkLst->index )
+            {
+               pMarkers[ pMrkLst->index - 1 ].canrepeat = pMrkLst->canrepeat;
+               pMrkPtr->pToken->index = pMrkLst->index;
+            }
+            pMrkPtr->pToken->pMTokens = pMrkPtr->pMTokens;
+            HB_PP_TOKEN_SETTYPE( pMrkPtr->pToken, pMrkPtr->type );
+            hb_xfree( pMrkPtr );
+         }
+         pMarkerList = pMarkerList->pNext;
+         hb_xfree( pMrkLst );
+      }
+
+      if( fValid )
+      {
+         if( fDelete )
+         {
+            hb_pp_directiveDel( pState, pMatch, usPCount, pMarkers, mode, fCommand );
+            hb_xfree( pMarkers );
+         }
+         else
+         {
+            PHB_PP_RULE pRule;
+            pRule = hb_pp_ruleNew( pMatch, pResult, mode, usPCount, pMarkers );
+            if( fCommand )
+            {
+               pRule->pPrev = pState->pCommands;
+               pState->pCommands = pRule;
+               pState->iCommands++;
+            }
+            else
+            {
+               pRule->pPrev = pState->pTranslations;
+               pState->pTranslations = pRule;
+               pState->iTranslations++;
+            }
+            pMatch = pResult = NULL;
+         }
+      }
+   }
+   hb_pp_tokenListFree( &pMatch );
+   hb_pp_tokenListFree( &pResult );
+}
+
+static BOOL hb_pp_tokenSkipExp( PHB_PP_TOKEN * pTokenPtr, PHB_PP_TOKEN pStop,
+                                USHORT mode, BOOL * pfStop )
+{
+   USHORT curtype, prevtype = 0, lbrtype = 0, rbrtype = 0;
+   PHB_PP_TOKEN pToken = * pTokenPtr;
+   int iBraces = 0;
+   BOOL fMatch;
+
+   if( pfStop )
+      * pfStop = FALSE;
+
+   while( TRUE )
+   {
+      if( HB_PP_TOKEN_ISEOC( pToken ) )
+      {
+         if( pfStop )
+            * pfStop = TRUE;
+         break;
+      }
+      curtype = HB_PP_TOKEN_TYPE( pToken->type );
+      if( iBraces )
+      {
+         if( curtype == lbrtype )
+            ++iBraces;
+         else if( curtype == rbrtype )
+            --iBraces;
+      }
+      else if( mode == HB_PP_CMP_ADDR && pToken == pStop )
+      {
+         if( pfStop )
+            * pfStop = TRUE;
+         break;
+      }
+      else if( curtype == HB_PP_TOKEN_COMMA )
+      {
+         if( pfStop )
+         {
+            if( mode != HB_PP_CMP_ADDR && HB_PP_TOKEN_NEEDRIGHT( prevtype ) )
+               * pfStop = TRUE;
+            else
+               pToken = pToken->pNext;
+         }
+         break;
+      }
+      else if( mode != HB_PP_CMP_ADDR &&
+               ( HB_PP_TOKEN_CLOSE_BR( curtype ) ||
+                 ( prevtype == 0 && HB_PP_TOKEN_NEEDLEFT( curtype ) ) ||
+                 ( ! HB_PP_TOKEN_CANJOIN( curtype ) &&
+                   ! HB_PP_TOKEN_CANJOIN( prevtype ) ) ||
+                 ( HB_PP_TOKEN_NEEDRIGHT( prevtype ) &&
+                   ! HB_PP_TOKEN_ISEXPTOKEN( pToken ) ) ||
+                 ( pStop && hb_pp_tokenEqual( pToken, pStop, mode ) ) ) )
+      {
+         if( pfStop )
+            * pfStop = TRUE;
+         break;
+      }
+      else if( HB_PP_TOKEN_OPEN_BR( curtype ) )
+      {
+         lbrtype = curtype;
+         rbrtype = ( curtype == HB_PP_TOKEN_LEFT_PB ? HB_PP_TOKEN_RIGHT_PB :
+                   ( curtype == HB_PP_TOKEN_LEFT_SB ? HB_PP_TOKEN_RIGHT_SB :
+                                                      HB_PP_TOKEN_RIGHT_CB ) );
+         ++iBraces;
+      }
+      if( curtype != HB_PP_TOKEN_INC && curtype != HB_PP_TOKEN_DEC )
+         prevtype = curtype;
+      pToken = pToken->pNext;
+   }
+
+   fMatch = pToken != * pTokenPtr;
+   * pTokenPtr = pToken;
+
+   return fMatch;
+}
+
+static BOOL hb_pp_tokenMatch( PHB_PP_TOKEN pMatch, PHB_PP_TOKEN * pTokenPtr,
+                              PHB_PP_TOKEN pStop, USHORT mode )
+{
+   BOOL fMatch = FALSE;
+   USHORT type;
+
+   type = HB_PP_TOKEN_TYPE( pMatch->type );
+   if( type == HB_PP_MMARKER_REGULAR )
+   {
+      if( !pStop )
+      {
+         pStop = pMatch->pNext;
+         while( pStop && HB_PP_TOKEN_TYPE( pStop->type ) == HB_PP_MMARKER_OPTIONAL )
+            pStop = pStop->pNext;
+      }
+      fMatch = hb_pp_tokenSkipExp( pTokenPtr, pStop, mode, NULL );
+   }
+   else if( type == HB_PP_MMARKER_LIST )
+   {
+      BOOL fStop = FALSE;
+      if( !pStop )
+      {
+         pStop = pMatch->pNext;
+         while( pStop && HB_PP_TOKEN_TYPE( pStop->type ) == HB_PP_MMARKER_OPTIONAL )
+            pStop = pStop->pNext;
+      }
+      do
+      {
+         if( ! hb_pp_tokenSkipExp( pTokenPtr, pStop, mode, &fStop ) )
+            break;
+         fMatch = TRUE;
+      }
+      while( !fStop );
+   }
+   else if( type == HB_PP_MMARKER_RESTRICT )
+   {
+      PHB_PP_TOKEN pRestrict = pMatch->pMTokens, pToken = * pTokenPtr;
+
+      /*
+       * Here we are strictly Clipper compatible. Clipper accepts dummy
+       * restrict marker which starts from comma, <id: ,[ sth,...]>
+       * which always match empty expression. The same effect can be
+       * reached by giving ,, in the world list on other positions.
+       */
+      while( pRestrict )
+      {
+         if( HB_PP_TOKEN_TYPE( pRestrict->type ) == HB_PP_TOKEN_COMMA )
+         {
+            * pTokenPtr = pToken;
+            fMatch = TRUE;
+            break;
+         }
+         else if( HB_PP_TOKEN_TYPE( pRestrict->type ) == HB_PP_TOKEN_AMPERSAND &&
+                  ( !pRestrict->pNext ||
+                    HB_PP_TOKEN_TYPE( pRestrict->pNext->type ) == HB_PP_TOKEN_COMMA ) &&
+                  ( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_MACRO ||
+                    ( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_AMPERSAND &&
+                      pToken->pNext &&
+                      HB_PP_TOKEN_TYPE( pToken->pNext->type ) == HB_PP_TOKEN_LEFT_PB ) ) )
+         {
+            if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_MACRO )
+            {
+               * pTokenPtr = pToken->pNext;
+            }
+            else
+            {
+               int iBraces = 1;
+               pToken = pToken->pNext->pNext;
+               while( iBraces > 0 && !HB_PP_TOKEN_ISEOC( pToken ) )
+               {
+                  if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_LEFT_PB )
+                     ++iBraces;
+                  else if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_RIGHT_PB )
+                     --iBraces;
+                  pToken = pToken->pNext;
+               }
+               * pTokenPtr = pToken;
+            }
+            fMatch = TRUE;
+            break;
+         }
+         else if( !HB_PP_TOKEN_ISEOC( pToken ) &&
+                  hb_pp_tokenEqual( pToken, pRestrict, mode ) )
+         {
+            pToken = pToken->pNext;
+            pRestrict = pRestrict->pNext;
+            if( !pRestrict )
+            {
+               * pTokenPtr = pToken;
+               fMatch = TRUE;
+               break;
+            }
+         }
+         else
+         {
+            pToken = * pTokenPtr;
+            do
+            {
+               type = HB_PP_TOKEN_TYPE( pRestrict->type );
+               pRestrict = pRestrict->pNext;
+            }
+            while( pRestrict && type != HB_PP_TOKEN_COMMA );
+         }
+      }
+   }
+   else if( type == HB_PP_MMARKER_WILD )
+   {
+      /* TODO? now we are strictly Clipper compatible, but we may
+         want to add some additional stop markers in the future here
+         to support wild match markers also as not the last expression */
+      if( !HB_PP_TOKEN_ISEOS( * pTokenPtr ) )
+      {
+         fMatch = TRUE;
+         do
+            * pTokenPtr = ( * pTokenPtr )->pNext;
+         while( !HB_PP_TOKEN_ISEOS( * pTokenPtr ) );
+      }
+   }
+   else if( type == HB_PP_MMARKER_EXTEXP )
+   {
+      if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) != HB_PP_TOKEN_RIGHT_PB &&
+          HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) != HB_PP_TOKEN_RIGHT_SB &&
+          HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) != HB_PP_TOKEN_COMMA &&
+          !HB_PP_TOKEN_NEEDLEFT( ( * pTokenPtr )->type ) )
+      {
+         if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_LEFT_PB )
+         {
+            if( !pStop )
+            {
+               pStop = pMatch->pNext;
+               while( pStop && HB_PP_TOKEN_TYPE( pStop->type ) == HB_PP_MMARKER_OPTIONAL )
+                  pStop = pStop->pNext;
+            }
+            fMatch = hb_pp_tokenSkipExp( pTokenPtr, pStop, mode, NULL );
+         }
+         else
+         {
+            do
+            {
+               * pTokenPtr = ( * pTokenPtr )->pNext;
+            }
+            while( !HB_PP_TOKEN_ISEOC( * pTokenPtr ) &&
+                   ( * pTokenPtr )->spaces == 0 &&
+                   HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) != HB_PP_TOKEN_COMMA );
+
+            fMatch = TRUE;
+         }
+      }
+   }
+   else if( type == HB_PP_MMARKER_NAME )
+   {
+      if( HB_PP_TOKEN_TYPE( ( * pTokenPtr )->type ) == HB_PP_TOKEN_KEYWORD )
+      {
+         * pTokenPtr = ( * pTokenPtr )->pNext;
+         fMatch = TRUE;
+      }
+   }
+   else if( hb_pp_tokenEqual( * pTokenPtr, pMatch, mode ) )
+   {
+      * pTokenPtr = ( * pTokenPtr )->pNext;
+      fMatch = TRUE;
+   }
+
+   return fMatch;
+}
+
+static BOOL hb_pp_patternMatch( PHB_PP_TOKEN pMatch, PHB_PP_TOKEN * pTokenPtr,
+                                PHB_PP_TOKEN pStop,
+                                USHORT mode, PHB_PP_RULE pRule )
+{
+   PHB_PP_TOKEN pToken = * pTokenPtr;
+   PHB_PP_TOKEN pFirst;
+   BOOL fOverflow = FALSE;
+
+   while( pMatch && !HB_PP_TOKEN_ISEOS( pToken ) )
+   {
+      if( HB_PP_TOKEN_TYPE( pMatch->type ) == HB_PP_MMARKER_OPTIONAL )
+      {
+         PHB_PP_TOKEN pOptional = pMatch, pLast, pNewStop = pMatch->pNext;
+
+         while( pNewStop && HB_PP_TOKEN_TYPE( pNewStop->type ) == HB_PP_MMARKER_OPTIONAL )
+            pNewStop = pNewStop->pNext;
+
+         do
+         {
+            pLast = pOptional;
+            pFirst = pToken;
+            if( hb_pp_patternMatch( pOptional->pMTokens, &pToken, pNewStop, mode, NULL ) &&
+                pFirst != pToken )
+            {
+               if( pRule && ! hb_pp_patternMatch( pOptional->pMTokens, &pFirst, pNewStop, mode, pRule ) )
+               {
+                  fOverflow = TRUE;
+                  break;
+               }
+               pOptional = pMatch;
+            }
+            else
+               pOptional = pOptional->pNext;
+         }
+         while( pOptional && HB_PP_TOKEN_TYPE( pOptional->type ) == HB_PP_MMARKER_OPTIONAL &&
+                !HB_PP_TOKEN_ISEOS( pToken ) );
+         pMatch = pLast;
+      }
+      else
+      {
+         pFirst = pToken;
+         if( hb_pp_tokenMatch( pMatch, &pToken, pStop, mode ) )
+         {
+            if( pRule && pMatch->index && pFirst != pToken )
+            {
+               if( !hb_pp_patternAddResult( pRule, pMatch->index, pFirst, pToken ) )
+               {
+                  fOverflow = TRUE;
+                  break;
+               }
+            }
+         }
+         else
+            break;
+      }
+
+      pMatch = pMatch->pNext;
+   }
+
+   if( !fOverflow )
+   {
+      while( pMatch && HB_PP_TOKEN_TYPE( pMatch->type ) == HB_PP_MMARKER_OPTIONAL )
+         pMatch = pMatch->pNext;
+      if( pMatch == NULL )
+      {
+         * pTokenPtr = pToken;
+         if( pRule )
+            pRule->pNextExpr = pToken;
+         return TRUE;
+      }
+   }
+   return FALSE;
+}
+
+static BOOL hb_pp_patternCmp( PHB_PP_RULE pRule, PHB_PP_TOKEN pToken,
+                              BOOL fCommand )
+{
+   PHB_PP_TOKEN pFirst = pToken;
+
+   if( hb_pp_patternMatch( pRule->pMatch, &pToken, NULL,
+                           HB_PP_CMP_MODE( pRule->mode ), NULL ) )
+   {
+      if( !fCommand || HB_PP_TOKEN_ISEOC( pToken ) )
+      {
+         if( hb_pp_patternMatch( pRule->pMatch, &pFirst, NULL,
+                                 HB_PP_CMP_MODE( pRule->mode ), pRule ) )
+            return TRUE;
+         else
+            hb_pp_patternClearResults( pRule );
+      }
+   }
+   return FALSE;
+}
+
+static PHB_PP_RESULT hb_pp_matchResultGet( PHB_PP_RULE pRule, USHORT usMatch,
+                                           USHORT usIndex )
+{
+   PHB_PP_MARKER pMarker = &pRule->pMarkers[ usIndex - 1];
+   PHB_PP_RESULT pMarkerResult;
+
+   /* Clipper PP does not check status of match marker but only how many
+      different values were assigned to match pattern */
+   if( pMarker->matches == 1 )
+      pMarkerResult = pMarker->pResult;
+   else if( usMatch < pMarker->matches )
+   {
+      pMarkerResult = pMarker->pResult;
+      while( usMatch-- )
+         pMarkerResult = pMarkerResult->pNext;
+   }
+   else
+      pMarkerResult = NULL;
+
+   return pMarkerResult;
+}
+
+static PHB_PP_TOKEN * hb_pp_matchResultLstAdd( PHB_PP_STATE pState,
+                                               USHORT spaces, USHORT type,
+                                               PHB_PP_TOKEN * pResultPtr,
+                                               PHB_PP_TOKEN pToken,
+                                               PHB_PP_TOKEN pStop )
+{
+   PHB_PP_TOKEN pNext;
+   BOOL fFirst = TRUE, fStop = FALSE;
+
+   while( TRUE )
+   {
+      pNext = pToken;
+      if( hb_pp_tokenSkipExp( &pNext, pStop, HB_PP_CMP_ADDR, &fStop ) &&
+          ( fStop ? pToken : pToken->pNext ) != pNext )
+      {
+         /* Check for '&' token followed by single keyword or '('
+            token and do not stringify such expressions but
+            clone them */
+         if( type == HB_PP_RMARKER_BLOCK )
+         {
+            BOOL fBlock = HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_LEFT_CB &&
+                          pToken->pNext &&
+                          ( fStop ? pToken->pNext : pToken->pNext->pNext ) != pNext &&
+                          HB_PP_TOKEN_TYPE( pToken->pNext->type ) == HB_PP_TOKEN_PIPE;
+
+            if( !fBlock )
+            {
+               hb_pp_tokenAdd( &pResultPtr, "{", 1, fFirst ? spaces : 1,
+                               HB_PP_TOKEN_LEFT_CB | HB_PP_TOKEN_STATIC );
+               hb_pp_tokenAdd( &pResultPtr, "|", 1, 0, HB_PP_TOKEN_PIPE | HB_PP_TOKEN_STATIC );
+               hb_pp_tokenAdd( &pResultPtr, "|", 1, 0, HB_PP_TOKEN_PIPE | HB_PP_TOKEN_STATIC );
+               fFirst = FALSE;
+            }
+            do
+            {
+               * pResultPtr = hb_pp_tokenClone( pToken );
+               if( fFirst )
+               {
+                  ( * pResultPtr )->spaces = spaces;
+                  fFirst = FALSE;
+               }
+               pResultPtr = &( * pResultPtr )->pNext;
+               pToken = pToken->pNext;
+            }
+            while( ( fStop ? pToken : pToken->pNext ) != pNext );
+            if( !fBlock )
+               hb_pp_tokenAdd( &pResultPtr, "}", 1, 0, HB_PP_TOKEN_RIGHT_CB | HB_PP_TOKEN_STATIC );
+         }
+         else if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_MACRO &&
+                  ( fStop ? pToken->pNext : pToken->pNext->pNext ) == pNext )
+         {
+            USHORT len = 0;
+            while( ++len < pToken->len &&
+                   HB_PP_ISNEXTIDCHAR( pToken->value[ len ] ) );
+            if( len == pToken->len ||
+                ( len == pToken->len - 1 && pToken->value[ len ] == '.' ) )
+            {
+               hb_pp_tokenAdd( &pResultPtr, pToken->value + 1, len - 1,
+                               fFirst ? spaces : pToken->spaces,
+                               HB_PP_TOKEN_KEYWORD );
+            }
+            else
+            {
+               hb_membufFlush( pState->pBuffer );
+               hb_pp_tokenStr( pToken, pState->pBuffer, FALSE, FALSE, 0 );
+               hb_pp_tokenAdd( &pResultPtr,
+                               hb_membufPtr( pState->pBuffer ),
+                               hb_membufLen( pState->pBuffer ),
+                               fFirst ? spaces : pToken->spaces,
+                               HB_PP_TOKEN_STRING );
+            }
+            pToken = pToken->pNext;
+            fFirst = FALSE;
+         }
+         else if( ( type == HB_PP_RMARKER_STRSMART &&
+                    ( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_STRING ||
+                      HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_LEFT_PB ) ) ||
+                  ( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_AMPERSAND &&
+                    pToken->pNext &&
+                    ( fStop ? pToken->pNext : pToken->pNext->pNext ) != pNext &&
+                    HB_PP_TOKEN_TYPE( pToken->pNext->type ) == HB_PP_TOKEN_LEFT_PB ) )
+         {
+            if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_AMPERSAND )
+               pToken = pToken->pNext;
+            do
+            {
+               * pResultPtr = hb_pp_tokenClone( pToken );
+               if( fFirst )
+               {
+                  ( * pResultPtr )->spaces = spaces;
+                  fFirst = FALSE;
+               }
+               pResultPtr = &( * pResultPtr )->pNext;
+               pToken = pToken->pNext;
+            }
+            while( ( fStop ? pToken : pToken->pNext ) != pNext );
+         }
+         else
+         {
+            /* leading spaces calculation in Clipper is broken when 
+               separate tokens are stringified, it can be quite
+               easy checked that it will interact with translation
+               done just before - spaces are partially inherited.
+               It means that Clipper PP does not clear some static
+               buffers where holds this information.
+               I decided to keep original internal spacing except the
+               first token */
+            BOOL fSpaces = FALSE;
+            if( !fFirst )
+               spaces = pToken->spaces;
+            hb_membufFlush( pState->pBuffer );
+            do
+            {
+               hb_pp_tokenStr( pToken, pState->pBuffer, fSpaces, FALSE, 0 );
+               fSpaces = TRUE;
+               pToken = pToken->pNext;
+            }
+            while( ( fStop ? pToken : pToken->pNext ) != pNext );
+            hb_pp_tokenAdd( &pResultPtr,
+                            hb_membufPtr( pState->pBuffer ),
+                            hb_membufLen( pState->pBuffer ),
+                            spaces, HB_PP_TOKEN_STRING );
+            fFirst = FALSE;
+         }
+      }
+      if( fStop )
+         break;
+      /* clone comma token */
+      * pResultPtr = hb_pp_tokenClone( pToken );
+      if( fFirst )
+      {
+         ( * pResultPtr )->spaces = spaces;
+         fFirst = FALSE;
+      }
+      pResultPtr = &( * pResultPtr )->pNext;
+      pToken = pNext;
+   }
+
+   return pResultPtr;
+}
+
+static PHB_PP_TOKEN * hb_pp_matchResultAdd( PHB_PP_STATE pState,
+                                 PHB_PP_RULE pRule, PHB_PP_TOKEN * pResultPtr,
+                                 PHB_PP_TOKEN pMatch, USHORT usMatch )
+{
+   PHB_PP_RESULT pMarkerResult = hb_pp_matchResultGet( pRule, usMatch, pMatch->index );
+   PHB_PP_TOKEN pToken, pStop;
+   BOOL fSpaces, fFirst;
+
+   if( HB_PP_TOKEN_TYPE( pMatch->type ) == HB_PP_RMARKER_REGULAR )
+   {
+      if( pMarkerResult )
+      {
+         pToken = pMarkerResult->pFirstToken;
+         pStop = pMarkerResult->pNextExpr;
+         fFirst = TRUE;
+         if( pToken != pStop )
+         {
+            do
+            {
+               * pResultPtr = hb_pp_tokenClone( pToken );
+               if( fFirst )
+               {
+                  ( * pResultPtr )->spaces = pMatch->spaces;
+                  fFirst = FALSE;
+               }
+               pResultPtr = &( * pResultPtr )->pNext;
+               pToken = pToken->pNext;
+            }
+            while( pToken != pStop );
+         }
+      }
+   }
+   else if( HB_PP_TOKEN_TYPE( pMatch->type ) == HB_PP_RMARKER_STRDUMP )
+   {
+      hb_membufFlush( pState->pBuffer );
+      if( pMarkerResult )
+      {
+         pToken = pMarkerResult->pFirstToken;
+         pStop = pMarkerResult->pNextExpr;
+         if( pToken != pStop )
+         {
+            fSpaces = FALSE;
+            do
+            {
+               hb_pp_tokenStr( pToken, pState->pBuffer, fSpaces, FALSE, 0 );
+               fSpaces = TRUE;
+               pToken = pToken->pNext;
+            }
+            while( pToken != pStop );
+         }
+      }
+      hb_pp_tokenAdd( &pResultPtr, hb_membufPtr( pState->pBuffer ),
+                      hb_membufLen( pState->pBuffer ),
+                      pMatch->spaces, HB_PP_TOKEN_STRING );
+   }
+   else if( HB_PP_TOKEN_TYPE( pMatch->type ) == HB_PP_RMARKER_STRSTD ||
+            HB_PP_TOKEN_TYPE( pMatch->type ) == HB_PP_RMARKER_STRSMART ||
+            HB_PP_TOKEN_TYPE( pMatch->type ) == HB_PP_RMARKER_BLOCK )
+   {
+      if( pMarkerResult )
+      {
+         pToken = pMarkerResult->pFirstToken;
+         pStop = pMarkerResult->pNextExpr;
+         /* We have to divide the expression to comma separated ones */
+         if( pToken != pStop )
+         {
+            pResultPtr = hb_pp_matchResultLstAdd( pState, pMatch->spaces,
+                  HB_PP_TOKEN_TYPE( pMatch->type ), pResultPtr, pToken, pStop );
+         }
+      }
+   }
+   else if( HB_PP_TOKEN_TYPE( pMatch->type ) == HB_PP_RMARKER_LOGICAL )
+   {
+      /* Clipper documentation is wrong and Clipper PP only checks
+         if such pattern was assigned not is non empty */
+      hb_pp_tokenAdd( &pResultPtr, pMarkerResult ? ".T." : ".F.", 3,
+               pMatch->spaces, HB_PP_TOKEN_LOGICAL | HB_PP_TOKEN_STATIC );
+   }
+   else if( HB_PP_TOKEN_TYPE( pMatch->type ) == HB_PP_RMARKER_NUL )
+   {
+      /* nothing to stuff */
+   }
+   else
+   {
+      /* TODO? internal error? */
+   }
+
+   return pResultPtr;
+}
+
+static PHB_PP_TOKEN *  hb_pp_patternStuff( PHB_PP_STATE pState,
+                                           PHB_PP_RULE pRule, USHORT usMatch,
+                                           PHB_PP_TOKEN pResultPattern,
+                                           PHB_PP_TOKEN * pResultPtr )
+{
+   while( pResultPattern )
+   {
+      if( pResultPattern->index )
+      {
+         pResultPtr = hb_pp_matchResultAdd( pState, pRule, pResultPtr, pResultPattern, usMatch );
+      }
+      else if( HB_PP_TOKEN_TYPE( pResultPattern->type ) == HB_PP_RMARKER_OPTIONAL )
+      {
+         USHORT usMaxMatch = 0, matches;
+         PHB_PP_TOKEN pToken = pResultPattern->pMTokens;
+         while( pToken )
+         {
+            if( pToken->index )
+            {
+               matches = pRule->pMarkers[ pToken->index - 1 ].matches;
+               if( matches > usMaxMatch )
+                  usMaxMatch = matches;
+            }
+            pToken = pToken->pNext;
+         }
+         for( matches = 0; matches < usMaxMatch; ++matches )
+         {
+            pResultPtr = hb_pp_patternStuff( pState, pRule, matches,
+                                             pResultPattern->pMTokens,
+                                             pResultPtr );
+         }
+      }
+      else
+      {
+         * pResultPtr = hb_pp_tokenClone( pResultPattern );
+         pResultPtr = &( * pResultPtr )->pNext;
+      }
+      pResultPattern = pResultPattern->pNext;
+   }
+
+   return pResultPtr;
+}
+
+static void hb_pp_patternReplace( PHB_PP_STATE pState, PHB_PP_RULE pRule,
+                                  PHB_PP_TOKEN * pTokenPtr )
+{
+   PHB_PP_TOKEN pFinalResult = NULL, * pResultPtr, pToken, pStop;
+
+   pResultPtr = hb_pp_patternStuff( pState, pRule, 0, pRule->pResult, &pFinalResult );
+
+   /* store original matched token pointer */
+   pStop = * pTokenPtr;
+   /* Replace matched tokens with result pattern */
+   * pResultPtr = pRule->pNextExpr;
+   * pTokenPtr = pFinalResult;
+   /* Copy number of leading spaces from the first matched token
+      to the first result token */
+   if( pFinalResult && pStop )
+      pFinalResult->spaces = pStop->spaces;
+   /* Free the matched tokens */
+   while( pStop != pRule->pNextExpr )
+   {
+      pToken = pStop;
+      pStop = pStop->pNext;
+      hb_pp_tokenFree( pToken );
+   }
+
+   hb_pp_patternClearResults( pRule );
+}
+
+static BOOL hb_pp_processDefine( PHB_PP_STATE pState, PHB_PP_TOKEN * pFirstPtr )
+{
+   PHB_PP_TOKEN * pPrevPtr;
+   BOOL fSubst = FALSE, fRepeat;
+   int iCycle = 0;
+
+   do
+   {
+      pPrevPtr = NULL;
+      fRepeat = FALSE;
+      while( !HB_PP_TOKEN_ISEOS( * pFirstPtr ) )
+      {
+         if( HB_PP_TOKEN_TYPE( ( * pFirstPtr )->type ) == HB_PP_TOKEN_KEYWORD )
+         {
+            PHB_PP_RULE pRule = hb_pp_defineFind( pState, * pFirstPtr );
+            if( pRule )
+            {
+               if( hb_pp_patternCmp( pRule, * pFirstPtr, FALSE ) )
+               {
+                  hb_pp_patternReplace( pState, pRule, pFirstPtr );
+                  fSubst = fRepeat = TRUE;
+                  if( ++pState->iCycle > pState->iMaxCycles ||
+                      ++iCycle > HB_PP_MAX_REPATS + pState->iDefinitions )
+                  {
+                     pState->iCycle = pState->iMaxCycles + 1;
+                     hb_pp_error( pState, 'E', HB_PP_ERR_CYCLIC_DEFINE, pRule->pMatch->value );
+                     return TRUE;
+                  }
+                  continue;
+               }
+               if( !pPrevPtr )
+                  pPrevPtr = pFirstPtr;
+            }
+         }
+         iCycle = 0;
+         pFirstPtr = &( * pFirstPtr )->pNext;
+      }
+      pFirstPtr = pPrevPtr;
+   }
+   while( pFirstPtr && fRepeat );
+
+   return fSubst;
+}
+
+static BOOL hb_pp_processTranslate( PHB_PP_STATE pState, PHB_PP_TOKEN * pFirstPtr )
+{
+   PHB_PP_TOKEN * pTokenPtr;
+   BOOL fSubst = FALSE, fRepeat;
+   int iCycle = 0;
+
+   do
+   {
+      pTokenPtr = pFirstPtr;
+      fRepeat = FALSE;
+      while( !HB_PP_TOKEN_ISEOS( * pTokenPtr ) )
+      {
+         PHB_PP_RULE pRule = pState->pTranslations;
+         while( pRule )
+         {
+            if( hb_pp_patternCmp( pRule, * pTokenPtr, FALSE ) )
+            {
+               hb_pp_patternReplace( pState, pRule, pTokenPtr );
+               fSubst = fRepeat = TRUE;
+               if( ++pState->iCycle > pState->iMaxCycles ||
+                   ++iCycle > HB_PP_MAX_REPATS + pState->iTranslations )
+               {
+                  pState->iCycle = pState->iMaxCycles + 1;
+                  hb_pp_error( pState, 'E', HB_PP_ERR_CYCLIC_TRANSLATE, pRule->pMatch->value );
+                  return TRUE;
+               }
+               pRule = pState->pTranslations;
+               continue;
+            }
+            pRule = pRule->pPrev;
+         }
+         iCycle = 0;
+         pTokenPtr = &( * pTokenPtr )->pNext;
+      }
+   }
+   while( fRepeat );
+
+   return fSubst;
+}
+
+static BOOL hb_pp_processCommand( PHB_PP_STATE pState, PHB_PP_TOKEN * pFirstPtr )
+{
+   PHB_PP_RULE pRule;
+   BOOL fSubst = FALSE, fRepeat = TRUE;
+   int iCycle = 0;
+
+   while( fRepeat && !HB_PP_TOKEN_ISEOC( * pFirstPtr ) )
+   {
+      fRepeat = FALSE;
+      pRule = pState->pCommands;
+      while( pRule )
+      {
+         if( hb_pp_patternCmp( pRule, * pFirstPtr, TRUE ) )
+         {
+            hb_pp_patternReplace( pState, pRule, pFirstPtr );
+            fSubst = fRepeat = TRUE;
+            if( ++pState->iCycle > pState->iMaxCycles ||
+                ++iCycle > HB_PP_MAX_REPATS + pState->iCommands )
+            {
+               pState->iCycle = pState->iMaxCycles + 1;
+               hb_pp_error( pState, 'E', HB_PP_ERR_CYCLIC_COMMAND, pRule->pMatch->value );
+               return TRUE;
+            }
+            break;
+         }
+         pRule = pRule->pPrev;
+      }
+   }
+
+   /* This is strictly compatible with Clipper PP which internally supports
+         text <!linefunc!>,<!endfunc!>
+      as stream begin directive */
+   if( !HB_PP_TOKEN_ISEOC( * pFirstPtr ) &&
+       hb_pp_tokenValueCmp( * pFirstPtr, "TEXT", HB_PP_CMP_DBASE ) )
+   {
+      PHB_PP_TOKEN pToken = ( * pFirstPtr )->pNext, * pFuncPtr;
+
+      if( pToken &&
+          HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_KEYWORD &&
+          pToken->pNext &&
+          HB_PP_TOKEN_TYPE( pToken->pNext->type ) == HB_PP_TOKEN_COMMA &&
+          pToken->pNext->pNext &&
+          HB_PP_TOKEN_TYPE( pToken->pNext->pNext->type ) == HB_PP_TOKEN_KEYWORD &&
+          HB_PP_TOKEN_ISEOC( pToken->pNext->pNext->pNext ) )
+      {
+         hb_pp_tokenListFree( &pState->pFuncOut );
+         hb_pp_tokenListFree( &pState->pFuncEnd );
+
+         pFuncPtr = &pState->pFuncOut;
+         hb_pp_tokenAdd( &pFuncPtr, pToken->value, pToken->len, 0, HB_PP_TOKEN_KEYWORD );
+         hb_pp_tokenAdd( &pFuncPtr, "(", 1, 0, HB_PP_TOKEN_LEFT_PB | HB_PP_TOKEN_STATIC );
+         hb_pp_tokenAdd( &pFuncPtr, "%", 1, 1, HB_PP_RMARKER_STRDUMP | HB_PP_TOKEN_STATIC );
+         hb_pp_tokenAdd( &pFuncPtr, ")", 1, 1, HB_PP_TOKEN_RIGHT_PB | HB_PP_TOKEN_STATIC );
+
+         pToken = pToken->pNext->pNext;
+         pFuncPtr = &pState->pFuncEnd;
+         hb_pp_tokenAdd( &pFuncPtr, pToken->value, pToken->len, 0, HB_PP_TOKEN_KEYWORD );
+         hb_pp_tokenAdd( &pFuncPtr, "(", 1, 0, HB_PP_TOKEN_LEFT_PB | HB_PP_TOKEN_STATIC );
+         hb_pp_tokenAdd( &pFuncPtr, ")", 1, 1, HB_PP_TOKEN_RIGHT_PB | HB_PP_TOKEN_STATIC );
+         pState->iStreamDump = HB_PP_STREAM_CLIPPER;
+         hb_pp_tokenListFreeCmd( pFirstPtr );
+         fSubst = TRUE;
+      }
+   }
+
+   return fSubst;
+}
+
+static BOOL hb_pp_concatenateKeywords( PHB_PP_STATE pState, PHB_PP_TOKEN * pFirstPtr )
+{
+   PHB_PP_TOKEN pToken = * pFirstPtr, pNext;
+   BOOL fChanged = FALSE;
+
+   while( pToken && pToken->pNext )
+   {
+      pNext = pToken->pNext;
+      if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_KEYWORD &&
+          pNext->spaces == 0 &&
+          HB_PP_TOKEN_TYPE( pNext->type ) == HB_PP_TOKEN_KEYWORD )
+      {
+         hb_membufFlush( pState->pBuffer );
+         hb_membufAddData( pState->pBuffer, pToken->value, pToken->len );
+         hb_membufAddData( pState->pBuffer, pNext->value, pNext->len );
+         hb_pp_tokenSetValue( pToken, hb_membufPtr( pState->pBuffer ),
+                                      hb_membufLen( pState->pBuffer ) );
+         pToken->pNext = pNext->pNext;
+         hb_pp_tokenFree( pNext );
+         fChanged = TRUE;
+      }
+      else
+         pToken = pNext;
+   }
+
+   return fChanged;
+}
+
+static int hb_pp_calcPrecedence( int iOperation )
+{
+   switch( iOperation )
+   {
+      /* not */
+      case HB_PP_TOKEN_NOT:
+         return HB_PP_PREC_NOT;
+
+      /* relational */
+      case HB_PP_TOKEN_EQUAL:
+      case HB_PP_TOKEN_HASH:
+      case HB_PP_TOKEN_NE:
+      case HB_PP_TOKEN_LE:
+      case HB_PP_TOKEN_GE:
+      case HB_PP_TOKEN_LT:
+      case HB_PP_TOKEN_GT:
+         return HB_PP_PREC_REL;
+
+      /* logical */
+      case HB_PP_TOKEN_AND:
+      case HB_PP_TOKEN_OR:
+         return HB_PP_PREC_LOG;
+
+      /* bit */
+      case HB_PP_TOKEN_PIPE:
+      case HB_PP_TOKEN_AMPERSAND:
+      case HB_PP_TOKEN_POWER:
+         return HB_PP_PREC_BIT;
+
+      /* math plus/minus */
+      case HB_PP_TOKEN_PLUS:
+      case HB_PP_TOKEN_MINUS:
+         return HB_PP_PREC_PLUS;
+
+      /* math mult/div/mode */
+      case HB_PP_TOKEN_MULT:
+      case HB_PP_TOKEN_DIV:
+      case HB_PP_TOKEN_MOD:
+         return HB_PP_PREC_MULT;
+   }
+
+   return HB_PP_PREC_NUL;
+}
+
+HB_LONG hb_pp_calcOperation( HB_LONG lValueLeft, HB_LONG lValueRight,
+                             int iOperation )
+{
+   switch( iOperation )
+   {
+      case HB_PP_TOKEN_EQUAL:
+         lValueLeft = ( lValueLeft == lValueRight ) ? 1 : 0;
+         break;
+      case HB_PP_TOKEN_HASH:
+      case HB_PP_TOKEN_NE:
+         lValueLeft = ( lValueLeft != lValueRight ) ? 1 : 0;
+         break;
+      case HB_PP_TOKEN_LE:
+         lValueLeft = ( lValueLeft <= lValueRight ) ? 1 : 0;
+         break;
+      case HB_PP_TOKEN_GE:
+         lValueLeft = ( lValueLeft >= lValueRight ) ? 1 : 0;
+         break;
+      case HB_PP_TOKEN_LT:
+         lValueLeft = ( lValueLeft < lValueRight ) ? 1 : 0;
+         break;
+      case HB_PP_TOKEN_GT:
+         lValueLeft = ( lValueLeft > lValueRight ) ? 1 : 0;
+         break;
+
+      case HB_PP_TOKEN_AND:
+         lValueLeft = ( lValueLeft && lValueRight ) ? 1 : 0;
+         break;
+      case HB_PP_TOKEN_OR:
+         lValueLeft = ( lValueLeft || lValueRight ) ? 1 : 0;
+         break;
+
+      case HB_PP_TOKEN_PIPE:
+         lValueLeft |= lValueRight;
+         break;
+      case HB_PP_TOKEN_AMPERSAND:
+         lValueLeft &= lValueRight;
+         break;
+      case HB_PP_TOKEN_POWER:
+         lValueLeft ^= lValueRight;
+         break;
+
+      case HB_PP_TOKEN_PLUS:
+         lValueLeft += lValueRight;
+         break;
+      case HB_PP_TOKEN_MINUS:
+         lValueLeft -= lValueRight;
+         break;
+      case HB_PP_TOKEN_MULT:
+         lValueLeft *= lValueRight;
+         break;
+      case HB_PP_TOKEN_DIV:
+         lValueLeft /= lValueRight;
+         break;
+      case HB_PP_TOKEN_MOD:
+         lValueLeft %= lValueRight;
+         break;
+   }
+
+   return lValueLeft;
+}
+
+PHB_PP_TOKEN hb_pp_calcValue( PHB_PP_TOKEN pToken, int iPrecedense,
+                              HB_LONG * plValue, BOOL * pfError )
+{
+   if( HB_PP_TOKEN_ISEOC( pToken ) )
+      * pfError = TRUE;
+   else if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_MINUS )
+   {
+      pToken = hb_pp_calcValue( pToken->pNext, HB_PP_PREC_NEG, plValue, pfError );
+      * plValue = - * plValue;
+   }
+   else if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_PLUS )
+   {
+      pToken = hb_pp_calcValue( pToken->pNext, iPrecedense, plValue, pfError );
+   }
+   else if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_NOT )
+   {
+      pToken = hb_pp_calcValue( pToken->pNext, HB_PP_PREC_NOT, plValue, pfError );
+      * plValue = * plValue ? 0 : 1;
+   }
+   else if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_LEFT_PB )
+   {
+      * pfError = TRUE;
+      pToken = hb_pp_calcValue( pToken->pNext, HB_PP_PREC_NUL, plValue, pfError );
+      if( ! * pfError && !HB_PP_TOKEN_ISEOC( pToken ) &&
+          HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_RIGHT_PB )
+         pToken = pToken->pNext;
+      else
+         * pfError = TRUE;
+   }
+   else if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_RIGHT_PB )
+   {
+      return pToken;
+   }
+   else if( HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_NUMBER )
+   {
+      int iOverflow;
+      *plValue = hb_strValInt( pToken->value, &iOverflow );
+      if( iOverflow )
+         * pfError = TRUE;
+      else
+      {
+         * pfError = FALSE;
+         pToken = pToken->pNext;
+      }
+   }
+   else
+      * pfError = TRUE;
+
+   while( !( * pfError || HB_PP_TOKEN_ISEOC( pToken ) ||
+              HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_RIGHT_PB ) )
+   {
+      int iNextOper = HB_PP_TOKEN_TYPE( pToken->type );
+      int iNextPrec = hb_pp_calcPrecedence( iNextOper );
+      if( iNextPrec < HB_PP_PREC_LOG )
+         * pfError = TRUE;
+      else if( iNextPrec > iPrecedense )
+      {
+         HB_LONG lValue = 0;
+         * pfError = TRUE;
+         pToken = hb_pp_calcValue( pToken->pNext, iNextPrec, &lValue, pfError );
+         if( ! * pfError )
+         {
+            * plValue = hb_pp_calcOperation( * plValue, lValue, iNextOper );
+         }
+      }
+      else
+         break;
+   }
+
+   return pToken;
+}
+
+static HB_LONG hb_pp_calculateValue( PHB_PP_STATE pState, PHB_PP_TOKEN pToken )
+{
+   BOOL fError = TRUE;
+   HB_LONG lValue = 0;
+
+   pToken = hb_pp_calcValue( pToken, HB_PP_PREC_NUL, &lValue, &fError );
+   if( !HB_PP_TOKEN_ISEOC( pToken ) )
+      fError = TRUE;
+
+   if( fError )
+   {
+      hb_pp_error( pState, 'E', HB_PP_ERR_DIRECTIVE_IF, NULL );
+      lValue = 0;
+   }
+
+   return lValue;
+}
+
+static void hb_pp_conditionPush( PHB_PP_STATE pState, BOOL fCond )
+{
+   if( pState->iCondCount == pState->iCondStackSize )
+   {
+      pState->iCondStackSize += 5;
+      if( pState->pCondStack )
+         pState->pCondStack = ( int * ) hb_xrealloc( pState->pCondStack,
+                                 pState->iCondStackSize * sizeof( BOOL ) );
+      else
+         pState->pCondStack = ( int * ) hb_xgrab( pState->iCondStackSize *
+                                                          sizeof( BOOL ) );
+   }
+   pState->pCondStack[ pState->iCondCount++ ] = pState->iCondCompile;
+   pState->iCondCompile = pState->iCondCompile ? HB_PP_COND_DISABLE :
+                          ( fCond ? 0 : HB_PP_COND_ELSE );
+}
+
+static void hb_pp_condCompile( PHB_PP_STATE pState, PHB_PP_TOKEN pToken,
+                               BOOL fNot )
+{
+   if( !pToken || HB_PP_TOKEN_TYPE( pToken->type ) != HB_PP_TOKEN_KEYWORD ||
+       !HB_PP_TOKEN_ISEOC( pToken->pNext ) )
+   {
+      hb_pp_error( pState, 'E', HB_PP_ERR_DIRECTIVE_IFDEF, NULL );
+   }
+   else
+   {
+      BOOL fCond = FALSE;
+
+      if( pState->iCondCompile == 0 )
+      {
+         fCond = hb_pp_defineFind( pState, pToken ) != NULL;
+         if( !fNot )
+            fCond = !fCond;
+      }
+      hb_pp_conditionPush( pState, fCond );
+   }
+}
+
+static void hb_pp_condCompileIf( PHB_PP_STATE pState, PHB_PP_TOKEN pToken )
+{
+   /* preprocess all define(s) */
+   hb_pp_processDefine( pState, &pToken->pNext );
+   hb_pp_conditionPush( pState, hb_pp_calculateValue( pState, pToken->pNext ) != 0 );
+}
+
+static void hb_pp_condCompileElif( PHB_PP_STATE pState, PHB_PP_TOKEN pToken )
+{
+   if( ( pState->iCondCompile & HB_PP_COND_DISABLE ) == 0 )
+   {
+      if( pState->iCondCompile )
+      {
+         /* preprocess all define(s) */
+         hb_pp_processDefine( pState, &pToken->pNext );
+         if( hb_pp_calculateValue( pState, pToken->pNext ) != 0 )
+            pState->iCondCompile ^= HB_PP_COND_ELSE;
+      }
+      else
+         pState->iCondCompile = HB_PP_COND_DISABLE;
+   }
+}
+
+static char * hb_pp_tokenListStr( PHB_PP_TOKEN pToken, PHB_MEM_BUFFER pBuffer,
+                                  BOOL fEol )
+{
+   BOOL fSpaces = FALSE;
+
+   hb_membufFlush( pBuffer );
+   while( !HB_PP_TOKEN_ISEOC( pToken ) )
+   {
+      hb_pp_tokenStr( pToken, pBuffer, fSpaces, FALSE, 0 );
+      pToken = pToken->pNext;
+      fSpaces = TRUE;
+   }
+   if( fEol )
+      hb_membufAddCh( pBuffer, '\n' );
+   hb_membufAddCh( pBuffer, 0 );
+
+   return hb_membufPtr( pBuffer );
+}
+
+static void hb_pp_genLineTokens( PHB_PP_STATE pState )
+{
+   pState->pNextTokenPtr = &pState->pTokenOut;
+
+#if defined( HB_PP_NO_LINEINFO_TOKEN )
+   hb_pp_tokenMoveCommand( pState->pNextTokenPtr, &pState->pFile->pTokenList );
+#else
+   if( pState->pFile->fGenLineInfo )
+   {
+      char szLine[ 10 ];
+
+      sprintf( szLine, "%d", pState->pFile->iCurrentLine );
+      hb_pp_tokenAdd( &pState->pNextTokenPtr, "#", 1, 0, HB_PP_TOKEN_DIRECTIVE | HB_PP_TOKEN_STATIC );
+      hb_pp_tokenAdd( &pState->pNextTokenPtr, "line", 4, 0, HB_PP_TOKEN_KEYWORD | HB_PP_TOKEN_STATIC );
+      hb_pp_tokenAdd( &pState->pNextTokenPtr, szLine, strlen( szLine ), 1, HB_PP_TOKEN_NUMBER );
+      if( pState->pFile->szFileName )
+         hb_pp_tokenAdd( &pState->pNextTokenPtr, pState->pFile->szFileName,
+                         strlen( pState->pFile->szFileName ), 1, HB_PP_TOKEN_STRING );
+      hb_pp_tokenAdd( &pState->pNextTokenPtr, "\n", 1, 0, HB_PP_TOKEN_EOL | HB_PP_TOKEN_STATIC );
+      pState->pFile->fGenLineInfo = FALSE;
+   }
+   else if( pState->pFile->iLastLine < pState->pFile->iCurrentLine )
+   {
+      do
+         hb_pp_tokenAdd( &pState->pNextTokenPtr, "\n", 1, 0, HB_PP_TOKEN_EOL | HB_PP_TOKEN_STATIC );
+      while( ++pState->pFile->iLastLine < pState->pFile->iCurrentLine );
+   }
+   pState->pFile->iLastLine = pState->pFile->iCurrentLine +
+                        hb_pp_tokenMoveCommand( pState->pNextTokenPtr,
+                                                &pState->pFile->pTokenList );
+#endif
+}
+
+static void hb_pp_preprocesToken( PHB_PP_STATE pState )
+{
+   while( !pState->pTokenOut && pState->pFile )
+   {
+      PHB_PP_TOKEN pToken;
+
+      if( !pState->pFile->pTokenList )
+      {
+         while( pState->pFile->pLineBuf ? pState->pFile->ulLineBufLen :
+                                          !pState->pFile->fEof )
+         {
+            hb_pp_getLine( pState );
+            if( pState->pFile->pTokenList || pState->fError )
+               break;
+         }
+
+         if( !pState->pFile->pTokenList )
+         {
+            if( pState->pFile->pLineBuf )
+               break;
+            /* this condition is only for compiler core code compatibility */
+            if( !pState->pFile->pPrev )
+               break;
+            hb_pp_includeClose( pState );
+            continue;
+         }
+      }
+
+      if( HB_PP_TOKEN_ISDIRECTIVE( pState->pFile->pTokenList ) )
+      {
+         BOOL fError = FALSE, fDirect;
+         /* Store it here to avoid possible problems after #INCLUDE */
+         PHB_PP_TOKEN * pFreePtr = &pState->pFile->pTokenList;
+
+         pToken = pState->pFile->pTokenList;
+         fDirect = HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_DIRECTIVE;
+         pToken = pToken->pNext;
+         if( !pToken || HB_PP_TOKEN_TYPE( pToken->type ) != HB_PP_TOKEN_KEYWORD )
+         {
+            fError = TRUE;
+         }
+#ifndef HB_C52_STRICT
+         /* Harbour PP extension */
+         else if( fDirect && pState->pFile->iCurrentLine &&
+                  HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_NOT &&
+                  pToken->spaces == 0 )
+         {
+            /* ignore first line if it begins with "#!"
+               minor extension which allow to use the same source code
+               as scripts in *nix system and compile it, this feature
+               will be necessary also when we integrate compiler with HVM and
+               add support for direct execution compiled .prg files */
+         }
+#endif
+         else if( hb_pp_tokenValueCmp( pToken, "IFDEF", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_condCompile( pState, pToken->pNext, TRUE );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "IFNDEF", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_condCompile( pState, pToken->pNext, FALSE );
+         }
+#ifndef HB_C52_STRICT
+         /* xHarbour PP extension */
+         else if( hb_pp_tokenValueCmp( pToken, "IF", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_condCompileIf( pState, pToken );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "ELIF", HB_PP_CMP_DBASE ) )
+         {
+            if( pState->iCondCount )
+               hb_pp_condCompileElif( pState, pToken );
+            else
+               hb_pp_error( pState, 'E', HB_PP_ERR_DIRECTIVE_ELSE, NULL );
+         }
+#endif
+         else if( hb_pp_tokenValueCmp( pToken, "ENDIF", HB_PP_CMP_DBASE ) )
+         {
+            if( pState->iCondCount )
+               pState->iCondCompile = pState->pCondStack[ --pState->iCondCount ];
+            else
+               hb_pp_error( pState, 'E', HB_PP_ERR_DIRECTIVE_ENDIF, NULL );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "ELSE", HB_PP_CMP_DBASE ) )
+         {
+            if( pState->iCondCount )
+               pState->iCondCompile ^= HB_PP_COND_ELSE;
+            else
+               hb_pp_error( pState, 'E', HB_PP_ERR_DIRECTIVE_ELSE, NULL );
+         }
+         else if( pState->iCondCompile )
+         {
+            /* conditional compilation - other preprocessing and output disabled */
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "INCLUDE", HB_PP_CMP_DBASE ) )
+         {
+            pToken = pToken->pNext;
+            if( pToken && HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_STRING )
+               hb_pp_includeFile( pState, pToken->value, FALSE );
+            else if( pToken && HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_LT )
+            {
+               pToken = pToken->pNext;
+               hb_membufFlush( pState->pBuffer );
+               while( !HB_PP_TOKEN_ISEOC( pToken ) &&
+                      HB_PP_TOKEN_TYPE( pToken->type ) != HB_PP_TOKEN_GT )
+               {
+                  hb_membufAddData( pState->pBuffer, pToken->value, pToken->len );
+                  pToken = pToken->pNext;
+               }
+               if( hb_membufLen( pState->pBuffer ) > 0 &&
+                   !HB_PP_TOKEN_ISEOC( pToken ) &&
+                   HB_PP_TOKEN_TYPE( pToken->type ) == HB_PP_TOKEN_GT )
+               {
+                  hb_membufAddCh( pState->pBuffer, '\0' );
+                  hb_pp_includeFile( pState, hb_membufPtr( pState->pBuffer ), TRUE );
+               }
+               else
+                  hb_pp_error( pState, 'F', HB_PP_ERR_WRONG_FILE_NAME, NULL );
+            }
+            else
+               hb_pp_error( pState, 'F', HB_PP_ERR_WRONG_FILE_NAME, NULL );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "STDOUT", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_disp( pState, hb_pp_tokenListStr( pToken->pNext,
+                                                    pState->pBuffer, TRUE ) );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "ERROR", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_error( pState, 'E', HB_PP_ERR_EXPLICIT,
+                         hb_pp_tokenListStr( pToken->pNext, pState->pBuffer, FALSE ) );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "DEFINE", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_defineNew( pState, pToken, fDirect );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "UNDEF", HB_PP_CMP_DBASE ) )
+         {
+            pToken = pToken->pNext;
+            if( !pToken || HB_PP_TOKEN_TYPE( pToken->type ) != HB_PP_TOKEN_KEYWORD ||
+                !HB_PP_TOKEN_ISEOC( pToken->pNext ) )
+               hb_pp_error( pState, 'E', HB_PP_ERR_DIRECTIVE_UNDEF, NULL );
+            else
+               hb_pp_defineDel( pState, pToken );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "TRANSLATE", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_directiveNew( pState, pToken, HB_PP_CMP_DBASE, FALSE, fDirect, FALSE );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "XTRANSLATE", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_directiveNew( pState, pToken, HB_PP_CMP_STD, FALSE, fDirect, FALSE );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "COMMAND", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_directiveNew( pState, pToken, HB_PP_CMP_DBASE, TRUE, fDirect, FALSE );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "XCOMMAND", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_directiveNew( pState, pToken, HB_PP_CMP_STD, TRUE, fDirect, FALSE );
+         }
+#ifndef HB_C52_STRICT
+         /* xHarbour PP extensions */
+         else if( hb_pp_tokenValueCmp( pToken, "UNTRANSLATE", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_directiveNew( pState, pToken, HB_PP_CMP_DBASE, FALSE, fDirect, TRUE );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "XUNTRANSLATE", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_directiveNew( pState, pToken, HB_PP_CMP_STD, FALSE, fDirect, TRUE );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "UNCOMMAND", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_directiveNew( pState, pToken, HB_PP_CMP_DBASE, TRUE, fDirect, TRUE );
+         }
+         else if( hb_pp_tokenValueCmp( pToken, "XUNCOMMAND", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_directiveNew( pState, pToken, HB_PP_CMP_STD, TRUE, fDirect, TRUE );
+         }
+         /* Clipper PP does not accept #line and generate error */
+         else if( hb_pp_tokenValueCmp( pToken, "LINE", HB_PP_CMP_DBASE ) )
+         {
+            /* ignore #line directives */
+         }
+#endif
+         /* #pragma support is always enabled even in strict compatibility
+            mode to allow control by programmer some PP issues */
+         else if( hb_pp_tokenValueCmp( pToken, "PRAGMA", HB_PP_CMP_DBASE ) )
+         {
+            hb_pp_pragmaNew( pState, pToken->pNext );
+         }
+         else
+            fError = TRUE;
+
+         if( fError )
+            hb_pp_error( pState, 'F', HB_PP_ERR_INVALID_DIRECTIVE, NULL );
+         hb_pp_tokenListFreeCmd( pFreePtr );
+         continue;
+      }
+      else if( pState->iCondCompile )
+      {
+         hb_pp_tokenListFreeCmd( &pState->pFile->pTokenList );
+      }
+      else
+      {
+         BOOL fDirective = FALSE;
+
+         pState->iCycle = 0;
+         while( !HB_PP_TOKEN_ISEOC( pState->pFile->pTokenList ) &&
+                pState->iCycle <= pState->iMaxCycles )
+         {
+            if( HB_PP_TOKEN_ISDIRECTIVE( pState->pFile->pTokenList ) )
+            {
+               fDirective = TRUE;
+               break;
+            }
+#ifndef HB_C52_STRICT
+            /* Harbour extension: concatenate keywords without spaces between
+               them */
+            hb_pp_concatenateKeywords( pState, &pState->pFile->pTokenList );
+#endif
+            if( hb_pp_processDefine( pState, &pState->pFile->pTokenList ) )
+               continue;
+            if( hb_pp_processTranslate( pState, &pState->pFile->pTokenList ) )
+               continue;
+            if( hb_pp_processCommand( pState, &pState->pFile->pTokenList ) )
+               continue;
+            break;
+         }
+         if( !fDirective && pState->pFile->pTokenList )
+         {
+            if( HB_PP_TOKEN_ISEOC( pState->pFile->pTokenList ) )
+               hb_pp_tokenListFreeCmd( &pState->pFile->pTokenList );
+            else
+               hb_pp_genLineTokens( pState );
+         }
+      }
+   }
+}
+
+static PHB_PP_TOKEN hb_pp_getToken( PHB_PP_STATE pState )
+{
+   if( pState->pTokenOut )
+   {
+      PHB_PP_TOKEN pToken = pState->pTokenOut;
+      pState->pTokenOut = pToken->pNext;
+      hb_pp_tokenFree( pToken );
+   }
+
+   if( !pState->pTokenOut )
+      hb_pp_preprocesToken( pState );
+
+   return pState->pTokenOut;
+}
+
+static void hb_pp_initDynDefines( PHB_PP_STATE pState )
+{
+   char szDefine[ 65 ];
+   char szResult[ 65 ];
+   char * pSrc, * pDst, * szPlatform;
+   int iYear, iMonth, iDay, i;
+
+   /* __PLATFORM__* */
+   pSrc = szPlatform = hb_verPlatform();
+   pDst = strcpy( szDefine, "__PLATFORM__" );
+   i = 12;
+   while( pSrc[ 0 ] > ' ' && i < ( int ) sizeof( szDefine ) - 1 )
+   {
+      if( HB_PP_ISNEXTIDCHAR( pSrc[ 0 ] ) )
+         pDst[ i++ ] = pSrc[ 0 ];
+      pSrc++;
+   }
+   pDst[ i ] = '\0';
+
+   i = 0;
+   pDst = szResult;
+   pDst[ i++ ] = '"';
+   if( pSrc[ 0 ] == ' ' )
+   {
+      while( *( ++pSrc ) && i < ( int ) sizeof( szResult ) - 2 )
+         pDst[ i++ ] = pSrc[ 0 ];
+   }
+   pDst[ i++ ] = '"';
+   pDst[ i ] = '\0';
+
+   hb_xfree( szPlatform );
+
+   hb_pp_addDefine( pState, szDefine, szResult );
+#ifdef HB_OS_UNIX
+   strcpy( szDefine + 12, "UNIX" );
+   hb_pp_addDefine( pState, szDefine, szResult );
+#endif
+
+   /* __HARBOUR__ */
+   sprintf( szResult, "%05d", HB_MAX( ( HB_VER_MAJOR << 8 ) | HB_VER_MINOR, 1 ) );
+   hb_pp_addDefine( pState, "__HARBOUR__", szResult );
+
+   /* __DATE__ */
+   hb_dateToday( &iYear, &iMonth, &iDay );
+   hb_dateStrPut( szResult + 1, iYear, iMonth, iDay );
+   szResult[ 0 ] = '"';
+   szResult[ 9 ] = '"';
+   szResult[ 10 ] = '\0';
+   hb_pp_addDefine( pState, "__DATE__", szResult );
+
+   /* __TIME__ */
+   hb_dateTimeStr( szResult + 1 );
+   szResult[ 0 ] = '"';
+   szResult[ 9 ] = '"';
+   szResult[ 10 ] = '\0';
+   hb_pp_addDefine( pState, "__TIME__", szResult );
+
+   sprintf( szResult, "%d", ( int ) sizeof( void * ) );
+#if defined( HB_ARCH_16BIT )
+   hb_pp_addDefine( pState, "__ARCH16BIT__", szResult );
+#elif defined( HB_ARCH_32BIT )
+   hb_pp_addDefine( pState, "__ARCH32BIT__", szResult );
+#elif defined( HB_ARCH_64BIT )
+   hb_pp_addDefine( pState, "__ARCH64BIT__", szResult );
+#endif
+
+#if defined( HB_LITTLE_ENDIAN )
+   hb_pp_addDefine( pState, "__LITTLE_ENDIAN__", szResult );
+#elif defined( HB_BIG_ENDIAN )
+   hb_pp_addDefine( pState, "__BIG_ENDIAN__", szResult );
+#elif defined( HB_PDP_ENDIAN )
+   hb_pp_addDefine( pState, "__PDP_ENDIAN__", szResult );
+#endif
+
+#ifdef HARBOUR_START_PROCEDURE
+   hb_pp_addDefine( pState, "__HB_MAIN__", HARBOUR_START_PROCEDURE );
+#endif
+}
+
+
+/*
+ * exported functions
+ */
+
+/*
+ * internal function to initialize predefined PP rules
+ */
+void hb_pp_initRules( PHB_PP_RULE * pRulesPtr, int * piRules,
+                      const HB_PP_DEFRULE pDefRules[], int iDefRules )
+{
+   PHB_PP_DEFRULE pDefRule;
+   PHB_PP_MARKER pMarkers;
+   PHB_PP_RULE pRule;
+
+   hb_pp_ruleListFree( pRulesPtr );
+   * piRules = iDefRules;
+
+   while( --iDefRules >= 0 )
+   {
+      pDefRule = ( PHB_PP_DEFRULE ) pDefRules + iDefRules;
+      if( pDefRule->markers > 0 )
+      {
+         USHORT marker;
+         ULONG ulBit;
+
+         pMarkers = ( PHB_PP_MARKER ) hb_xgrab( pDefRule->markers * sizeof( HB_PP_MARKER ) );
+         memset( pMarkers, '\0', pDefRule->markers * sizeof( HB_PP_MARKER ) );
+         for( marker = 0, ulBit = 1; marker < pDefRule->markers; ++marker, ulBit <<= 1 )
+         {
+            if( pDefRule->repeatbits & ulBit )
+               pMarkers[ marker ].canrepeat = TRUE;
+         }
+      }
+      else
+         pMarkers = NULL;
+      pRule = hb_pp_ruleNew( pDefRule->pMatch, pDefRule->pResult,
+                             pDefRule->mode, pDefRule->markers, pMarkers );
+      pRule->pPrev = * pRulesPtr;
+      * pRulesPtr = pRule;
+   }
+}
+
+
+/*
+ * create new PP context
+ */
+PHB_PP_STATE hb_pp_new( void )
+{
+   return hb_pp_stateNew();
+}
+
+/*
+ * mark current rules as standard ones
+ */
+void hb_pp_setStdBase( PHB_PP_STATE pState )
+{
+   pState->fError = FALSE;
+   hb_pp_ruleSetStd( pState->pDefinitions );
+   hb_pp_ruleSetStd( pState->pTranslations );
+   hb_pp_ruleSetStd( pState->pCommands );
+}
+
+/*
+ * initialize PP context
+ */
+void 
+hb_pp_init( PHB_PP_STATE pState, char * szStdCh, BOOL fQuiet,
+                 PHB_PP_OPEN_FUNC  pOpenFunc, PHB_PP_CLOSE_FUNC pCloseFunc,
+                 PHB_PP_ERROR_FUNC pErrorFunc, PHB_PP_DISP_FUNC pDispFunc,
+                 PHB_PP_DUMP_FUNC pDumpFunc, PHB_PP_SWITCH_FUNC pSwitchFunc )
+{
+   pState->fQuiet      = fQuiet;
+   pState->pOpenFunc   = pOpenFunc;
+   pState->pCloseFunc  = pCloseFunc;
+   pState->pErrorFunc  = pErrorFunc;
+   pState->pDispFunc   = pDispFunc;
+   pState->pDumpFunc   = pDumpFunc;
+   pState->pSwitchFunc = pSwitchFunc;
+
+   if( !szStdCh )
+   {
+      hb_pp_initStaticRules( pState );
+   }
+   else if( * szStdCh )
+   {
+      char szFileName[ _POSIX_PATH_MAX + 1 ];
+      PHB_PP_FILE pFile = pState->pFile;
+      PHB_FNAME pFileName;
+
+      pFileName = hb_fsFNameSplit( szStdCh );
+      if( !pFileName->szExtension )
+          pFileName->szExtension = ".ch";
+      hb_fsFNameMerge( szFileName, pFileName );
+      szStdCh = szFileName;
+      hb_xfree( pFileName );
+
+      pState->pFile = hb_pp_FileNew( pState, szFileName, FALSE, NULL, pState->pOpenFunc );
+      if( !pState->pFile )
+      {
+         pState->pFile = pFile;
+         hb_pp_error( pState, 'F', HB_PP_ERR_CANNOT_OPEN_RULES, szFileName );
+      }
+      else
+      {
+         pState->iFiles++;
+         while( hb_pp_getToken( pState ) );
+         if( pState->pFile )
+            hb_pp_FileFree( pState->pFile, pState->pCloseFunc );
+         pState->pFile = pFile;
+         pState->iFiles--;
+      }
+   }
+   else if( !pState->fQuiet )
+   {
+      hb_pp_disp( pState, "Standard command definitions excluded.\n" );
+   }
+
+   hb_pp_initDynDefines( pState );
+   hb_pp_setStdBase( pState );
+}
+
+/*
+ * free PP context
+ */
+void hb_pp_free( PHB_PP_STATE pState )
+{
+   hb_pp_stateFree( pState );
+}
+
+/*
+ * reset PP context, used for multiple .prg file compilation
+ * with DO ... or *.clp files
+ */
+void hb_pp_reset( PHB_PP_STATE pState )
+{
+   pState->fError = FALSE;
+
+   hb_pp_InFileFree( pState );
+   hb_pp_OutFileFree( pState );
+
+   hb_pp_ruleNonStdFree( &pState->pDefinitions );
+   hb_pp_ruleNonStdFree( &pState->pTranslations );
+   hb_pp_ruleNonStdFree( &pState->pCommands );
+}
+
+/*
+ * add search path for included files
+ */
+void hb_pp_addSearchPath( PHB_PP_STATE pState, const char * szPath, BOOL fReplace )
+{
+   if( fReplace && pState->pIncludePath )
+   {
+      hb_fsFreeSearchPath( pState->pIncludePath );
+      pState->pIncludePath = NULL;
+   }
+
+   if( szPath && * szPath )
+   {
+      hb_fsAddSearchPath( szPath, &pState->pIncludePath );
+   }
+}
+
+/*
+ * close all open input files and set the given one as new
+ */
+void hb_pp_inFile( PHB_PP_STATE pState, char * szFileName, FILE * file_in )
+{
+   hb_pp_InFileFree( pState );
+
+   pState->fError = FALSE;
+
+   pState->pFile = hb_pp_FileNew( pState, szFileName, FALSE, file_in, NULL );
+   if( ! pState->pFile )
+      hb_pp_error( pState, 'F', HB_PP_ERR_CANNOT_OPEN_INPUT, szFileName );
+   else
+      pState->iFiles++;
+}
+
+/*
+ * set output (.ppo) file handle
+ */
+void hb_pp_outFile( PHB_PP_STATE pState, char * szOutFileName, FILE * file_out )
+{
+   hb_pp_OutFileFree( pState );
+
+   if( szOutFileName )
+   {
+      pState->fError = FALSE;
+
+      if( file_out )
+         pState->file_out = file_out;
+      else
+         pState->file_out = fopen( szOutFileName, "w" );
+
+      if( pState->file_out )
+      {
+         pState->szOutFileName = hb_strdup( szOutFileName );
+         pState->fWritePreprocesed = TRUE;
+      }
+      else
+      {
+         hb_pp_error( pState, 'F', HB_PP_ERR_CANNOT_CREATE_FILE, szOutFileName );
+      }
+   }
+}
+
+/*
+ * return currently preprocessed file name
+ */
+char * hb_pp_fileName( PHB_PP_STATE pState )
+{
+   if( pState->pFile )
+      return pState->pFile->szFileName;
+   else
+      return NULL;
+}
+
+/*
+ * return currently preprocessed line number
+ */
+int hb_pp_line( PHB_PP_STATE pState )
+{
+   if( pState->pFile )
+      return pState->pFile->iCurrentLine;
+   else
+      return 0;
+}
+
+/*
+ * return currently preprocessed file name
+ */
+char * hb_pp_outFileName( PHB_PP_STATE pState )
+{
+   return pState->szOutFileName;
+}
+
+/*
+ * return next preprocessed line
+ */
+char * hb_pp_nextLine( PHB_PP_STATE pState, ULONG * pulLen )
+{
+   if( pState->pFile )
+   {
+      PHB_PP_TOKEN pToken;
+      USHORT ltype = 0;
+
+      pState->fError = FALSE;
+
+      if( !pState->pOutputBuffer )
+         pState->pOutputBuffer = hb_membufNew();
+      else
+         hb_membufFlush( pState->pOutputBuffer );
+
+      while( ( pToken = hb_pp_getToken( pState ) ) != NULL )
+      {
+#if defined( HB_PP_NO_LINEINFO_TOKEN )
+         int iLine;
+         if( pState->fWritePreprocesed )
+         {
+            if( pState->pFile->fGenLineInfo )
+            {
+               fprintf( pState->file_out, "#line %d", pState->pFile->iCurrentLine );
+               if( pState->pFile->szFileName )
+               {
+                  fprintf( pState->file_out, " \"%s\"", pState->pFile->szFileName );
+               }
+               fputc( '\n', pState->file_out );
+               pState->pFile->fGenLineInfo = FALSE;
+            }
+            else if( pState->pFile->iLastLine < pState->pFile->iCurrentLine )
+            {
+               do
+                  fputc( '\n', pState->file_out );
+               while( ++pState->pFile->iLastLine < pState->pFile->iCurrentLine );
+            }
+         }
+         pState->pFile->iLastLine = pState->pFile->iCurrentLine;
+         iLine = hb_pp_tokenStr( pToken, pState->pOutputBuffer, TRUE, TRUE, ltype );
+         if( iLine )
+         {
+            pState->pFile->iLastLine += iLine;
+            break;
+         }
+#else
+         if( hb_pp_tokenStr( pToken, pState->pOutputBuffer, TRUE, TRUE, ltype ) )
+            break;
+#endif
+         /* only single command in one call */
+         if( !pState->pTokenOut->pNext )
+            break;
+
+         ltype = HB_PP_TOKEN_TYPE( pToken->type );
+      }
+
+      if( pState->fWritePreprocesed )
+      {
+         fwrite( hb_membufPtr( pState->pOutputBuffer ), sizeof( char ),
+                 hb_membufLen( pState->pOutputBuffer ), pState->file_out );
+      }
+
+      if( pulLen )
+         * pulLen = hb_membufLen( pState->pOutputBuffer );
+      hb_membufAddCh( pState->pOutputBuffer, '\0' );
+
+      return hb_membufPtr( pState->pOutputBuffer );
+   }
+
+   if( pulLen )
+      * pulLen = 0;
+   return NULL;
+}
+
+/*
+ * preprocess given buffer
+ */
+char * hb_pp_parseLine( PHB_PP_STATE pState, char * pLine, ULONG * pulLen )
+{
+   PHB_PP_TOKEN pToken;
+   PHB_PP_FILE pFile;
+   USHORT ltype = 0;
+   ULONG ulLen;
+
+   pState->fError = FALSE;
+
+   if( !pState->pOutputBuffer )
+      pState->pOutputBuffer = hb_membufNew();
+   else
+      hb_membufFlush( pState->pOutputBuffer );
+
+   ulLen = pulLen ? * pulLen : strlen( pLine );
+
+   pFile = hb_pp_FileBufNew( pLine, ulLen );
+   pFile->pPrev = pState->pFile;
+   pState->pFile = pFile;
+   pState->iFiles++;
+
+   while( ( pToken = hb_pp_getToken( pState ) ) != NULL )
+   {
+      hb_pp_tokenStr( pToken, pState->pOutputBuffer, TRUE, TRUE, ltype );
+      ltype = HB_PP_TOKEN_TYPE( pToken->type );
+   }
+
+   if( ( ulLen && pLine[ ulLen - 1 ] == '\n' ) ||
+       hb_membufLen( pState->pOutputBuffer ) == 0 ||
+       hb_membufPtr( pState->pOutputBuffer )
+                        [ hb_membufLen( pState->pOutputBuffer ) - 1 ] != '\n' )
+      hb_membufAddCh( pState->pOutputBuffer, '\0' );
+   else
+      hb_membufPtr( pState->pOutputBuffer )
+                        [ hb_membufLen( pState->pOutputBuffer ) - 1 ] = '\0';
+
+   if( pulLen )
+      * pulLen = hb_membufLen( pState->pOutputBuffer ) - 1;
+
+   if( pState->pFile == pFile )
+   {
+      pState->pFile = pFile->pPrev;
+      hb_pp_FileFree( pFile, NULL );
+      pState->iFiles--;
+   }
+
+   return hb_membufPtr( pState->pOutputBuffer );
+}
+
+/*
+ * add new define value
+ */
+void hb_pp_addDefine( PHB_PP_STATE pState, char * szDefName, char * szDefValue )
+{
+   PHB_PP_TOKEN pMatch, pResult, pToken;
+   PHB_PP_FILE pFile;
+
+   pState->fError = FALSE;
+
+   pFile = hb_pp_FileBufNew( szDefName, strlen( szDefName ) );
+   pFile->pPrev = pState->pFile;
+   pState->pFile = pFile;
+   pState->iFiles++;
+   hb_pp_getLine( pState );
+   pMatch = pState->pFile->pTokenList;
+   pState->pFile->pTokenList = NULL;
+   pToken = hb_pp_tokenResultEnd( &pMatch, TRUE );
+   hb_pp_tokenListFree( &pToken );
+
+   if( szDefValue && !pState->fError )
+   {
+      pFile->pLineBuf = szDefValue;
+      pFile->ulLineBufLen = strlen( szDefValue );
+      hb_pp_getLine( pState );
+      pResult = pState->pFile->pTokenList;
+      pState->pFile->pTokenList = NULL;
+      pToken = hb_pp_tokenResultEnd( &pResult, TRUE );
+      hb_pp_tokenListFree( &pToken );
+   }
+   else
+      pResult = NULL;
+
+   if( pState->fError || !pMatch )
+   {
+      hb_pp_tokenListFree( &pMatch );
+      hb_pp_tokenListFree( &pResult );
+   }   
+   else
+   {
+      hb_pp_defineAdd( pState, HB_PP_CMP_CASE, 0, NULL, pMatch, pResult );
+   }
+   pState->pFile = pFile->pPrev;
+   hb_pp_FileFree( pFile, NULL );
+   pState->iFiles--;
+}
+
+/*
+ * delete define value
+ */
+void hb_pp_delDefine( PHB_PP_STATE pState, char * szDefName )
+{
+   PHB_PP_TOKEN pToken;
+
+   pToken = hb_pp_tokenNew( szDefName, strlen( szDefName ),
+                            0, HB_PP_TOKEN_KEYWORD );
+   hb_pp_defineDel( pState, pToken );
+   hb_pp_tokenFree( pToken );
 }
diff --git a/harbour/source/pp/ppgen.c b/harbour/source/pp/ppgen.c
new file mode 100644
index 0000000000..89c35cd45f
--- /dev/null
+++ b/harbour/source/pp/ppgen.c
@@ -0,0 +1,396 @@
+/*
+ * $Id$
+ */
+
+/*
+ * Harbour Project source code:
+ * 
+ *
+ * Copyright 2006 Przemyslaw Czerpak <druzus / at / priv.onet.pl>
+ * www - http://www.harbour-project.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this software; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
+ *
+ * As a special exception, the Harbour Project gives permission for
+ * additional uses of the text contained in its release of Harbour.
+ *
+ * The exception is that, if you link the Harbour libraries with other
+ * files to produce an executable, this does not by itself cause the
+ * resulting executable to be covered by the GNU General Public License.
+ * Your use of that executable is in no way restricted on account of
+ * linking the Harbour library code into it.
+ *
+ * This exception does not however invalidate any other reasons why
+ * the executable file might be covered by the GNU General Public License.
+ *
+ * This exception applies only to the code released by the Harbour
+ * Project under the name Harbour.  If you copy code from other
+ * Harbour Project or Free Software Foundation releases into a copy of
+ * Harbour, as the General Public License permits, the exception does
+ * not apply to the code that you add in this way.  To avoid misleading
+ * anyone as to the status of such modified files, you must delete
+ * this exception notice from them.
+ *
+ * If you write modifications of your own for Harbour, it is your choice
+ * whether to permit this exception to apply to your modifications.
+ * If you do not wish that, delete this exception notice.
+ *
+ */
+
+#include "ppcore.c"
+
+
+/*
+ * library functions used by PP core code
+ * necessary to create stand alone binries
+ */
+void * hb_xgrab( ULONG ulSize ) { return malloc( ulSize ); }
+void * hb_xrealloc( void * pMem, ULONG ulSize ) { return realloc( pMem, ulSize ); }
+void hb_xfree( void * pMem ) { free( pMem ); }
+
+
+void hb_pp_initStaticRules( PHB_PP_STATE pState )
+{
+   HB_SYMBOL_UNUSED( pState );
+}
+
+
+/*
+ * functions to create .c files with rules defined in given PP context
+ */
+static int hb_pp_writeTokenCount( PHB_PP_TOKEN pToken )
+{
+   int iToken = 0;
+   while( pToken )
+   {
+      iToken += hb_pp_writeTokenCount( pToken->pMTokens ) + 1;
+      pToken = pToken->pNext;
+   }
+   return iToken;
+}
+
+static void hb_pp_writeToken( FILE * fout, PHB_PP_TOKEN pToken,
+                              char * szName, int iToken, BOOL fLast )
+{
+   while( pToken )
+   {
+      int iOptional = hb_pp_writeTokenCount( pToken->pMTokens ), i;
+
+      i = strlen( szName );
+      if( pToken->pNext )
+         fprintf( fout, "   { %s +%2d", szName, iToken + iOptional + 1 );
+      else
+         fprintf( fout, "   { NULL%*.s", i, "" );
+      if( iOptional )
+         fprintf( fout, ", %s +%2d", szName, iToken + 1 );
+      else
+         fprintf( fout, ", NULL%*.s", i, "" );
+
+      i = 16 - strlen( pToken->value );
+      fprintf( fout, ", \"%s\", %*.s %2d,%2d, 0x%04x, %d }%s\n",
+               pToken->value,
+               i < 0 ? 0 : i, "",
+               pToken->len, pToken->spaces,
+               pToken->type | HB_PP_TOKEN_STATIC | HB_PP_TOKEN_PREDEFINED,
+               pToken->index,
+               fLast && !pToken->pNext && iOptional == 0 ? "" : "," );
+
+      if( iOptional )
+         hb_pp_writeToken( fout, pToken->pMTokens, szName, iToken + 1,
+                           pToken->pNext == NULL && fLast );
+
+      iToken += iOptional + 1;
+      pToken = pToken->pNext;
+   }
+}
+
+static void hb_pp_writeTokenList( FILE * fout, PHB_PP_TOKEN pTokenLst, char * szName )
+{
+   int iTokens;
+
+   iTokens = hb_pp_writeTokenCount( pTokenLst );
+   if( iTokens )
+   {
+      fprintf( fout, "static HB_PP_TOKEN %s[ %d ] = {\n",
+               szName, iTokens );
+      hb_pp_writeToken( fout, pTokenLst, szName, 0, TRUE );
+      fprintf( fout, "};\n" );
+   }
+}
+
+static int hb_pp_writeRules( FILE * fout, PHB_PP_RULE pFirst, char * szName )
+{
+   char szMatch[ 16 ], szResult[ 16 ];
+   ULONG ulRepeatBits, ulBit;
+   PHB_PP_RULE pRule;
+   int iRule;
+   USHORT u;
+
+   iRule = 0;
+   pRule = pFirst;
+   while( pRule )
+   {
+      ++iRule;
+      if( pRule->pMatch )
+      {
+         sprintf( szMatch, "s_%cm%03d", szName[0], iRule );
+         hb_pp_writeTokenList( fout, pRule->pMatch, szMatch );
+      }
+
+      if( pRule->pResult )
+      {
+         sprintf( szResult, "s_%cr%03d", szName[0], iRule );
+         hb_pp_writeTokenList( fout, pRule->pResult, szResult );
+      }
+      pRule = pRule->pPrev;
+   }
+
+   fprintf( fout, "static const HB_PP_DEFRULE s_%s[ %d ] = {\n",
+            szName, iRule );
+
+   iRule = 0;
+   pRule = pFirst;
+   while( pRule )
+   {
+      ++iRule;
+      if( pRule->pMatch )
+         sprintf( szMatch, "s_%cm%03d", szName[0], iRule );
+      else
+         strcpy( szMatch, "NULL   " );
+      if( pRule->pResult )
+         sprintf( szResult, "s_%cr%03d", szName[0], iRule );
+      else
+         strcpy( szResult, "NULL   " );
+
+      ulRepeatBits = 0;
+      for( u = 0, ulBit = 1; u < pRule->markers; ++u, ulBit <<= 1 )
+      {
+         if( pRule->pMarkers[ u ].canrepeat )
+            ulRepeatBits |= ulBit;
+      }
+      fprintf( fout, "   { %s, %s, %d,%2d, 0x%04lx }%s\n",
+               szMatch, szResult, HB_PP_CMP_MODE( pRule->mode ),
+               pRule->markers, ulRepeatBits, pRule->pPrev ? "," : "" );
+      pRule = pRule->pPrev;
+   }
+   fprintf( fout, "};\n\n" );
+   return iRule;
+}
+
+static void hb_pp_generateInitFunc( FILE * fout, int iRules,
+                                    char * szVar, char * szRule )
+{
+   fprintf( fout, "   hb_pp_initRules( &pState->p%s, &pState->i%s, ",
+            szVar, szVar );
+   if( iRules )
+      fprintf( fout, "s_%s, %d );\n", szRule, iRules );
+   else
+      fprintf( fout, "NULL, 0 );\n" );
+}
+
+static void hb_pp_generateRules( FILE * fout, PHB_PP_STATE pState )
+{
+   int iDefs = 0, iTrans = 0, iCmds = 0;
+
+   fprintf( fout, "/*\n * $Id$\n */\n\n/*\n"
+         " * Harbour Project source code:\n"
+         " *    Build in preprocessor rules.\n"
+         " *\n"
+         " * Copyright 2006 Przemyslaw Czerpak <druzus / at / priv.onet.pl>\n"
+         " * www - http://www.harbour-project.org\n"
+         " *\n"
+         " * This file is generate automatically by Harbour preprocessor\n"
+         " * and is covered by the same license as Harbour PP\n"
+         " */\n\n#define _HB_PP_INTERNAL\n#include \"hbpp.h\"\n\n" );
+
+   if( pState->pDefinitions )
+      iDefs = hb_pp_writeRules( fout, pState->pDefinitions, "def" );
+   if( pState->pTranslations )
+      iTrans = hb_pp_writeRules( fout, pState->pTranslations, "trs" );
+   if( pState->pCommands )
+      iCmds = hb_pp_writeRules( fout, pState->pCommands, "cmd" );
+
+   fprintf( fout, "\nvoid hb_pp_initStaticRules( PHB_PP_STATE pState )\n{\n" );
+   hb_pp_generateInitFunc( fout, iDefs,  "Definitions",  "def" );
+   hb_pp_generateInitFunc( fout, iTrans, "Translations", "trs" );
+   hb_pp_generateInitFunc( fout, iCmds,  "Commands",     "cmd" );
+   fprintf( fout, "}\n" );
+}
+
+static void hb_pp_undefCompilerRules( PHB_PP_STATE pState )
+{
+   int i;
+   PHB_PP_RULE * pRulePtr, pRule;
+   char * szRules[] = { "__HARBOUR__",
+                        "__DATE__",
+                        "__TIME__",
+                        "__HB_MAIN__",
+                        "__ARCH16BIT__",
+                        "__ARCH32BIT__",
+                        "__ARCH64BIT__",
+                        "__LITTLE_ENDIAN__",
+                        "__BIG_ENDIAN__",
+                        "__PDP_ENDIAN__",
+                        NULL };
+
+   for( i = 0; szRules[ i ]; ++i )
+      hb_pp_delDefine( pState, szRules[ i ] );
+
+   pRulePtr = &pState->pDefinitions;
+   while( * pRulePtr )
+   {
+      pRule = *pRulePtr;
+      if( !pRule->pMatch->pNext &&
+          strncmp( pRule->pMatch->value, "__PLATFORM__", 12 ) == 0 )
+      {
+         * pRulePtr = pRule->pPrev;
+         hb_pp_ruleFree( pRule );
+         pState->iDefinitions--;
+      }
+      else
+         pRulePtr = &pRule->pPrev;
+   }
+}
+
+static int hb_pp_preprocesfile( PHB_PP_STATE pState, char * szRuleFile )
+{
+   int iResult = 0;
+   ULONG ulLen;
+
+   while( hb_pp_nextLine( pState, &ulLen ) != NULL && ulLen );
+
+   if( szRuleFile )
+   {
+      FILE * foutr;
+
+      foutr = fopen( szRuleFile, "w" );
+      if( !foutr )
+      {
+         perror( szRuleFile );
+         iResult = 1;
+      }
+      else
+      {
+         hb_pp_undefCompilerRules( pState );
+         hb_pp_generateRules( foutr, pState );
+         fclose( foutr );
+      }
+   }
+
+   return iResult;
+}
+
+
+/*
+ * ppgen only functions
+ */
+static void hb_pp_usage( char * szName )
+{
+   printf( "Syntax:  %s <file>[.prg] [options]\n\n", szName );
+   printf( "Options: -i<path>  \tadd #include file search path\n"
+           "         -o[<file>]\tcreates .c file with PP rules\n"
+           "         -w        \twrite preprocessed (.ppo) input file\n"
+           "         -q        \tdisable information messages\n" );
+}
+
+int main( int argc, char * argv[] )
+{
+   char * szFile = NULL, * szRuleFile = NULL;
+   BOOL fQuiet = FALSE, fWrite = FALSE;
+   PHB_PP_STATE pState;
+   int iResult, i;
+
+   pState = hb_pp_new();
+
+   if( argc >= 2 )
+   {
+      szFile = argv[1];
+      for( i = 2; szFile && i < argc; i++ )
+      {
+         if( !HB_ISOPTSEP( argv[i][0] ) )
+            szFile = NULL;
+         else
+         {
+            switch( argv[i][1] )
+            {
+               case 'q':
+               case 'Q':
+                  if( argv[i][2] )
+                     szFile = NULL;
+                  else
+                     fQuiet = TRUE;
+                  break;
+
+               case 'w':
+               case 'W':
+                  if( argv[i][2] )
+                     szFile = NULL;
+                  else
+                     fWrite = TRUE;
+                  break;
+
+               case 'i':
+               case 'I':
+                  if( argv[i][2] )
+                     hb_pp_addSearchPath( pState, argv[i] + 2, FALSE );
+                  else
+                     szFile = NULL;
+                  break;
+
+               case 'o':
+               case 'O':
+                  if( argv[i][2] )
+                     szRuleFile = argv[i] + 2;
+                  else
+                     szFile = NULL;
+                  break;
+
+               default:
+                  szFile = NULL;
+                  break;
+            }
+         }
+      }
+   }
+
+   if( szFile )
+   {
+      hb_pp_init( pState, NULL, fQuiet, NULL, NULL, NULL, NULL, NULL, NULL );
+      hb_pp_inFile( pState, szFile, NULL );
+      if( fWrite )
+      {
+         char szFileName[ _POSIX_PATH_MAX + 1 ];
+         PHB_FNAME pFileName;
+
+         pFileName = hb_fsFNameSplit( szFile );
+         pFileName->szExtension = ".ppo";
+         hb_fsFNameMerge( szFileName, pFileName );
+         hb_xfree( pFileName );
+
+         hb_pp_outFile( pState, szFileName, NULL );
+      }
+      iResult = hb_pp_preprocesfile( pState, szRuleFile );
+   }
+   else
+   {
+      hb_pp_usage( argv[0] );
+      iResult = 1;
+   }
+
+   hb_pp_free( pState );
+
+   return iResult;
+}
diff --git a/harbour/source/pp/pplib.c b/harbour/source/pp/pplib.c
index 6a3e61d518..0621d9325d 100644
--- a/harbour/source/pp/pplib.c
+++ b/harbour/source/pp/pplib.c
@@ -4,9 +4,9 @@
 
 /*
  * Harbour Project source code:
- * Preprocessor runtime library callable version
+ * 
  *
- * Copyright 1999 Felipe G. Coury <fcoury@creation.com.br>
+ * Copyright 2006 Przemyslaw Czerpak <druzus / at / priv.onet.pl>
  * www - http://www.harbour-project.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -50,216 +50,169 @@
  *
  */
 
-/*
- * Avoid tracing in preprocessor/compiler.
- */
-#if ! defined(HB_TRACE_UTILS)
-   #if defined(HB_TRACE_LEVEL)
-      #undef HB_TRACE_LEVEL
-   #endif
-#endif
-
-#include <stdio.h>
-/* #include <setjmp.h> */
 
 #include "hbpp.h"
-#include "hbcomp.h"
 #include "hbapi.h"
+#include "hbapiitm.h"
+#include "hbapifs.h"
 #include "hbapierr.h"
+#include "hbvm.h"
 
-#ifdef HB_EXTENSION
+static PHB_PP_STATE s_pp_state = NULL;
 
-HB_PATHNAMES * hb_comp_pIncludePath = NULL;
-PHB_FNAME      hb_comp_pFileName = NULL;
-FILES          hb_comp_files;
-int            hb_comp_iLine;       /* currently parsed file line number */
-int            hb_comp_iLinePRG;
-int            hb_comp_iLineINLINE = 0;
+static void hb_pp_ErrorMessage( char * szMsgTable[], char cPrefix, int iCode,
+                                const char * szParam1, const char * szParam2 )
+{
+   HB_TRACE(HB_TR_DEBUG, ("hb_pp_ErrorGen(%p, %c, %d, %s, %s)", szMsgTable, cPrefix, iCode, szParam1, szParam2));
 
-/* These are need for the PP #pragma support */
-BOOL           hb_comp_bPPO = FALSE;           /* flag indicating, is ppo output needed */
-BOOL           hb_comp_bStartProc = TRUE;      /* holds if we need to create the starting procedure */
-BOOL           hb_comp_bLineNumbers = TRUE;    /* holds if we need pcodes with line numbers */
+   /* ignore warning messages */
+   if( cPrefix != 'W' )
+   {
+      char szMsgBuf[ 1024 ];
+      PHB_ITEM pError;
+      sprintf( szMsgBuf, szMsgTable[ iCode - 1 ], szParam1, szParam2 );
+      pError = hb_errRT_New( ES_ERROR, "PP", 9999, ( ULONG ) iCode, szMsgBuf,
+                             NULL, 0, EF_NONE | EF_CANDEFAULT );
+      hb_errLaunch( pError );
+      hb_errRelease( pError );
+   }
+}
 
-#if 0
-BOOL           hb_comp_bShortCuts = TRUE;      /* .and. & .or. expressions shortcuts */
-#endif
+static void hb_pp_Disp( const char * szMessage )
+{
+   /* ignore stdout messages when PP used as library */
+   HB_SYMBOL_UNUSED( szMessage );
+}
 
-int            hb_comp_iWarnings = 0;                     /* enable parse warnings */
-BOOL           hb_comp_bAutoMemvarAssume = FALSE;         /* holds if undeclared variables are automatically assumed MEMVAR (-a)*/
-BOOL           hb_comp_bForceMemvars = FALSE;             /* holds if memvars are assumed when accesing undeclared variable (-v)*/
-BOOL           hb_comp_bDebugInfo = FALSE;                /* holds if generate debugger required info */
-int            hb_comp_iExitLevel = HB_EXITLEVEL_DEFAULT; /* holds if there was any warning during the compilation process */
-FILE *         hb_comp_yyppo = NULL;
+static PHB_PP_STATE hb_pp_stateParam( int * piParam )
+{
+   PHB_ITEM pItem = hb_parptr( 1 );
 
-/* static jmp_buf s_env; */
+   if( pItem )
+   {
+      * piParam = 2;
+      return ( PHB_PP_STATE ) hb_itemGetPtr( pItem );
+   }
+   else
+   {
+      * piParam = 1;
+      if( !s_pp_state )
+      {
+         s_pp_state = hb_pp_new();
+         hb_pp_init( s_pp_state, NULL, TRUE, NULL, NULL,
+                     hb_pp_ErrorMessage, hb_pp_Disp, NULL, NULL );
+      }
+      return s_pp_state;
+   }
+}
 
 HB_FUNC( __PP_INIT )
 {
-   hb_pp_Table();
-   hb_pp_Init();
-   hb_comp_files.iFiles = 0;
+   PHB_PP_STATE pState;
+   int iParam;
 
-   if( ISCHAR( 1 ) )
+   pState = hb_pp_stateParam( &iParam );
+   if( pState )
    {
-      hb_fsAddSearchPath( hb_parc( 1 ), &hb_comp_pIncludePath );
+      hb_pp_reset( pState );
+
+      if( ISCHAR( iParam ) )
+         hb_pp_addSearchPath( pState, hb_parc( iParam ), TRUE );
+
+      hb_retptr( pState );
+   }
+   else
+      hb_ret();
+}
+
+HB_FUNC( __PP_FREE )
+{
+   PHB_ITEM pItem = hb_parptr( 1 );
+
+   if( pItem )
+   {
+      PHB_PP_STATE pState = ( PHB_PP_STATE ) hb_itemGetPtr( pItem );
+      if( pState )
+         hb_pp_free( pState );
+   }
+   else if( s_pp_state )
+   {
+      hb_pp_free( s_pp_state );
+      s_pp_state = NULL;
    }
 }
 
 HB_FUNC( __PP_PATH )
 {
-   if( ISLOG( 2 ) && hb_parl( 2 ) && hb_comp_pIncludePath )
-   {
-      hb_fsFreeSearchPath( hb_comp_pIncludePath );
-      hb_comp_pIncludePath = NULL;
-   }
+   PHB_PP_STATE pState;
+   int iParam;
 
-   if( ISCHAR( 1 ) )
+   pState = hb_pp_stateParam( &iParam );
+   if( pState )
    {
-      hb_fsAddSearchPath( hb_parc( 1 ), &hb_comp_pIncludePath );
-   }
-}
-
-HB_FUNC( __PP_FREE )
-{
-   if( hb_comp_pIncludePath )
-   {
-      hb_fsFreeSearchPath( hb_comp_pIncludePath );
-      hb_comp_pIncludePath = NULL;
-   }
-
-   hb_pp_Free();
-
-   if( hb_pp_aCondCompile )
-   {
-      hb_xfree( hb_pp_aCondCompile );
-      hb_pp_aCondCompile = NULL;
+      hb_pp_addSearchPath( pState, hb_parc( iParam ), hb_parl( iParam + 1 ) );
    }
 }
 
 HB_FUNC( __PPADDRULE )
 {
-   if( ISCHAR( 1 ) )
-   {
-      char * ptr = hb_parc( 1 );
-      char * hb_buffer;
+   PHB_PP_STATE pState;
+   int iParam;
 
-      HB_SKIPTABSPACES( ptr );
-      if( *ptr == '#' )
+   pState = hb_pp_stateParam( &iParam );
+   if( pState )
+   {
+      char * szText = hb_parc( iParam );
+      ULONG ulLen = hb_parclen( iParam );
+
+      if( szText )
       {
-         if( !hb_pp_aCondCompile )
+         while( ulLen && ( szText[ 0 ] == ' ' || szText[ 0 ] == '\t' ) )
          {
-            hb_pp_Table();
-            hb_pp_Init();
-            hb_comp_files.iFiles = 0;
+            ++szText;
+            --ulLen;
          }
-         hb_pp_ParseDirective( ptr );
-         if( hb_comp_files.pLast )
-         {
-            hb_buffer = ( char* ) hb_xgrab( HB_PP_STR_SIZE );
-            while( hb_pp_Internal( NULL,hb_buffer ) > 0 );
-            hb_pp_CloseInclude();
-            hb_xfree( hb_buffer );
-         }
-         hb_retl( 1 );
       }
-      else
-         hb_retl( 0 );
+
+      if( szText && ulLen && szText[ 0 ] == '#' )
+      {
+         hb_pp_reset( pState );
+         hb_pp_parseLine( pState, szText, &ulLen );
+
+         /* probably for #included files parsing the old code was making
+            sth like that */
+         do
+         {
+            if( hb_vmRequestQuery() != 0 )
+               return;
+         }
+         while( hb_pp_nextLine( pState, NULL ) );
+
+         hb_retl( TRUE );
+         return;
+      }
    }
-   else
-      hb_retl( 0 );
+   hb_retl( FALSE );
 }
 
 HB_FUNC( __PREPROCESS )
 {
-   if( ISCHAR( 1 ) )
+   PHB_PP_STATE pState;
+   int iParam;
+
+   pState = hb_pp_stateParam( &iParam );
+   if( pState )
    {
-      char * pText = ( char * ) hb_xgrab( HB_PP_STR_SIZE );
-      char * pOut = ( char * ) hb_xgrab( HB_PP_STR_SIZE );
+      char * szText = hb_parc( iParam );
+      ULONG ulLen = hb_parclen( iParam );
 
-      /* if( setjmp( s_env ) == 0 ) */
-      { 
-         char * ptr = pText;
-         int slen;
-
-         /*   hb_pp_Init();   */
-
-         slen = HB_MIN( hb_parclen( 1 ), HB_PP_STR_SIZE - 1 );
-         memcpy( pText, hb_parc( 1 ), slen );
-         pText[ slen ] = 0; /* Preprocessor expects null-terminated string */
-         if( slen )
-         {
-            memset( pOut, 0, HB_PP_STR_SIZE );
-
-            HB_SKIPTABSPACES( ptr );
-
-            if( !hb_pp_topDefine )
-               hb_pp_Table();
-            if( *ptr && hb_pp_ParseExpression( ptr, pOut, FALSE ) > 0 )
-            {
-               /* Some error here? */
-            }
-         }
-         hb_retc( pText ); /* Preprocessor returns parsed line in input buffer */
+      if( szText && ulLen )
+      {
+         szText = hb_pp_parseLine( pState, szText, &ulLen );
+         hb_retclen( szText, ulLen );
+         return;
       }
-      /* else
-      {  */
-         /* an error occured during parsing.
-          * The longjmp was used in GenError()
-          */
-      /*   hb_retc( NULL );
-      } */
-
-      hb_xfree( pText );
-      hb_xfree( pOut );
    }
-   else
-      hb_retc( NULL );
+
+   hb_retc( NULL );
 }
-
-void hb_compGenError( char * szErrors[], char cPrefix, int iError, const char * szError1, const char * szError2 )
-{
-   PHB_ITEM pError;
-   char buffer[ 128 ];
-
-   HB_SYMBOL_UNUSED( cPrefix );
-
-   HB_TRACE(HB_TR_DEBUG, ("hb_compGenError(%p, %c, %d, %s, %s)", szErrors, cPrefix, iError, szError1, szError2));
-
-   /* TOFIX: The internal buffers allocated by the preprocessor should be
-             deallocated here */
-
-   sprintf( buffer, szErrors[ iError - 1 ], szError1, szError2 );
-   pError = hb_errRT_New( ES_ERROR, "PP", 9999, ( ULONG ) iError, buffer, NULL, 0, EF_NONE | EF_CANDEFAULT );
-   hb_errLaunch( pError );
-   hb_errRelease( pError );
-
-   /* longjmp( s_env, iError == 0 ? -1 : iError ); */
-}
-
-void hb_compGenWarning( char * szWarnings[], char cPrefix, int iWarning, const char * szWarning1, const char * szWarning2 )
-{
-   HB_TRACE(HB_TR_DEBUG, ("hb_compGenWarning(%p, %c, %d, %s, %s)", szWarnings, cPrefix, iWarning, szWarning1, szWarning2));
-
-   /* NOTE: All warnings are simply ignored */
-
-   HB_SYMBOL_UNUSED( szWarnings );
-   HB_SYMBOL_UNUSED( cPrefix );
-   HB_SYMBOL_UNUSED( iWarning );
-   HB_SYMBOL_UNUSED( szWarning1 );
-   HB_SYMBOL_UNUSED( szWarning2 );
-}
-
-PINLINE   hb_compInlineAdd( char * szFunName )
-{
-   HB_SYMBOL_UNUSED( szFunName );
-   return NULL;
-}
-
-void hb_compParserStop( void  )
-{
-   ;
-}
-
-#endif
-
diff --git a/harbour/source/rdd/workarea.c b/harbour/source/rdd/workarea.c
index c814ae9b61..9ac89d47ad 100644
--- a/harbour/source/rdd/workarea.c
+++ b/harbour/source/rdd/workarea.c
@@ -1362,6 +1362,7 @@ ERRCODE hb_waClearFilter( AREAP pArea )
       hb_itemRelease( pArea->dbfi.abFilterText );
       pArea->dbfi.abFilterText = NULL;
    }
+   pArea->dbfi.fOptimized = FALSE;
    pArea->dbfi.fFilter = FALSE;
 
    return SUCCESS;
@@ -1446,7 +1447,7 @@ ERRCODE hb_waSetFilter( AREAP pArea, LPDBFILTERINFO pFilterInfo )
    {
       pArea->dbfi.abFilterText = hb_itemNew( pFilterInfo->abFilterText );
    }
-   pArea->dbfi.fOptimized = pArea->dbfi.fOptimized;
+   pArea->dbfi.fOptimized = pFilterInfo->fOptimized;
    pArea->dbfi.fFilter = TRUE;
 
    return SUCCESS;
diff --git a/harbour/source/rtl/dates.c b/harbour/source/rtl/dates.c
index 6e41d498f1..4a2b5c9463 100644
--- a/harbour/source/rtl/dates.c
+++ b/harbour/source/rtl/dates.c
@@ -54,9 +54,6 @@
  * The following parts are Copyright of the individual authors.
  * www - http://www.harbour-project.org
  *
- * Copyright 1999 Jose Lalin <dezac@corevia.com>
- *    hb_dateDOW()
- *
  * Copyright 1999 David G. Holm <dholm@jsd-llc.com>
  *    hb_dateFormat()
  *
@@ -64,10 +61,7 @@
  *
  */
 
-#define HB_OS_WIN_32_USED
-
 #include <ctype.h>
-#include <time.h>
 
 #include "hbapi.h"
 #include "hbdate.h"
@@ -243,51 +237,3 @@ HB_EXPORT char * hb_dateFormat( const char * szDate, char * szFormattedDate, con
 
    return szFormattedDate;
 }
-
-HB_EXPORT void hb_dateToday( int * piYear, int * piMonth, int * piDay )
-{
-#if defined(HB_OS_WIN_32)
-   {
-      SYSTEMTIME st;
-      GetLocalTime( &st );
-
-      *piYear  = st.wYear;
-      *piMonth = st.wMonth;
-      *piDay   = st.wDay;
-   }
-#else
-   {
-      time_t t;
-      struct tm * oTime;
-
-      time( &t );
-      oTime = localtime( &t );
-
-      *piYear  = oTime->tm_year + 1900;
-      *piMonth = oTime->tm_mon + 1;
-      *piDay   = oTime->tm_mday;
-   }
-#endif
-}
-
-/* NOTE: The passed buffer must be at least 9 chars long */
-
-HB_EXPORT void hb_dateTimeStr( char * pszTime )
-{
-#if defined(HB_OS_WIN_32)
-   {
-      SYSTEMTIME st;
-      GetLocalTime( &st );
-      sprintf( pszTime, "%02d:%02d:%02d", st.wHour, st.wMinute, st.wSecond );
-   }
-#else
-   {
-      time_t t;
-      struct tm * oTime;
-
-      time( &t );
-      oTime = localtime( &t );
-      sprintf( pszTime, "%02d:%02d:%02d", oTime->tm_hour, oTime->tm_min, oTime->tm_sec );
-   }
-#endif
-}
diff --git a/harbour/utils/hbpp/Makefile b/harbour/utils/hbpp/Makefile
index 779f1e7ada..6924dd12c1 100644
--- a/harbour/utils/hbpp/Makefile
+++ b/harbour/utils/hbpp/Makefile
@@ -5,11 +5,14 @@
 ROOT = ../../
 
 C_SOURCES=\
+	ppcore.c \
+	ppcomp.c \
+	pptable.c \
+	pragma.c \
 
 C_MAIN=hbpp.c
 
 LIBS=\
-	pp \
 	common \
 
 include $(TOP)$(ROOT)config/bin.cf
diff --git a/harbour/utils/hbpp/hbpp.c b/harbour/utils/hbpp/hbpp.c
index d2512976df..28bac703b6 100644
--- a/harbour/utils/hbpp/hbpp.c
+++ b/harbour/utils/hbpp/hbpp.c
@@ -70,7 +70,7 @@
 #include "hbpp.h"
 #include "hbcomp.h"
 
-extern int hb_pp_ParseDefine( char * );
+extern int hb_pp_ParseDefine_( char * );
 
 static void AddSearchPath( char * szPath, HB_PATHNAMES * * pSearchList );
 static void OutTable( DEFINES * endDefine, COMMANDS * endCommand );
@@ -142,16 +142,16 @@ int main( int argc, char * argv[] )
                  {
                     if( ( pAssign = strchr( szDefText, '=' ) ) == NULL )
                     {
-                       hb_pp_AddDefine( szDefText, 0 );
+                       hb_pp_AddDefine_( szDefText, 0 );
                     }
                     else
                     {
                        szDefText[ pAssign - szDefText ] = '\0';
 
-                       //hb_pp_AddDefine( szDefText,  pAssign + 1 );
+                       //hb_pp_AddDefine_( szDefText,  pAssign + 1 );
                        sDefLine = (char*) hb_xgrab( strlen( szDefText ) + 1 + strlen( pAssign + 1 ) + 1 );
                        sprintf( sDefLine, "%s %s", szDefText, pAssign + 1 );
-                       hb_pp_ParseDefine( sDefLine );
+                       hb_pp_ParseDefine_( sDefLine );
                        hb_xfree( sDefLine );
                     }
                  }
diff --git a/harbour/utils/hbpp/hbpp.h b/harbour/utils/hbpp/hbpp.h
new file mode 100644
index 0000000000..2a1a9cda66
--- /dev/null
+++ b/harbour/utils/hbpp/hbpp.h
@@ -0,0 +1,184 @@
+/*
+ * $Id$
+ */
+
+/*
+ * Harbour Project source code:
+ * Header file for the Preprocesor
+ *
+ * Copyright 1999 Alexander S.Kresin <alex@belacy.belgorod.su>
+ * www - http://www.harbour-project.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this software; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
+ *
+ * As a special exception, the Harbour Project gives permission for
+ * additional uses of the text contained in its release of Harbour.
+ *
+ * The exception is that, if you link the Harbour libraries with other
+ * files to produce an executable, this does not by itself cause the
+ * resulting executable to be covered by the GNU General Public License.
+ * Your use of that executable is in no way restricted on account of
+ * linking the Harbour library code into it.
+ *
+ * This exception does not however invalidate any other reasons why
+ * the executable file might be covered by the GNU General Public License.
+ *
+ * This exception applies only to the code released by the Harbour
+ * Project under the name Harbour.  If you copy code from other
+ * Harbour Project or Free Software Foundation releases into a copy of
+ * Harbour, as the General Public License permits, the exception does
+ * not apply to the code that you add in this way.  To avoid misleading
+ * anyone as to the status of such modified files, you must delete
+ * this exception notice from them.
+ *
+ * If you write modifications of your own for Harbour, it is your choice
+ * whether to permit this exception to apply to your modifications.
+ * If you do not wish that, delete this exception notice.
+ *
+ */
+
+#ifndef HB_PP_H_
+#define HB_PP_H_
+
+#include "hbapi.h"
+#include "hbapifs.h"
+#include "hberrors.h"
+#include "hbver.h"
+
+HB_EXTERN_BEGIN
+
+struct _DEFINES;
+typedef struct _DEFINES
+{
+   char * name;
+   int namelen;
+   char * pars;
+   int    npars;
+   char * value;
+   struct _DEFINES * last;
+} DEFINES;
+
+struct _COMMANDS;
+typedef struct _COMMANDS
+{
+   int com_or_xcom;
+   char * name;
+   int namelen;
+   char * mpatt;
+   char * value;
+   struct _COMMANDS * last;
+} COMMANDS;
+
+#define HB_PP_STR_SIZE  12288
+#define HB_PP_BUFF_SIZE 4096
+
+#define HB_SKIPTABSPACES( sptr ) while( *( sptr ) == ' ' || *( sptr ) == '\t' ) ( sptr )++
+
+/* PPCORE.C exported functions and variables */
+
+#define HB_INCLUDE_FUNC_( hbFunc ) BOOL hbFunc( char *, HB_PATHNAMES * )
+typedef HB_INCLUDE_FUNC_( HB_INCLUDE_FUNC );
+typedef HB_INCLUDE_FUNC * HB_INCLUDE_FUNC_PTR;
+
+extern void   hb_pp_SetRules_( HB_INCLUDE_FUNC_PTR hb_compInclude, BOOL hb_comp_bQuiet );
+extern int    hb_pp_ReadRules( void );
+extern void   hb_pp_Init( void );
+extern void   hb_pp_Free( void );
+extern void   hb_pp_CloseInclude( void );
+extern int    hb_pp_ParseDirective_( char * ); /* Parsing preprocessor directives ( #... ) */
+extern int    hb_pp_ParseExpression( char *, char *, BOOL ); /* Parsing a line ( without preprocessor directive ) */
+extern int    hb_pp_WrStr( FILE *, char * );
+extern int    hb_pp_RdStr( FILE *, char *, int, BOOL, char *, int *, int * );
+extern void   hb_pp_Stuff( char *, char *, int, int, int );
+extern int    hb_pp_strocpy( char *, char * );
+extern DEFINES * hb_pp_AddDefine_( char *, char * );         /* Add new #define to a linked list */
+
+extern int    hb_pp_lInclude;
+extern int *  hb_pp_aCondCompile;
+extern int    hb_pp_nCondCompile;
+extern char * hb_pp_szErrors[];
+extern char * hb_pp_szWarnings[];
+extern int    hb_pp_nEmptyStrings;
+extern int    hb_pp_LastOutLine;
+extern int    hb_pp_StreamBlock;
+extern BOOL   hb_pp_NestedLiteralString;
+extern BOOL   hb_pp_LiteralEscSeq;
+extern unsigned int  hb_pp_MaxTranslateCycles;
+
+/* PPCOMP.C exported functions */
+
+extern int    hb_pp_Internal( FILE *, char * );
+extern void   hb_pp_InternalFree( void );
+
+#if 0
+#define HB_PP_STREAM_DUMP_C   1 /* pragma BEGINDUMP */
+#define HB_PP_STREAM_CLIPPER  2 /* clipper compatible TEXT/ENDTEXT */
+#define HB_PP_STREAM_PRG      4 /* TEXT/ENDTEXT lines joined with LF */
+#define HB_PP_STREAM_C        8 /* TEXT/ENDTEXT lines joined and ESC seq processed */
+#else
+#define HB_PP_STREAM_DUMP_C   2 /* pragma BEGINDUMP */
+#define HB_PP_STREAM_CLIPPER  3 /* clipper compatible TEXT/ENDTEXT */
+#define HB_PP_STREAM_PRG      4 /* TEXT/ENDTEXT lines joined with LF */
+#define HB_PP_STREAM_C        5 /* TEXT/ENDTEXT lines joined and ESC seq processed */
+#endif
+
+extern BOOL   hb_pp_StreamBlockBegin( char *, int );
+extern void   hb_pp_BlockEnd( void );
+
+/* PPTABLE.C exported functions and variables */
+
+extern void   hb_pp_Table( void );
+
+extern DEFINES *  hb_pp_topDefine;
+extern COMMANDS * hb_pp_topCommand;
+extern COMMANDS * hb_pp_topTranslate;
+
+/* PRAGMA.C exported functions */
+
+extern BOOL hb_pp_ParsePragma( char * szline );
+
+/*
+ * Errors generated by Harbour preprocessor
+ */
+#define HB_PP_ERR_CANNOT_OPEN                   1
+#define HB_PP_ERR_DIRECTIVE_ELSE                2
+#define HB_PP_ERR_DIRECTIVE_ENDIF               3
+#define HB_PP_ERR_WRONG_NAME                    4
+#define HB_PP_ERR_DEFINE_ABSENT                 5
+#define HB_PP_ERR_COMMAND_DEFINITION            6
+#define HB_PP_ERR_PATTERN_DEFINITION            7
+#define HB_PP_ERR_RECURSE                       8
+#define HB_PP_ERR_WRONG_DIRECTIVE               9
+#define HB_PP_ERR_EXPLICIT                      10
+#define HB_PP_ERR_MEMALLOC                      11
+#define HB_PP_ERR_MEMREALLOC                    12
+#define HB_PP_ERR_MEMFREE                       13
+#define HB_PP_ERR_PRAGMA_BAD_VALUE              14
+#define HB_PP_ERR_CANNOT_OPEN_RULES             15
+#define HB_PP_ERR_BAD_RULES_FILE_NAME           16
+#define HB_PP_ERR_TOO_MANY_INCLUDES             17
+#define HB_PP_ERR_BUFFER_OVERFLOW               18
+#define HB_PP_ERR_LABEL_MISSING_IN_DEFINE       19
+#define HB_PP_ERR_PARE_MISSING_IN_DEFINE        20
+#define HB_PP_ERR_LABEL_DUPL_IN_DEFINE          21
+
+#define HB_PP_WARN_DEFINE_REDEF                 1
+#define HB_PP_WARN_NO_DIRECTIVES                2
+
+HB_EXTERN_END
+
+#endif /* HB_PP_H_ */
+
diff --git a/harbour/source/pp/ppcomp.c b/harbour/utils/hbpp/ppcomp.c
similarity index 99%
rename from harbour/source/pp/ppcomp.c
rename to harbour/utils/hbpp/ppcomp.c
index 022c900614..064ac19d58 100644
--- a/harbour/source/pp/ppcomp.c
+++ b/harbour/utils/hbpp/ppcomp.c
@@ -341,7 +341,7 @@ static void pp_ParseBuffer( PFILE pFile, int *plLine )
 
       if( *ptr == '#' )
       {
-         BOOL bIgnore = hb_pp_ParseDirective( ptr );
+         BOOL bIgnore = hb_pp_ParseDirective_( ptr );
 
          if( pFile != hb_comp_files.pLast )
          {
@@ -604,7 +604,7 @@ int hb_pp_ReadRules( void )
 
               if( *ptr == '#' )
               {
-                 hb_pp_ParseDirective( ptr );
+                 hb_pp_ParseDirective_( ptr );
               }
 
               *s_szLine = '\0';
diff --git a/harbour/utils/hbpp/ppcore.c b/harbour/utils/hbpp/ppcore.c
new file mode 100644
index 0000000000..cfc4a45ef2
--- /dev/null
+++ b/harbour/utils/hbpp/ppcore.c
@@ -0,0 +1,4813 @@
+/*
+ * $Id$
+ */
+
+/*
+ * Harbour Project source code:
+ * Preprocessor core module
+ *
+ * Copyright 1999 Alexander S.Kresin <alex@belacy.belgorod.su>
+ * www - http://www.harbour-project.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this software; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
+ *
+ * As a special exception, the Harbour Project gives permission for
+ * additional uses of the text contained in its release of Harbour.
+ *
+ * The exception is that, if you link the Harbour libraries with other
+ * files to produce an executable, this does not by itself cause the
+ * resulting executable to be covered by the GNU General Public License.
+ * Your use of that executable is in no way restricted on account of
+ * linking the Harbour library code into it.
+ *
+ * This exception does not however invalidate any other reasons why
+ * the executable file might be covered by the GNU General Public License.
+ *
+ * This exception applies only to the code released by the Harbour
+ * Project under the name Harbour.  If you copy code from other
+ * Harbour Project or Free Software Foundation releases into a copy of
+ * Harbour, as the General Public License permits, the exception does
+ * not apply to the code that you add in this way.  To avoid misleading
+ * anyone as to the status of such modified files, you must delete
+ * this exception notice from them.
+ *
+ * If you write modifications of your own for Harbour, it is your choice
+ * whether to permit this exception to apply to your modifications.
+ * If you do not wish that, delete this exception notice.
+ *
+ */
+
+/*
+ * The following parts are Copyright of the individual authors.
+ * www - http://www.harbour-project.org
+ *
+ * Copyright 1999-2001 Viktor Szakats <viktor.szakats@syenar.hu>
+ *    __DATE__, __TIME__, __HB_MAIN__ support
+ *
+ * Copyright 2000 Ron Pinkas <Ron@Profit-Master.com>
+ *
+ * hb_pp_SetRules() and related code for supportting
+ * replaceable rules with -w switch
+ *
+ * See doc/license.txt for licensing terms.
+ *
+ */
+
+/*
+ * Avoid tracing in preprocessor/compiler.
+ */
+#if ! defined(HB_TRACE_UTILS)
+#if defined(HB_TRACE_LEVEL)
+#undef HB_TRACE_LEVEL
+#endif
+#endif
+
+#include <time.h>
+#include <errno.h>
+
+#include "hbpp.h"
+#include "hbcomp.h"
+
+#if defined( OS_UNIX_COMPATIBLE )
+#include <sys/timeb.h>
+#else
+#include <sys/timeb.h>
+#endif
+
+int hb_pp_ParseDefine_( char * );        /* Process #define directive */
+
+static COMMANDS *AddCommand( char * );  /* Add new #command to an array  */
+static COMMANDS *AddTranslate( char * );        /* Add new #translate to an array  */
+static DEFINES *DefSearch( char *, int, BOOL * );
+static COMMANDS *ComSearch( char *, COMMANDS * );
+static COMMANDS *TraSearch( char *, COMMANDS * );
+
+static int ParseUndef( char * );        /* Process #undef directive */
+static int ParseIfdef( char *, int );   /* Process #ifdef directive */
+static void ParseCommand( char *, BOOL, BOOL ); /* Process #command or #translate directive */
+static void ConvertPatterns( char *, int, char *, int );        /* Converting result pattern in #command and #translate */
+static int WorkDefine( char **, char *, DEFINES * );    /* Replace fragment of code with a #defined result text */
+static int WorkPseudoF( char **, char *, DEFINES * );   /* Replace pseudofunction with a #defined result text */
+static int WorkCommand( char *, char *, COMMANDS * );
+static int WorkTranslate( char *, char *, COMMANDS *, int * );
+static int CommandStuff( char *, char *, char *, int *, BOOL, BOOL );
+static int RemoveSlash( char * );
+static int WorkMarkers( char **, char **, char *, int *, BOOL, BOOL );
+static int getExpReal( char *, char **, BOOL, int, BOOL, BOOL );
+static BOOL isExpres( char *, BOOL );
+static BOOL TestOptional( char *, char * );
+static BOOL CheckOptional( char *, char *, char *, int *, BOOL, BOOL );
+static void SkipOptional( char ** );
+
+static void SearnRep( char *, char *, int, char *, int * );
+static int ReplacePattern( char, char *, int, char *, int );
+static void pp_rQuotes( char *, char * );
+static int md_strAt( char *, int, char *, BOOL, BOOL, BOOL, int );
+
+#define MD_STR_AT_IGNORECASE  0 /* search ignoring case */
+#define MD_STR_AT_USESUBCASE  1 /* use case specified in search string (old) */
+static char *PrevSquare( char *, char *, int * );
+static int IsInStr( char, char * );
+static int stroncpy( char *, char *, int );
+static int strincpy( char *, char * );
+static BOOL truncmp( char **, char **, BOOL );
+static BOOL strincmp( char *, char **, BOOL );
+static int strotrim( char *, BOOL );    /* Ron Pinkas 2001-02-14 added 2nd parameter */
+static int NextWord( char **, char *, BOOL );
+static int NextName( char **, char * );
+static int NextParm( char **, char * );
+static BOOL OpenInclude( char *, HB_PATHNAMES *, PHB_FNAME, BOOL bStandardOnly, char * );
+static BOOL IsIdentifier( char *szProspect );
+static int IsMacroVar( char *szText, BOOL isCommand );
+static void RemoveOptional( char *cpatt );
+static int ConvertOptional( char *cpatt, int len, BOOL bLeft );
+
+#define ISNAME( c )  ( isalnum( c ) || ( c ) == '_' || ( c ) > 0x7E )
+#define MAX_NAME     255
+#define MAX_EXP      2048
+#define PATTERN_SIZE 2048
+
+#define STATE_INIT      0
+#define STATE_NORMAL    1
+#define STATE_COMMENT   2
+#define STATE_QUOTE1    3
+#define STATE_QUOTE2    4
+#define STATE_QUOTE3    5
+#define STATE_ID_END    6
+#define STATE_ID        7
+#define STATE_EXPRES    8
+#define STATE_EXPRES_ID 9
+#define STATE_BRACKET   10
+
+#define IT_EXPR       1
+#define IT_ID         2
+#define IT_COMMA      3
+#define IT_ID_OR_EXPR 4
+
+#define HB_PP_MAX_INCLUDES FOPEN_MAX - 5 - 1
+
+#define HB_PP_MATCH_MARK '\1'
+#define HB_PP_OPT_START  '\2'
+#define HB_PP_OPT_END    '\3'
+
+/* Ron Pinkas added 2000-01-24 */
+#define IS_2CHAR_OPERATOR( p ) ( p[0] && p[1] && ( strncmp( p, ":=", 2 ) == 0 || \
+                                                   strncmp( p, "+=", 2 ) == 0 || \
+                                                   strncmp( p, "-=", 2 ) == 0 || \
+                                                   strncmp( p, "*=", 2 ) == 0 || \
+                                                   strncmp( p, "/=", 2 ) == 0 || \
+                                                   strncmp( p, "^=", 2 ) == 0 || \
+                                                   strncmp( p, "==", 2 ) == 0 || \
+                                                   strncmp( p, "<>", 2 ) == 0 || \
+                                                   strncmp( p, "<=", 2 ) == 0 || \
+                                                   strncmp( p, ">=", 2 ) == 0 || \
+                                                   strncmp( p, "++", 2 ) == 0 || \
+                                                   strncmp( p, "--", 2 ) == 0 || \
+                                                   strncmp( p, "->", 2 ) == 0      ) )
+/* END, Ron Pinkas added 2000-01-24 */
+
+
+static int s_kolAddDefs = 0;
+static int s_kolAddComs = 0;
+static int s_kolAddTras = 0;
+static int s_ParseState;
+static int s_maxCondCompile;
+static int s_aIsRepeate[5];
+static int s_Repeate;
+static BOOL s_bReplacePat = TRUE;
+static int s_numBrackets;
+static char s_groupchar;
+static char s_prevchar;
+/* additional buffers for expressions */
+static char *s_expreal = NULL;   /* allocation inside WorkMarkers */
+static char *s_expcopy = NULL;   /* allocation inside SearnExp */
+
+/* global variables */
+int *hb_pp_aCondCompile = NULL;
+int hb_pp_nCondCompile = 0;
+BOOL hb_pp_NestedLiteralString = FALSE;
+BOOL hb_pp_LiteralEscSeq = FALSE;
+unsigned int hb_pp_MaxTranslateCycles = 1024;
+int hb_pp_StreamBlock = 0;
+char *hb_pp_STD_CH = NULL;
+
+/* Ron Pinkas added 2000-11-21 */
+static BOOL s_bArray = FALSE;
+
+/* Table with parse errors */
+char *hb_pp_szErrors[] = {
+   "Can\'t open #include file: \'%s\'; %s",
+   "#else does not match #ifdef",
+   "#endif does not match #ifdef",
+   "Bad filename in #include",
+   "#define without parameters",
+   "Missing => in #translate/#command \'%s\' [%s]'",
+   "Error in pattern definition",
+   "Cycled #define",
+   "Invalid name follows #: \'%s\'",
+   "\'%s\'",
+   "Memory allocation error",
+   "Memory reallocation error",
+   "Freeing a NULL memory pointer",
+   "Value out of range in #pragma directive",
+   "Can\'t open command definitions file: \'%s\'",
+   "Invalid command definitions file name: \'%s\'",
+   "Too many nested #includes, can\'t open: \'%s\'",
+   "Input buffer overflow",
+   "Label missing in #define '%s'",
+   "Comma or right parenthesis missing in #define '%s'",
+   "Label duplicated in #define '%s(%s)'",
+};
+
+/* Table with warnings */
+char *hb_pp_szWarnings[] = {
+   "1Redefinition or duplicate definition of #define %s",
+   "1No directives in command definitions file"
+};
+
+void hb_pp_SetRules_( HB_INCLUDE_FUNC_PTR pIncludeFunc, BOOL bQuiet )
+{
+   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_SetRules_()" ) );
+
+   if( hb_pp_STD_CH )
+   {
+      if( *hb_pp_STD_CH > ' ' )
+      {
+         hb_comp_pFileName = hb_fsFNameSplit( hb_pp_STD_CH );
+
+         if( hb_comp_pFileName->szName )
+         {
+            char szFileName[_POSIX_PATH_MAX];
+
+            if( !hb_comp_pFileName->szExtension )
+               hb_comp_pFileName->szExtension = ".ch";
+
+            hb_fsFNameMerge( szFileName, hb_comp_pFileName );
+
+            if( ( *pIncludeFunc ) ( szFileName, hb_comp_pIncludePath ) )
+            {
+               hb_pp_Init(  );
+
+               hb_pp_ReadRules(  );
+
+               if( s_kolAddComs || s_kolAddTras || s_kolAddDefs > 3 )
+               {
+                  if( !bQuiet )
+                     printf( "Loaded: %i Commands, %i Translates, %i Defines from: %s\n", s_kolAddComs, s_kolAddTras, s_kolAddDefs - 3, szFileName );
+               }
+               else
+               {
+                  hb_compGenWarning( hb_pp_szWarnings, 'I', HB_PP_WARN_NO_DIRECTIVES, NULL /*szFileName */ , NULL );
+               }
+
+               fclose( hb_comp_files.pLast->handle );
+               hb_xfree( hb_comp_files.pLast->pBuffer );
+               hb_xfree( hb_comp_files.pLast->szFileName );
+               if( hb_comp_files.pLast->yyBuffer )
+               {
+                  hb_compParserStop(  );        /* uses hb_comp_files.pLast */
+               }
+               hb_xfree( hb_comp_files.pLast );
+               hb_comp_files.pLast = NULL;
+               hb_comp_files.iFiles = 0;
+
+               hb_xfree( ( void * ) hb_comp_pFileName );
+               hb_comp_pFileName = NULL;
+            }
+            else
+            {
+               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_CANNOT_OPEN_RULES, szFileName, NULL );
+            }
+         }
+         else
+         {
+            hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_BAD_RULES_FILE_NAME, hb_pp_STD_CH, NULL );
+         }
+      }
+      else
+      {
+         if( !bQuiet )
+            printf( "Standard command definitions excluded.\n" );
+
+         hb_pp_Init(  );
+      }
+      hb_xfree( hb_pp_STD_CH );
+   }
+   else
+   {
+      hb_pp_Table(  );
+      hb_pp_Init(  );
+   }
+}
+
+void hb_pp_Free( void )
+{
+   DEFINES *stdef;
+   COMMANDS *stcmd;
+
+   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_Free()" ) );
+
+   while( s_kolAddDefs )
+   {
+      stdef = hb_pp_topDefine;
+      if( stdef->pars )
+         hb_xfree( stdef->pars );
+      if( stdef->value )
+         hb_xfree( stdef->value );
+      if( stdef->name )
+         hb_xfree( stdef->name );
+      hb_pp_topDefine = stdef->last;
+      hb_xfree( stdef );
+      s_kolAddDefs--;
+   }
+   while( s_kolAddComs )
+   {
+      stcmd = hb_pp_topCommand;
+      if( stcmd->mpatt )
+         hb_xfree( stcmd->mpatt );
+      if( stcmd->value )
+         hb_xfree( stcmd->value );
+      hb_xfree( stcmd->name );
+      hb_pp_topCommand = stcmd->last;
+      hb_xfree( stcmd );
+      s_kolAddComs--;
+   }
+   while( s_kolAddTras )
+   {
+      stcmd = hb_pp_topTranslate;
+      if( stcmd->mpatt )
+         hb_xfree( stcmd->mpatt );
+      if( stcmd->value )
+         hb_xfree( stcmd->value );
+      hb_xfree( stcmd->name );
+      hb_pp_topTranslate = stcmd->last;
+      hb_xfree( stcmd );
+      s_kolAddTras--;
+   }
+   if( hb_pp_aCondCompile )
+   {
+      hb_xfree( ( void * ) hb_pp_aCondCompile );
+      hb_pp_aCondCompile = NULL;
+   }
+   hb_pp_InternalFree(  );
+   
+   if( s_expreal )
+   {
+      hb_xfree( ( void *) s_expreal );
+      s_expreal = NULL;
+   }
+   if( s_expcopy )
+   {
+      hb_xfree( ( void *) s_expcopy );
+      s_expcopy = NULL;
+   }
+}
+
+void hb_pp_Init( void )
+{
+   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_Init()" ) );
+
+   hb_pp_Free(  );
+
+   s_ParseState = 0;
+   s_maxCondCompile = 5;
+   s_bReplacePat = TRUE;
+   s_prevchar = 'A';
+
+   if( !hb_pp_aCondCompile )
+      hb_pp_aCondCompile = ( int * ) hb_xgrab( sizeof( int ) * 5 );
+
+   hb_pp_nCondCompile = 0;
+
+   {
+      char sOS[64];
+      char sVer[64];
+      char *pSrc, *pDst;
+      char *szPlatform = hb_verPlatform(  );
+      int n;
+
+      strcpy( sOS, "__PLATFORM__" );
+
+      pSrc = szPlatform;
+      n = strlen( sOS );
+      pDst = sOS;
+
+      while( *pSrc && *pSrc != ' ' && n < ( int ) sizeof( sOS ) - 1 )
+      {
+         if( *pSrc == '_' || ( *pSrc >= 'A' && *pSrc <= 'Z' ) || ( *pSrc >= 'a' && *pSrc <= 'z' ) || ( *pSrc >= '0' && *pSrc <= '9' ) )
+         {
+            pDst[n++] = *pSrc;
+         }
+         pSrc++;
+      }
+      pDst[n] = 0;
+
+      n = 0;
+      pDst = sVer;
+      pDst[n++] = '"';
+      if( *pSrc == ' ' )
+      {
+         while( *( ++pSrc ) && n < ( int ) sizeof( sVer ) - 2 )
+            pDst[n++] = *pSrc;
+      }
+      pDst[n++] = '"';
+      pDst[n] = 0;
+
+      hb_pp_AddDefine_( sOS, sVer );
+#ifdef HB_OS_UNIX
+      strcpy( &sOS[12], "UNIX" );
+      hb_pp_AddDefine_( sOS, sVer );
+#endif
+      hb_xfree( szPlatform );
+   }
+
+   {
+      char szResult[6];
+      USHORT usHarbour = ( 256 * HB_VER_MAJOR ) + HB_VER_MINOR;
+
+      /*
+         This updates __HARBOUR__ on every change of HB_VER_MAJOR / HB_VER_MINOR
+         HIBYTE is the HB_VER_MAJOR value and the LOBYTE is the HB_VER_MINOR value.
+
+         The check below is to ensure that __HARBOUR__ gets the
+         value of 1 by default
+       */
+      sprintf( szResult, "%05d", ( usHarbour ? usHarbour : 1 ) );
+      hb_pp_AddDefine_( "__HARBOUR__", szResult );
+   }
+
+   {
+      char szResult[11];
+      time_t t;
+      struct tm *oTime;
+
+      time( &t );
+      oTime = localtime( &t );
+
+      sprintf( szResult, "\"%04d%02d%02d\"", oTime->tm_year + 1900, oTime->tm_mon + 1, oTime->tm_mday );
+      hb_pp_AddDefine_( "__DATE__", szResult );
+
+      sprintf( szResult, "\"%02d:%02d:%02d\"", oTime->tm_hour, oTime->tm_min, oTime->tm_sec );
+      hb_pp_AddDefine_( "__TIME__", szResult );
+   }
+
+   {
+      char szResult[11];
+
+      sprintf( szResult, "%d", ( int ) sizeof( void * ) );
+#if defined( HB_ARCH_16BIT )
+      hb_pp_AddDefine_( "__ARCH16BIT__", szResult );
+#elif defined( HB_ARCH_32BIT )
+      hb_pp_AddDefine_( "__ARCH32BIT__", szResult );
+#elif defined( HB_ARCH_64BIT )
+      hb_pp_AddDefine_( "__ARCH64BIT__", szResult );
+#endif
+
+#if defined( HB_LITTLE_ENDIAN )
+      hb_pp_AddDefine_( "__LITTLE_ENDIAN__", szResult );
+#elif defined( HB_BIG_ENDIAN )
+      hb_pp_AddDefine_( "__BIG_ENDIAN__", szResult );
+#elif defined( HB_PDP_ENDIAN )
+      hb_pp_AddDefine_( "__PDP_ENDIAN__", szResult );
+#endif
+   }
+
+#ifdef HARBOUR_START_PROCEDURE
+   hb_pp_AddDefine_( "__HB_MAIN__", HARBOUR_START_PROCEDURE );
+#endif
+}
+
+/* Table with parse warnings */
+/* NOTE: The first character stores the warning's level that triggers this
+ * warning. The warning's level is set by -w<n> command line option.
+ */
+
+int hb_pp_ParseDirective_( char *sLine )
+{
+   char sDirective[MAX_NAME];
+   char szInclude[_POSIX_PATH_MAX];
+   int i;
+   int bIgnore = 1;
+   char *sParse;
+
+   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_ParseDirective_(%s)", sLine ) );
+
+   strotrim( sLine, TRUE );
+   hb_pp_strocpy( sLine, sLine + 1 );
+   sParse = sLine;
+
+   i = NextName( &sLine, sDirective );
+   hb_strupr( sDirective );
+
+   HB_SKIPTABSPACES( sLine );
+
+   if( i == 4 && memcmp( sDirective, "ELSE", 4 ) == 0 )
+   {                            /* ---  #else  --- */
+      if( hb_pp_nCondCompile == 0 )
+         hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_DIRECTIVE_ELSE, NULL, NULL );
+      else if( hb_pp_nCondCompile == 1 || hb_pp_aCondCompile[hb_pp_nCondCompile - 2] )
+         hb_pp_aCondCompile[hb_pp_nCondCompile - 1] = 1 - hb_pp_aCondCompile[hb_pp_nCondCompile - 1];
+   }
+
+   else if( i >= 4 && i <= 5 && memcmp( sDirective, "ENDIF", i ) == 0 )
+   {                            /* --- #endif  --- */
+      if( hb_pp_nCondCompile == 0 )
+         hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_DIRECTIVE_ENDIF, NULL, NULL );
+      else
+         hb_pp_nCondCompile--;
+   }
+
+   else if( i >= 4 && i <= 5 && memcmp( sDirective, "IFDEF", i ) == 0 )
+      ParseIfdef( sLine, TRUE );        /* --- #ifdef  --- */
+
+   else if( i >= 4 && i <= 6 && memcmp( sDirective, "IFNDEF", i ) == 0 )
+      ParseIfdef( sLine, FALSE );       /* --- #ifndef  --- */
+
+   else if( hb_pp_nCondCompile == 0 || hb_pp_aCondCompile[hb_pp_nCondCompile - 1] )
+   {
+      if( i >= 4 && i <= 7 && memcmp( sDirective, "INCLUDE", i ) == 0 )
+      {                         /* --- #include --- */
+         char cDelimChar;
+
+         if( *sLine != '\"' && *sLine != '\'' && *sLine != '<' )
+            hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_WRONG_NAME, NULL, NULL );
+
+         cDelimChar = *sLine;
+         if( cDelimChar == '<' )
+            cDelimChar = '>';
+         else if( cDelimChar == '`' )
+            cDelimChar = '\'';
+
+         sLine++;
+         i = 0;
+         while( *( sLine + i ) != '\0' && *( sLine + i ) != cDelimChar )
+            i++;
+         if( *( sLine + i ) != cDelimChar )
+            hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_WRONG_NAME, NULL, NULL );
+         *( sLine + i ) = '\0';
+
+         if( !OpenInclude( sLine, hb_comp_pIncludePath, hb_comp_pFileName, ( cDelimChar == '>' ), szInclude ) )
+         {
+            if( errno == 0 || errno == EMFILE )
+               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_TOO_MANY_INCLUDES, sLine, NULL );
+            else
+            {
+#if defined(__CYGWIN__) || defined(__IBMCPP__) || defined(__LCC__)
+               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_CANNOT_OPEN, sLine, "" );
+#else
+               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_CANNOT_OPEN, sLine, strerror( errno ) );
+#endif
+            }
+         }
+      }
+
+      else if( i >= 4 && i <= 6 && memcmp( sDirective, "DEFINE", i ) == 0 )
+         hb_pp_ParseDefine_( sLine );    /* --- #define  --- */
+
+      else if( i >= 4 && i <= 5 && memcmp( sDirective, "UNDEF", i ) == 0 )
+         ParseUndef( sLine );   /* --- #undef  --- */
+
+      else if( ( i >= 4 && i <= 7 && memcmp( sDirective, "COMMAND", i ) == 0 ) || ( i >= 4 && i <= 8 && memcmp( sDirective, "XCOMMAND", i ) == 0 ) )
+         /* --- #command  --- */
+         ParseCommand( sLine, ( i == 7 ) ? FALSE : TRUE, TRUE );
+
+      else
+         if( ( i >= 4 && i <= 9 && memcmp( sDirective, "TRANSLATE", i ) == 0 )
+             || ( i >= 4 && i <= 10 && memcmp( sDirective, "XTRANSLATE", i ) == 0 ) )
+         /* --- #translate  --- */
+         ParseCommand( sLine, ( i == 9 ) ? FALSE : TRUE, FALSE );
+
+      else if( i >= 4 && i <= 6 && memcmp( sDirective, "STDOUT", i ) == 0 )
+         printf( "%s\n", sLine );       /* --- #stdout  --- */
+
+      else if( i >= 4 && i <= 5 && memcmp( sDirective, "ERROR", i ) == 0 )
+         /* --- #error  --- */
+         hb_compGenError( hb_pp_szErrors, 'E', HB_PP_ERR_EXPLICIT, sLine, NULL );
+
+      else if( i == 4 && memcmp( sDirective, "LINE", 4 ) == 0 )
+         return -1;
+
+      else if( i == 6 && memcmp( sDirective, "PRAGMA", 6 ) == 0 )
+      {
+         hb_pp_strocpy( sParse, sParse + 6 );
+         bIgnore = hb_pp_ParsePragma( sParse ); /* --- #pragma  --- */
+      }
+      else
+         hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_WRONG_DIRECTIVE, sDirective, NULL );
+   }
+   return bIgnore;
+}
+
+int hb_pp_ParseDefine_( char *sLine )
+{
+   char defname[MAX_NAME], pars[MAX_NAME + 1];
+   int i, npars = -1;
+   DEFINES *lastdef;
+
+   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_ParseDefine_(%s)", sLine ) );
+
+   HB_SKIPTABSPACES( sLine );
+   if( ISNAME( ( BYTE ) * sLine ) )
+   {
+      char *cParams = NULL;
+
+      NextName( &sLine, defname );
+      if( *sLine == '(' )       /* If pseudofunction was found */
+      {
+         int iParLen = 0;
+         int iLen;
+
+         sLine++;
+         HB_SKIPTABSPACES( sLine );
+
+         npars = 0;
+         while( *sLine && *sLine != ')' )
+         {
+            if( ISNAME( ( BYTE ) * sLine ) )
+            {
+               NextName( &sLine, pars );
+               iLen = strlen( pars );
+               if( cParams == NULL )
+               {
+                  /* 'xy0' -> '~xy0' */
+                  cParams = ( char * ) hb_xgrab( iLen + 2 );
+               }
+               else
+               {
+                  /* '~xy0' -> '~xy,~ab0' */
+                  char *cPos;
+
+                  cPos = strstr( cParams, pars );
+                  if( cPos && ( cPos[iLen] == ',' || cPos[iLen] == '\0' ) )
+                  {
+                     cPos--;
+                     if( *cPos == '\001' )
+                        hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_LABEL_DUPL_IN_DEFINE, defname, pars );
+                  }
+                  cParams = ( char * ) hb_xrealloc( cParams, iParLen + iLen + 3 );
+                  cParams[iParLen++] = ',';
+                  cParams[iParLen] = '\0';
+               }
+               cParams[iParLen] = '\001';
+               strcpy( cParams + iParLen + 1, pars );
+               iParLen += iLen + 1;
+               npars++;
+               HB_SKIPTABSPACES( sLine );
+            }
+            else
+               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_LABEL_MISSING_IN_DEFINE, defname, NULL );
+
+            if( *sLine == ',' )
+            {
+               sLine++;
+               HB_SKIPTABSPACES( sLine );
+               if( *sLine == ')' )
+                  hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_LABEL_MISSING_IN_DEFINE, defname, NULL );
+            }
+         }
+         HB_SKIPTABSPACES( sLine );
+         if( *sLine == '\0' )
+            hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_PARE_MISSING_IN_DEFINE, defname, NULL );
+
+         sLine++;
+      }
+
+      HB_SKIPTABSPACES( sLine );
+
+      if( cParams )
+      {
+         char *tmp = cParams;
+         char *cPos;
+         int iPar, iLen, iPos, iOldPos;
+
+         iLen = strlen( sLine );
+         for( i = 0; i < npars; i++ )
+         {
+            /*1z,1y */
+            cPos = strchr( tmp, ',' );
+            if( cPos )
+               iPar = cPos - tmp;
+            else
+               iPar = strlen( tmp );
+            memcpy( pars, tmp, iPar );
+            pars[iPar] = '\0';
+            iOldPos = 0;
+            while( ( iPos = md_strAt( pars + 1, iPar - 1, sLine + iOldPos, TRUE, FALSE, FALSE, MD_STR_AT_IGNORECASE ) ) != 0 )
+            {
+               if( sLine[iOldPos + iPos] != '\001' )
+               {
+                  hb_pp_Stuff( pars, sLine + iOldPos + iPos - 1, iPar, iPar - 1, iLen - iPos - iOldPos );
+                  iLen++;
+               }
+               iOldPos += iPos + iPar;
+            }
+            if( cPos )
+               tmp = cPos + 1;
+         }
+      }
+      lastdef = hb_pp_AddDefine_( defname, ( *sLine == '\0' ) ? NULL : sLine );
+
+      if( lastdef )
+      {
+         lastdef->npars = npars;
+         lastdef->pars = cParams;
+      }
+      else if( cParams )
+         hb_xfree( cParams );
+   }
+   else
+      hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_DEFINE_ABSENT, NULL, NULL );
+
+   return 0;
+}
+
+DEFINES *hb_pp_AddDefine_( char *defname, char *value )
+{
+   BOOL isNew;
+   DEFINES *stdef;
+   int len = strlen( defname );
+
+   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_AddDefine_(%s, %s)", defname, value ) );
+
+   stdef = DefSearch( defname, len, &isNew );
+
+   if( stdef != NULL )
+   {
+      hb_compGenWarning( hb_pp_szWarnings, 'I', HB_PP_WARN_DEFINE_REDEF, defname, NULL );
+
+      if( isNew )
+      {
+         if( stdef->pars )
+            hb_xfree( stdef->pars );
+         if( stdef->value )
+            hb_xfree( stdef->value );
+      }
+      else
+         return NULL;
+   }
+   else
+   {
+      stdef = ( DEFINES * ) hb_xgrab( sizeof( DEFINES ) );
+      stdef->last = hb_pp_topDefine;
+      hb_pp_topDefine = stdef;
+      stdef->name = hb_strdup( defname );
+      stdef->namelen = len;
+      stdef->npars = -1;
+
+      s_kolAddDefs++;
+   }
+
+   stdef->value = ( value == NULL ) ? NULL : hb_strdup( value );
+   stdef->pars = NULL;
+
+   return stdef;
+}
+
+static int ParseUndef( char *sLine )
+{
+   char defname[MAX_NAME];
+   DEFINES *stdef;
+   BOOL isNew;
+   int len;
+
+   HB_TRACE( HB_TR_DEBUG, ( "ParseUndef(%s)", sLine ) );
+
+   NextWord( &sLine, defname, FALSE );
+
+   len = strlen( defname );
+   if( ( stdef = DefSearch( defname, len, &isNew ) ) != NULL )
+   {
+      if( isNew )
+      {
+         if( stdef->pars )
+            hb_xfree( stdef->pars );
+         if( stdef->value )
+            hb_xfree( stdef->value );
+         hb_xfree( stdef->name );
+      }
+      stdef->pars = NULL;
+      stdef->value = NULL;
+      stdef->name = NULL;
+      stdef->namelen = 0;
+   }
+
+   return 0;
+}
+
+static int ParseIfdef( char *sLine, int usl )
+{
+   char defname[MAX_NAME];
+   DEFINES *stdef;
+   int len = 0;
+
+   HB_TRACE( HB_TR_DEBUG, ( "ParseIfdef(%s, %d)", sLine, usl ) );
+
+   if( hb_pp_nCondCompile == 0 || hb_pp_aCondCompile[hb_pp_nCondCompile - 1] )
+   {
+      len = NextWord( &sLine, defname, FALSE );
+      if( *defname == '\0' )
+         hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_DEFINE_ABSENT, NULL, NULL );
+   }
+   if( hb_pp_nCondCompile == s_maxCondCompile )
+   {
+      s_maxCondCompile += 5;
+      hb_pp_aCondCompile = ( int * ) hb_xrealloc( hb_pp_aCondCompile, sizeof( int ) * s_maxCondCompile );
+   }
+   if( hb_pp_nCondCompile == 0 || hb_pp_aCondCompile[hb_pp_nCondCompile - 1] )
+   {
+      if( ( ( stdef = DefSearch( defname, len, NULL ) ) != NULL && usl ) || ( stdef == NULL && !usl ) )
+         hb_pp_aCondCompile[hb_pp_nCondCompile] = 1;
+      else
+         hb_pp_aCondCompile[hb_pp_nCondCompile] = 0;
+   }
+   else
+      hb_pp_aCondCompile[hb_pp_nCondCompile] = 0;
+
+   hb_pp_nCondCompile++;
+
+   return 0;
+}
+
+static DEFINES *DefSearch( char *defname, int len, BOOL * isNew )
+{
+   int kol = 0, j;
+   DEFINES *stdef = hb_pp_topDefine;
+
+   HB_TRACE( HB_TR_DEBUG, ( "DefSearch(%s)", defname ) );
+
+   while( stdef != NULL )
+   {
+      kol++;
+      if( stdef->name != NULL && stdef->namelen == len )
+      {
+         for( j = 0; *( stdef->name + j ) == *( defname + j ) && *( stdef->name + j ) != '\0'; j++ ) ;
+         if( *( stdef->name + j ) == *( defname + j ) )
+         {
+            if( isNew )
+               *isNew = ( s_kolAddDefs >= kol );
+            return stdef;
+         }
+      }
+      stdef = stdef->last;
+   }
+   return NULL;
+}
+
+static COMMANDS *ComSearch( char *cmdname, COMMANDS * stcmdStart )
+{
+   COMMANDS *stcmd = ( stcmdStart ) ? stcmdStart : hb_pp_topCommand;
+
+   HB_TRACE( HB_TR_DEBUG, ( "ComSearch(%s, %p)", cmdname, stcmdStart ) );
+
+   while( stcmd != NULL )
+   {
+      int j;
+
+      for( j = 0; ( *( stcmd->name + j ) == toupper( *( cmdname + j ) ) ) &&
+           ( *( stcmd->name + j ) != '\0' ) && ( ( stcmd->com_or_xcom ) ? 1 : ( j < 4 || ISNAME( ( BYTE ) * ( cmdname + j + 1 ) ) ) ); j++ ) ;
+      if( ( *( stcmd->name + j ) == toupper( *( cmdname + j ) ) )
+          || ( !stcmd->com_or_xcom && j >= 4 && *( stcmd->name + j ) != '\0' && *( cmdname + j ) == '\0' ) )
+         break;
+
+      stcmd = stcmd->last;
+   }
+
+   return stcmd;
+}
+
+static COMMANDS *TraSearch( char *cmdname, COMMANDS * sttraStart )
+{
+   int j;
+   COMMANDS *sttra = ( sttraStart ) ? sttraStart : hb_pp_topTranslate;
+
+   HB_TRACE( HB_TR_DEBUG, ( "TraSearch(%s, %p)", cmdname, sttraStart ) );
+
+   while( sttra != NULL )
+   {
+      for( j = 0; *( sttra->name + j ) == toupper( *( cmdname + j ) ) &&
+           *( sttra->name + j ) != '\0' && ( ( sttra->com_or_xcom ) ? 1 : ( j < 4 || ISNAME( ( BYTE ) * ( cmdname + j + 1 ) ) ) ); j++ ) ;
+      if( *( sttra->name + j ) == toupper( *( cmdname + j ) )
+          || ( !sttra->com_or_xcom && j >= 4 && *( sttra->name + j ) != '\0' && *( cmdname + j ) == '\0' ) )
+         break;
+      sttra = sttra->last;
+   }
+   return sttra;
+}
+
+static void ParseCommand( char *sLine, BOOL com_or_xcom, BOOL com_or_tra )
+{
+#if !defined(HB_PP_DEBUG_MEMORY)
+   static char mpatt[PATTERN_SIZE];
+#else
+   char *mpatt = ( char * ) hb_xgrab( PATTERN_SIZE );
+#endif
+   char *rpatt;
+
+   char cmdname[MAX_NAME];
+   COMMANDS *stcmd;
+   int mlen, rlen;
+   int ipos;
+
+   /* Ron Pinkas added 2000-12-03 */
+   BOOL bOk = FALSE;
+
+   HB_TRACE( HB_TR_DEBUG, ( "ParseCommand(%s, %d, %d)", sLine, com_or_xcom, com_or_tra ) );
+
+   HB_SKIPTABSPACES( sLine );
+   ipos = 0;
+
+   /* JFL 2000-09-19 */
+   /* This was the original line as Alexander wrote it */
+   /* while( *sLine != '\0' && *sLine != ' ' && *sLine != '\t' && *sLine != '<' && *sLine != '=' && ( *sLine != '(' || ipos == 0 ) ) */
+   /* Now the line #xtranslate = name(.. => will be allowed */
+
+   /* I changed it to the following to allow < and = to be the first char within a translate or xtranslate */
+   while( *sLine != '\0' && *sLine != ' ' && *sLine != '\t'
+          && ( *sLine != '<' || ipos == 0 ) && ( *sLine != '=' || ipos == 0 ) && ( *sLine != '(' || ipos == 0 ) )
+   {
+      /* Ron Pinkas added 2000-01-24 */
+      if( !ISNAME( ( BYTE ) * sLine ) )
+      {
+         if( *sLine == '[' && ipos )
+            break;
+
+         if( IS_2CHAR_OPERATOR( sLine ) )
+         {
+            *( cmdname + ipos++ ) = *sLine++;
+            *( cmdname + ipos++ ) = *sLine++;
+            break;
+         }
+         else
+         {
+            *( cmdname + ipos++ ) = *sLine++;
+            break;
+         }
+      }
+      /* END, Ron Pinkas added 2000-01-24 */
+
+      *( cmdname + ipos++ ) = *sLine++;
+   }
+   *( cmdname + ipos ) = '\0';
+
+   if( !ipos )
+   {
+#if defined(HB_PP_DEBUG_MEMORY)
+      hb_xfree( ( void * ) mpatt );
+#endif
+      return;
+   }
+
+   hb_strupr( cmdname );
+   HB_SKIPTABSPACES( sLine );
+
+   /* Ron Pinkas added 2000-12-03 */
+   ipos = 0;
+   while( *sLine )
+   {
+      mpatt[ipos++] = *sLine;
+
+      if( *sLine == '=' )
+      {
+         int i = ipos;
+
+         sLine++;
+         mpatt[i++] = *sLine;
+
+         while( *sLine && ( *sLine == ' ' || *sLine == '\t' ) )
+         {
+            sLine++;
+            mpatt[i++] = *sLine;
+         }
+
+         if( *sLine == '>' )
+         {
+            ipos = ipos - 2;
+            while( mpatt[ipos] == ' ' || mpatt[ipos] == '\t' )
+            {
+               ipos--;
+            }
+
+            mpatt[ipos + 1] = '\0';
+            sLine++;
+            bOk = TRUE;
+            break;
+         }
+
+         ipos = i;
+      }
+
+      sLine++;
+   }
+   /* End - Ron Pinkas added 2000-12-03 */
+
+   /* Ron Pinkas modified 2000-12-03
+      if( (ipos = hb_strAt( "=>", 2, sLine, strlen(sLine) )) > 0 ) */
+   if( bOk )
+   {
+      /* Ron Pinkas removed 2000-12-03
+         stroncpy( mpatt, sLine, ipos-1 ); */
+
+      mlen = strotrim( mpatt, TRUE );
+
+      /* Ron Pinkas removed 2000-12-03
+         sLine += ipos + 1; */
+
+      HB_SKIPTABSPACES( sLine );
+      /* hb_pp_strocpy( rpatt, sLine ); */
+      rpatt = sLine;
+      rlen = strotrim( rpatt, TRUE );
+
+      ConvertPatterns( mpatt, mlen, rpatt, rlen );
+      RemoveSlash( mpatt );
+      rlen = RemoveSlash( rpatt );
+
+      if( com_or_tra )
+         stcmd = AddCommand( cmdname );
+      else
+         stcmd = AddTranslate( cmdname );
+
+      stcmd->com_or_xcom = com_or_xcom;
+      stcmd->mpatt = hb_strdup( mpatt );
+      stcmd->value = ( rlen > 0 ) ? hb_strdup( rpatt ) : NULL;
+   }
+   else
+   {
+      sLine -= ( ipos + 1 );
+      hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_COMMAND_DEFINITION, cmdname, sLine );
+   }
+#if defined(HB_PP_DEBUG_MEMORY)
+   hb_xfree( ( void * ) mpatt );
+#endif
+}
+
+/* Remove escape characters and check '[' optional markers
+*/
+static int ConvertOptional( char *cpatt, int len, BOOL bLeft )
+{
+   int i = 0;
+
+   while( cpatt[i] != '\0' )
+   {
+      if( cpatt[i] == '"' || cpatt[i] == '\'' )
+      {
+         char c = cpatt[i];
+
+         i++;
+         while( cpatt[i] && cpatt[i] != c )
+         {
+            i++;
+         }
+         i++;
+         continue;              /* skip "strings" */
+      }
+
+      if( cpatt[i] == '[' )
+      {
+         if( i && cpatt[i - 1] == '\\' )
+         {
+            hb_pp_Stuff( "", cpatt + i - 1, 0, 1, len - i + 1 );
+            len--;
+            continue;
+         }
+         else
+         {
+            int j = i + 1;
+            int iOpenBrackets = 1;
+            BOOL bOption = FALSE;
+
+            while( cpatt[j] && iOpenBrackets )
+            {
+               if( cpatt[j] == '[' && cpatt[j - 1] != '\\' )
+                  iOpenBrackets++;
+               else if( cpatt[j] == ']' && cpatt[j - 1] != '\\' )
+               {
+                  if( --iOpenBrackets == 0 && ( bOption || bLeft ) )
+                  {
+                     cpatt[i] = HB_PP_OPT_START;
+                     cpatt[j] = HB_PP_OPT_END;
+                  }
+               }
+               else if( cpatt[j] == '<' )
+               {
+                  j++;
+                  while( cpatt[j] == ' ' || cpatt[j] == '\t' )
+                     j++;
+                  if( strchr( "*(!-{.\"", cpatt[j] ) || ISNAME( ( BYTE ) cpatt[j] ) )
+                  {
+                     bOption = TRUE;
+                     continue;
+                  }
+               }
+               else if( cpatt[j] == '"' || cpatt[j] == '\'' )
+               {
+                  char c = cpatt[j];
+
+                  j++;
+                  while( cpatt[j] && cpatt[j] != c )
+                  {
+                     j++;
+                  }
+               }
+               j++;
+            }
+
+            if( iOpenBrackets )
+            {
+               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_PATTERN_DEFINITION, cpatt + i, NULL );
+            }
+         }
+      }
+      else if( cpatt[i] == ']' )
+      {
+         if( i && cpatt[i - 1] == '\\' )
+         {
+            hb_pp_Stuff( "", cpatt + i - 1, 0, 1, len - i + 1 );
+            len--;
+            continue;
+         }
+      }
+      i++;
+   }
+
+   return len;
+}
+
+static void RemoveOptional( char *cpatt )
+{
+   int i = 0;
+   int len = strlen( cpatt );
+   int iOpenBra = 0;
+
+   while( cpatt[i] != '\0' )
+   {
+      if( cpatt[i] == '"' || cpatt[i] == '\'' )
+      {
+         char c = cpatt[i++];
+
+         while( cpatt[i] && cpatt[i] != c )
+         {
+            i++;
+         }
+         if( cpatt[i] )
+            i++;
+         continue;              /* skip "strings" */
+      }
+      if( cpatt[i] == '[' )
+      {
+         i++;
+         iOpenBra++;
+         while( cpatt[i] && iOpenBra )
+         {
+            if( cpatt[i] == '[' )
+               iOpenBra++;
+            else if( cpatt[i] == ']' )
+               iOpenBra--;
+            i++;
+         }
+         continue;              /* skip [strings] */
+      }
+
+      if( cpatt[i] == HB_PP_OPT_START || cpatt[i] == HB_PP_OPT_END )
+      {
+         hb_pp_Stuff( "", cpatt + i, 0, 1, len - i + 1 );
+         len--;
+      }
+      else
+         i++;
+   }
+}
+
+
+/* ConvertPatterns()
+ * Converts result pattern in #command and #translate to inner format
+ */
+
+static void ConvertPatterns( char *mpatt, int mlen, char *rpatt, int rlen )
+{
+   int i = 0, ipos, ifou;
+   int explen, rmlen;
+   char exppatt[MAX_NAME], expreal[5] = "   0";
+   char lastchar = '@', exptype;
+   char *ptr, *ptrtmp;
+
+   HB_TRACE( HB_TR_DEBUG, ( "ConvertPatterns(%s, %d, %s, %d)", mpatt, mlen, rpatt, rlen ) );
+
+   expreal[0] = HB_PP_MATCH_MARK;
+   mlen = ConvertOptional( mpatt, mlen, TRUE ); /* left pattern */
+   rlen = ConvertOptional( rpatt, rlen, FALSE );        /* right pattern */
+
+   while( *( mpatt + i ) != '\0' )
+   {
+      if( mpatt[i] == '"' || mpatt[i] == '\'' )
+      {
+         char c = mpatt[i];
+
+         i++;
+         while( mpatt[i] && mpatt[i] != c )
+         {
+            i++;
+         }
+         i++;
+         continue;              /* skip "strings" */
+      }
+
+      if( *( mpatt + i ) == '<' )
+      {
+         if( i && mpatt[ i-1 ] == '\\' )
+         {
+            i++;
+            continue;
+         }
+         
+         /* Drag match marker, determine it type */
+         explen = 0;
+         ipos = i;
+         i++;
+         exptype = '0';
+         while( *( mpatt + i ) == ' ' || *( mpatt + i ) == '\t' )
+            i++;
+         if( *( mpatt + i ) == '*' )    /* Wild match marker */
+         {
+            exptype = '3';
+            i++;
+         }
+         else if( *( mpatt + i ) == '(' )       /* Extended expression match marker */
+         {
+            exptype = '4';
+            i++;
+         }
+         else if( *( mpatt + i ) == '!' )       /* Minimal expression match marker */
+         {
+            exptype = '5';
+            i++;
+         }
+         ptr = mpatt + i;
+         while( *ptr != '>' )
+         {
+            if( *ptr == '\0' || *ptr == '<' || *ptr == '[' || *ptr == ']' )
+            {
+               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_PATTERN_DEFINITION, NULL, NULL );
+               return;
+            }
+            ptr++;
+         }
+
+         while( *( mpatt + i ) != '>' )
+         {
+            if( *( mpatt + i ) == ',' ) /* List match marker */
+            {
+               exptype = '1';
+               while( *( mpatt + i ) != '>' )
+                  i++;
+               break;
+            }
+            else if( *( mpatt + i ) == ':' )    /* Restricted match marker */
+            {
+               exptype = '2';
+               *( mpatt + i-- ) = ' ';
+               break;
+            }
+            if( *( mpatt + i ) != ' ' && *( mpatt + i ) != '\t' )
+               *( exppatt + explen++ ) = *( mpatt + i );
+            i++;
+         }
+
+         if( exptype == '3' )
+         {
+            if( *( exppatt + explen - 1 ) == '*' )
+               explen--;
+            else
+               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_PATTERN_DEFINITION, NULL, NULL );
+         }
+         else if( exptype == '4' )
+         {
+            if( *( exppatt + explen - 1 ) == ')' )
+               explen--;
+            else
+               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_PATTERN_DEFINITION, NULL, NULL );
+         }
+         else if( exptype == '5' )
+         {
+            if( *( exppatt + explen - 1 ) == '!' )
+               explen--;
+            else
+               hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_PATTERN_DEFINITION, NULL, NULL );
+         }
+
+         rmlen = i - ipos + 1;
+         /* Convert match marker into inner format */
+         lastchar = ( lastchar != 'Z' ) ? ( ( char ) ( ( unsigned int ) lastchar + 1 ) ) : 'a';
+         expreal[1] = lastchar;
+         expreal[2] = exptype;
+         hb_pp_Stuff( expreal, mpatt + ipos, 4, rmlen, mlen - ipos );
+         mlen += 4 - rmlen;
+         i += 4 - rmlen;
+
+         /* Look for appropriate result markers */
+         ptr = rpatt;
+         while( ( ifou = hb_strAt( exppatt, explen, ptr, rlen - ( ptr - rpatt ) ) ) > 0 )
+         {
+            /* Convert result marker into inner format */
+            ifou--;
+            ptr += ifou;
+            ptrtmp = ptr + 1;
+            rmlen = explen;
+            exptype = '0';      /* regular result marker */
+            do
+            {
+               ptr--;
+               rmlen++;
+               ifou--;
+               if( *ptr == '<' )
+                  continue;
+               else if( *ptr == '\"' )
+                  exptype = '2';        /* normal stringify result marker */
+               else if( *ptr == '(' )
+                  exptype = '3';        /* Smart stringify result marker */
+               else if( *ptr == '{' )
+                  exptype = '4';        /* Blockify result marker */
+               else if( *ptr == '.' )
+                  exptype = '5';        /* Logify result marker */
+               else if( *ptr == '-' )
+                  exptype = '6';        /* ommit (remove) result marker */
+               else if( *ptr == ' ' || *ptr == '\t' )
+                  continue;
+               else
+                  ifou = -1;
+            }
+            while( ifou >= 0 && *ptr != '<' && *( ptr - 1 ) != '\\' );
+
+            if( ifou >= 0 && *ptr == '<' )
+            {
+               ptr += rmlen++;
+               while( *ptr != '\0' && *ptr != '>' && *( ptr - 1 ) != '\\' )
+               {
+                  if( *ptr != ' ' && *ptr != '\t' && *ptr != '\"' && *ptr != ')' && *ptr != '}' && *ptr != '.' && *ptr != '-' )
+                  {
+                     ifou = -1;
+                     break;
+                  }
+                  rmlen++;
+                  ptr++;
+               }
+               if( ifou >= 0 && *ptr == '>' )
+               {
+                  ptr -= rmlen;
+                  ptr++;
+                  if( exptype == '0' && *( ptr - 1 ) == '#' && *( ptr - 2 ) != '\\' )
+                  {
+                     exptype = '1';     /* dumb stringify result marker */
+                     ptr--;
+                     rmlen++;
+                  }
+                  expreal[2] = exptype;
+                  hb_pp_Stuff( expreal, ptr, 4, rmlen, rlen + ( rpatt - ptr ) );
+                  rlen += 4 - rmlen;
+               }
+               else
+                  ptr = ptrtmp;
+            }
+            else
+               ptr = ptrtmp;
+         }
+      }
+      i++;
+   }
+}
+
+static COMMANDS *AddCommand( char *cmdname )
+{
+   COMMANDS *stcmd;
+
+   HB_TRACE( HB_TR_DEBUG, ( "AddCommand(%s)", cmdname ) );
+
+   stcmd = ( COMMANDS * ) hb_xgrab( sizeof( COMMANDS ) );
+   stcmd->last = hb_pp_topCommand;
+   hb_pp_topCommand = stcmd;
+   stcmd->name = hb_strdup( cmdname );
+   stcmd->namelen = strlen( cmdname );
+   s_kolAddComs++;
+   return stcmd;
+}
+
+static COMMANDS *AddTranslate( char *traname )
+{
+   COMMANDS *sttra;
+
+   HB_TRACE( HB_TR_DEBUG, ( "AddTranslate(%s)", traname ) );
+
+   sttra = ( COMMANDS * ) hb_xgrab( sizeof( COMMANDS ) );
+   sttra->last = hb_pp_topTranslate;
+   hb_pp_topTranslate = sttra;
+   sttra->name = hb_strdup( traname );
+   sttra->namelen = strlen( traname );
+   s_kolAddTras++;
+   return sttra;
+}
+
+int hb_pp_ParseExpression( char *sLine, char *sOutLine, BOOL bSplitLines )
+{
+#if !defined(HB_PP_DEBUG_MEMORY)
+   static char rpatt[PATTERN_SIZE];
+#else
+   char *rpatt = ( char * ) hb_xgrab( PATTERN_SIZE );
+#endif
+   char sToken[MAX_NAME];
+   char *ptri, *ptro, *ptrb;
+   int lenToken, i, ipos, isdvig, lens;
+   int ifou;
+   int rezDef, rezTra, rezCom;
+   unsigned int kolpass = 0;
+   DEFINES *stdef;
+   COMMANDS *stcmd;
+
+   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_ParseExpression(%s, %s)", sLine, sOutLine ) );
+
+   do
+   {
+      strotrim( sLine, FALSE );
+
+      rezDef = 0;
+      rezTra = 0;
+      rezCom = 0;
+      isdvig = 0;
+
+      do
+      {
+         ptro = sOutLine;
+         ptri = sLine + isdvig;
+         if( bSplitLines )
+            ipos = md_strAt( ";", 1, ptri, TRUE, FALSE, FALSE, MD_STR_AT_IGNORECASE );
+         else
+            ipos = 0;
+
+         if( ipos > 0 )
+         {
+            *( ptri + ipos - 1 ) = '\0';
+         }
+
+         HB_SKIPTABSPACES( ptri );
+
+         if( *ptri == '#' )
+         {
+            int bIgnore;
+
+            strcpy( rpatt, ptri );
+            bIgnore = hb_pp_ParseDirective_( rpatt );
+
+            if( ipos > 0 )
+            {
+               ipos--;
+               *( sLine + isdvig + ipos - 1 ) = ';';
+               *( sLine + isdvig + ipos ) = ' ';
+            }
+
+            lens = strlen( sLine + isdvig );
+            if( bIgnore )
+               hb_pp_Stuff( " ", sLine + isdvig, 0, ( ipos ) ? ipos : lens, lens );
+            else
+               hb_pp_Stuff( rpatt, sLine + isdvig, strlen( rpatt ), ( ipos ) ? ipos : lens, lens );
+
+            if( ipos > 0 )
+            {
+               ipos = 1;
+            }
+         }
+         else
+         {                      /* Look for macros from #define      */
+            while( ( lenToken = NextName( &ptri, sToken ) ) > 0 )
+            {
+#if 0
+               printf( "Token: >%s< Line: >%s<\n", sToken, sLine );
+#endif
+
+               if( ( stdef = DefSearch( sToken, lenToken, NULL ) ) != NULL )
+               {
+                  ptrb = ptri - lenToken;
+
+                  if( ( i = WorkDefine( &ptri, ptro, stdef ) ) >= 0 )
+                  {
+                     rezDef++;
+                     lens = strlen( ptrb );
+
+                     if( ipos > 0 )
+                     {
+                        *( ptrb + lens ) = ';';
+                        lens += strlen( ptrb + lens + 1 );
+                     }
+
+                     hb_pp_Stuff( ptro, ptrb, i, ptri - ptrb, lens + 1 );
+                     if( ipos > 0 )
+                     {
+                        ipos += i - ( ptri - ptrb );
+                        *( sLine + isdvig + ipos - 1 ) = '\0';
+                     }
+                     ptri += i - ( ptri - ptrb );
+                  }
+               }
+            }
+
+            if( rezDef == 0 )
+            {
+               /* Look for definitions from #translate    */
+               stcmd = hb_pp_topTranslate;
+               while( stcmd != NULL )
+               {
+                  ptri = sLine + isdvig;
+                  lenToken = stcmd->namelen;
+
+                  while( ( ifou = md_strAt( stcmd->name, lenToken, ptri, TRUE, FALSE, FALSE, MD_STR_AT_USESUBCASE ) ) > 0 )
+                  {
+                     ptri += ifou - 1;
+
+                     if( ( i = WorkTranslate( ptri + lenToken, ptro, stcmd, &lens ) ) >= 0 )
+                     {
+                        lens += lenToken;
+                        while( lens > 0 && ( *( ptri + lens - 1 ) == ' ' || *( ptri + lens - 1 ) == '\t' ) )
+                        {
+                           lens--;
+                        }
+
+                        if( ipos > 0 )
+                        {
+                           *( sLine + isdvig + ipos - 1 ) = ';';
+                        }
+
+                        hb_pp_Stuff( ptro, ptri, i, lens, strlen( ptri ) );
+                        rezTra = 1;
+
+                        if( ipos > 0 )
+                        {
+                           ipos += i - lens;
+                           *( sLine + isdvig + ipos - 1 ) = '\0';
+                        }
+
+                        ptri += i;
+                     }
+                     else
+                     {
+                        ptri += lenToken;
+                     }
+                  }
+
+                  stcmd = stcmd->last;
+               }
+            }                   /* rezDef == 0 */
+
+            /* Look for definitions from #command      */
+            /* JFL ! Was 3 but insufficient in most cases */
+            /* I know this is a new hardcoded limit ... any better idea's welcome */
+            if( rezDef == 0 && rezTra == 0 && kolpass < 20 )
+            {
+               ptri = sLine + isdvig;
+               HB_SKIPTABSPACES( ptri );
+
+               if( ISNAME( ( BYTE ) * ptri ) )
+               {
+                  NextName( &ptri, sToken );
+               }
+               else
+               {
+                  /* Ron Pinkas commented 2000-01-24
+                     i = 0;
+                     while( *ptri != ' ' && *ptri != '\t' && *ptri != '\0' && *ptri != '\"' && *ptri != '\'' && *ptri != '('  && !ISNAME( ( BYTE ) *ptri ) )
+                     {
+                     *(sToken+i) = *ptri++;
+                     i++;
+                     }
+                     *(sToken+i) = '\0';
+                   */
+
+                  /* Ron Pinkas added 2000-01-24 */
+                  if( IS_2CHAR_OPERATOR( ptri ) )
+                  {
+                     sToken[0] = *ptri++;
+                     sToken[1] = *ptri++;
+                     sToken[2] = '\0';
+                  }
+                  else
+                  {
+                     sToken[0] = *ptri++;
+                     sToken[1] = '\0';
+                  }
+                  /* END, Ron Pinkas added 2000-01-24 */
+               }
+
+               HB_SKIPTABSPACES( ptri );
+
+               if( ( *ptri == '\0'
+                     || ( *ptri != '='
+                          && ( !IsInStr( *ptri, ":/+*-%^" )
+                               || *( ptri + 1 ) != '=' ) && ( *ptri != '-'
+                                                              || *( ptri + 1 ) != '>' ) ) ) && ( stcmd = ComSearch( sToken, NULL ) ) != NULL )
+               {
+                  ptro = sOutLine;
+
+                  i = WorkCommand( ptri, ptro, stcmd );
+                  ptri = sLine + isdvig;
+
+                  if( ipos > 0 )
+                  {
+                     *( ptri + ipos - 1 ) = ';';
+                  }
+
+                  if( i >= 0 )
+                  {
+                     if( isdvig + ipos > 0 )
+                     {
+                        lens = strlen( sLine + isdvig );
+                        hb_pp_Stuff( ptro, sLine + isdvig, i, ( ipos ) ? ipos - 1 : lens, lens );
+
+                        if( ipos > 0 )
+                        {
+                           ipos = i + 1;
+                        }
+                     }
+                     else
+                     {
+                        memcpy( sLine, sOutLine, i + 1 );
+                     }
+                  }
+
+                  rezCom = 1;
+               }
+               else if( ipos > 0 )
+               {
+                  *( sLine + isdvig + ipos - 1 ) = ';';
+               }
+            }
+            else if( ipos > 0 )
+            {
+               *( sLine + isdvig + ipos - 1 ) = ';';
+            }
+         }
+
+         isdvig += ipos;
+      }
+      while( ipos != 0 );
+
+      kolpass++;
+
+      if( kolpass > hb_pp_MaxTranslateCycles && ( rezDef || rezTra || rezCom ) )
+      {
+         hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_RECURSE, NULL, NULL );
+         break;
+      }
+   }
+   while( rezDef || rezTra || rezCom );
+
+   RemoveOptional( sLine );
+   if( *sOutLine )
+   {
+      RemoveOptional( sOutLine );
+   }
+
+#if defined(HB_PP_DEBUG_MEMORY)
+   hb_xfree( ( void * ) rpatt );
+#endif
+   return 0;
+}
+
+static int WorkDefine( char **ptri, char *ptro, DEFINES * stdef )
+{
+   int npars, lens;
+   char *ptr;
+
+   HB_TRACE( HB_TR_DEBUG, ( "WorkDefine(%p, %s, %p)", ptri, ptro, stdef ) );
+
+   if( stdef->npars < 0 )
+   {
+      lens = hb_pp_strocpy( ptro, stdef->value );
+   }
+   else
+   {
+      HB_SKIPTABSPACES( *ptri );
+
+      if( **ptri == '(' )
+      {
+         npars = 0;
+         ptr = *ptri;
+
+         do
+         {
+            ptr++;
+
+            if( NextParm( &ptr, NULL ) > 0 )
+            {
+               npars++;
+            }
+         }
+         while( *ptr != ')' && *ptr != '\0' );
+
+         if( *ptr == ')' && stdef->npars == npars )
+         {
+            /* Ron Pinkas added 2000-11-21 */
+            char *pTmp = ptr + 1;
+
+            while( *pTmp && ( *pTmp == ' ' || *pTmp == '\t' ) )
+            {
+               pTmp++;
+            }
+            if( *pTmp == '[' )
+            {
+               s_bArray = TRUE;
+            }
+            /* END - Ron Pinkas added 2000-11-21 */
+
+            lens = WorkPseudoF( ptri, ptro, stdef );
+         }
+         else
+         {
+            return -1;
+         }
+      }
+      else
+      {
+         return -1;
+      }
+   }
+
+   return lens;
+}
+
+static int WorkPseudoF( char **ptri, char *ptro, DEFINES * stdef )
+{
+   char parfict[MAX_NAME], *ptrreal;
+   char *ptrb;
+   int ipos, ifou, ibeg;
+   int lenfict, lenreal, lenres;
+
+   HB_TRACE( HB_TR_DEBUG, ( "WorkPseudoF(%p, %s, %p)", ptri, ptro, stdef ) );
+
+   lenres = hb_pp_strocpy( ptro, stdef->value );        /* Copying value of macro to destination string  */
+
+   if( stdef->pars )
+   {
+      ipos = 0;
+      ibeg = 0;
+      do                        /* Parsing through parameters */
+      {                         /* in macro definition        */
+         if( *( stdef->pars + ipos ) == ',' || *( stdef->pars + ipos ) == '\0' )
+         {
+            *( parfict + ipos - ibeg ) = '\0';
+            lenfict = ipos - ibeg;
+
+            if( **ptri != ')' )
+            {
+               ( *ptri )++;     /* Get next real parameter */
+               HB_SKIPTABSPACES( *ptri );
+               ptrreal = *ptri;
+               lenreal = NextParm( ptri, NULL );
+
+               ptrb = ptro;
+               while( ( ifou = hb_strAt( parfict, lenfict, ptrb, lenres - ( ptrb - ptro ) ) ) > 0 )
+               {
+                  ptrb = ptrb + ifou - 1;
+                  if( !ISNAME( ( BYTE ) * ( ptrb - 1 ) ) && !ISNAME( ( BYTE ) * ( ptrb + lenfict ) ) )
+                  {
+                     hb_pp_Stuff( ptrreal, ptrb, lenreal, lenfict, lenres + ( ptro - ptrb ) );
+                     lenres += lenreal - lenfict;
+                     ptrb += lenreal;
+                  }
+                  else
+                  {
+                     ptrb++;
+                  }
+               }
+
+               ibeg = ipos + 1;
+            }
+         }
+         else
+         {
+            *( parfict + ipos - ibeg ) = *( stdef->pars + ipos );
+         }
+
+         if( *( stdef->pars + ipos ) == '\0' )
+         {
+            break;
+         }
+
+         ipos++;
+      }
+      while( 1 );
+   }
+   else
+   {
+      while( **ptri != ')' )
+      {
+         ( *ptri )++;
+      }
+   }
+
+   ( *ptri )++;
+
+   return lenres;
+}
+
+static int WorkCommand( char *ptri, char *ptro, COMMANDS * stcmd )
+{
+   int rez;
+   int lenres;
+   char *ptrmp;
+   char *sToken = stcmd->name;
+
+   HB_TRACE( HB_TR_DEBUG, ( "WorkCommand(%s, %s, %p)", ptri, ptro, stcmd ) );
+
+   do
+   {
+      lenres = hb_pp_strocpy( ptro, stcmd->value );     /* Copying result pattern */
+      ptrmp = stcmd->mpatt;     /* Pointer to a match pattern */
+      s_Repeate = 0;
+      s_groupchar = '@';
+      rez = CommandStuff( ptrmp, ptri, ptro, &lenres, TRUE, stcmd->com_or_xcom );
+
+      stcmd = stcmd->last;
+      if( rez < 0 && stcmd != NULL )
+         stcmd = ComSearch( sToken, stcmd );
+   }
+   while( rez < 0 && stcmd != NULL );
+
+   *( ptro + lenres ) = '\0';
+   if( rez >= 0 )
+   {
+      return lenres;
+   }
+   return -1;
+}
+
+static int WorkTranslate( char *ptri, char *ptro, COMMANDS * sttra, int *lens )
+{
+   int rez;
+   int lenres;
+   char *ptrmp;
+   char *sToken = sttra->name;
+
+   HB_TRACE( HB_TR_DEBUG, ( "WorkTranslate(%s, %s, %p, %p)", ptri, ptro, sttra, lens ) );
+
+   do
+   {
+      lenres = hb_pp_strocpy( ptro, sttra->value );
+      ptrmp = sttra->mpatt;
+      s_Repeate = 0;
+      s_groupchar = '@';
+      rez = CommandStuff( ptrmp, ptri, ptro, &lenres, FALSE, sttra->com_or_xcom );
+
+      sttra = sttra->last;
+
+      if( rez < 0 && sttra != NULL )
+      {
+         sttra = TraSearch( sToken, sttra );
+      }
+   }
+   while( rez < 0 && sttra != NULL );
+
+   *( ptro + lenres ) = '\0';
+
+   if( rez >= 0 )
+   {
+      *lens = rez;
+      return lenres;
+   }
+
+   return -1;
+}
+
+#define MAX_OPTIONALS 64
+
+static int CommandStuff( char *ptrmp, char *inputLine, char *ptro, int *lenres, BOOL com_or_tra, BOOL com_or_xcom )
+{
+   BOOL endTranslation = FALSE;
+   int ipos;
+   char *lastopti[MAX_OPTIONALS], *strtopti = NULL, *strtptri = NULL;
+   char *ptri = inputLine, *ptr, tmpname[MAX_NAME];
+   int isWordInside = 0;
+   char szMatch[2];
+   char *cSkipped[MAX_OPTIONALS];
+   int iSkipped = 0;
+
+   /*
+      printf( "MP: >%s<\nIn: >%s<\n", ptrmp, ptri );
+    */
+
+   HB_TRACE( HB_TR_DEBUG, ( "CommandStuff(%s, %s, %s, %p, %d, %d)", ptrmp, inputLine, ptro, lenres, com_or_tra, com_or_xcom ) );
+
+   s_numBrackets = 0;
+   HB_SKIPTABSPACES( ptri );
+   if( ptrmp == NULL )
+   {
+      if( *ptri != '\0' )
+         return -1;
+   }
+   else
+   {
+      while( *ptri != '\0' && !endTranslation )
+      {
+         HB_SKIPTABSPACES( ptrmp );
+         if( *ptrmp == HB_PP_OPT_START && !s_numBrackets && !strtopti )
+         {
+            /* Store start position of outermost optional in pattern */
+            strtopti = ptrmp;
+         }
+         if( !s_numBrackets && strtopti && strtptri != ptri && 
+             ( ISNAME( ( BYTE ) * ptri ) || *ptri == '&' ) )
+         {
+            /* Input stream starts with a word or macro -store the position
+             * which matches the outermost optional in pattern
+             */
+            strtptri = ptri;
+            ptrmp = strtopti;
+            ptr = ptri;
+            ipos = NextName( &ptr, tmpname );   /* get starting keyword */
+            ipos = md_strAt( tmpname, ipos, strtopti, TRUE, TRUE, TRUE, MD_STR_AT_USESUBCASE );
+            if( ipos && TestOptional( strtopti, strtopti + ipos - 2 ) )
+            {
+               /* the keyword from input is found in the pattern */
+               ptr = PrevSquare( strtopti + ipos - 2, strtopti, NULL );
+               if( ptr )
+                  ptrmp = ptr;
+               if( ptr != strtopti )
+               {
+                  cSkipped[ iSkipped++ ] = strtopti;
+               }
+            }
+         }
+
+         switch ( *ptrmp )
+         {
+            case HB_PP_OPT_START:
+               if( !s_numBrackets )
+                  isWordInside = 0;
+               s_numBrackets++;
+               s_aIsRepeate[s_Repeate] = 0;
+               lastopti[s_Repeate++] = ptrmp;
+               ptrmp++;
+               if( !CheckOptional( ptrmp, ptri, ptro, lenres, com_or_tra, com_or_xcom ) )
+               {
+                  SkipOptional( &ptrmp );
+               }
+               break;
+
+            case HB_PP_OPT_END:
+               if( s_Repeate )
+               {
+                  s_Repeate--;
+                  if( s_aIsRepeate[s_Repeate] )
+                  {
+                     if( ISNAME( ( BYTE ) * ptri ) )
+                     {
+                        ptr = ptri;
+                        ipos = NextName( &ptr, tmpname );
+                        ipos = md_strAt( tmpname, ipos, ptrmp, TRUE, TRUE, TRUE, MD_STR_AT_USESUBCASE );
+                        if( ipos && TestOptional( ptrmp + 1, ptrmp + ipos - 2 ) )
+                        {
+                           ptr = PrevSquare( ptrmp + ipos - 2, ptrmp + 1, NULL );
+                           if( !ptr || CheckOptional( ptrmp + 1, ptri, ptro, lenres, com_or_tra, com_or_xcom ) )
+                           {
+                              ptrmp = lastopti[s_Repeate];
+                              ptrmp++;
+                              s_Repeate++;
+                              SkipOptional( &ptrmp );
+                              s_numBrackets++;
+                              ptrmp++;
+                              strtptri = ptri;
+                           }
+                           else
+                              ptrmp = lastopti[s_Repeate];
+                        }
+                        else
+                        {
+                           ptrmp = lastopti[s_Repeate];
+                        }
+                     }
+                     else
+                     {
+                        ptrmp = lastopti[s_Repeate];
+                     }
+                  }
+                  else
+                  {
+                     if( !isWordInside )
+                        strtopti = NULL;
+                     ptrmp++;
+                  }
+                  s_numBrackets--;
+               }
+               else
+               {
+                  if( !isWordInside )
+                     strtopti = NULL;
+                  s_numBrackets--;
+                  ptrmp++;
+               }
+               break;
+
+            case ',':
+               if( s_numBrackets == 1 )
+                  isWordInside = 1;
+               if( !s_numBrackets )
+                  strtopti = NULL;
+               if( *ptri == ',' )
+               {
+                  ptrmp++;
+                  ptri++;
+               }
+               else
+               {
+                  if( s_numBrackets )
+                  {
+                     SkipOptional( &ptrmp );
+                  }
+                  else
+                     return -1;
+               }
+               break;
+
+            case HB_PP_MATCH_MARK:     /*  Match marker */
+               if( !s_numBrackets )
+                  strtopti = NULL;
+               if( s_numBrackets == 1 && *( ptrmp + 2 ) == '2' )
+                  isWordInside = 1;     /*  restricted match marker  */
+               if( ! WorkMarkers( &ptrmp, &ptri, ptro, lenres, com_or_tra, com_or_xcom ) )
+               {
+                  if( s_numBrackets )
+                  {
+                     SkipOptional( &ptrmp );
+                  }
+                  else
+                     return -1;
+               }
+               break;
+
+            case '\0':
+               if( iSkipped )
+               {
+                  ptrmp = cSkipped[ --iSkipped ];
+                  break;
+               }
+               if( com_or_tra )
+                  return -1;
+               else
+                  endTranslation = TRUE;
+               break;
+
+            default:           /*   Key word    */
+               if( s_numBrackets == 1 )
+                  isWordInside = 1;
+               if( !s_numBrackets )
+                  strtopti = NULL;
+               ptr = ptri;
+               if( *ptri == ',' || truncmp( &ptri, &ptrmp, !com_or_xcom ) )
+               {
+                  ptri = ptr;
+                  if( s_numBrackets )
+                  {
+                     SkipOptional( &ptrmp );
+                  }
+                  else 
+                     return -1;
+               }
+         }
+         HB_SKIPTABSPACES( ptri );
+      };
+   }
+
+   if( *ptrmp != '\0' )
+   {
+      if( s_Repeate )
+      {
+         s_Repeate = 0;
+         ptrmp = lastopti[0];
+      }
+      s_numBrackets = 0;
+      do
+      {
+         HB_SKIPTABSPACES( ptrmp );
+         if( *ptrmp != '\0' )
+            switch ( *ptrmp )
+            {
+               case HB_PP_OPT_START:
+                  ptrmp++;
+                  SkipOptional( &ptrmp );
+                  ptrmp++;
+                  break;
+               case HB_PP_OPT_END:
+                  ptrmp++;
+                  break;
+               default:
+                  return -1;
+            }
+      }
+      while( *ptrmp != '\0' );
+   }
+
+   szMatch[0] = HB_PP_MATCH_MARK;
+   szMatch[1] = '\0';
+   SearnRep( szMatch, "", 0, ptro, lenres );
+   *( ptro + *lenres ) = '\0';
+
+   if( com_or_tra )
+      return 1;
+   else
+      return ( ptri - inputLine );
+}
+
+static int RemoveSlash( char *cpatt )
+{
+   int i = 0;
+   int lenres = strlen( cpatt );
+
+   while( cpatt[i] != '\0' )
+   {
+      if( cpatt[i] == '"' || cpatt[i] == '\'' )
+      {
+         char c = cpatt[i];
+
+         i++;
+         while( cpatt[i] && cpatt[i] != c )
+         {
+            i++;
+         }
+         i++;
+         continue;              /* skip "strings" */
+      }
+      if( cpatt[i] == '[' )
+      {
+         i++;
+         while( cpatt[i] && cpatt[i] != ']' )
+         {
+            i++;
+         }
+         i++;
+         continue;              /* skip [strings] */
+      }
+
+      if( cpatt[i] == '\\' )
+      {
+         hb_pp_Stuff( "", cpatt + i, 0, 1, lenres - i + 1 );
+         lenres--;
+         i++;
+      }
+      else
+         i++;
+   }
+   return lenres;
+}
+
+static int WorkMarkers( char **ptrmp, char **ptri, char *ptro, int *lenres, BOOL com_or_tra, BOOL com_or_xcom )
+{
+#if ! defined(HB_PP_DEBUG_MEMORY)
+   char exppatt[MAX_NAME];
+#else
+   char *exppatt = ( char * ) hb_xgrab( MAX_NAME );
+#endif
+   int lenreal = 0, maxlenreal, lenpatt;
+   int rezrestr, ipos, nBra;
+   char *ptr, *ptrtemp;
+
+   HB_TRACE( HB_TR_DEBUG, ( "WorkMarkers(%p, %p, %s, %p)", ptrmp, ptri, ptro, lenres ) );
+
+   
+   maxlenreal = HB_PP_STR_SIZE;
+   if( s_expreal == NULL )
+      s_expreal = ( char * ) hb_xgrab( maxlenreal );
+      
+   /* Copying a match pattern to 'exppatt' */
+   lenpatt = stroncpy( exppatt, *ptrmp, 4 );
+   *ptrmp += 4;
+
+   HB_SKIPTABSPACES( *ptrmp );
+
+   /* JFL removed 12/11/2001 to allow param like (,,3) as allowed by clipper */
+   /*
+      if( **ptri == ',' )
+      {
+      if( s_numBrackets )
+      {
+      return 0;
+      }
+      } */
+
+   ptrtemp = *ptrmp;
+
+   if( *( exppatt + 2 ) != '2' && *ptrtemp == HB_PP_OPT_END )
+   {
+      ptrtemp++;
+      HB_SKIPTABSPACES( ptrtemp );
+
+      while( *ptrtemp == HB_PP_OPT_START )
+      {
+         nBra = 0;
+         ptrtemp++;
+
+         while( ( *ptrtemp != HB_PP_OPT_END || nBra ) && *ptrtemp != '\0' )
+         {
+            if( *ptrtemp == HB_PP_OPT_START )
+            {
+               nBra++;
+            }
+            else if( *ptrtemp == HB_PP_OPT_END )
+            {
+               nBra--;
+            }
+            ptrtemp++;
+         }
+         ptrtemp++;
+
+         HB_SKIPTABSPACES( ptrtemp );
+      }
+   }
+
+   if( *( exppatt + 2 ) != '2' && *ptrtemp != HB_PP_MATCH_MARK
+       && *ptrtemp != ',' && *ptrtemp != HB_PP_OPT_START && *ptrtemp != HB_PP_OPT_END && *ptrtemp != '\0' )
+   {
+      lenreal = strincpy( s_expreal, ptrtemp );
+
+      if( ( ipos = md_strAt( s_expreal, lenreal, *ptri, TRUE, TRUE, FALSE, MD_STR_AT_USESUBCASE ) ) > 0 )
+      {
+         if( ptrtemp > *ptrmp )
+         {
+            if( ipos == 1 )
+            {
+               if( s_numBrackets )
+               {
+#if defined(HB_PP_DEBUG_MEMORY)
+                  hb_xfree( ( void * ) exppatt );
+#endif
+                  return 0;
+               }
+            }
+            else
+            {
+               maxlenreal = ipos;
+               lenreal = 0;
+            }
+         }
+         else
+         {
+            /*
+               printf( "\nFound: '%s' Len: %i In: '%s' At: %i \n", s_expreal, lenreal, *ptri, ipos );
+             */
+
+            lenreal = stroncpy( s_expreal, *ptri, ipos - 1 );
+
+            if( ipos > 1 )
+            {
+               if( *( exppatt + 2 ) == '5' )    /*  ----  Minimal match marker  */
+               {
+                  if( IsIdentifier( s_expreal ) )
+                  {
+                     *ptri += lenreal;
+                  }
+               }
+               else if( isExpres( s_expreal, *( exppatt + 2 ) == '1' ) )
+               {
+                  *ptri += lenreal;
+               }
+            }
+            else
+            {
+               if( s_numBrackets )
+               {
+#if defined(HB_PP_DEBUG_MEMORY)
+                  hb_xfree( ( void * ) exppatt );
+#endif
+                  return 0;
+               }
+               else
+               {
+                  lenreal = 0;
+               }
+            }
+         }
+      }
+      else
+      {
+         if( s_numBrackets )
+         {
+#if defined(HB_PP_DEBUG_MEMORY)
+            hb_xfree( ( void * ) exppatt );
+#endif
+            return 0;
+         }
+         else
+         {
+            lenreal = 0;
+         }
+      }
+   }
+
+   if( *( exppatt + 2 ) == '4' )        /*  ----  extended match marker  */
+   {
+      if( !lenreal )
+         lenreal = getExpReal( s_expreal, ptri, FALSE, maxlenreal, FALSE, FALSE );
+      {
+         SearnRep( exppatt, s_expreal, lenreal, ptro, lenres );
+      }
+   }
+   else if( *( exppatt + 2 ) == '3' )   /*  ----  wild match marker  */
+   {
+      lenreal = hb_pp_strocpy( s_expreal, *ptri );
+      *ptri += lenreal;
+      SearnRep( exppatt, s_expreal, lenreal, ptro, lenres );
+   }
+   else if( *( exppatt + 2 ) == '2' )   /*  ---- restricted match marker  */
+   {
+      while( **ptrmp != '>' )
+      {
+         *( exppatt + lenpatt++ ) = *( ( *ptrmp )++ );
+      }
+      *( exppatt + lenpatt ) = '\0';
+      ( *ptrmp )++;
+
+      ptr = exppatt + 4;
+      rezrestr = 0;
+      while( *ptr != '\0' )
+      {
+         if( *ptr == '&' )
+         {
+            /* rglab: Thu Sep  2 21:30:07 2004
+             * Special Clipper undocumented restricted match marker: 
+             * <x:&>
+             * Clipper accepts the macro variable only here.
+             * eg.
+             * SET FILTER TO &var. 
+             * SET FILTER TO &var.foo
+             * SET FILTER TO &(var) 
+             *
+             * Notice that any expression that starts from the macro
+             * variable is not valid for this marker
+             * eg.
+             * SET FILTER TO &var+1
+             *  the above command is preprocessed by a general rule
+             * that is using smart match marker <(x)>
+             */
+            if( **ptri == '&' )
+            {
+               char * ptrmacro = *ptri; /* save current position */
+               
+               *ptri += 1;
+               HB_SKIPTABSPACES( *ptri );
+               if( **ptri == '(' )      /* macro expression &( expr )  */
+               {
+                  lenreal = getExpReal( s_expreal + 2, ptri, TRUE, maxlenreal, FALSE, TRUE );
+                  if( !( **ptri == '\0' || **ptri == ' ' ) && com_or_tra )
+                     break;
+                  s_expreal[0] = '&';
+                  s_expreal[1] = '(';
+                  lenreal +=3;
+                  s_expreal[lenreal-1] = ')';
+                  SearnRep( exppatt, s_expreal, lenreal, ptro, lenres );
+                  rezrestr = 1;
+               }
+               else
+               {
+                  lenreal = IsMacroVar( *ptri, com_or_tra );
+                  if( lenreal > 0 )
+                  {
+                     if( ! com_or_tra )
+                     {
+                        /* translate */
+                           strncpy( s_expreal + 1, *ptri, lenreal );
+                           s_expreal[0] = '&';
+                           s_expreal[lenreal + 1] = '\0';
+                           *ptri += lenreal;
+                           SearnRep( exppatt, s_expreal, lenreal + 1, ptro, lenres );
+                           rezrestr = 1;
+                           break;
+                     }
+                     else
+                     {
+                        char * ptmp = *ptri + lenreal;
+                        HB_SKIPTABSPACES( ptmp );
+                        if( ! IsInStr( *ptmp, ":/+*-%^=<>[{.," ) || 
+                            (*ptmp && ptmp[0]=='+' && ptmp[1]=='+') ||
+                           (*ptmp && ptmp[0]=='-' && ptmp[1]=='-') )
+                        {
+                        /* NOTE:
+                         * Clipper usually bounds to left the '++' and '--'
+                         * operators which means that the following code:
+                         * #command XCALL <x> <y> => <x>( <y> )
+                         *  XCALL &a ++b
+                         * is preprocessed into:
+                         * &a( ++b )
+                         * However if used with restricted macro match marker:
+                         * #command MCALL <x:&> <y> => <x>( <y> )
+                         * then
+                         *  MCALL &a ++b
+                         * is preprocessed into:
+                         * &a ++( b )
+                        */
+                           strncpy( s_expreal + 1, *ptri, lenreal );
+                           s_expreal[0] = '&';
+                           s_expreal[lenreal + 1] = '\0';
+                           *ptri += lenreal;
+                           SearnRep( exppatt, s_expreal, lenreal + 1, ptro, lenres );
+                           rezrestr = 1;
+                           break;
+                        }
+                        else
+                        {
+#if defined(HB_PP_DEBUG_MEMORY)
+                           hb_xfree( ( void * ) exppatt );
+#endif
+                           *ptri = ptrmacro; /* restore '&' char */
+                           return 0;
+                        }
+                     }
+                  }
+                  else
+                  {
+#if defined(HB_PP_DEBUG_MEMORY)
+                     hb_xfree( ( void * ) exppatt );
+#endif
+                     *ptri -= 1; /* restore '&' char */
+                     return 0;
+                  }
+               }
+               break;
+            }
+            else
+            {
+               ptr++;
+            }
+         }
+         else
+         {
+            HB_SKIPTABSPACES( ptr );
+            /* Comparing real parameter and restriction value */
+            ptrtemp = ptr;
+            if( !strincmp( *ptri, &ptr, !com_or_xcom ) )
+            {
+               lenreal = stroncpy( s_expreal, *ptri, ( ptr - ptrtemp ) );
+               *ptri += lenreal;
+               SearnRep( exppatt, s_expreal, lenreal, ptro, lenres );
+               rezrestr = 1;
+               break;
+            }
+            else
+            {
+               while( *ptr != ',' && *ptr != '\0' )
+               {
+                  ptr++;
+               }
+               if( *ptr == ',' )
+               {
+                  ptr++;
+               }
+            }
+         }
+      }
+      if( rezrestr == 0 )
+      {
+         /* If restricted match marker doesn't correspond to real parameter */
+#if defined(HB_PP_DEBUG_MEMORY)
+         hb_xfree( ( void * ) exppatt );
+#endif
+         return 0;
+      }
+   }
+   else if( *( exppatt + 2 ) == '1' )   /*  ---- list match marker  */
+   {
+      if( !lenreal )
+      {
+         lenreal = getExpReal( s_expreal, ptri, TRUE, maxlenreal, FALSE, FALSE );
+      }
+
+      if( lenreal )
+      {
+         SearnRep( exppatt, s_expreal, lenreal, ptro, lenres );
+      }
+      else
+      {
+#if defined(HB_PP_DEBUG_MEMORY)
+         hb_xfree( ( void * ) exppatt );
+#endif
+         return 0;
+      }
+   }
+   else                         /*  ---- regular match marker  */
+   {
+      /* Copying a real expression to 's_expreal' */
+      if( !lenreal )
+      {
+         lenreal = getExpReal( s_expreal, ptri, FALSE, maxlenreal, FALSE, FALSE );
+      }
+
+      /*
+         printf("Len: %i Pat: %s Exp: %s\n", lenreal, exppatt, s_expreal );
+       */
+
+      if( lenreal )
+      {
+         SearnRep( exppatt, s_expreal, lenreal, ptro, lenres );
+      }
+      else
+      {
+#if defined(HB_PP_DEBUG_MEMORY)
+         hb_xfree( ( void * ) exppatt );
+#endif
+         return 0;
+      }
+   }
+
+#if defined(HB_PP_DEBUG_MEMORY)
+   hb_xfree( ( void * ) exppatt );
+#endif
+   return 1;
+}
+
+static int getExpReal( char *expreal, char **ptri, BOOL prlist, int maxrez, BOOL bStrict, BOOL bInBrackets )
+{
+   int lens = 0;
+   char *sZnaki = "+-=><*/$.:#%!^";
+   int State;
+   int StBr1 = 0, StBr2 = 0, StBr3 = 0;
+   BOOL rez = FALSE;
+   BOOL bMacro = FALSE;
+   BOOL bBrackets = FALSE;
+   char *cStart = expreal;
+   char cLastSep = '\0';
+   char cLastChar = '\0';
+
+   HB_TRACE( HB_TR_DEBUG, ( "getExpReal(%s, %p, %d, %d, %d, %d)", expreal, ptri, prlist, maxrez, bStrict, bInBrackets ) );
+
+   HB_SKIPTABSPACES( *ptri );
+
+   if( **ptri == '(' && bInBrackets )
+   {
+      /* scan expression including start and end brackets */
+      bBrackets = TRUE;
+      ( * ptri )++;
+      prlist = TRUE;
+   }
+   State = ( **ptri == '\'' || **ptri == '\"' || **ptri == '[' ) ? STATE_EXPRES : STATE_ID;
+      
+   while( **ptri != '\0' && !rez && lens < maxrez )
+   {
+      if( State == STATE_EXPRES || ( cLastChar && strchr( "({[.|,$!#=<>^%*/+-", cLastChar ) ) )
+         /* Ron Pinkas added if on State 2001-05-02 to avoid 
+            multiple strings concatination. 
+          */
+      {
+         if( **ptri == '"' )
+         {
+            if( expreal != NULL )
+            {
+               *expreal++ = **ptri;
+            }
+
+            ( *ptri )++;
+            lens++;
+
+            while( **ptri != '\0' && lens < maxrez )
+            {
+               if( expreal != NULL )
+               {
+                  *expreal++ = **ptri;
+               }
+
+               if( **ptri == '"' )
+               {
+                  break;
+               }
+
+               ( *ptri )++;
+               lens++;
+            }
+
+            ( *ptri )++;
+            lens++;
+
+            cLastChar = '"';
+            State = ( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 ) ? STATE_ID_END : STATE_BRACKET;
+            continue;
+         }
+         else if( **ptri == '\'' )
+         {
+            char *pString;
+
+            if( expreal != NULL )
+            {
+               *expreal++ = **ptri;
+            }
+
+            ( *ptri )++;
+            lens++;
+
+            pString = expreal;
+
+            while( **ptri != '\0' && lens < maxrez )
+            {
+               if( expreal != NULL )
+               {
+                  *expreal++ = **ptri;
+               }
+
+               if( **ptri == '\'' )
+               {
+                  break;
+               }
+
+               ( *ptri )++;
+               lens++;
+            }
+
+            if( expreal != NULL )
+            {
+               *( expreal - 1 ) = '\0';
+               if( strchr( pString, '"' ) == NULL )
+               {
+                  *( pString - 1 ) = '"';
+                  *( expreal - 1 ) = '"';
+               }
+               else
+               {
+                  *( expreal - 1 ) = '\'';
+               }
+            }
+
+            ( *ptri )++;
+            lens++;
+
+            cLastChar = '\'';
+            State = ( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 ) ? STATE_ID_END : STATE_BRACKET;
+            continue;
+         }
+         else if( **ptri == '[' )
+            /* ( see below 5-2-2001 
+               && ( State == STATE_EXPRES || ( strchr( ")]}.", cLastChar ) == NULL 
+               && ! ISNAME( ( BYTE ) cLastChar ) ) )
+             */
+         {
+            char *pString;
+
+            if( expreal != NULL )
+            {
+               *expreal++ = **ptri;
+            }
+
+            ( *ptri )++;
+            lens++;
+
+            pString = expreal;
+
+            while( **ptri != '\0' && lens < maxrez )
+            {
+               if( expreal != NULL )
+               {
+                  *expreal++ = **ptri;
+               }
+
+               if( **ptri == ']' )
+               {
+                  break;
+               }
+
+               ( *ptri )++;
+               lens++;
+            }
+
+            if( expreal != NULL )
+            {
+               *( expreal - 1 ) = '\0';
+               if( strchr( pString, '"' ) == NULL )
+               {
+                  *( pString - 1 ) = '"';
+                  *( expreal - 1 ) = '"';
+               }
+               else if( strchr( pString, '\'' ) == NULL )
+               {
+                  *( pString - 1 ) = '\'';
+                  *( expreal - 1 ) = '\'';
+               }
+               else
+               {
+                  *( expreal - 1 ) = ']';
+               }
+            }
+
+            ( *ptri )++;
+            lens++;
+
+            cLastChar = ']';
+            State = ( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 ) ? STATE_ID_END : STATE_BRACKET;
+            continue;
+         }
+         /* Added by Ron Pinkas 2001-05-02 
+            ( removed lots of related scattered logic below! 
+          */
+      }
+      else if( strchr( "'\"", **ptri ) )
+      {
+         /* New String, can't belong to extracted expression. */
+         break;
+      }
+      else if( **ptri == '[' && ( strchr( ")]}.", cLastChar ) == NULL && !ISNAME( ( BYTE ) cLastChar ) ) )      /* New String, can't belong to extracted expression. */
+      {
+         break;
+      }
+      /* End - END - Added by Ron Pinkas 2000-11-05 */
+
+#if 0
+      printf( "State: %i Char:%c\n", State, **ptri );
+#endif
+
+      switch ( State )
+      {
+         case STATE_BRACKET:
+         {
+            if( **ptri == '(' )
+            {
+               StBr1++;
+            }
+            else if( **ptri == '[' )
+            {
+               StBr2++;
+            }
+            else if( **ptri == '{' )
+            {
+               StBr3++;
+            }
+            else if( **ptri == ')' )
+            {
+               StBr1--;
+               if( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 )
+               {
+                     State = STATE_ID_END;
+               }
+            }
+            else if( **ptri == ']' )
+            {
+               StBr2--;
+               if( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 )
+               {
+                  State = STATE_ID_END;
+               }
+            }
+            else if( **ptri == '}' )
+            {
+               StBr3--;
+               if( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 )
+               {
+                  State = STATE_ID_END;
+               }
+            }
+
+            break;
+         }
+
+         case STATE_ID:
+         case STATE_ID_END:
+         {
+            if( ( ( ISNAME( ( BYTE ) ** ptri ) || **ptri == '\\' || **ptri == '&' ) && State == STATE_ID_END ) || **ptri == ',' )
+            {
+               if( **ptri == ',' )
+               {
+                  if( !prlist )
+                  {
+                     rez = TRUE;
+                  }
+                  else
+                  {
+                     State = STATE_EXPRES;
+                  }
+                  cLastSep = ',';
+               }
+               else
+               {
+                  rez = TRUE;
+               }
+            }
+            else if( ( **ptri == '+' && *( *ptri + 1 ) == '+' ) || ( **ptri == '-' && *( *ptri + 1 ) == '-' ) )
+            {
+               cLastChar = **ptri;
+
+               if( expreal )
+               {
+                  *expreal++ = **ptri;
+               }
+               (*ptri)++;
+               lens++;
+
+               if( expreal )
+               {
+                  *expreal++ = **ptri;
+               }
+               (*ptri)++;
+               lens++;
+
+               if( State == STATE_ID )
+               {
+                  // Prefix ONLY when lens == 0 (2) oterwise MUST be a postfix.
+                  if( lens == 2 )
+                  {
+                     while( **ptri == ' ' && lens < maxrez )
+                     {
+                        if( expreal )
+                        {
+                           *expreal++ = **ptri;
+                        }
+                        (*ptri)++;
+                        lens++;
+                     }
+                  }
+                  else
+                  {
+                     State = ( StBr1 == 0 && StBr2 == 0 && StBr3 == 0 )? STATE_ID_END: STATE_BRACKET;
+                  }
+               }
+               continue;
+            }
+            else if( IsInStr( **ptri, sZnaki ) )
+            {
+               cLastSep = ',';
+               /* Ron Pinkas added 2000-06-02 */
+               if( **ptri == '.' && bMacro )
+               {
+                  /* Macro terminator '.' */
+                  if( *( *ptri + 1 ) == ' ' )
+                  {
+                     State = STATE_ID_END;
+                  }
+
+                  bMacro = FALSE;
+
+                  /* Ron Pinkas added 2000-05-03 */
+                  /* Macro terminator is NOT a coninutation char unlike '.' of logical operators, so we don't want it recorded as cLastChar! */
+                  if( expreal != NULL )
+                  {
+                     *expreal++ = **ptri;
+                  }
+                  ( *ptri )++;
+                  lens++;
+                  continue;
+                  /* END - Ron Pinkas added 2000-05-03 */
+               }
+               else if( **ptri == '*' && *( *ptri + 1 ) == '*' )
+               {
+                  /* Clipper replaces ** with ^ operator */
+                  if( expreal != NULL )
+                  {
+                     *expreal++ = '^';
+                  }
+                  ( *ptri ) += 2;
+                  lens++;
+                  cLastChar = '^';
+                  State = STATE_EXPRES;
+                  continue;
+               }
+               else
+                  /* Ron Pinkas end 2000-06-02 */
+                  State = STATE_EXPRES;
+            }
+            else if( **ptri == '(' )
+            {
+               State = STATE_BRACKET;
+               StBr1 = 1;
+            }
+            else if( **ptri == '[' )
+            {
+               StBr2++;
+               State = STATE_BRACKET;
+            }
+            else if( **ptri == '{' )
+            {
+               State = STATE_BRACKET;
+               StBr3 = 1;
+            }
+            else if( **ptri == ')' && StBr1 == 0 )
+            {
+               if( bBrackets )
+               {
+                  ( *ptri )++;
+               }
+               rez = TRUE;
+            }
+            else if( **ptri == ']' && StBr2 == 0 )
+            {
+               rez = TRUE;
+            }
+            else if( **ptri == '}' && StBr3 == 0 )
+            {
+               rez = TRUE;
+            }
+            else if( **ptri == '&' )
+            {
+               bMacro = TRUE;
+            }
+            else if( **ptri == ' ' )
+            {
+               State = STATE_ID_END;
+               bMacro = FALSE;
+            }
+
+            break;
+         }
+
+         case STATE_EXPRES:
+         case STATE_EXPRES_ID:
+         {
+            if( **ptri == '[' )
+            {
+               StBr2++;
+               State = STATE_BRACKET;
+            }
+            else if( ISNAME( ( BYTE ) ** ptri ) )
+            {
+               if( prlist && cLastSep == ' ' )
+               {
+                  State = STATE_ID_END;
+                  rez = TRUE;
+               }
+               else
+                  State = STATE_EXPRES_ID;
+               cLastSep = **ptri;
+            }
+            else if( **ptri == ' ' )
+            {
+               if( !prlist )
+               {
+                  if( State == STATE_EXPRES_ID )
+                  {
+                     State = STATE_ID_END;
+                  }
+                  else if( lens > 2 && ( ( *( *ptri - 2 ) == '+' && *( *ptri - 1 ) == '+' ) || ( *( *ptri - 2 ) == '-' && *( *ptri - 1 ) == '-' ) ) )
+                  {
+                     State = STATE_ID_END;
+                  }
+               }
+               if( cLastSep != ',' )
+                  cLastSep = ' ';
+            }
+            /* Ron Pinkas added 2000-06-14 */
+            else if( **ptri == ')' && StBr1 == 0 )
+            {
+               rez = TRUE;
+            }
+            /* Ron Pinkas end 2000-06-14 */
+            else if( **ptri == '(' )
+            {
+               StBr1++;
+               State = STATE_BRACKET;
+            }
+            else if( **ptri == '{' )
+            {
+               StBr3++;
+               State = STATE_BRACKET;
+            }
+            else if( **ptri == '}' && StBr3 == 0 )
+            {
+               rez = TRUE;
+            }
+            else if( **ptri == ',' )
+            {
+               if( !prlist )
+               {
+                  rez = TRUE;
+                  State = STATE_EXPRES;
+               }
+               cLastSep = ',';
+            }
+            else if( **ptri == '.' && *( *ptri - 2 ) == '.' &&
+                     ( *( *ptri - 1 ) == 'T' || *( *ptri - 1 ) == 'F' || *( *ptri - 1 ) == 't' || *( *ptri - 1 ) == 'f' ) )
+            {
+               State = STATE_ID_END;
+            }
+            else if( **ptri == '&' )
+            {
+               State = STATE_ID;
+               continue;
+            }
+            else
+            {
+               State = STATE_EXPRES;
+               cLastSep = ',';
+            }
+
+            break;
+         }
+      }
+
+      if( !rez )
+      {
+         /* Ron Pinkas added 2000-06-17 */
+         if( **ptri != ' ' && **ptri != '\t' )
+         {
+            cLastChar = **ptri;
+         }
+         /* Ron Pinkas end 2000-06-17 */
+
+         if( expreal != NULL )
+            *expreal++ = **ptri;
+
+         ( *ptri )++;
+         lens++;
+      }
+   }
+   if( !rez && lens >= maxrez )
+   {
+      hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_BUFFER_OVERFLOW, NULL, NULL );
+   }
+
+   if( expreal != NULL && expreal > cStart )
+   {
+      while( *( expreal - 1 ) == ' ' && expreal > cStart )
+      {
+         expreal--;
+         lens--;
+      }
+
+      *expreal = '\0';
+   }
+
+   /* Ron Pinkas added 2000-06-21 */
+   if( bStrict )
+   {
+      if( State == STATE_QUOTE1 || State == STATE_QUOTE2 || State == STATE_QUOTE3 || State == STATE_BRACKET || StBr1 || StBr2 || StBr3 )
+      {
+         /* Alexander should we include this???
+            expreal = NULL;
+          */
+         lens = 0;
+      }
+   }
+   /* Ron Pinkas end 2000-06-21 */
+
+   return lens;
+}
+
+static BOOL isExpres( char *stroka, BOOL prlist )
+{
+   int l1, l2;
+
+   HB_TRACE( HB_TR_DEBUG, ( "isExpres(%s)", stroka ) );
+
+#if 0
+   printf( "Exp: >%s<\n", stroka );
+#endif
+
+   l1 = strlen( stroka );
+   l2 = getExpReal( NULL, &stroka, prlist, HB_PP_STR_SIZE, TRUE, FALSE );
+
+#if 0
+   printf( "Len1: %i Len2: %i RealExp: >%s< Last: %c\n", l1, l2, stroka - l2, ( stroka - l2 )[l1 - 1] );
+#endif
+
+   /* Ron Pinkas modified 2000-06-17 Expression can't be valid if last charcter is one of these: ":/+*-%^=(<>"
+      return ( l1 <= l2 );
+    */
+
+   return ( l1 <= l2 /*&& ! IsInStr( ( stroka - l2 )[l1-1], ":/+*-%^=(<>[{" ) */  );
+}
+
+static BOOL TestOptional( char *ptr1, char *ptr2 )
+{
+   int nbr = 0;
+   BOOL flagname = FALSE;
+   int statevar = 0;
+
+   HB_TRACE( HB_TR_DEBUG, ( "TestOptional(%s, %s)", ptr1, ptr2 ) );
+
+   while( ptr1 <= ptr2 )
+   {
+      if( *ptr1 == HB_PP_OPT_START )
+      {
+         nbr++;
+      }
+      else if( *ptr1 == HB_PP_OPT_END )
+      {
+         if( nbr )
+         {
+            nbr--;
+            flagname = FALSE;
+         }
+         else
+            return 0;
+      }
+      else if( *ptr1 == HB_PP_MATCH_MARK && *( ptr1 + 2 ) == '2' && nbr )
+         statevar = 1;
+      else if( *ptr1 == '>' && statevar )
+         statevar = 0;
+      else if( *ptr1 != ' ' && *ptr1 != '\t' && !statevar )
+      {
+         if( nbr )
+            flagname = TRUE;
+         else
+            return 0;
+      }
+      ptr1++;
+   }
+   /*   if( !flagname )
+      while( *ptr1 != ']' )
+      {
+      if( *ptr1 == '[' || *ptr1 == '\0' ) return 0;
+      ptr1++;
+      } */
+   return !flagname;
+}
+
+static BOOL CheckOptional( char *ptrmp, char *ptri, char *ptro, int *lenres, BOOL com_or_tra, BOOL com_or_xcom )
+{
+   int save_numBr = s_numBrackets, save_Repeate = s_Repeate;
+   BOOL endTranslation = FALSE;
+   BOOL bResult = TRUE;
+   char *lastInputptr[5];
+   char *lastopti[3], *ptr;
+
+   HB_SYMBOL_UNUSED( com_or_tra );
+
+   HB_TRACE( HB_TR_DEBUG, ( "CheckOptional(%s, %s, %s, %p, %d, %d)", ptrmp, ptri, ptro, lenres, com_or_tra, com_or_xcom ) );
+
+   s_bReplacePat = FALSE;
+   lastInputptr[s_Repeate] = ptri;
+   while( *ptri != '\0' && !endTranslation && bResult )
+   {
+      HB_SKIPTABSPACES( ptrmp );
+      switch ( *ptrmp )
+      {
+         case HB_PP_OPT_START:
+            s_numBrackets++;
+            s_aIsRepeate[s_Repeate] = 0;
+            lastInputptr[s_Repeate] = ptri;
+            lastopti[s_Repeate++] = ptrmp;
+            ptrmp++;
+            break;
+
+         case HB_PP_OPT_END:
+            if( s_numBrackets == save_numBr )
+               endTranslation = TRUE;
+            else
+            {
+               if( s_Repeate )
+               {
+                  s_Repeate--;
+                  ptrmp = lastopti[s_Repeate];
+               }
+               else
+                  ptrmp++;
+               s_numBrackets--;
+            }
+            break;
+
+         case ',':
+            if( *ptri == ',' )
+            {
+               ptrmp++;
+               ptri++;
+            }
+            else
+            {
+               if( s_numBrackets - save_numBr > 0 )
+               {
+                  SkipOptional( &ptrmp );
+                  ptri = lastInputptr[s_Repeate];
+               }
+               else
+                  bResult = FALSE;
+            }
+            break;
+
+         case HB_PP_MATCH_MARK:        /*  Match marker */
+            if( !WorkMarkers( &ptrmp, &ptri, ptro, lenres, com_or_tra, com_or_xcom ) )
+            {
+               if( s_numBrackets - save_numBr > 0 )
+               {
+                  SkipOptional( &ptrmp );
+                  ptri = lastInputptr[s_Repeate];
+               }
+               else
+                  bResult = FALSE;
+            }
+            break;
+
+         case '\0':
+            bResult = FALSE;
+
+         default:              /*   Key word    */
+            ptr = ptri;
+            if( *ptri == ',' || truncmp( &ptri, &ptrmp, !com_or_xcom ) )
+            {
+               ptri = ptr;
+               if( s_numBrackets - save_numBr > 0 )
+               {
+                  SkipOptional( &ptrmp );
+                  ptri = lastInputptr[s_Repeate];
+               }
+               else
+                  bResult = FALSE;
+            }
+      }
+      HB_SKIPTABSPACES( ptri );
+   };
+
+   if( *ptri == '\0' )
+   {
+      do
+      {
+         HB_SKIPTABSPACES( ptrmp );
+         if( *ptrmp == HB_PP_OPT_START )
+         {
+            ptrmp++;
+            SkipOptional( &ptrmp );
+         }
+         else if( *ptrmp == HB_PP_OPT_END )
+            break;
+         else
+         {
+            bResult = 0;
+            break;
+         }
+      }
+      while( 1 );
+   }
+   s_Repeate = save_Repeate;
+   s_numBrackets = save_numBr;
+   s_bReplacePat = TRUE;
+   return bResult;
+}
+
+static void SkipOptional( char **ptri )
+{
+   int nbr = 0;
+
+   HB_TRACE( HB_TR_DEBUG, ( "SkipOptional(%p)", ptri ) );
+
+   while( **ptri != HB_PP_OPT_END || nbr )
+   {
+      switch ( **ptri )
+      {
+         case HB_PP_OPT_START:
+            nbr++;
+            break;
+         case HB_PP_OPT_END:
+            nbr--;
+            break;
+         case HB_PP_MATCH_MARK:
+            ( *ptri ) += 3;
+            if( *( *ptri - 1 ) == '2' )
+               while( **ptri != '>' )
+                  ( *ptri )++;
+            break;
+      }
+      ( *ptri )++;
+   }
+   if( **ptri == HB_PP_OPT_END && s_numBrackets > 0 )
+   {
+      if( s_Repeate )
+         s_Repeate--;
+      s_numBrackets--;
+      ( *ptri )++;
+   }
+}
+
+static void SearnRep( char *exppatt, char *expreal, int lenreal, char *ptro, int *lenres )
+{
+   int ifou, isdvig = 0;
+   BOOL rezs, bFound = FALSE;
+   int kolmarkers;
+   int lennew, i;
+   char lastchar = '0';
+   char *ptr, *ptr2, *ptrOut = ptro;
+
+   HB_TRACE( HB_TR_DEBUG, ( "SearnRep(%s, %s, %d, %s, %p)", exppatt, expreal, lenreal, ptro, lenres ) );
+
+   if( s_expcopy == NULL )
+      s_expcopy = ( char * ) hb_xgrab( HB_PP_STR_SIZE );
+   
+   if( *( exppatt + 1 ) == '\0' )
+      *( ptro + *lenres ) = '\0';
+
+   while( ( ifou = md_strAt( exppatt, ( *( exppatt + 1 ) ) ? 2 : 1, ptrOut, FALSE, FALSE, TRUE, MD_STR_AT_USESUBCASE ) ) > 0 )
+   {
+      bFound = TRUE;
+      rezs = FALSE;
+      ptr = ptrOut + ifou - 1;
+      kolmarkers = 0;
+      ptr = PrevSquare( ptr, ptro, &kolmarkers );
+      if( ptr )
+      {
+         if( s_Repeate )
+            s_aIsRepeate[s_Repeate - 1]++;
+         if( !s_bReplacePat )
+            return;
+
+         ptr2 = ptrOut + ifou + 3;
+         while( *ptr2 != HB_PP_OPT_END || *( ptr2 - 1 ) == '\\' )
+         {
+            if( *ptr2 == HB_PP_MATCH_MARK )
+               kolmarkers++;
+            ptr2++;
+         }
+
+         if( s_Repeate && lenreal && kolmarkers && lastchar != '0' && *( ptrOut + ifou + 2 ) == '0' )
+         {
+            isdvig += ifou;
+            rezs = TRUE;
+         }
+         else if( s_Repeate )
+         {
+            if( lenreal == 0 )
+            {
+               if( s_numBrackets >= 2 )
+               {
+                  isdvig += ifou;
+                  continue;
+               }
+               else
+               {
+                  hb_pp_Stuff( "", ptr, 0, ptr2 - ptr + 1, *lenres - ( ptr - ptro ) );
+                  *lenres -= ptr2 - ptr + 1;
+                  isdvig = ptr - ptro;
+                  rezs = TRUE;
+               }
+            }
+            else
+            {
+               lennew = ptr2 - ptr - 1;
+
+               if( lennew < HB_PP_STR_SIZE-2 )
+               {
+                  memcpy( s_expcopy, ptr + 1, lennew );
+               }
+               else
+               {
+                  hb_compGenError( hb_pp_szErrors, 'F', HB_PP_ERR_BUFFER_OVERFLOW, NULL, NULL );
+                  return;
+               }
+               *( s_expcopy + lennew++ ) = ' ';
+               *( s_expcopy + lennew ) = '\0';
+               while( ( i = hb_strAt( exppatt, 2, s_expcopy, lennew ) ) > 0 )
+                  lennew += ReplacePattern( exppatt[2], expreal, lenreal, s_expcopy + i - 1, lennew );
+               if( kolmarkers )
+               {
+                  s_groupchar = ( char ) ( ( unsigned int ) s_groupchar + 1 );
+                  for( i = 0; i < lennew; i++ )
+                     if( *( s_expcopy + i ) == HB_PP_MATCH_MARK )
+                     {
+                        *( s_expcopy + i + 3 ) = s_groupchar;
+                        i += 4;
+                     }
+               }
+               hb_pp_Stuff( s_expcopy, ptr, lennew, 0, *lenres - ( ptr - ptro ) );
+               *lenres += lennew;
+               isdvig = ptr - ptro + ( ptr2 - ptr - 1 ) + lennew;
+               rezs = TRUE;
+            }
+         }
+         else if( exppatt[0] == '\001' && exppatt[1] == '\000' )
+         {
+            /* final pass to remove optional markers */
+            hb_pp_Stuff( "", ptr, 0, ptr2 - ptr + 1, *lenres - ( ptr - ptro ) );
+            *lenres -= ptr2 - ptr + 1;
+            isdvig = ptr - ptro;
+            rezs = TRUE;
+         }
+      }
+
+      if( !rezs && s_bReplacePat )
+      {
+         if( *( ptrOut + ifou + 2 ) != '0' && *( exppatt + 1 ) )
+         {
+            isdvig = ptrOut - ptro + ifou;
+            do
+            {
+               if( lastchar == '0' )
+                  lastchar = *( ptrOut + ifou + 2 );
+               if( lastchar != *( ptrOut + ifou + 2 ) )
+               {
+                  ifou +=3;
+                  ptrOut = ptrOut + ifou;
+                  continue;
+               }
+               
+               *lenres += ReplacePattern( exppatt[2], expreal, lenreal, ptrOut + ifou - 1, *lenres - ifou + 1 );
+               ptrOut = ptrOut + ifou;
+            }
+            while( ( ifou = md_strAt( exppatt, ( *( exppatt + 1 ) ) ? 2 : 1, ptrOut, FALSE, FALSE, TRUE, MD_STR_AT_USESUBCASE ) ) > 0 );
+            if( ! s_Repeate )
+            {
+               lastchar++;
+               ptrOut = ptro + isdvig;
+               isdvig = 0;
+               continue;
+            }
+            return;
+         }
+         else if( lastchar == '0' )
+         {
+            *lenres += ReplacePattern( (exppatt[1]?exppatt[2]:exppatt[1]), expreal, lenreal, ptrOut + ifou - 1, *lenres - isdvig - ifou + 1 );
+            isdvig += ifou - 1;
+         }
+         else
+         {
+            ptrOut += ifou + 1;
+            continue;
+         }
+      }
+      else if( !s_bReplacePat )
+         isdvig += ifou;
+      ptrOut = ptro + isdvig;
+   }
+   if( !bFound && s_Repeate )
+      s_aIsRepeate[s_Repeate - 1]++;
+}
+
+static BOOL ScanMacro( char *expreal, int lenitem, int *pNewLen )
+{
+   int i;
+
+   HB_TRACE( HB_TR_DEBUG, ( "ScanMacro(%s, %d, %p)", expreal, lenitem, pNewLen ) );
+
+   expreal++;                   /* skip '&' character */
+   i = 0;
+
+   while( expreal[i] == ' ' || expreal[i] == '\t' )
+   {
+      i++;
+   }
+   if( expreal[i] == '(' )
+   {
+      *pNewLen = lenitem - 1;
+      return TRUE;
+   }
+   else if( isalpha( ( BYTE ) expreal[i] ) || expreal[i] == '_' )
+   {
+      i++;
+      while( ISNAME( ( BYTE ) expreal[i] ) )
+      {
+         i++;
+      }
+      *pNewLen = i;
+      if( expreal[i] == '.' )
+      {
+         i++;
+      }
+      while( expreal[i] == ' ' || expreal[i] == '\t' )
+      {
+         i++;
+      }
+      if( expreal[i] == '\0' || expreal[i] == ',' || expreal[i] == ')' )   /* || expreal[i] == ' ' )*/
+      {
+         return TRUE;
+      }
+   }
+   *pNewLen = lenitem;
+   return FALSE;
+}
+
+static int pp_Stringify( BOOL bSmart, char **ptro, int *lenres, char *expr, int lenitem )
+{
+   int rmlen = 0;
+   int lenTrim = lenitem;
+   int iAdd = 0;
+   char sQuotes[3] = "\"\"";
+   BOOL bComma = expr[lenitem] == ',';
+
+   while( *expr == ' ' && lenTrim )
+   {
+      expr++;
+      lenTrim--;
+   }
+   while( lenTrim && expr[lenTrim - 1] == ' ' )
+   {
+      lenTrim--;
+   }
+
+   if( !lenTrim )
+   {
+      /* empty string - do nothing unless the comma is required */
+   }
+   else if( *expr == '&' )
+   {
+      /* macro operator */
+      BOOL bSmartMacro;
+      int lennew;
+
+      lennew = lenTrim;
+      bSmartMacro = ScanMacro( expr, lenTrim, &lennew );
+      if( bSmartMacro )
+      {
+         /* remove macro operator '&' */
+         lenTrim = lennew;
+         hb_pp_Stuff( expr + 1, *ptro, lenTrim, 0, *lenres );
+      }
+      else
+      {
+         /* enclose expression in string markers */
+         iAdd = 2;
+         pp_rQuotes( expr, sQuotes );
+         hb_pp_Stuff( sQuotes, *ptro, iAdd, 0, *lenres );
+         hb_pp_Stuff( expr, *ptro + 1, lenTrim, 0, *lenres + iAdd );
+      }
+   }
+   else if( bSmart && ( *expr == '('
+                        || ( *expr == '\"' && *( expr + lenTrim - 1 ) == '\"' )
+                        || ( *expr == '[' && *( expr + lenTrim - 1 ) == ']' ) || ( *expr == '\'' && *( expr + lenTrim - 1 ) == '\'' ) ) )
+   {
+      /* items enclosed in () "" '' [] leave unchanged */
+      hb_pp_Stuff( expr, *ptro, lenTrim, 0, *lenres );
+   }
+   else
+   {
+      /* enclose expression in string markers */
+      iAdd = 2;
+      pp_rQuotes( expr, sQuotes );
+      hb_pp_Stuff( sQuotes, *ptro, iAdd, 0, *lenres );
+      hb_pp_Stuff( expr, *ptro + 1, lenTrim, 0, *lenres + iAdd );
+   }
+   ( *ptro ) += lenTrim + iAdd;
+   ( *lenres ) += lenTrim + iAdd;
+
+   if( bComma )
+   {
+      hb_pp_Stuff( ",", *ptro, 1, 0, *lenres );
+      ( *lenres )++;
+      ( *ptro )++;
+      rmlen++;
+   }
+   rmlen += lenTrim + iAdd;
+
+   return rmlen;
+}
+
+static int ReplacePattern( char patttype, char *expreal, int lenreal, char *ptro, int lenres )
+{
+   int rmlen = lenreal, ifou, lenitem;
+   char sQuotes[4] = "\"\",";
+
+   HB_TRACE( HB_TR_DEBUG, ( "ReplacePattern(%c, %s, %d, %s, %p)", patttype, expreal, lenreal, ptro, lenres ) );
+
+   switch ( *( ptro + 2 ) )
+   {
+      case '0':                /* Regular result marker  */
+         hb_pp_Stuff( expreal, ptro, lenreal, 4, lenres );
+         break;
+
+      case '1':                /* Dumb stringify result marker  */
+         pp_rQuotes( expreal, sQuotes );
+         hb_pp_Stuff( sQuotes, ptro, 2, 4, lenres );
+         if( lenreal )
+            hb_pp_Stuff( expreal, ptro + 1, lenreal, 0, lenres );
+         rmlen = lenreal + 2;
+         if( *sQuotes == '[' )
+            hb_pp_NestedLiteralString = TRUE;
+         break;
+
+      case '2':                /* Normal stringify result marker  */
+         hb_pp_Stuff( "", ptro, 0, 4, lenres ); /* remove match marker */
+         lenres -= 4;
+         if( patttype == '1' )  /* list match marker */
+         {
+            rmlen = 0;
+            do
+            {
+               ifou = md_strAt( ",", 1, expreal, FALSE, TRUE, FALSE, MD_STR_AT_IGNORECASE );
+               if( *expreal != '\0' )
+               {
+                  rmlen += pp_Stringify( FALSE, &ptro, &lenres, expreal, ( ( ifou ) ? ifou - 1 : lenreal ) );
+               }
+               expreal += ifou;
+               lenreal -= ifou;
+            }
+            while( ifou > 0 );
+         }
+         else
+         {
+            rmlen = pp_Stringify( FALSE, &ptro, &lenres, expreal, lenreal );
+         }
+         break;
+
+      case '3':                /* Smart stringify result marker  */
+         hb_pp_Stuff( "", ptro, 0, 4, lenres ); /* remove match marker */
+         lenres -= 4;
+         if( patttype == '1' )  /* list match marker */
+         {
+            rmlen = 0;
+            do
+            {
+               ifou = md_strAt( ",", 1, expreal, FALSE, TRUE, FALSE, MD_STR_AT_IGNORECASE );
+               if( *expreal != '\0' )
+               {
+                  rmlen += pp_Stringify( TRUE, &ptro, &lenres, expreal, ( ( ifou ) ? ifou - 1 : lenreal ) );
+               }
+               expreal += ifou;
+               lenreal -= ifou;
+            }
+            while( ifou > 0 );
+         }
+         else
+         {
+            rmlen = pp_Stringify( TRUE, &ptro, &lenres, expreal, lenreal );
+         }
+         break;
+
+      case '4':                /* Blockify result marker  */
+         if( !lenreal )
+            hb_pp_Stuff( expreal, ptro, lenreal, 4, lenres );
+         else if( patttype == '1' )     /* list match marker */
+         {
+            hb_pp_Stuff( "", ptro, 0, 4, lenres );
+            lenres -= 4;
+            rmlen = 0;
+            do
+            {
+               ifou = md_strAt( ",", 1, expreal, FALSE, TRUE, FALSE, MD_STR_AT_IGNORECASE );
+               lenitem = ( ifou ) ? ifou - 1 : lenreal;
+               if( *expreal != '\0' )
+               {
+                  int i;
+                  
+                  i = ( ifou ) ? 6 : 5;
+                  hb_pp_Stuff( "{|| },", ptro, i, 0, lenres );
+                  hb_pp_Stuff( expreal, ptro + 4, lenitem, 0, lenres + i );
+                  ptro += i + lenitem;
+                  rmlen += i + lenitem;
+               }
+               expreal += ifou;
+               lenreal -= ifou;
+            }
+            while( ifou > 0 );
+         }
+         else if( lenreal && *expreal == '{' )
+         {
+            hb_pp_Stuff( expreal, ptro, lenreal, 4, lenres );
+         }
+         else
+         {
+            hb_pp_Stuff( "{|| }", ptro, 5, 4, lenres );
+            hb_pp_Stuff( expreal, ptro + 4, lenreal, 0, lenres );
+            rmlen = lenreal + 5;
+         }
+         break;
+
+      case '5':                /* Logify result marker  */
+         rmlen = 3;
+         if( !lenreal )
+         {
+            hb_pp_Stuff( ".F.", ptro, 3, 4, lenres );
+         }
+         else
+            hb_pp_Stuff( ".T.", ptro, 3, 4, lenres );
+         break;
+
+      case '6':                /* Ommit result marker  */
+         rmlen = 1;
+         hb_pp_Stuff( " ", ptro, 1, 4, lenres );
+         break;
+   }
+   return rmlen - 4;
+}
+
+static void pp_rQuotes( char *expreal, char *sQuotes )
+{
+   BOOL lQuote1 = FALSE;
+   BOOL lQuote2 = FALSE;
+
+   HB_TRACE( HB_TR_DEBUG, ( "pp_rQuotes(%s, %s)", expreal, sQuotes ) );
+
+   /*
+      printf( "String: >%s< Delim: %s\n", expreal, sQuotes );
+    */
+
+   while( *expreal != '\0' )
+   {
+      if( *expreal == '\"' )
+         lQuote2 = TRUE;
+      else if( *expreal == '\'' )
+         lQuote1 = TRUE;
+      expreal++;
+   }
+   if( lQuote2 )
+   {
+      if( lQuote1 )
+      {
+         *sQuotes = '[';
+         *( sQuotes + 1 ) = ']';
+      }
+      else
+      {
+         *sQuotes = '\'';
+         *( sQuotes + 1 ) = '\'';
+      }
+   }
+   else
+   {
+      *sQuotes = '\"';
+      *( sQuotes + 1 ) = '\"';
+   }
+}
+
+int hb_pp_RdStr( FILE * handl_i, char *buffer, int maxlen, BOOL lContinue, char *sBuffer, int *lenBuffer, int *iBuffer )
+{
+   int readed = 0;
+   int State = 0;
+   char cha, cLast = '\0', symbLast = '\0';
+   BOOL lDropSpaces = lContinue;
+
+   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_RdStr(%p, %s, %d, %d, %s, %p, %p)", handl_i, buffer, maxlen, lDropSpaces, sBuffer, lenBuffer, iBuffer ) );
+
+   if( *lenBuffer == 0 )
+   {
+      return -1;
+   }
+
+   while( 1 )
+   {
+      if( *iBuffer == *lenBuffer )
+      {
+         if( ( *lenBuffer = fread( sBuffer, 1, HB_PP_BUFF_SIZE, handl_i ) ) < 1 )
+         {
+            sBuffer[0] = '\n';
+         }
+         *iBuffer = 0;
+      }
+
+      cha = sBuffer[*iBuffer];
+      ( *iBuffer )++;
+
+      if( cha == '\r' )
+      {
+         cha = ' ';
+      }
+
+      if( cha == '\n' )
+      {
+         if( ( hb_pp_StreamBlock != HB_PP_STREAM_DUMP_C ) && s_ParseState == STATE_COMMENT && symbLast == ';' )
+         {
+            buffer[readed++] = ';';
+         }
+         break;
+      }
+      else
+      {
+         if( hb_pp_StreamBlock == HB_PP_STREAM_DUMP_C )
+         {
+            buffer[readed++] = cha;
+            continue;
+         }
+      }
+
+      if( maxlen > 0 )
+      {
+         switch ( s_ParseState )
+         {
+            case STATE_COMMENT:
+               if( cha == '/' && cLast == '*' )
+               {
+                  s_ParseState = STATE_NORMAL;
+                  cha = ' ';
+               }
+
+               cLast = cha;
+
+               if( cha != ' ' && cha != '\t' )
+               {
+                  symbLast = cha;
+               }
+               break;
+
+            case STATE_QUOTE1:
+               if( cha == '\'' )
+                  s_ParseState = STATE_NORMAL;
+               break;
+
+            case STATE_QUOTE2:
+               if( cha == '\"' )
+                  s_ParseState = STATE_NORMAL;
+               break;
+
+            case STATE_QUOTE3:
+               if( cha == ']' )
+                  s_ParseState = STATE_NORMAL;
+               break;
+
+            default:
+               switch ( cha )
+               {
+                  case '[':
+                     /* Ron Pinkas modified 2000-06-17
+                        if( ISNAME(( BYTE ) s_prevchar) || s_prevchar == ']' )
+                      */
+                     if( ISNAME( ( BYTE ) s_prevchar ) || strchr( ")]}.", s_prevchar ) )
+                     {
+                        s_ParseState = STATE_BRACKET;
+                     }
+                     else
+                     {
+                        s_ParseState = STATE_QUOTE3;
+                     }
+                     break;
+
+                  case ']':
+                     s_ParseState = STATE_NORMAL;
+                     break;
+
+                  case '\"':
+                     if( s_ParseState != STATE_BRACKET )
+                     {
+                        s_ParseState = STATE_QUOTE2;
+                     }
+                     break;
+
+                  case '\'':
+                     if( s_ParseState != STATE_BRACKET )
+                     {
+                        s_ParseState = STATE_QUOTE1;
+                     }
+                     break;
+
+                  case '&':
+                     if( readed > 0 && buffer[readed - 1] == '&' )
+                     {
+                        maxlen = 0;
+                        readed--;
+                     }
+                     break;
+
+                  case '/':
+                     if( readed > 0 && buffer[readed - 1] == '/' && !hb_pp_StreamBlock )
+                     {
+                        maxlen = 0;
+                        readed--;
+                     }
+                     break;
+
+                  case '*':
+                     if( readed > 0 && buffer[readed - 1] == '/' && !hb_pp_StreamBlock )
+                     {
+                        s_ParseState = STATE_COMMENT;
+                        readed--;
+                     }
+                     else if( !State && !lContinue )
+                     {
+                        maxlen = readed = 0;
+                     }
+                     break;
+               }
+
+               if( cha != ' ' && cha != ';' )
+               {
+                  s_prevchar = cha;
+               }
+         }
+
+         if( cha != ' ' && cha != '\t' )
+         {
+            State = 1;
+         }
+
+         if( lDropSpaces && State )
+         {
+            lDropSpaces = 0;
+         }
+
+         if( readed < maxlen && ( !lDropSpaces || readed == 0 ) && s_ParseState != STATE_COMMENT )
+         {
+            buffer[readed++] = cha;
+         }
+      }
+   }
+
+   while( --readed >= 0 && ( buffer[readed] == ' ' || buffer[readed] == '\t' ) ) ;
+
+   if( buffer[readed] != ';' && s_ParseState != STATE_COMMENT )
+   {
+      s_ParseState = STATE_NORMAL;
+   }
+
+   if( maxlen )
+   {
+      if( readed < maxlen )
+         readed++;
+   }
+   else
+      readed++;
+   buffer[readed] = '\0';
+
+#if 0
+   printf( "%s\n", buffer );
+#endif
+
+   return readed;
+}
+
+int hb_pp_WrStr( FILE * handl_o, char *buffer )
+{
+   int lens = strlen( buffer );
+
+   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_WrStr(%p, %s)", handl_o, buffer ) );
+
+   /* Ron Pinkas added 2001-01-20 */
+   if( hb_comp_files.iFiles == 1 )
+   {
+      for( ; hb_pp_LastOutLine < hb_comp_iLine - 1; hb_pp_LastOutLine++ )
+      {
+         fwrite( "\n", 1, 1, handl_o );
+      }
+      hb_pp_LastOutLine = hb_comp_iLine;
+   }
+   /* END Ron Pinkas added 2001-01-20 */
+
+   fwrite( buffer, lens, 1, handl_o );
+
+   if( *( buffer + lens - 1 ) != '\n' )
+   {
+      fwrite( "\n", 1, 1, handl_o );
+   }
+
+   return 0;
+}
+
+static int md_strAt( char *szSub, int lSubLen, char *szText, BOOL checkword, BOOL checkPrth, BOOL bRule, int iCaseOption )
+{
+   int State = STATE_NORMAL;
+   long lPos = 0, lSubPos = 0;
+   int kolPrth = 0, kolSquare = 0, kolFig = 0;
+   int lCase;
+   int iNestedQuote3 = 0;
+   char cLastChar = '\0';
+
+   HB_TRACE( HB_TR_DEBUG, ( "md_strAt(%s, %d, %s, %d, %d, %d)", szSub, lSubLen, szText, checkword, checkPrth, iCaseOption ) );
+
+   if( iCaseOption == MD_STR_AT_IGNORECASE )
+   {
+      lCase = 0;
+   }
+   else
+   {
+      lCase = ( *szSub == HB_PP_MATCH_MARK ) ? 0 : 1;
+   }
+
+   while( *( szText + lPos ) != '\0' && lSubPos < lSubLen )
+   {
+      if( State == STATE_QUOTE1 )
+      {
+         if( *( szText + lPos ) == '\'' )
+         {
+            State = STATE_NORMAL;
+         }
+         lPos++;
+      }
+      else if( State == STATE_QUOTE2 )
+      {
+         if( *( szText + lPos ) == '\"' )
+         {
+            State = STATE_NORMAL;
+         }
+         lPos++;
+      }
+      else if( State == STATE_QUOTE3 )
+      {
+         if( *( szText + lPos ) == ']' )
+         {
+            if( --iNestedQuote3 == 0 )
+               State = STATE_NORMAL;
+         }
+         else if( *( szText + lPos ) == '[' )
+            iNestedQuote3++;
+         lPos++;
+      }
+      else
+      {
+         if( State == STATE_BRACKET )
+         {
+            if( *( szText + lPos ) == ']' && ( lPos == 0 || *( szText + lPos - 1 ) != '\\' ) )
+            {
+               kolSquare--;
+               if( kolSquare == 0 )
+               {
+                  State = STATE_NORMAL;
+               }
+
+               cLastChar = ']';
+               lPos++;
+               continue;
+            }
+            else if( *( szText + lPos ) == '[' && ( lPos == 0 || *( szText + lPos - 1 ) != '\\' ) )
+            {
+               kolSquare++;
+               cLastChar = '[';
+               lPos++;
+               continue;
+            }
+            else if( *( szText + lPos ) == ',' )
+            {
+               cLastChar = ',';
+               lPos++;
+               continue;
+            }
+         }
+         else
+         {
+            if( ( *( szText + lPos ) == '\'' || *( szText + lPos ) == '`' ) && ( lPos == 0 || *( szText + lPos - 1 ) != '\\' ) )
+            {
+               State = STATE_QUOTE1;
+               lPos++;
+               continue;
+            }
+            else if( *( szText + lPos ) == '\"' && ( lPos == 0 || *( szText + lPos - 1 ) != '\\' ) )
+            {
+               State = STATE_QUOTE2;
+               lPos++;
+               continue;
+            }
+            else if( bRule == FALSE && *( szText + lPos ) == '[' && strchr( ")]}.", cLastChar ) == NULL && !ISNAME( ( BYTE ) cLastChar ) )
+            {
+               State = STATE_QUOTE3;
+               iNestedQuote3++;
+               lPos++;
+               continue;
+            }
+            else if( *( szText + lPos ) == '[' && ( lPos == 0 || *( szText + lPos - 1 ) != '\\' ) )
+            {
+               State = STATE_BRACKET;
+               kolSquare++;
+               cLastChar = '[';
+               lPos++;
+               continue;
+            }
+            else if( *( szText + lPos ) == '(' )
+            {
+               kolPrth++;
+            }
+            else if( *( szText + lPos ) == ')' )
+            {
+               kolPrth--;
+            }
+            else if( *( szText + lPos ) == '{' )
+            {
+               kolFig++;
+            }
+            else if( *( szText + lPos ) == '}' )
+            {
+               kolFig--;
+            }
+            else if( szText[lPos] == '.' && szSub[0] != '.' )
+            {
+               if( toupper( szText[lPos + 1] ) == 'T' && szText[lPos + 2] == '.' )
+               {
+                  lPos += 3;
+               }
+               else if( toupper( szText[lPos + 1] ) == 'F' && szText[lPos + 2] == '.' )
+               {
+                  lPos += 3;
+               }
+               else if( toupper( szText[lPos + 1] ) == 'O' && toupper( szText[lPos + 2] ) == 'R' && szText[lPos + 4] == '.' )
+               {
+                  lPos += 4;
+               }
+               else if( toupper( szText[lPos + 1] ) == 'A'
+                        && toupper( szText[lPos + 2] ) == 'N' && toupper( szText[lPos + 3] ) == 'D' && szText[lPos + 4] == '.' )
+               {
+                  lPos += 5;
+               }
+               else if( toupper( szText[lPos + 1] ) == 'N'
+                        && toupper( szText[lPos + 2] ) == 'O' && toupper( szText[lPos + 3] ) == 'T' && szText[lPos + 4] == '.' )
+               {
+                  lPos += 5;
+               }
+               else
+               {
+                  lPos++;
+               }
+
+               lSubPos = 0;
+               continue;
+            }
+         }
+
+         if( !lSubPos && checkPrth &&
+             ( ( ( kolPrth > 1 )
+                 || ( kolPrth == 1 && *( szText + lPos ) != '(' )
+                 || ( kolPrth == 0 && *( szText + lPos ) == ')' ) )
+               || ( ( kolFig > 1 ) || ( kolFig == 1 && *( szText + lPos ) != '{' ) || ( kolFig == 0 && *( szText + lPos ) == '}' ) ) ) )
+         {
+            cLastChar = *( szText + lPos );
+            lPos++;
+            continue;
+         }
+
+         if( lSubPos && checkPrth && ( kolPrth > 0 || kolFig > 0 ) )
+         {
+            cLastChar = *( szText + lPos );
+            lPos++;
+            lSubPos = 0;
+            continue;
+         }
+
+         if( ( lCase
+               && toupper( *( szText + lPos ) ) == toupper( *( szSub + lSubPos ) ) ) || ( !lCase && *( szText + lPos ) == *( szSub + lSubPos ) ) )
+         {
+            lSubPos++;
+            cLastChar = *( szText + lPos );
+            lPos++;
+
+            if( lSubPos >= lSubLen && checkword &&
+                ( ( ISNAME( ( BYTE ) * szSub ) && lPos > lSubPos
+                    && ISNAME( ( BYTE ) * ( szText + lPos - lSubPos - 1 ) ) )
+                  || ( ISNAME( ( BYTE ) * ( szSub + lSubLen - 1 ) ) && ISNAME( ( BYTE ) * ( szText + lPos ) ) ) ) )
+            {
+               lSubPos = 0;
+            }
+         }
+         else if( lSubPos )
+         {
+            lSubPos = 0;
+         }
+         else
+         {
+            cLastChar = *( szText + lPos );
+            lPos++;
+         }
+      }
+   }
+
+#if 0
+   if( bRule == 0 && szSub[0] != ';' )
+   {
+      printf( "Rule: %i Find: >%s< In: >%s<\n", bRule, szSub, szText );
+      printf( "Pos: %i Len: %i At: >%s<\n", lPos, lSubLen, ( szText + lPos - lSubLen ) );
+   }
+#endif
+
+   return ( lSubPos < lSubLen ? 0 : lPos - lSubLen + 1 );
+}
+
+static char *PrevSquare( char *ptr, char *bound, int *kolmark )
+{
+   HB_TRACE( HB_TR_DEBUG, ( "PrevSquare(%s, %s, %d)", ptr, bound, kolmark == NULL ? 0 : *kolmark ) );
+   while( ptr > bound )
+   {
+      if( kolmark && *ptr == HB_PP_MATCH_MARK )
+      {
+         ( *kolmark )++;
+      }
+      else if( *ptr == HB_PP_OPT_START || *ptr == HB_PP_OPT_END )
+      {
+         break;
+      }
+      ptr--;
+   }
+   return ( *ptr == HB_PP_OPT_START ) ? ptr : NULL;
+}
+
+static int IsInStr( char symb, char *s )
+{
+   HB_TRACE( HB_TR_DEBUG, ( "IsInStr(%c, %s)", symb, s ) );
+
+   while( *s != '\0' )
+      if( *s++ == symb )
+         return 1;
+   return 0;
+}
+
+/* ptri = string for inserting
+	ptro = output string
+	len1 = length of ptri string
+	len2 = length of ptro string that will be replaced
+	lenres = length of ptro string
+*/
+void hb_pp_Stuff( char *ptri, char *ptro, int len1, int len2, int lenres )
+{
+   char *ptr1, *ptr2;
+   int i;
+
+   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_Stuff(%s, %s, %d, %d, %d)", ptri, ptro, len1, len2, lenres ) );
+
+   if( len1 > len2 )
+   {
+      ptr1 = ptro + lenres + 1;
+      ptr2 = ptro + lenres + len1 - len2;
+      /* This is a static buffer - current inserting can erase the null char
+         than we need set it again.
+       */
+      ptr2[1] = '\0';
+      for( i = 0; i <= lenres; ptr2--, i++ )
+      {
+         ptr1--;
+         *ptr2 = *ptr1;
+      }
+   }
+   else
+   {
+      ptr1 = ptro + len2;
+      ptr2 = ptro + len1;
+      for( ; ptr1 <= ptro + lenres; ptr1++, ptr2++ )
+         *ptr2 = *ptr1;
+   }
+   ptr2 = ptro;
+   for( i = 0; i < len1; i++ )
+      *ptr2++ = *( ptri + i );
+}
+
+int hb_pp_strocpy( char *ptro, char *ptri )
+{
+   int lens = 0;
+
+   HB_TRACE( HB_TR_DEBUG, ( "hb_pp_strocpy(%s, %s)", ptro, ptri ) );
+
+   if( ptri != NULL )
+      while( *ptri != '\0' )
+      {
+         *ptro++ = *ptri++;
+         lens++;
+      }
+   *ptro = '\0';
+   return lens;
+}
+
+static int stroncpy( char *ptro, char *ptri, int lens )
+{
+   int i = 0;
+
+   HB_TRACE( HB_TR_DEBUG, ( "stroncpy(%s, %s, %d)", ptro, ptri, lens ) );
+
+   for( ; i < lens; i++ )
+      *( ptro + i ) = *ptri++;
+   i--;
+   while( i > 0 && *( ptro + i ) == ' ' )
+      i--;
+   i++;
+   *( ptro + i ) = '\0';
+   return i;
+}
+
+static BOOL truncmp( char **ptro, char **ptri, BOOL lTrunc )
+{
+   char *ptrb = *ptro, co, ci;
+   
+   HB_TRACE( HB_TR_DEBUG, ( "truncmp(%p, %p, %d)", ptro, ptri, lTrunc ) );
+
+      
+   for( ;
+        **ptri != ' ' && **ptri != '\t' && **ptri != ','
+        && **ptri != HB_PP_OPT_START && **ptri != HB_PP_OPT_END
+        && **ptri != HB_PP_MATCH_MARK && **ptri != '\0' && toupper( **ptri ) == toupper( **ptro ); ( *ptro )++, ( *ptri )++ ) ;
+   co = *( *ptro - 1 );
+   ci = **ptri;
+   
+   if( ( ( ci == ' ' || ci == ',' || ci == HB_PP_OPT_START ||
+           ci == HB_PP_OPT_END || ci == HB_PP_MATCH_MARK || ci == '\0' ) &&
+         ( ( !ISNAME( ( BYTE ) ** ptro ) && ISNAME( ( BYTE ) co ) ) || 
+         ( !ISNAME( ( BYTE ) co ) ) ) ) )
+      return FALSE;
+   else if( lTrunc && *ptro - ptrb >= 4 && ISNAME( ( BYTE ) ci ) && !ISNAME( ( BYTE ) ** ptro ) && ISNAME( ( BYTE ) co ) )
+   {
+      while( ISNAME( ( BYTE ) ** ptri ) )
+         ( *ptri )++;
+      return FALSE;
+   }
+   return TRUE;
+}
+
+static BOOL strincmp( char *ptro, char **ptri, BOOL lTrunc )
+{
+   char *ptrb = ptro, co, ci;
+
+   HB_TRACE( HB_TR_DEBUG, ( "strincmp(%s, %p)", ptro, ptri ) );
+
+   for( ;
+        **ptri != ',' && **ptri != HB_PP_OPT_START && **ptri != HB_PP_OPT_END
+        && **ptri != HB_PP_MATCH_MARK && **ptri != '\0' && toupper( **ptri ) == toupper( *ptro ); ptro++, ( *ptri )++ ) ;
+   co = *( ptro - 1 );
+   ci = **ptri;
+   if( ( ( ci == ' ' || ci == ',' || ci == HB_PP_OPT_START ||
+           ci == HB_PP_OPT_END || ci == HB_PP_MATCH_MARK || ci == '\0' ) &&
+         ( ( !ISNAME( ( BYTE ) * ptro ) && ISNAME( ( BYTE ) co ) ) || ( !ISNAME( ( BYTE ) co ) ) ) ) )
+      return FALSE;
+   else if( lTrunc && ptro - ptrb >= 4 && ISNAME( ( BYTE ) ci ) && !ISNAME( ( BYTE ) * ptro ) && ISNAME( ( BYTE ) co ) )
+   {
+      /*      while( ISNAME(( BYTE ) **ptri) ) (*ptri)++; */
+      return FALSE;
+   }
+   return TRUE;
+}
+
+static int strincpy( char *ptro, char *ptri )
+{
+   int lens = 0;
+
+   HB_TRACE( HB_TR_DEBUG, ( "strincpy(%s, %s)", ptro, ptri ) );
+
+   for( ;
+        *ptri != ' ' && *ptri != ',' && *ptri != HB_PP_OPT_START
+        && *ptri != HB_PP_OPT_END && *ptri != HB_PP_MATCH_MARK && *ptri != '\0'; ptro++, ptri++, lens++ )
+      *ptro = *ptri;
+   return lens;
+}
+
+static int strotrim( char *stroka, BOOL bRule )
+{
+   char *ptr = stroka, lastc = '0', curc;
+   int lens = 0, State = STATE_NORMAL;
+
+   HB_TRACE( HB_TR_DEBUG, ( "strotrim(%s)", stroka ) );
+
+   while( ( curc = *stroka ) != '\0' )
+   {
+      if( State == STATE_QUOTE1 )
+      {
+         if( curc == '\'' )
+         {
+            State = STATE_NORMAL;
+         }
+      }
+      else if( State == STATE_QUOTE2 )
+      {
+         if( curc == '\"' )
+         {
+            State = STATE_NORMAL;
+         }
+      }
+      else if( State == STATE_QUOTE3 )
+      {
+         if( curc == ']' )
+         {
+            State = STATE_NORMAL;
+         }
+      }
+      else
+      {
+         if( curc == '\'' )
+         {
+            State = STATE_QUOTE1;
+         }
+         else if( curc == '\"' )
+         {
+            State = STATE_QUOTE2;
+         }
+         /* Ron Pinkas added 2000-11-05 */
+         /* Ron Pinkas 2001-02-14 added bRule logic  (removed array logic). */
+         else if( curc == '[' && bRule == FALSE )       /* && ( strchr( ")]}.", cLastChar ) == NULL && ! ISNAME( ( BYTE ) cLastChar ) ) ) */
+         {
+            State = STATE_QUOTE3;
+         }
+         /* END - Ron Pinkas added 2000-11-05 */
+         else if( curc == '\t' )
+         {
+            curc = ' ';
+         }
+      }
+
+      if( State != STATE_NORMAL || curc != ' ' ||
+          ( curc == ' ' && !bRule ) ||
+          ( curc == ' ' && lastc != ' ' && lastc != ',' && lastc != '(' && *( stroka + 1 ) != ',' && *( stroka + 1 ) != ' ' && *( stroka + 1 ) ) )
+      {
+         *ptr++ = curc;
+         lastc = curc;
+         lens++;
+      }
+
+      stroka++;
+   }
+
+   *ptr = '\0';
+
+   return lens;
+}
+
+static int NextWord( char **sSource, char *sDest, BOOL lLower )
+{
+   int i = 0;
+
+   HB_TRACE( HB_TR_DEBUG, ( "NextWord(%p, %s, %d)", sSource, sDest, lLower ) );
+
+   HB_SKIPTABSPACES( ( *sSource ) );
+
+   while( **sSource != '\0' && **sSource != ' ' && **sSource != '\t' && **sSource != '(' )
+   {
+      *sDest++ = ( lLower ) ? tolower( **sSource ) : **sSource;
+      ( *sSource )++;
+      i++;
+   }
+
+   *sDest = '\0';
+
+   return i;
+}
+
+static int NextName( char **sSource, char *sDest )
+{
+   /* Ron Pinkas added 2000-11-08 */
+   char cLastChar = '\0', *pString = NULL, *pTmp;
+
+   /* END - Ron Pinkas added 2000-11-08 */
+
+   int lenName = 0, State = STATE_NORMAL;
+
+   HB_TRACE( HB_TR_DEBUG, ( "NextName(%p, %s)", sSource, sDest ) );
+
+#if 0
+   printf( "In: >%s<\n", *sSource );
+#endif
+
+   while( **sSource != '\0' && ( !ISNAME( ( BYTE ) ** sSource ) || State != STATE_NORMAL ) )
+   {
+      if( State == STATE_QUOTE1 )
+      {
+         if( **sSource == '\'' )
+         {
+            State = STATE_NORMAL;
+
+            /* Ron Pinkas added 2000-11-08 */
+            **sSource = '\0';
+            if( strchr( pString, '"' ) == NULL )
+            {
+               *pString = '"';
+               **sSource = '"';
+            }
+            else
+            {
+               **sSource = '\'';
+            }
+            /* END - Ron Pinkas added 2000-11-08 */
+         }
+      }
+      else if( State == STATE_QUOTE2 )
+      {
+         if( **sSource == '\"' )
+         {
+            State = STATE_NORMAL;
+         }
+      }
+      else if( State == STATE_QUOTE3 )
+      {
+         if( **sSource == ']' )
+         {
+            State = STATE_NORMAL;
+
+            /* Ron Pinkas added 2000-11-08 */
+            **sSource = '\0';
+            if( strchr( pString, '"' ) == NULL )
+            {
+               *pString = '"';
+               **sSource = '"';
+            }
+            else if( strchr( pString, '\'' ) == NULL )
+            {
+               *pString = '\'';
+               **sSource = '\'';
+            }
+            else
+            {
+               **sSource = ']';
+            }
+            /* END - Ron Pinkas added 2000-11-08 */
+         }
+      }
+      else if( ( *sSource )[0] == HB_PP_OPT_START || ( *sSource )[0] == HB_PP_OPT_END )
+      {
+         State = STATE_NORMAL;
+      }
+      /* Ron Pinkas added 2001-02-21 */
+      else if( ( *sSource )[0] == '.' && toupper( ( *sSource )[1] ) == 'A'
+               && toupper( ( *sSource )[2] ) == 'N' && toupper( ( *sSource )[3] ) == 'D' && ( *sSource )[4] == '.' )
+      {
+         ( *sSource ) += 5;
+         cLastChar = ' ';
+         continue;
+      }
+      else if( ( *sSource )[0] == '.' && toupper( ( *sSource )[1] ) == 'N'
+               && toupper( ( *sSource )[2] ) == 'O' && toupper( ( *sSource )[3] ) == 'T' && ( *sSource )[4] == '.' )
+      {
+         ( *sSource ) += 5;
+         cLastChar = ' ';
+         continue;
+      }
+      else if( ( *sSource )[0] == '.' && toupper( ( *sSource )[1] ) == 'O' && toupper( ( *sSource )[2] ) == 'R' && ( *sSource )[3] == '.' )
+      {
+         ( *sSource ) += 4;
+         cLastChar = ' ';
+         continue;
+      }
+      /* End - Ron Pinkas added 2001-02-21 */
+      else if( ( *sSource )[0] == '.' && toupper( ( *sSource )[1] ) == 'T' && ( *sSource )[2] == '.' )
+      {
+         ( *sSource ) += 3;
+         cLastChar = ' ';
+         continue;
+      }
+      else if( ( *sSource )[0] == '.' && toupper( ( *sSource )[1] ) == 'F' && ( *sSource )[2] == '.' )
+      {
+         ( *sSource ) += 3;
+         cLastChar = ' ';
+         continue;
+      }
+      else if( **sSource == '\'' )
+      {
+         /* Ron Pinkas added 2000-11-08 */
+         pString = *sSource;
+         State = STATE_QUOTE1;
+      }
+      else if( **sSource == '\"' )
+      {
+         /* Ron Pinkas added 2000-11-08 */
+         pString = *sSource;
+         State = STATE_QUOTE2;
+      }
+      /* Ron Pinkas added 2000-11-08 */
+      else if( **sSource == '[' && s_bArray == FALSE && strchr( ")]}.\"\'", cLastChar ) == NULL && !ISNAME( ( BYTE ) cLastChar ) )
+      {
+         /* Ron Pinkas added 2000-11-08 */
+         pString = *sSource;
+         State = STATE_QUOTE3;
+      }
+      /* END - Ron Pinkas added 2000-11-08 */
+
+      /* Ron Pinkas added 2000-11-08 */
+      if( State == STATE_NORMAL && **sSource != ' ' && **sSource != '\t' )
+      {
+         cLastChar = **sSource;
+      }
+      /* END - Ron Pinkas added 2000-11-08 */
+
+      ( *sSource )++;
+   }
+
+   while( **sSource != '\0' && ISNAME( ( BYTE ) ** sSource ) )
+   {
+      *sDest++ = *( *sSource )++;
+      lenName++;
+   }
+
+   *sDest = '\0';
+
+   /* Ron Pinkas added 2000-11-08 - Prepare for next run. */
+   pTmp = *sSource;
+   while( *pTmp && ( *pTmp == ' ' || *pTmp == '\t' || *pTmp == HB_PP_OPT_END || *pTmp == HB_PP_OPT_START ) )
+   {
+      pTmp++;
+   }
+
+   s_bArray = ( *pTmp == '[' );
+   /* END - Ron Pinkas added 2000-11-08 */
+
+#if 0
+   printf( "NextName: >%s<\n", sDest - lenName );
+   printf( "Rest: >%s<\n", *sSource );
+#endif
+
+   return lenName;
+}
+
+static int NextParm( char **sSource, char *sDest )
+{
+   int lenName = 0, State = STATE_NORMAL, StBr = 0;
+   char cLastChar = '\0';
+
+   HB_TRACE( HB_TR_DEBUG, ( "NextParm(%p, %s)", sSource, sDest ) );
+
+   HB_SKIPTABSPACES( ( *sSource ) );
+
+   while( **sSource != '\0' )
+   {
+      if( State == STATE_QUOTE1 )
+      {
+         if( **sSource == '\'' )
+         {
+            State = STATE_NORMAL;
+         }
+      }
+      else if( State == STATE_QUOTE2 )
+      {
+         if( **sSource == '\"' )
+         {
+            State = STATE_NORMAL;
+         }
+      }
+      else if( State == STATE_QUOTE3 )
+      {
+         if( **sSource == ']' )
+         {
+            State = STATE_NORMAL;
+         }
+      }
+      else if( **sSource == '\'' )
+      {
+         State = STATE_QUOTE1;
+      }
+      else if( **sSource == '\"' )
+      {
+         State = STATE_QUOTE2;
+      }
+      else if( **sSource == '[' && strchr( ")]}.", cLastChar ) == NULL && !ISNAME( ( BYTE ) cLastChar ) )
+      {
+         State = STATE_QUOTE3;
+      }
+      /* Ron Pinkas added 2000-11-26 */
+      else if( **sSource == '[' )
+      {
+         StBr++;
+      }
+      else if( **sSource == ']' )
+      {
+         StBr--;
+      }
+      /* END - Ron Pinkas added 2000-11-26 */
+      else if( **sSource == '{' )
+      {
+         StBr++;
+      }
+      else if( **sSource == '}' )
+      {
+         StBr--;
+      }
+      else if( **sSource == '(' )
+      {
+         StBr++;
+      }
+      else if( **sSource == ')' || **sSource == ',' )
+      {
+         if( StBr == 0 )
+         {
+            break;
+         }
+
+         if( **sSource == ')' )
+         {
+            StBr--;
+         }
+      }
+
+      if( sDest != NULL )
+      {
+         *sDest++ = **sSource;
+      }
+
+      if( State == STATE_NORMAL && **sSource != ' ' && **sSource != '\t' )
+      {
+         cLastChar = **sSource;
+      }
+
+      ( *sSource )++;
+      lenName++;
+   }
+
+   if( sDest )
+   {
+      *sDest = '\0';
+   }
+
+#if 0
+   if( sDest )
+      printf( "NextParm: >%s<\n", sDest - lenName );
+   else
+      printf( "NextParm Len: %i\n", lenName );
+#endif
+
+   return lenName;
+}
+
+static BOOL IsIdentifier( char *szProspect )
+{
+   if( isalpha( ( BYTE ) szProspect[0] ) || szProspect[0] == '_' )
+   {
+      int i = 1;
+
+      while( ISNAME( ( BYTE ) szProspect[i] ) )
+      {
+         i++;
+      }
+      while( szProspect[i] == ' ' )
+      {
+         i++;
+      }
+
+      return ( szProspect[i] == '\0' );
+   }
+
+   return FALSE;
+}
+
+
+static int IsMacroVar( char *szText, BOOL isCommand )
+{
+   int len = 0;
+
+   if( isalpha( ( BYTE ) szText[0] ) || szText[0] == '_' )
+   {
+      int i = 1;
+
+      while( ISNAME( ( BYTE ) szText[i] ) || isdigit( ( BYTE ) szText[i] ) || szText[i] == '&' || szText[i] == '.' )
+      {
+         i++;
+      }
+/*         
+      while( ISNAME( ( BYTE ) szText[i] ) || szText[i] == '&' )
+      {
+         i++;
+      }
+      if( szText[i] == '.' || szText[i] == '&' )
+      {
+         i++;
+         while( ISNAME(( BYTE ) szText[i]) || isdigit( ( BYTE ) szText[i] ) || szText[i] == '&' || szText[i] == '.' )
+         {
+            i++;
+         }
+      }
+*/
+      len = i;
+      if( !( szText[i] == '\0' || szText[i] == ' ' || szText[i] == ')' ) && isCommand )
+      {
+         return 0;
+      }
+   }
+   return len;
+}
+
+
+static BOOL OpenInclude( char *szFileName, HB_PATHNAMES * pSearch, PHB_FNAME pMainFileName, BOOL bStandardOnly, char *szInclude )
+{
+   FILE *fptr;
+   PHB_FNAME pFileName;
+   PFILE pFile;
+
+   HB_TRACE( HB_TR_DEBUG, ( "OpenInclude(%s, %p, %p, %d, %s)", szFileName, pSearch, pMainFileName, ( int ) bStandardOnly, szInclude ) );
+
+   errno = 0;
+   if( bStandardOnly )
+   {
+      fptr = 0;
+      szInclude[0] = '\0';
+   }
+   else
+   {
+      pFileName = hb_fsFNameSplit( szFileName );
+
+      if( ( pFileName->szPath == NULL || *( pFileName->szPath ) == '\0' ) && pMainFileName )
+         pFileName->szPath = pMainFileName->szPath;
+
+      hb_fsFNameMerge( szInclude, pFileName );
+
+      fptr = fopen( szInclude, "r" );
+      hb_xfree( pFileName );
+   }
+
+   if( !fptr && pSearch && errno != EMFILE )
+   {
+      pFileName = hb_fsFNameSplit( szFileName );
+      pFileName->szName = szFileName;
+      pFileName->szExtension = NULL;
+      while( pSearch && !fptr )
+      {
+         pFileName->szPath = pSearch->szPath;
+         hb_fsFNameMerge( szInclude, pFileName );
+         fptr = fopen( szInclude, "r" );
+         pSearch = pSearch->pNext;
+      }
+      hb_xfree( pFileName );
+   }
+
+   if( fptr )
+   {
+      pFile = ( PFILE ) hb_xgrab( sizeof( _FILE ) );
+      pFile->handle = fptr;
+      pFile->pBuffer = hb_xgrab( HB_PP_BUFF_SIZE );
+      pFile->iBuffer = pFile->lenBuffer = 10;
+      pFile->yyBuffer = NULL;
+      pFile->szFileName = hb_strdup( szFileName );
+
+      if( hb_comp_files.pLast )
+         hb_comp_files.pLast->iLine = hb_comp_iLine;
+      hb_comp_iLine = 1;
+
+      pFile->iLine = 1;
+      pFile->pPrev = hb_comp_files.pLast;
+      hb_comp_files.pLast = pFile;
+      hb_comp_files.iFiles++;
+      return TRUE;
+   }
+
+   return FALSE;
+}
+
+
+void hb_pp_CloseInclude( void )
+{
+   PFILE pFile;
+
+   /* we close the currently include file and continue */
+   fclose( hb_comp_files.pLast->handle );
+   hb_xfree( hb_comp_files.pLast->pBuffer );
+   hb_xfree( hb_comp_files.pLast->szFileName );
+   pFile = ( PFILE ) ( ( PFILE ) hb_comp_files.pLast )->pPrev;
+   hb_xfree( hb_comp_files.pLast );
+   hb_comp_files.pLast = pFile;
+   if( hb_comp_files.pLast )
+      hb_comp_iLine = hb_comp_files.pLast->iLine;
+   hb_comp_files.iFiles--;
+}
diff --git a/harbour/utils/hbpp/pplib.c b/harbour/utils/hbpp/pplib.c
new file mode 100644
index 0000000000..206495daed
--- /dev/null
+++ b/harbour/utils/hbpp/pplib.c
@@ -0,0 +1,265 @@
+/*
+ * $Id$
+ */
+
+/*
+ * Harbour Project source code:
+ * Preprocessor runtime library callable version
+ *
+ * Copyright 1999 Felipe G. Coury <fcoury@creation.com.br>
+ * www - http://www.harbour-project.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this software; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
+ *
+ * As a special exception, the Harbour Project gives permission for
+ * additional uses of the text contained in its release of Harbour.
+ *
+ * The exception is that, if you link the Harbour libraries with other
+ * files to produce an executable, this does not by itself cause the
+ * resulting executable to be covered by the GNU General Public License.
+ * Your use of that executable is in no way restricted on account of
+ * linking the Harbour library code into it.
+ *
+ * This exception does not however invalidate any other reasons why
+ * the executable file might be covered by the GNU General Public License.
+ *
+ * This exception applies only to the code released by the Harbour
+ * Project under the name Harbour.  If you copy code from other
+ * Harbour Project or Free Software Foundation releases into a copy of
+ * Harbour, as the General Public License permits, the exception does
+ * not apply to the code that you add in this way.  To avoid misleading
+ * anyone as to the status of such modified files, you must delete
+ * this exception notice from them.
+ *
+ * If you write modifications of your own for Harbour, it is your choice
+ * whether to permit this exception to apply to your modifications.
+ * If you do not wish that, delete this exception notice.
+ *
+ */
+
+/*
+ * Avoid tracing in preprocessor/compiler.
+ */
+#if ! defined(HB_TRACE_UTILS)
+   #if defined(HB_TRACE_LEVEL)
+      #undef HB_TRACE_LEVEL
+   #endif
+#endif
+
+#include <stdio.h>
+/* #include <setjmp.h> */
+
+#include "hbpp.h"
+#include "hbcomp.h"
+#include "hbapi.h"
+#include "hbapierr.h"
+
+#ifdef HB_EXTENSION
+
+HB_PATHNAMES * hb_comp_pIncludePath = NULL;
+PHB_FNAME      hb_comp_pFileName = NULL;
+FILES          hb_comp_files;
+int            hb_comp_iLine;       /* currently parsed file line number */
+int            hb_comp_iLinePRG;
+int            hb_comp_iLineINLINE = 0;
+
+/* These are need for the PP #pragma support */
+BOOL           hb_comp_bPPO = FALSE;           /* flag indicating, is ppo output needed */
+BOOL           hb_comp_bStartProc = TRUE;      /* holds if we need to create the starting procedure */
+BOOL           hb_comp_bLineNumbers = TRUE;    /* holds if we need pcodes with line numbers */
+
+#if 0
+BOOL           hb_comp_bShortCuts = TRUE;      /* .and. & .or. expressions shortcuts */
+#endif
+
+int            hb_comp_iWarnings = 0;                     /* enable parse warnings */
+BOOL           hb_comp_bAutoMemvarAssume = FALSE;         /* holds if undeclared variables are automatically assumed MEMVAR (-a)*/
+BOOL           hb_comp_bForceMemvars = FALSE;             /* holds if memvars are assumed when accesing undeclared variable (-v)*/
+BOOL           hb_comp_bDebugInfo = FALSE;                /* holds if generate debugger required info */
+int            hb_comp_iExitLevel = HB_EXITLEVEL_DEFAULT; /* holds if there was any warning during the compilation process */
+FILE *         hb_comp_yyppo = NULL;
+
+/* static jmp_buf s_env; */
+
+HB_FUNC( __PP_INIT )
+{
+   hb_pp_Table();
+   hb_pp_Init();
+   hb_comp_files.iFiles = 0;
+
+   if( ISCHAR( 1 ) )
+   {
+      hb_fsAddSearchPath( hb_parc( 1 ), &hb_comp_pIncludePath );
+   }
+}
+
+HB_FUNC( __PP_PATH )
+{
+   if( ISLOG( 2 ) && hb_parl( 2 ) && hb_comp_pIncludePath )
+   {
+      hb_fsFreeSearchPath( hb_comp_pIncludePath );
+      hb_comp_pIncludePath = NULL;
+   }
+
+   if( ISCHAR( 1 ) )
+   {
+      hb_fsAddSearchPath( hb_parc( 1 ), &hb_comp_pIncludePath );
+   }
+}
+
+HB_FUNC( __PP_FREE )
+{
+   if( hb_comp_pIncludePath )
+   {
+      hb_fsFreeSearchPath( hb_comp_pIncludePath );
+      hb_comp_pIncludePath = NULL;
+   }
+
+   hb_pp_Free();
+
+   if( hb_pp_aCondCompile )
+   {
+      hb_xfree( hb_pp_aCondCompile );
+      hb_pp_aCondCompile = NULL;
+   }
+}
+
+HB_FUNC( __PPADDRULE )
+{
+   if( ISCHAR( 1 ) )
+   {
+      char * ptr = hb_parc( 1 );
+      char * hb_buffer;
+
+      HB_SKIPTABSPACES( ptr );
+      if( *ptr == '#' )
+      {
+         if( !hb_pp_aCondCompile )
+         {
+            hb_pp_Table();
+            hb_pp_Init();
+            hb_comp_files.iFiles = 0;
+         }
+         hb_pp_ParseDirective( ptr );
+         if( hb_comp_files.pLast )
+         {
+            hb_buffer = ( char* ) hb_xgrab( HB_PP_STR_SIZE );
+            while( hb_pp_Internal( NULL, hb_buffer ) > 0 );
+            hb_pp_CloseInclude();
+            hb_xfree( hb_buffer );
+         }
+         hb_retl( 1 );
+      }
+      else
+         hb_retl( 0 );
+   }
+   else
+      hb_retl( 0 );
+}
+
+HB_FUNC( __PREPROCESS )
+{
+   if( ISCHAR( 1 ) )
+   {
+      char * pText = ( char * ) hb_xgrab( HB_PP_STR_SIZE );
+      char * pOut = ( char * ) hb_xgrab( HB_PP_STR_SIZE );
+
+      /* if( setjmp( s_env ) == 0 ) */
+      { 
+         char * ptr = pText;
+         int slen;
+
+         /*   hb_pp_Init();   */
+
+         slen = HB_MIN( hb_parclen( 1 ), HB_PP_STR_SIZE - 1 );
+         memcpy( pText, hb_parc( 1 ), slen );
+         pText[ slen ] = 0; /* Preprocessor expects null-terminated string */
+         if( slen )
+         {
+            memset( pOut, 0, HB_PP_STR_SIZE );
+
+            HB_SKIPTABSPACES( ptr );
+
+            if( !hb_pp_topDefine )
+               hb_pp_Table();
+            if( *ptr && hb_pp_ParseExpression( ptr, pOut, FALSE ) > 0 )
+            {
+               /* Some error here? */
+            }
+         }
+         hb_retc( pText ); /* Preprocessor returns parsed line in input buffer */
+      }
+      /* else
+      {  */
+         /* an error occured during parsing.
+          * The longjmp was used in GenError()
+          */
+      /*   hb_retc( NULL );
+      } */
+
+      hb_xfree( pText );
+      hb_xfree( pOut );
+   }
+   else
+      hb_retc( NULL );
+}
+
+void hb_compGenError( char * szErrors[], char cPrefix, int iError, const char * szError1, const char * szError2 )
+{
+   PHB_ITEM pError;
+   char buffer[ 128 ];
+
+   HB_SYMBOL_UNUSED( cPrefix );
+
+   HB_TRACE(HB_TR_DEBUG, ("hb_compGenError(%p, %c, %d, %s, %s)", szErrors, cPrefix, iError, szError1, szError2));
+
+   /* TOFIX: The internal buffers allocated by the preprocessor should be
+             deallocated here */
+
+   sprintf( buffer, szErrors[ iError - 1 ], szError1, szError2 );
+   pError = hb_errRT_New( ES_ERROR, "PP", 9999, ( ULONG ) iError, buffer, NULL, 0, EF_NONE | EF_CANDEFAULT );
+   hb_errLaunch( pError );
+   hb_errRelease( pError );
+
+   /* longjmp( s_env, iError == 0 ? -1 : iError ); */
+}
+
+void hb_compGenWarning( char * szWarnings[], char cPrefix, int iWarning, const char * szWarning1, const char * szWarning2 )
+{
+   HB_TRACE(HB_TR_DEBUG, ("hb_compGenWarning(%p, %c, %d, %s, %s)", szWarnings, cPrefix, iWarning, szWarning1, szWarning2));
+
+   /* NOTE: All warnings are simply ignored */
+
+   HB_SYMBOL_UNUSED( szWarnings );
+   HB_SYMBOL_UNUSED( cPrefix );
+   HB_SYMBOL_UNUSED( iWarning );
+   HB_SYMBOL_UNUSED( szWarning1 );
+   HB_SYMBOL_UNUSED( szWarning2 );
+}
+
+PINLINE   hb_compInlineAdd( char * szFunName )
+{
+   HB_SYMBOL_UNUSED( szFunName );
+   return NULL;
+}
+
+void hb_compParserStop( void  )
+{
+   ;
+}
+
+#endif
+
diff --git a/harbour/source/pp/pptable.c b/harbour/utils/hbpp/pptable.c
similarity index 100%
rename from harbour/source/pp/pptable.c
rename to harbour/utils/hbpp/pptable.c
diff --git a/harbour/source/pp/pragma.c b/harbour/utils/hbpp/pragma.c
similarity index 100%
rename from harbour/source/pp/pragma.c
rename to harbour/utils/hbpp/pragma.c
diff --git a/harbour/utils/hbpptest/pretest.prg b/harbour/utils/hbpptest/pretest.prg
index 834d2f63ef..11be7f1689 100644
--- a/harbour/utils/hbpptest/pretest.prg
+++ b/harbour/utils/hbpptest/pretest.prg
@@ -6,9 +6,10 @@
    #xtranslate HB_OSNewLine() => ( Chr( 13 ) + Chr( 10 ) )
 #endif
 
-#command TEXT TO VAR <v> => #pragma __stream|%s||<v>:=
-#command CTEXT TO VAR <v> => #pragma __cstream|%s||<v>:=
-#command XTEXT TO VAR <v> => #pragma __text|<v>+=%s+HB_OSNEWLINE()||<v>:=""
+/* #command TEXT TO VAR <v> => #pragma __stream|<v>:=%s */
+#command TEXT TO VAR <v> => #pragma __text|<v>+=%s;<v>:=""
+#command CTEXT TO VAR <v> => #pragma __cstream|<v>:=%s
+#command XTEXT TO VAR <v> => #pragma __text|<v>+=%s+HB_OSNEWLINE();<v>:=""
 
 /* Testing preprocessor */
 
@@ -18,7 +19,7 @@ LOCAL nCnt:=0
 LOCAL nRes:=0
 
 /* ---------------------------------------------------------------------*/
-  in := "#xtranslate CCC <v> => QOUT( <v>[2] [, <v>[<v>][3]] )"+HB_OSNewLine()+;
+  in := "#xtranslate CCC <v> => QOUT( <v>[2] [, <v>\[<v>\]\[3\]] )"+HB_OSNewLine()+;
         "CCC b"
   pre := "QOUT(b[2] ,bb[3] )"
   nRes += PreResult( pre, PreRun( in, pre ), @nCnt )
@@ -43,7 +44,7 @@ LOCAL nRes:=0
 /*------------*/
 XTEXT TO VAR in
 #define RED {255,0,0}
-#xcommand SET TOOLTIP TO <color> OF <form> => SM( TTH (<"form">), 1, RGB(<color>[1], <color>\[2\], <color>[, <color>[ 3 ] ]), 0)
+#xcommand SET TOOLTIP TO <color> OF <form> => SM( TTH (<"form">), 1, RGB(<color>\[1], <color>\[2\], <color>[, <color>\[ 3 \] ]), 0)
 SET TOOLTIP TO RED OF form1
 ENDTEXT
 TEXT TO VAR pre    
@@ -52,7 +53,7 @@ ENDTEXT
   nRes += PreResult( pre, PreRun( in, pre ), @nCnt )
 
 /*------------*/
-  in :="#command ZZZ [<v>] => QOUT([<v>[1]])"
+  in :="#command ZZZ [<v>] => QOUT([<v>\[1\]])"
   __PreProcess( in )
   in :="ZZZ a"
   pre :="QOUT(a[1] )"
@@ -1233,6 +1234,7 @@ FUNCTION PreResult( pre, out, pCnt )
 LOCAL i
 
   pCnt++
+  pre:=strtran(pre," "); out:=strtran(out," ")
   IF( pre == out )
     RETURN 1
   ELSE