--------------------------------------------------
                         VFP C++ COMPILER USER MANUAL
                                 January 2017
                 --------------------------------------------------
                 (C)SHENZHEN BAIYUJIA SOFTWARE TECHNOLOGY CO., LTD.



                     /----------------------------------\
                     | Chapter 1 DEVELOPMENT BACKGROUND |
                     \----------------------------------/


     Visual FoxPro 9.0 is the latest and the last version of Microsoft's dBASE-
compatible software development platform.

     dBASE was created by Ashton-Tate Corporation, who released dBASE II in 1980.
Fox Software Corporation, the most successful competitor, released FoxBASE in 1984.
Finally Microsoft bought Fox Software in 1992 (for about $173 million).

     When Visual FoxPro 9.0 was released in 2004, after 20 years passed by with
Ups and Downs, Microsoft's data-centric development platform is still used by many
developers and companies. This seems to be a miracle!

     However, VFP always has been a "pseudo" compiler which outputs "p-code" that,
generally, cannot be protected against de-compilation. In fact, there are a lot of
VFP decompilers available, such as ReFox, UnFoxAll and VFPDecoder, to name only a few.
VFP always was - and still is: "only a pseudo-compiler"! This has always been the
weakest point of VFP viewed from the user/developer's perspective. Although there
are some VFP encryption software systems available, none of them is able to protect
VFP's P-code completely against ALL available decompilers!

     What do you think? Is there REALLY NO WAY to make VFP a full-blown native-code
compiler like MASM, C/C++ and Delphi? Today, an old saying comes true again: Nothing
Is impossible! There it is, your native-executable compiler for Visual FoxPro!



                     /-------------------------------\
                     | Chapter 2 PROGRAM ENVIRONMENT |
                     \-------------------------------/


1. The hardware environment:

     IBM-compatible PC machine (PentiumIII 800MHz or above CPU, 256MB or more
memory).

2. The software environment:

     Microsoft Windows 2000, Windows XP, Windows Vista, Windows 7, Windows 8,
Windows 8.1, Windows 10 (x86/x64).
     Microsoft Visual FoxPro 6.0, Visual FoxPro 7.0, Visual FoxPro 8.0,
Visual FoxPro 9.0, Visual FoxPro Advanced, Visual FoxPro Advanced (x64).
     Microsoft Visual C++ 6.0 (Visual Studio 98), Visual C++ 7.0 (Visual Studio .NET),
Visual C++ 8.0 (Visual Studio 2005), Visual C++ 9.0 (Visual Studio 2008),
Visual C++ 10.0 (Visual Studio 2010), Visual C++ 11.0 (Visual Studio 2012),
Visual C++ 12.0 (Visual Studio 2013), Visual C++ 14.0 (Visual Studio 2015),
Visual C++ 14.1 (Visual Studio 2017).



                     /---------------------------\
                     | Chapter 3 INSTALL PROGRAM |
                     \---------------------------/


1. Install VFP C++ Compiler:

     VFP C++ Compiler is a GREEN-SOFTWARE, we can copy to the hard disk and run.

     Run the setup program VCSETUP.EXE can Install VFP C++ Compiler to the folder
C:\Program Files\Baiyujia VFP C++ Compiler.

2. Run VFP C++ Compiler:

     Double-click the shortcut VFP C++ Compiler on the desktop, or run C:\Program Files\
Baiyujia VFP C++ Compiler\VC.EXE, we can entry the VFP C++ Compiler main form.

     Now we can double-click VCTEST\VCTEST.VCF, and click "Start Compile",
after compile completed, then generated VCTEST.EXE and VCTEST.DLL. And then
double-click VCTEST.EXE to start the test program, if the test program is
normal that VFP C++ Compiler has been installed successfully.



                    /-----------------------------\
                    | Chapter 4 DECLARE VARIABLES |
                    \-----------------------------/


1. Variables category

     VFP C++ Compiler divided variables into general variables, category variables
and macro variables.

     General variables: Except category variables and macro variables, such as:
x1, x2 and so on.
     Category variables: If declare abc*, the variables beginning of abc are
category variables.
     Macro variables: If declare xyz&, the variables beginning of xyz are macro
variables.

2. Declare variables

     1, declare general variables

     In VFP, there are a few methods to declare variables, such as:
     Method 1: x1=123
     Method 2: STORE 123 TO x1
     Method 3: PUBLIC x1, PRIVATE x1, LOCAL x1, ... TO x1, ... TO ARRAY x1 and
so on.

     VFP C++ Compiler only process the case of method 1. In other words, if we use
the x1=123, VFP C++ Compiler will compile x1 to internal name; if the variable x1 in
another file, but the file has not been included in the final executable file,
then we can use STORE 123 TO x1, so x1 will not be compiled to internal name.

     2, declare category variables

     In VFP, there are:
     DISPLAY MEMORY LIKE abc*
     SAVE TO FileName ALL LIKE abc*
     RELEASE ALL LIKE abc*
     VFP C++ Compiler can accurately identify these statements, and as a category
variable abc* to compile.

     We can also use the following format to declare category variable:
     * LIKE abc*

     If declare category variable abc*, then abc will be compiled to __vc_xxx,
abc123 will be compiled to __vc_xxxa, abcdef will be compiled to __vc_xxxb and
so on.

     If declare category variable abc*, we must declare all variables beginning
of abc. In other words, the following statements may be happen an error when run:
     * LIKE abc*
     abc123=123
     STORE "abcdef" TO abcdef

     Or we can set:
     /VCNAMECATEGORY=OFF does not Compile Category Variable Names
     to resolved the problem.

     3, declare macro variables

     We can use the following format to declare macro variable:
     * LIKE xyz&

     If declare macro variable xyz&, then xyz will be compiled to __vc_xxx,
xyz123 will be compiled to __vc_xxx123, xyzdef will be compiled to__vc_xxxdef
and so on.

     If declare macro variable xyz&, we must declare all variables beginning of
xyz. In other words, the following statements may be happen an error when run:
     * LIKE xyz&
     xyz123=123
     STORE "xyzdef" TO xyzdef

     Or we can set:
     /VCNAMEMACRO=OFF does not Compile Macro Variable Names
     to resolved the problem.

3. Declare procedures

     Same as declare variables, we must explicitly declare the procedure name
need to compile.

     If only:
     PROCEDURE pabc
     VFP C++ Compiler will not compile pabc to internal name.

     If we have:
     PROCEDURE pabc
     * pabc=
     VFP C++ Compiler will compile pabc to internal name.

     Recommend use the following standard format to declare procedures and
variables:
     PROCEDURE pabc
     PARAMETERS m.x1, m.x2
     * pabc=
     * m.x1=
     * m.x2=
     PRIVATE m.x3
     m.x3=0

4. Reserved words

     Reserved words include reserved words of VFP and common Win32API function
names, DECLARE function names are also reserved words.

     VFP C++ Compiler will automatically compile reserved words to internal name,
users do not have to do a special process.

     Proposed do not use reserved words as variable names, process names, field
names, etc., that may make conflicts.



                     /-----------------------------------\
                     | Chapter 5 COMMAND LINE PARAMETERS |
                     \-----------------------------------/


     Run VC.EXE /? will display the details of command line parameters:
     VFP C++ Compiler for Windows XP
     (C)SHENZHEN BAIYUJIA SOFTWARE TECHNOLOGY CO., LTD.
     Usage: VC VFP project file
               VFP run file
               C/C++ compiler file
               Compile options
     /HELP Help
     /VCLEVEL=n Compile and Encrypt Level
     /VCPRG=ON|OFF Compile Program Files
     /VCSCX=ON|OFF Compile Form Files
     /VCSTRUC=ON|OFF Compile Structured Programming Commands
     /VCOPT=ON|OFF Optimize Code
     /VCOPT2=ON|OFF Optimize Code Level II
     /VCENCRYPT=ON|OFF Encrypt Executable File
     /VCPACKEXE=ON|OFF Compress  Executable File
     /VFPLIB=ON|OFF Include VFP Support Library
     /VCLIB=ON|OFF Include Visual C++ Library
     /VCPACKDLL=ON|OFF Compress  Dynamic Link Library File
     /VCPACK=ON|OFF Pack Executable File
     /VCSTEP=ON|OFF Single Step Compile Mode
     /DEBUG=ON|OFF Debug Mode
     /APPDEBUG=ON|OFF Application Debug Mode
     /APPERROR=ON|OFF Application Error Log File
     /SILENT=ON|OFF Silent Mode

1. VFP project file

     Usually, It can be specify a VFP project file with file extension is PJX,
we can also specify as follows:
     1, VFP program file with file extension is PRG, if the project is only
one PRG file.
     2, VFP list file with file extension is LST, the file stored a list of
the files, such as VCTEST.LST:
     CONFIG.FPW
     VCTEST.PRG
     VCTEST.SCX
     VCTEST.FRX
     The first PRG file is the main file, and support the *? wildcards.
     3, VFP C++ Compiler start file with file extension is VCF, the file stored
command line parameters, such as VCTEST.VCF:
     VCTEST.PJX       ; VFP project file
     VFP9\VFP9.EXE    ; VFP run file
     FOXRUN7\MAKE.BAT ; C/C++ compiler file
     /VCLEVEL=1       ; Compile and Encrypt Level

     To the COM server program, VFP C++ Compiler only supports the VFP project file
with file extension is PJX.

     VFP C++ Compiler can compile a COM server program as:
     1, Win32 executable / COM server program, the file extension is EXE, the
dynamic link library extension is DLL;
     2, Single-threaded COM server program, the file extension is DLL, the
dynamic link library extension is EXE;
     3, Multi-threaded COM server program, the file extension is DLL, the
dynamic link library extension is EXE.

     VFP C++ Compiler only compile the COM server program, it does not process the
COM server program registration.

2. VFP run file

     We can specify VFP run file such as VFP6.EXE, VFP7.EXE, VFP8.EXE, VFP9.EXE,
VFPA.EXE. VFP C++ Compiler currently supports Visual FoxPro 6.0/7.0/8.0/9.0/Advanced/
Advanced (x64) version.

     The program compiled with Visual FoxPro 6.0 required VC runtime MSVCRT.DLL,
VFP runtime VFP6R*.DLL (recommended version: 6.0.8961.0) to run.
     The program compiled with Visual FoxPro 7.0 required VC runtime MSVCR70.DLL,
VFP runtime VFP7R*.DLL (recommended version: 7.0.0.9465) to run.
     The program compiled with Visual FoxPro 8.0 required VC runtime MSVCR70.DLL,
VFP runtime VFP8R*.DLL (recommended version: 8.0.0.3117), GDI+ graphics library
GDIPLUS.DLL to run.
     The program compiled with Visual FoxPro 9.0 required VC runtime MSVCR71.DLL,
VFP runtime VFP9R*.DLL (recommended version: 9.0.0.5721 or later), GDI+ graphics
library GDIPLUS.DLL to run.
     The program compiled with Visual FoxPro Advanced required VC runtime MSVCR71.DLL,
VFP runtime VFPAR.DLL (recommended version: 10.0.0.0 or later), GDI+ graphics
library GDIPLUS.DLL to run.
     The program compiled with Visual FoxPro Advanced (x64) required VC runtime
MSVCR100.DLL, VFP runtime VFPAR.DLL (recommended version: 10.0.0.0 or later), GDI+
graphics library GDIPLUS.DLL to run.

3. C/C++ compiler file

     The C/C++ compiler file have installed to the FOXRUN folder, now only specify
the compile mode:
     MAKE.BAT: minimizing size of optimizing compile, the default compile mode;
     MAKE_O1.BAT: minimizing size of optimizing compile;
     MAKE_O2.BAT: maximize speed of optimizing compile;
     MAKE_OD.BAT: non-optimizing compile, it is recommended to use debugging.

     The program compiled with Visual C++ 6.0 required VC runtime MSVCRT.DLL
to run.
     The program compiled with Visual C++ 7.0 required VC runtime MSVCR70.DLL
to run.
     The program compiled with Visual C++ 8.0 need to install Microsoft .NET
Framework 2.0 or Microsoft Visual C++ 2005 Redistributable Package or copy
MICROSOFT.VC80.CRT.MANIFEST and MSVCR80.DLL to the program folder to run.
     The program compiled with Visual C++ 9.0 need to install Microsoft .NET
Framework 3.5 or Microsoft Visual C++ 2008 Redistributable Package or copy
MICROSOFT.VC90.CRT.MANIFEST and MSVCR90.DLL to the program folder to run.
     The program compiled with Visual C++ 10.0 required VC runtime MSVCR100.DLL
to run, only run on Windows XP SP2 or later.
     The program compiled with Visual C++ 11.0 required VC runtime MSVCR110.DLL
to run, only run on Windows Vista or later.
     The program compiled with Visual C++ 11.0 Update 1 or later required VC runtime
MSVCR110.DLL to run, only run on Windows XP SP2 or later.
     The program compiled with Visual C++ 12.0 required VC runtime MSVCR120.DLL
to run, only run on Windows XP SP2 or later.
     The program compiled with Visual C++ 14.0 need to install Microsoft Visual C++
2015 Redistributable Package to run, only run on Windows XP SP2 or later.
     The program compiled with Visual C++ 14.1 need to install Microsoft Visual C++
2017 Redistributable Package to run, only run on Windows XP SP2 or later.

     Data Alignment: 1 byte, 2 bytes, 4 bytes, 8 bytes, 16 bytes.
     Recommend select 4 or 8 bytes aligned for 32-bit system.
     Recommend select 8 or 16 bytes aligned for 64-bit system.

     More C/C++ compile options please refer to the C/C++ compiler help documentation.

4. Compile options

     The first three command line parameters must be input with the following order:
     The first parameter must be: VFP project file
     The second parameter must be: VFP run file
     The third parameter must be: C/C++ compiler file

     The fourth and other command line parameters for the compile options, we can
enter in any order.

     1, /VCLEVEL=n Compile and Encrypt Level

     The default compile and encrypt level is 1, maximum is 99.
     Usually select compile and encrypt level 1 can encrypt, select high-level
compile and encrypt level then generated executable file encryption strength
Increased, but slightly reduced speed.
     As the nested level of VFP DO command is 128 (VFP 9.0 can be set to the
maximum 65000), if we select compile and encrypt level 1, so the nested level
of VFP DO command is 128/3 = 42 level, if we select compile and encrypt level 5,
so the nested level of VFP DO command is 128/3/5 = 8 level, in some large program
may happen "Allowed DO nesting level exceeded" error.

     2, /VCPRG=ON|OFF Compile Program Files

     The default is ON, which allows Compile Program Files.
     Program Files include:
     Program file, the file extension is PRG;
     Format file, the file extension is FMT;
     Screen file, the file extension is SPR;
     Menu file, the file extension is MPR;
     Query file, the file extension is QPR.

     3, /VCSCX=ON|OFF Compile Form Files

     The default is ON, which allows Compile Form Files.
     Form Files include:
     Form file, the file extension is SCX;
     Class library file, the file extension is VCX;
     Report file, the file extension is FRX;
     Label file, the file extension is LBX.

     4, /VCSTRUC=ON|OFF Compile Structured Programming Commands

     The default is ON, which allows Compile Structured Programming Commands.
     Structured Programming Commands include:
     DO CASE ... ENDCASE
     DO WHILE ... ENDDO
     FOR EACH ... ENDFOR
     FOR ... ENDFOR
     IF ... ENDIF
     SCAN ... ENDSCAN
     TRY ... ENDTRY

     5, /VCOPT=ON|OFF Optimize Code

     The default is ON, VFP C++ Compiler compiled and generated optimized code for
the executable file, and run speed improved significantly.
     If set to OFF, VFP C++ Compiler does not compiled and generated optimized code
for the executable file.
     Usually, the optimization of code (line number) ratio between 60% and 80%.

     6, /VCOPT2=ON|OFF Optimize Code Level II

     The default is ON, VFP C++ Compiler compiled and generated optimized code level
II for the executable file, and run faster.
     If set to OFF, VFP C++ Compiler does not compiled and generated optimized code
level II for the executable file.

     7, /VCENCRYPT=ON|OFF Encrypt Executable File

     The default is ON, VFP C++ Compiler compiled and encrypted the executable file.
     If set to OFF, VFP C++ Compiler only compiled and generated the executable file,
does not encrypt the executable file.

     8, /VCPACKEXE=ON|OFF Compress Executable File (does not support COM server)

     The default is OFF, VFP C++ Compiler only compiled and generated the executable file,
does not compress the executable file.
     If set to ON, VFP C++ Compiler compiled and compressed the executable file.
     Usually, VFP C++ Compiler compiled and generated the encrypted executable file
compression rate between 10% and 30%, the unencrypted executable file compression
rate between 5% and 15%.

     9, /VFPLIB=ON|OFF Include VFP Support Library (does not support COM server)
        /VFPLIBLANGUAGE=... VFP Support Library Language (only support Visual FoxPro Advanced)

     The default is OFF, VFP C++ Compiler compiled and generated executable file does
not contain the VFP runtime file.
     If set to ON, VFP C++ Compiler compiled and generated executable file contain
VFP runtime file and VC runtime file.
     For Visual FoxPro Advanced, we can select VFP Support Library Language:
     CHS - Simplified Chinese
     CHT - Traditional Chinese
     CSY - Czech
     DEU - German
     ENU - English
     ESN - Spanish
     FRA - French
     KOR - Korean
     RUS - Russian

     10, /VCLIB=ON|OFF Include Visual C++ Library (does not support COM server)

     The default is OFF, VFP C++ Compiler compiled and generated executable file does
not contain the VC runtime file.
     If set to ON, VFP C++ Compiler compiled and generated executable file contain
the VC runtime file.

     11, /VCPACKDLL=ON|OFF Compress Dynamic Link Library File

     The default is OFF, VFP C++ Compiler only compiled and generated the dynamic link
library file, does not compress the dynamic link library file.
     If set to ON, VFP C++ Compiler compiled and compressed the dynamic link
library file.
     Usually, VFP C++ Compiler compiled and generated dynamic link library file
compression rate between 30% and 50%.

     12, /VCPACK=ON|OFF Pack Executable File (does not support COM server)

     The default is OFF, VFP C++ Compiler does not pack executable file.
     If set to ON, VFP C++ Compiler packed executable file.
     We can use MoleBox or Thinstall pack software to pack dynamic link library
file and other files (for example, VFP support library files) into the generated
executable file.

     13, /VCSTEP=ON|OFF Single Step Compile Mode

     The default is OFF, VFP C++ Compiler compiled many VFP statements to one C function.
     If set to ON, VFP C++ Compiler compiled only one VFP statement to one C function.

     14, /DEBUG=ON|OFF Debug Mode

     The default is OFF, that is, turn off debug mode.
     If the program is compiled to run have problem, we can set the debug
mode to ON, so that VFP C++ Compiler will generate a log file and retain the
temporary files, easy to analyze the reasons for problem.

     15, /APPDEBUG=ON|OFF Application Debug Mode

     The default is OFF, that is, turn off application debug mode.
     If the program is compiled to run have problem, we can set the application
debug mode to ON, so that VFP C++ Compiler will generate a log file when the program
running, easy to analyze the reasons for problem.

     16, /APPERROR=ON|OFF Application Error Log File

     The default is OFF, that is, turn off application error log file.
     If the program is compiled to run have problem, we can set the application
error log file to ON, so that VFP C++ Compiler will generate a error log file when the
program running, easy to analyze the reasons for problem.

     17, /SILENT=ON|OFF Silent Mode

     The default is OFF, VFP C++ Compiler will display the main form.
     If set to ON, VFP C++ Compiler will not display the main form, easy to call
in a batch.

     18, /VCINCREMENTAL=ON|OFF Incremental Compile Mode

     The default is OFF, VFP C++ Compiler will compile all files in the VFP project file.
     If set to ON, VFP C++ Compiler only compile the modified files in the VFP project file.

     19, /VCSAVEINCREMENTAL=ON|OFF Save Incremental Compile Files

     The default is OFF, VFP C++ Compiler will not retain the temporary files.
     If set to ON, VFP C++ Compiler will retain the temporary files for incremental compile.

     20, /VCMULTITASK=ON|OFF Multi-Task Compile Mode

     The default is OFF, that is, turn off multi-task compile mode.
     If set to ON, VFP C++ Compiler will run multi-task to compile the files in the VFP
project file.

     21, /VCMULTITASKNUMBER=n Multi-Task Number

     The default multi-task number is 1, maximum is 99.
     Usually we can set it to the maximum number of threads for the CPU supported,
for example, for a 2 cores 4 threads CPU, we can set it to 4.
     Recommend to set it for multi-core or multi-thread CPU.

     We can use the "Save Compile Options" function to write the command line
parameters to a VCF file, such as VCTEST.VCF:
     VCTEST.PJX       ; VFP project file
     VFP9\VFP9.EXE    ; VFP run file
     FOXRUN7\MAKE.BAT ; C/C++ compiler file
     /VCLEVEL=1       ; Compile and Encrypt Level
     Then double-click the file we can call VFP C++ Compiler to compile the program.

5. More compile options

     0, /VCINSERTINITCODE=ON|OFF Insert Init Code

     The default is OFF, VFP C++ Compiler will not insert init code.
     If set to ON, VFP C++ Compiler will insert init code specified in the
user init code file (<PROJECT-NAME>.VCI).

     1, /VCKEYWORD=ON|OFF Compile Keywords

     The default is OFF, VFP C++ Compiler does not compile keywords.
     If set to ON, VFP C++ Compiler compiled keywords.

     2, /VCNAME=ON|OFF Compile Variable Names

     The default is OFF, VFP C++ Compiler does not compile variable names.
     If set to ON, VFP C++ Compiler compiled variable names.

     3, /VCNAMECATEGORY=ON|OFF Compile Category Variable Names

     The default is ON, VFP C++ Compiler compiled category variable names.
     If set to OFF, VFP C++ Compiler does not compile category variable names.

     4, /VCNAMEMACRO=ON|OFF Compile Macro Variable Names

     The default is ON, VFP C++ Compiler compiled macro variable names.
     If set to OFF, VFP C++ Compiler does not compile macro variable names.

     5, /VCNAMETYPE=n Variable Names Encode Type

     The encode charset for compile variable names, include:
     0: English Alphabets A-Z
     1: English Alphabet O(0x4F) and Digit 0(0x30)
     2: Chinese Characters 0xFAA1-0xFAFA
     3: Chinese Characters 0xA6AF and 0xAFB0
     4: MD5 Code - 16 Characters
     5: MD5 Code - 32 Characters

     6, /VCNAMEONLYVCV=ON|OFF Only Compile Variable Names in the User Variable
        Names File

     The default is OFF, VFP C++ Compiler will compile all variable names.
     If set to ON, VFP C++ Compiler only compile variable names specified in the
user variable names file (<PROJECT-NAME>.VCV).

     7, /VCNAMEEXCLUDEVCD2=ON|OFF Does Not Compile Variable Names in String Delimiters
        /VCNAMEEXCLUDEVCD3=ON|OFF Does Not Compile Field Names or Property Names
        /VCNAMEEXCLUDEVCW=ON|OFF Does Not Compile Variable Names Specified in
        the User Reserved Words File

     The default is OFF, VFP C++ Compiler will compile all variable names.
     If set to ON, VFP C++ Compiler does not compile variable names in string
delimiters, field names or property names, variable names specified in the user
reserved words file (<PROJECT-NAME>.VCW).

     8, /VCNAMEMULTIPROJ=ON|OFF Compile Variable Names for Multiple Projects

     The default is OFF, VFP C++ Compiler compile variable names for each project.
     If set to ON, VFP C++ Compiler compiled variable names for multiple projects.

     9, /VCNAMESCANPROJDIR=ON|OFF Scan Files in Project Folder and its Subfolders

     The default is ON, VFP C++ Compiler scanned files in project folder and its
subfolders. If the variable name same with the file name in the project folder
and its subfolders, it will not be compiled to internal name.
     If set to OFF, VFP C++ Compiler does not scan files in project folder and its
subfolders.

     10, /VCNAMESCANDIR=ON|OFF Scan Folders
         /VCNAMESCANDIRLIST=... Scan Folders List

     The default is OFF, VFP C++ Compiler does not scan other folders.
     If set to ON, VFP C++ Compiler also scan the folders in the scan folders list.

     11, /VCNAMEONLYTEXTMERGEDELI=ON|OFF For Text Merge Statements, Only Compile
         Variable Names in the Text Merge Delimiters

     The default is OFF, for text merge statements (include \, \\, TEXT ... ENDTEXT
statements), VFP C++ Compiler compiled all variable names in the statements.
     If set to ON, for text merge statements (include \, \\, TEXT ... ENDTEXT
statements), VFP C++ Compiler only compiled variable names in the text merge delimiters.

     12, /VCSCXINIT=ON|OFF Convert Form's Properties into Procedure Init
         /VCFASTSCXINIT=ON|OFF Fast Convert Form's Properties into Procedure Init
         /VCSCXINITMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not convert form's properties.
     If set to ON, VFP C++ Compiler converted form's properties into procedure init.
     If set Fast Convert to ON, VFP C++ Compiler only convert the VFP base class object's
properties into procedure init,

     It is valid for the counter in the modulus list only.

     13, /VCSCXINITFOXRUNOFF=ON|OFF Does Not Compile Form's Procedure Init
         /VCSCXINITFOXRUNOFFMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler compiled form's procedure init.
     If set to ON, VFP C++ Compiler insert =[FOXURN OFF] into the form's procedure init,
and does not compile form's procedure init.

     It is valid for the counter in the modulus list only.

     14, /VCFRXINIT=ON|OFF Convert Report's Expressions into Procedure Init
         /VCFASTFRXINIT=ON|OFF Fast Convert Report's Expressions into Procedure Init
         /VCFRXINITMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not convert report's expressions.
     If set to ON, VFP C++ Compiler converted report's expressions into procedure init.
     If set Fast Convert to ON, VFP C++ Compiler only convert the TextBox control's
expressions into procedure init, it does not convert the Label control's expressions
into procedure init,

     It is valid for the counter in the modulus list only.

     15, /VCFRXINITFOXRUNOFF=ON|OFF Does Not Compile Report's Procedure Init
         /VCFRXINITFOXRUNOFFMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler compiled report's procedure init.
     If set to ON, VFP C++ Compiler insert =[FOXURN OFF] into the report's procedure init,
and does not compile report's procedure init.

     It is valid for the counter in the modulus list only.

     16, /VCSCX_RESERVEDPROPERTIES_GRID_HEIGHT=ON|OFF Reserved Properties for Grid.Height
         /VCSCX_RESERVEDPROPERTIES_TEXTBOX_CONTROLSOURCE=ON|OFF Reserved Properties for
          TextBox.ControlSource
         /VCSCX_RESERVEDPROPERTIES_OTHERS=ON|OFF Reserved Other Properties
         /VCSCX_RESERVEDPROPERTIES_OTHERSLIST= Reserved Other Properties List

     The default is OFF, VFP C++ Compiler does not reserved properties.
     If set to ON, VFP C++ Compiler reserved properties.

     To reserved someone property, that is does not convert the property into procedure
init.

     17, /VCSCX_CLEANDATA_COMMENT_WHEN_BLANK=ON|OFF Clean Data for Object's Comment When
          Blank (Comment = "")
         /VCSCX_CLEANDATA_OLECONTROL_COMMENT=ON|OFF Clean Data for OLEControl.Comment
         /VCSCX_CLEANDATA_CLASS_INFO=ON|OFF Clean Data for Class Info

     The default is OFF, VFP C++ Compiler does not clean data.
     If set to ON, VFP C++ Compiler clean data.

     18, /VCFRX_CLEANDATA_SHOW_POSITION=ON|OFF Clean Data for Show Position
         /VCFRX_CLEANDATA_PRINTER_DRIVER_INFO=ON|OFF Clean Data for Printer Driver Info
         /VCFRX_CLEANDATA_COMMENT_WHEN_BLANK=ON|OFF Clean Data for Object's Comment When
          Blank (Comment==" ")
         /VCFRX_DELETEDATA_COMMENT=ON|OFF Delete Data for Comment Object (Objtype=0)
         /VCFRX_DELETEDATA_WHEN_PRINTWHENISFALSE=ON|OFF Delete Data When Print When is
          Flase (Supexpr==".F.")
         /VCFRX_AUTORELEASEVARIABLES=ON|OFF Automatic Release Variables Defined in
          Report's Procedure Init

     The default is OFF, VFP C++ Compiler does not clean or delete data.
     If set to ON, VFP C++ Compiler clean or delete data.

     19, /VCTOLARGEPROC=ON|OFF Compile to Large Procedure Files Format (only used for VFP 9.0)

     The default is OFF, VFP C++ Compiler does not compile to large procedure files format.
     If set to ON, VFP C++ Compiler compile to large procedure files format and automatically
fix the large program files BUG.

     About the large procedure files format, please refer to:
     baiyujia website: www.baiyujia.com/vfpdocuments/f_vhfox.asp

     20, /VCNOTDISPLAY_LARGEPROC=ON|OFF Does Not Display the Large Program Files in the
          Project (only used for VFP 9.0)

     The default is OFF, VFP C++ Compiler display the large program files in the project.
     If set to ON, VFP C++ Compiler does not display the large program files in the project
(if the large program files BUG has been fixed).

     About the large program files BUG, please refer to:
     baiyujia website: www.baiyujia.com/vfpdocuments/f_vfp9fix2.asp

     21, /VCNOTDISPLAY_RELATIONALEXPR=ON|OFF Does Not Display the Invalid RelationalExpr Expression

     The default is OFF, VFP C++ Compiler display the invalid relationalexpr expression.
     If set to ON, VFP C++ Compiler does not display the invalid relationalexpr expression
(if the invalid relationalexpr expression BUG has been fixed).

     About the invalid relationalexpr expression BUG, please refer to:
     baiyujia website: www.baiyujia.com/vfpdocuments/f_vfp9fix4.asp

     22, /VCFILESEARCHPATH=... File Search Path

     Specified the search path for class library files and header files.

     23, /VCPLUGIN_MYPROTECT=ON|OFF Run MyProtect Plugin
         /VCPLUGIN_MYPROTECTFILE=... MyProtect Plugin File

     The default is OFF, VFP C++ Compiler does not run MyProtect plugin.
     If set to ON, VFP C++ Compiler run the specified MyProtect plugin before generate the
executable file.

     24, /VCEXPANDEXPEVALUATE=ON|OFF Expand Expression With EVALUATE() Function
         /VCEXPANDEXPEVALUATELEVEL=n Expand Times
         /VCEXPANDEXPEVALUATEMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not expand expression with EVALUATE() function.
     If set to ON, VFP C++ Compiler expanded expression with EVALUATE() function.

     To expand expression with EVALUATE() function, for example,
     x1="ABC"
     will be expanded to:
     x1=(EVALUATE('"ABC"'))

     The default expand times is 1, maximum is 99.

     It is valid for the counter in the modulus list only.

     25, /VCEXPANDEXPCHR=ON|OFF Expand Expression With CHR() Function
         /VCEXPANDEXPCHRMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not expand expression with CHR() function.
     If set to ON, VFP C++ Compiler expanded expression with CHR() function.

     To expand expression with CHR() function, for example,
     x1="ABC"
     will be expanded to:
     x1=(CHR(65)+CHR(66)+CHR(67))

     It is valid for the counter in the modulus list only.

     26, /VCEXPANDEXPCHR_L=m Maximum Character Number Expanded on the Left
         /VCEXPANDEXPCHR_R=n Maximum Character Number Expanded on the Right

     Use of 0-m characters on the left and 0-n characters on the right to expand expression.

     27, /VCEXPANDEXP=ON|OFF Expand Expression With IIF() Function
         /VCEXPANDEXPMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not expand expression with IIF() function.
     If set to ON, VFP C++ Compiler expanded expression with IIF() function.

     To expand expression with IIF() function, for example,
     x1=x2
     will be expanded to:
     x1=IIF(.T.,x2,123)
     or
     x1=IIF(.F.,123,x2)

     It is valid for the counter in the modulus list only.

     28, /VCEXPANDEXP_IIF_T=m Maximum Number of IIF(.T.
         /VCEXPANDEXP_IIF_F=n Maximum Number of IIF(.F.

     Use of 0-m IIF(.T. and 0-n IIF(.F. to expand expression.

     29, /VCEXPANDEXPSTRUC_IIF_T=m Maximum Number of IIF(.T. in Structured Programming Commands
         /VCEXPANDEXPSTRUC_IIF_F=n Maximum Number of IIF(.F. in Structured Programming Commands

     Use of 0-m IIF(.T. and 0-n IIF(.F. to expand expression in structured programming commands.

     30, /VCEXPANDEXPSCXINIT_IIF_T=m Maximum Number of IIF(.T. in Form's Procedure Init
         /VCEXPANDEXPSCXINIT_IIF_F=n Maximum Number of IIF(.F. in Form's Procedure Init

     Use of 0-m IIF(.T. and 0-n IIF(.F. to expand expression in form's procedure init.

     31, /VCEXPANDEXPFRXINIT_IIF_T=m Maximum Number of IIF(.T. in Report's Procedure Init
         /VCEXPANDEXPFRXINIT_IIF_F=n Maximum Number of IIF(.F. in Report's Procedure Init

     Use of 0-m IIF(.T. and 0-n IIF(.F. to expand expression in report's procedure init.

     32, /VCDECOMPCOND=ON|OFF Decompose Complex Conditional Statement

     The default is OFF, VFP C++ Compiler does not decompose complex conditional statement.
     If set to ON, VFP C++ Compiler decompose complex conditional statement.

     To decompose complex conditional statement, for example,
     IF x1 OR x2
        ?"Y"
     ELSE
        ?"N"
     ENDIF
     will be decomposed to:
     IF x1
        ?"Y"
     ELSE
        IF x2
           ?"Y"
        ELSE
           ?"N"
        ENDIF
     ENDIF

     Usually, the program's complexities will increase as exponential when
decompose complex conditional statement.
     --------------------------------------------------------------------------------------------------------------------
     | Structured Programming Commands | Maximum of Nested Level for VFP | Maximum of Nested Level for VFP C++ Compiler |
     --------------------------------------------------------------------------------------------------------------------
     | IF ... ENDIF                    |            63                   |            143                               |
     --------------------------------------------------------------------------------------------------------------------
     | DO CASE ... ENDCASE             |            31                   |            143                               |
     --------------------------------------------------------------------------------------------------------------------
     | DO WHILE ... ENDDO              |            63                   |             91                               |
     --------------------------------------------------------------------------------------------------------------------
     | FOR ... ENDFOR                  |            63                   |             91                               |
     --------------------------------------------------------------------------------------------------------------------
     | SCAN ... ENDSCAN                |            63                   |             91                               |
     --------------------------------------------------------------------------------------------------------------------
     | TRY ... ENDTRY                  |            63                   |             91                               |
     --------------------------------------------------------------------------------------------------------------------
    As the maximum of nested level for VFP structured programming commands is 63,
some large program may happen "Structure nesting is too deep" error when decompose
complex conditional statement.

     33, /VCFASTDECOMPIF=ON|OFF Fast Decompose IF Statement
         /VCFASTDECOMPIFCONDNUMBER=n Condition Number
         /VCFASTDECOMPIFRECURSELEVEL=n Recurse Level
         /VCFASTDECOMPIFCODELINENUMBER=n Code Line Number
         /VCFASTDECOMPIFCODELENGTH=n Code Length
         /VCFASTDECOMPIFMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not fast decompose IF statement.
     If set to ON, VFP C++ Compiler fast decompose IF statement.

     To fast decompose IF statement, for example,
     IF x1 OR x2 OR x3 OR x4 OR x5
     Use another decompose methods, decompose faster and the generated code smaller.

     The default condition number is 9, maximum is 99.
     The default recurse level is 9, maximum is 99.
     The default code line number is 999, maximum is 9999.
     The default code length is 99999, maximum is 999999.

     To fast decompose IF statement when the condition number is great than the
specified condition number OR the recurse level is great than the specified recurse
level OR the code line number is great than the specified code line number OR the
code length is great than the specified code length AND the counter in the modulus
list only.

     If the condition is too complex, VFP C++ Compiler fast decomposed IF statement
automatically.

     34, /VCFASTDECOMPDOCASE=ON|OFF Fast Decompose DO CASE Statement
         /VCFASTDECOMPDOCASECASENUMBER=n CASE Number
         /VCFASTDECOMPDOCASECONDNUMBER=n Condition Number
         /VCFASTDECOMPDOCASERECURSELEVEL=n Recurse Level
         /VCFASTDECOMPDOCASECODELINENUMBER=n Code Line Number
         /VCFASTDECOMPDOCASECODELENGTH=n Code Length
         /VCFASTDECOMPDOCASEMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not fast decompose DO CASE statement.
     If set to ON, VFP C++ Compiler fast decompose DO CASE statement.

     To fast decompose DO CASE statement, for example,
     CASE x1 AND x2 AND x3 AND x4 AND x5
     Use another decompose methods, decompose faster and the generated code smaller.

     The default CASE number is 9, maximum is 99.
     The default condition number is 9, maximum is 99.
     The default recurse level is 9, maximum is 99.
     The default code line number is 999, maximum is 9999.
     The default code length is 99999, maximum is 999999.

     To fast decompose DO CASE statement when the CASE number is great than the
specified CASE number OR the condition number is great than the specified condition
number OR the recurse level is great than the specified recurse level OR the code
line number is great than the specified code line number OR the code length is great
than the specified code length AND the counter in the modulus list only.

     If the condition is too complex, VFP C++ Compiler fast decomposed DO CASE statement
automatically.

     35, /VCEXPANDINLINE=ON|OFF Expand Inline Function
         /VCEXPANDINLINELEVEL=n Expand Times
         /VCEXPANDINLINEMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not expand inline function.
     If set to ON, VFP C++ Compiler expand inline function.

     The default expand times is 1, maximum is 99.

     It is valid for the counter in the modulus list only.

     36, /VCANTIDISASM=ON|OFF Anti-Disassembly (does not support 64-bit program)
         /VCANTIDISASMMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not generate anti-disassembly code.
     If set to ON, VFP C++ Compiler will generate anti-disassembly code.

     It is valid for the counter in the modulus list only.

     37, /VCMOVE=ON|OFF Move Statement
         /VCMOVELEVEL=n Move Times
         /VCMOVEMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not move statement.
     If set to ON, VFP C++ Compiler move statement.

     To move statement, for example,
     statement
     will be moved to:
     =[GOTO FOXRUN_GOTO_LABEL_XXX_START]
     =[FOXRUN_GOTO_LABEL_XXX_END:]
     ...
     =[FOXRUN_GOTO_LABEL_XXX_START:]
     statement
     =[GOTO FOXRUN_GOTO_LABEL_XXX_END]

     The default move times is 1, maximum is 99.

     It is valid for the counter in the modulus list only.

     38, /VCMOVEGOTO=ON|OFF Move GOTO Statement
         /VCMOVEGOTOMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not move GOTO statement.
     If set to ON, VFP C++ Compiler move GOTO statement.

     It is valid for the counter in the modulus list only.

     39, /VCFASTMOVE=ON|OFF Fast Move Statement
         /VCFASTMOVELEVEL=n Fast Move Times
         /VCFASTMOVEMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not fast move statement.
     If set to ON, VFP C++ Compiler fast move statement.

     The default fast move times is 1, maximum is 99.

     It is valid for the counter in the modulus list only.

     40, /VCNOTMOVE=ON|OFF Does Not Move Statement
         /VCNOTMOVEMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not move statement.
     If set to ON, VFP C++ Compiler move statement.

     It is valid for the counter in the modulus list only.

     41, /VCREENCRYPT=ON|OFF Reencrypt Code When Run
         /VCREENCRYPTMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, that is not encrypt code after the code have run.
     If set to ON, the code more secure, but run slower.

     It is valid for the counter in the modulus list only.

     42, /VCFASTENCRYPT=ON|OFF Fast Encrypt Code
         /VCFASTENCRYPTMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not fast encrypt code.
     If set to ON, VFP C++ Compiler encrypted some bytes of the code, encrypt and decrypt
faster, and run faster.

     It is valid for the counter in the modulus list only.

     43, /VCNOTENCRYPT=ON|OFF Does Not Encrypt Code
         /VCNOTENCRYPTMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler encrypted code.
     If set to ON, VFP C++ Compiler generated code smaller and compile faster, does not
decrypt code and run faster.

     It is valid for the counter in the modulus list only.

     44, /VCENCRYPTPCODE=ON|OFF Encrypt P-Code
         /VCENCRYPTPCODEMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not encrypt P-Code.
     If set to ON, VFP C++ Compiler encrypted P-Code.

     It is valid for the counter in the modulus list only.

     45, /VCFASTENCRYPTPCODE=ON|OFF Fast Encrypt P-Code
         /VCFASTENCRYPTPCODEMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler does not fast encrypt P-Code.
     If set to ON, VFP C++ Compiler Fast Encrypted P-Code, encrypt and decrypt faster,
and run faster.

     It is valid for the counter in the modulus list only.

     46, /VCNOTENCRYPTPCODE=ON|OFF Does Not Encrypt P-Code
         /VCNOTENCRYPTPCODEMODLIST=0,1,2,3,4,5,6,7 Modulus List

     The default is OFF, VFP C++ Compiler encrypted P-Code.
     If set to ON, VFP C++ Compiler does not encrypt and decrypt P-Code and run faster.

     It is valid for the counter in the modulus list only.

     To compile and generate the best compatibility code, please refer to the
following settings:
     /VCKEYWORD=OFF           ; does not Compile Keywords
     /VCNAME=OFF              ; does not Compile Variable Names
     /VCSCXINIT=OFF           ; does not Convert Form's Properties into Procedure Init
     /VCFRXINIT=OFF           ; does not Convert Report's Expressions into Procedure Init
     /VCEXPANDEXPEVALUATE=OFF ; does not Expand Expression With EVALUATE() Function
     /VCEXPANDEXPCHR=OFF      ; does not Expand Expression With CHR() Function
     /VCEXPANDEXP=OFF         ; does not Expand Expression With IIF() Function
     /VCDECOMPCOND=OFF        ; does not Decompose Complex Conditional Statement
     /VCEXPANDINLINE=OFF      ; does not Expand Inline Function
     /VCANTIDISASM=OFF        ; does not Anti-Disassembly
     /VCMOVE=OFF              ; does not Move Statement

     To compile and generate the smallest file size code, please refer to the following
settings:
     /VCENCRYPT=OFF ; does not Encrypt Executable File
     /VCPACKEXE=ON  ; Compress Executable File
     /VFPLIB=OFF    ; does not Include VFP Support Library
     /VCLIB=OFF     ; does not Include Visual C++ Library
     /VCPACKDLL=ON  ; Compress Dynamic Link Library File

     To compile and generate the run fastest code, please refer to the following
settings:
     /VCKEYWORD=OFF           ; does not Compile Keywords
     /VCSCXINIT=OFF           ; does not Convert Form's Properties into Procedure Init
     /VCFRXINIT=OFF           ; does not Convert Report's Expressions into Procedure Init
     /VCEXPANDEXPEVALUATE=OFF ; does not Expand Expression With EVALUATE() Function
     /VCEXPANDEXPCHR=OFF      ; does not Expand Expression With CHR() Function
     /VCEXPANDEXP=OFF         ; does not Expand Expression With IIF() Function

     To compile and generate the highest encryption strength code, please refer to
the following settings:
     /VCLEVEL=3                  ; Compile and Encrypt Level
     /VCENCRYPT=ON               ; Encrypt Executable File
     /VCPACKEXE=ON               ; Compress Executable File
     /VCPACKDLL=ON               ; Compress Dynamic Link Library File
     /VCKEYWORD=ON               ; Compile Keywords
     /VCNAME=ON                  ; Compile Variable Names
     /VCSCXINIT=ON               ; Convert Form's Properties into Procedure Init
     /VCFRXINIT=ON               ; Convert Report's Expressions into Procedure Init
     /VCEXPANDEXPEVALUATE=ON     ; Expand Expression With EVALUATE() Function
     /VCEXPANDEXPEVALUATELEVEL=3 ; Expand Times
     /VCEXPANDEXPCHR=ON          ; Expand Expression With CHR() Function
     /VCEXPANDEXPCHR_L=20        ; Maximum Character Number Expanded on the Left
     /VCEXPANDEXPCHR_R=30        ; Maximum Character Number Expanded on the Right
     /VCEXPANDEXP=ON             ; Expand Expression With IIF() Function
     /VCEXPANDEXP_IIF_T=20       ; Maximum Number of IIF(.T.
     /VCEXPANDEXP_IIF_F=30       ; Maximum Number of IIF(.F.
     /VCDECOMPCOND=ON            ; Decompose Complex Conditional Statement
     /VCEXPANDINLINE=ON          ; Expand Inline Function
     /VCEXPANDINLINELEVEL=3      ; Expand Times
     /VCANTIDISASM=ON            ; Anti-Disassembly
     /VCMOVE=ON                  ; Move Statement
     /VCMOVELEVEL=3              ; Move Times
     /VCMOVEGOTO=ON              ; Move GOTO Statement
     /VCREENCRYPT=ON             ; Reencrypt Code When Run
     /VCENCRYPTPCODE=ON          ; Encrypt P-Code



                     /-------------------------\
                     | Chapter 6 EXTENDED CODE |
                     \-------------------------/


1. CODE PRAGMAS

     Usually, C/C++ code can insert some optimize pragmas to control the
compiler options, such as #pragma optimize.

     Similarly, we can also insert the following pragmas to control the
VFP C++ Compiler option:
     =[FOXRUN ON]
     =[FOXRUN OFF]
     VFP C++ Compiler scan =[FOXRUN OFF], then the code is not compiled until
scan =[FOXRUN ON].

     We can also insert the following pragmas to control the single step
compile option:
     =[FOXSTEP ON]
     =[FOXSTEP OFF]
     VFP C++ Compiler scan =[FOXSTEP OFF], then the code is not single step
compiled until scan =[FOXSTEP ON].

2. LABEL AND GOTO STATEMENT

     Now, we can use LABEL and GOTO statement, such as:
     =[LABEL1:]
     =[GOTO LABEL1]

     Note for use GOTO statement:
     GOTO statement can only jump in the function body, it can not jump to
another function body.

3. INLINE FUNCTION

     We can use the following format to declare inline function:
     * inline [PROCEDURE | FUNCTION] pabc

     Note for use inline function:
     If we use #DEFINE preprocessor statement to define a constant in the
inline function, we need use #UNDEF preprocessor statement to undefine the
constant in the inline function, otherwise they will happen "Constant is
already created with #DEFINE" error.
     Usually, only expand inline function in the following commands:
     ?
     @
     \ | \\
     =
     IF
     CASE
     DO WHILE
     RETURN
     STORE
     WAIT

4. INLINE C STATEMENT

     Now, we can use inline c statement, such as:
     =[__C MessageBoxA(0,mytext,mytitle,0);]

5. INLINE ASSEMBLY STATEMENT (does not support 64-bit program)

     Now, we can use inline assembly statement, such as:
     =[__ASM CALL MessageBoxA]

6. INCLUDE C FILE

     Now, we can include c file, such as:
     =[INCLUDE VCTEST.C]

7. INCLUDE ASSEMBLY FILE (does not support 64-bit program)

     Now, we can include assembly file, such as:
     =[INCLUDEASM VCTEST.ASM]

8. LOCAL COMPILE OPTION

     We can use the following format to set the local compile option:
     =[VCOPTION compile option]

     We can use the following format to restore the global compile option:
     =[VCOPTION $(DEFAULT)]



                     /------------------------\
                     | Chapter 7 SPECIAL CODE |
                     \------------------------/


1. Code changes:
     SET LIBRARY TO FileName
     Will be automatically changed to:
     SET LIBRARY TO FileName ADDITIVE

     SET DATASESSION TO nDataSessionNumber
     Will be automatically changed to:
     SET DATASESSION TO nDataSessionNumber
     SET TALK OFF

2. The following command to compile, there may be have problem:
     RETRY
     RETURN TO
     Please refer to the sample programs VCTEST_RETRY\VCTEST.PRG,
VCTEST_RETURN_TO\VCTEST.PRG.

3. The error handling procedure:
     ON ERROR DO perrorun WITH ERROR(), MESS(), MESS(1), SYS(16), LINENO()
     Please refer to the sample programs VCTEST_ON_ERROR\PERRORUN.PRG.

4. Field name conflict:
     Please refer to the sample programs VCTEST_FIELD\VCTEST.PRG.

5. Recursive calls:
     Please refer to the sample programs VCTEST_GETNEXTID\F_GETNEXTID.PRG.

6. API library merger:
     Please refer to the sample programs VCTEST_ADD\FOXRUN.H, VCTEST_ADD\VCTEST.PRG.

7. Version information:
     Please refer to the sample file version information VCTEST\VERSIONINFO.TXT.

8. The following command must be explicitly run, can not run as macro replacement:
     RETURN
     RETRY
     SUSPEND
     RESUME
     CANCEL
     QUIT
     READ EVENTS
     CLEAR EVENTS
     DOEVENTS
     ERROR
     ON ERROR
     ON SHUTDOWN
     SET LIBRARY
     RELEASE LIBRARY
     SET PROCEDURE
     RELEASE PROCEDURE
     CLEAR ALL
     CLEAR PROGRAM
     CLEAR MEMORY
     RELEASE ALL
     CLOSE ALL
     CLOSE PROCEDURE
     PRIVATE ALL

     To run as macro replacement, such as:
     x1="RETURN"
     &x1

9. The following command must be explicitly run, can not run as macro replacement,
   and runtime have been neglected:
     APPEND PROCEDURES
     ASSERT
     BUILD APP
     BUILD EXE
     BUILD PROJECT
     CREATE FORM
     CREATE MENU
     CREATE QUERY
     CREATE SCREEN
     CREATE VIEW
     DEBUGOUT
     MODIFY CONNECTION
     MODIFY DATABASE
     MODIFY FORM
     MODIFY MENU
     MODIFY PROCEDURE
     MODIFY PROJECT
     MODIFY QUERY
     MODIFY SCREEN
     MODIFY VIEW
     SET DEBUG
     SET DEVELOPMENT
     SET DOHISTORY
     SET ECHO
     SET LIBRARY TO
     SET STEP



                     /----------------------------\
                     | Chapter 8 COMPILER COMPARE |
                     \----------------------------/


     ---------------------------------------------------------------------------------------------------------------
     | Compare Item                    | Masm, C/C++, Delphi Compiler    | VFP C++ Compiler                        |
     ---------------------------------------------------------------------------------------------------------------
     | Variable names, function names  | Compile to address              | Compile to NTI number                   |
     ---------------------------------------------------------------------------------------------------------------
     | Structured programming commands | Compile to JA/JB/JMP            | Compile to JA/JB/JMP                    |
     ---------------------------------------------------------------------------------------------------------------
     | Executable file(s)              | Compiled and generated EXE file | Compiled and generated EXE and DLL file |
     ---------------------------------------------------------------------------------------------------------------
     | Executable file(s) compression  | Can compress the EXE file       | Can compress the EXE and DLL file       |
     ---------------------------------------------------------------------------------------------------------------
     | VC runtime files                | MSVCR*.DLL                      | MSVCR*.DLL, VFPCORE.DLL                 |
     ---------------------------------------------------------------------------------------------------------------
     | API function library files      | KERNEL32.DLL, USER32.DLL etc.   | VFP?R.DLL, VFP?R???.DLL                 |
     ---------------------------------------------------------------------------------------------------------------



                     /------------------\
                     | Chapter 9 OTHERS |
                     \------------------/


     VFP C++ Compiler compiled and generated the executable file to be decompile
impossible. When VFP C++ Compiler became a popular software, the VFP decompile
software such as ReFox, UnFoxAll, VFPDecoder, FoxTools etc. will gradually
Disappear. Of course, the compile and decompile, encryption and decryption
is always the relationship between the spear and shield, such as Soft-ICE,
OllyDbg, W32Dasm etc. is still the powerful tool for Cracker.

     VFP C++ Compiler compiled and generated the executable file is a GREEN-SOFTWARE,
it can publish without include VFP runtime files.

     Welcome to our website to download the latest version of VFP C++ Compiler:
http://www.baiyujia.com.

     For about VFP C++ Compiler questions or suggestions, please e-mail to ccb2000@163.com.