
                                        _______     ,eg ,,_
                       +$*****g         `\3^^-\4    `\8  ]1
                        &)    )          ]y    {     -2  :#
                        QZ               {#        _ =$   &
                        #3   ,  --,.=gg  <Q  ,g  ,MY"a$   $
                        4j__af   \G /g   {&ag@/  Q9  ]Q   3
                        &$^""#    fgQ    i&   +  {&  -d   6
                        &t         #9    ]$      1$  =9   f
                        [g     _  #4&    (9    g,(8  ]9  _
                        [{    j? /g {Y   ?4   /#  Q,pJ$_`9a
                        f9  _z@',Q~ _#+ ad#ggdVQ  ?9&'8^ ]9
                      -dQ9555S* Y^^ ""`^""

  Ŀ                  -- 
        ;          --PR0UDLY PRSNT---            Ŀ
    Ϳ  :
    :-         <\.<\ Private COMpiler v2.7b2 by ExEd!  />./>            :
    -- -              - -  :
     : Ŀ  Ļ
    ĳĳĿ 
         -- --ĳĳ 
  Ϳ  ļ Ϳ
  ;  Ŀ  |
  :  : ;               --[Rfrnc]--            : ;
    --- -              - --  
                                                                       :
                                                               
 Ŀ
           PCOM 2.7b2 by Edward C Willemsen of ExEd! software            
-- -             - -Ĵ
                                                                             
 Private COMpiler converts a kind of script file into a .COM/.EXE/.ASM file. 
                                                                             |
| Usage: PCOM <script file>|<option> [args].                                  |
|                                                                             :
| If the script file is named DOIT.SCR, then PCOM creates an executable       :
| file called DOIT.COM/PCOM.EXE.                                              :
|                                                                             :
| The filename does not need the extension .SCR, this automatically will be   :
| add. So if you type 'PCOM HELLO', PCOM will interpret this as 'HELLO.SCR'.  :
|                                                                             :
: For who?                                                                    :
:                                                                             :
:        If you don't possess some knowledge of programming, you'll still     :
:        be able to create a good made to measure executable, like a bbs text :
:        screen or an advertisement.                                          :
:                                                                             :
:        If you do possess some programming knowledge, you can use this       :
:        program to upgrade or fix your current programs, or hack/patch/crack :
:        others.  ( And distribute the .COM/.EXE ;-)                          :
:                                                                             :
:        For those, like myself, who are to lazy to write the 'almost' same   :
:        code again and again and again. . .                                  :
:                                                                             :
: About the examples. If there is an .EXE or a .COM file, try that program at :
: first. Then compile the script file and run the patch file. Rerun the .EXE  :
: or the .COM and notice the difference or read the .TXT file going with the  |
: example.                                                                    |
:                                                                             |
: If you create an usefull patch then you havn't got to distribute the script |
| file, because the .COM/.EXE file is a stand alone executable. If you want   |
| everybody to know how you fixed it, distribute the script, so that others   
 can learn from your knowledge.                                              
                                                                             
-- -             - -Ĵ
                                                                             
| The compiler does not add some unimportant stuff into the output file, like 
: my name 'ExEd!' or anything else! So the most tiny possible executable file |
: is created. The generated code is 2..5 pass assembly code, so no NOPS       :
| are added. BUT you can add unimportant stuff yourself by using the *...     |
 option, see below.                                                          |
                                                                             
-- -              - -Ĵ
                                                                             
 The valid PCOM options are the following:                                   
|                                                                             
:        /? For the advanced help page.                                       |
:                                                                             :
|        /a For the Ascii Table (hex notated).                                :
|                                                                             :
|        /b For the Ascii Table (dec notated).                                :
|                                                                             :
        /o For the Color chart (hex notated).                                |
                                                                             |
        /c For the valid commands.                                           |
                                                                             
        /g Show the PCOM.CFG settings, overrule -? with the -?- argument.    
                                                                             
        /t For the ASCII to hex and decimal conversion utility.              
                                                                             
        /d For decimal to hex conversion.                                    
                                                                             
        /h For hex to decimal conversion.                                    
                                                                             
-- -              - -Ĵ
                                                                             
 The valid PCOM arguments are:                                               
|                                                                             
|        -d For debugging mode, an output file will be created.               |
:                                                                             |
:        -s For debugging mode without creating an output file.               |
:                                                                             |
:        -x For creating a .EXE output file.                                  |
:                                                                             |
:        -e Encrypt the output .COM or .EXE file.                             |
:                                                                             |
:        -i Put anti-hacker code in the .COM or .EXE file.                    |
:                                                                             |
:        -r Run the executable after creation.                                |
:                                                                             |
:        -a Create assembler output file.                                     |
:                                                                             |
:        -A Create assembler output file including script comments.           |
:                                                                             |
| In the debug mode every action is shown to the user. You have to press a    :
| key for the next step of compilation. If there are no errors found, the     |
 .COM/.EXE is created. This mode will not add any code in the output file.   |
                                                                             
 For example:  PCOM TEST -x -d -r will create a file called TEST.EXE         
               and PCOM will create it in debug mode. Afterwards it will run 
               the generated executable.                                     
                                                                             
-- -              - -Ĵ
                                                                             
 The valid script commands are the following:                                
                                                                             
        ;...             = Comments.                                         
                                                                             
        @...             = Output ... to screen.                             
                           Note: A CR/LF will be added.                      
                           Technical: The standard interrupt is used, so a   
                                      line will and with a '$'-sign.         
                                                                             
        @~xx:...         = Colored ... output to screen, xx is the hex       
                           notated color value which can be found using the  
                           PCOM /o command.                                  
                           Note: A CR/LF will be added.                      
                                                                             
        +...             = Open file ... in read/overwrite/add mode.         
                           Note: File existence is automatically implemented.
                                 So when file ... does not exist, the        
|                                 string 'File not found!' will be displayed  
|                                 and the XXXXX.COM will exit to dos with     
|                                 errorlevel 1. You can overwrite old code    
|                                 and append new at the and of the file.      
|                                 If you want to use the =... function, open  
|                                 the file in this mode!                      
|                                                                             |
|        #...             = Creates new file ... in append mode.              |
|                           Note: Now you are able to create text files like  |
|                                 *.REG and *.KEY files.                      |
|                                                                             |
:        .                = Write CR/LF                                       |
:                           Note: The CR/LF in the "... line is removed, so   |
:                                 this could be rotten with text files. By    |
:                                 using the DOT you can create a CR/LF.       :
:                                                                             :
:        -                = Close the open file                               :
:                           Note: The file system works LIFO, so if you       :
:                                open more then one file, the first file to   :
:                                close is the last file opend.                :
:                                                                             :
:        >xxxx:xxxx       = Move file pointer from start to xxxx:xxxx.        :
:                           ( 32-bits searcher, 4096 Mb, able ).              :
:                           Note: Remember that byte 1 of the file is at      :
:                                 position 0000:0000!                         :
:                                                                             :
:        |xxxx:xxxx       = Move the file pointer from current position       :
:                           to the current + xxxx:xxxx.                       :
:                                                                             :
:        )                = Move the file pointer to the end of the file.     :
:                           Note: You can add text or code at the and of the  :
:                                 file opened with +... or #...               :
:                                                                             :
:        (                = Pretty useless function, because a file is already:
:                           at this position when you open it. BUT it might   :
:                           be usefull when you want to check a byte first and:
:                           then want to modify the begin of it. ( You can    :
:                           also write >0000:0000. )                          :
:                                                                             :
:        "...             = Write string ... into the open/created file.      :
:                           Note: The CR/LF will be skipped. Use the . command:
:                                 for writing a newline into a file.          :
:                                                                             :
:        '...             = Write code ... into the open/created file. (hex). :
:                                                                             :
:        *...             = Append footer in the output file.                 :
:                           Note: You can place the *... code anywhere in     :
:                                 the script, but the footer will be placed   :
:                                 at the end of the .COM/.EXE. You can add one:
:                                 footer!                                     :
:                                                                             :
:        =...             = Check byte ... with the byte of file pointer pos. :
:                           Note: Handy for checking the validity of the file :
:                                 you want to patch.                          :
:                                                                             :
:        ?...             = Get user input and place it in the ... variable.  :
:                           Note: ?Variable will create a variable called     :
:                                 %Variable%. The name is not case sensitive  :
:                                 and may be almost as long as you like (132  :
:                                 characters).                                :
:                                                                             :
:        !...:...         = Check from file ... that it's size is ...         :
:                           Syntax: !TEST.EXE:4672329                         :
:                                   The name is in 8.3 notation and           :
:                                   the size is in bytes.                     :
:                                                                             :
:        &RHS:...         = Change the attribute of file ...  Uppercase will  :
:                           set the attribute, lowercase will reset the       :
:                           attribute.                                        :
:                           Note: No file existence check is done.            :
:                                                                             :
:        $key             = Wait for a key (without echo).                    :
:                                                                             :
:        $snd             = Lets the internal bleeper bleep.                  :
:                                                                             :
:        $con             = Sets the cursor on.                               :
:                                                                             :
:        $cof             = Sets the cursor off.                              :
:                                                                             :
:        $cls             = Clears the screen.                                :
:                           Note: This option will undo the already used      :
:                                 $cof and $chr command!                      :
:                                                                             |
|        $chr             = Set 40x25 character text mode.                    
                           Note: Just for a fancy lay-out.                   
                                ( The $cls sets the 80x25 charakter mode ).  
                                                                             
        $chl             = Set 80x50 character text mode.                    
                                                                             
        $lck             = Locks the computer. So you'll force the user to   
                           reboot.                                           
                                                                             
        $y/n             = Y/y will continue the program, all other keys will
                           terminate your created program.                   
                           Example: Are you sure [y/n]?                      
                                    ->@Are you sure [y/n]?                   
                                    ->$Y/N                                   
                           If you press any other key then Y or y, the       
                           program quits with errorlevel 1. Normally is quits
                           with errorlevel 0.                                
                           Note: With 'the program' we main your created     
                                 .EXE/.COM file.                             
                                                                             
        $sbd             = Set boot drive.                                   
                           Note: I needed this for patching the IO.SYS.      
                                                                             
        $prn             = Generate a print-screen ( always funny ;)         
                                                                             
        $fdb             = Full windowed dos-box.                            
                           Tested in Win95/98/NT, does not harm in plain DOS.
|                                                                             
|        $dsk:x           = Change to drive X:                                |
|                                                                             |
|        $rep:x           = Repeat x times the codelines between { and }.     |
|                           Note: Loops may be nested.                        |
|                                                                             |
|        $ccs:xx          = Clear colored screen, xx is the colornumber which |
|                           can be found using the PCOM /o command. xx is hex |
|                           notated.                                          |
|                                                                             |
|        $cur:x,y         = Change the cursors position.                      |
|                           Example: Set cursor on 1,2 : $cur:1,2             |
|                                    Where 1 is horizontal positioning and    |
|                                    2 is vertical positioning.               |
|                                    Set cursor at 1,23 : $cur:1,23.          |
|                                    Set cursor at 40,2 : $cur:40,2.          |
|                           Note: 0,0 is the origin af the screen!            |
|                                                                             |
|        $ren:x>y         = Rename file x into y.                             :
|                                                                             :
:        $cdr:...         = Change to directory ...                           :
:                           Note: Use dubble \ for the root. This is a kind of:
:                                 caused by the C++ manner of string typing.  :
:                                                                             :
:        $rdr:...         = Remove directory ...                              :
|                                                                             :
|        $mdr:...         = Make directory ...                                :
|                                                                             |
|        $del:...         = Delete file ...                                   |
                                                                             
        $num:...         = Switches numlock status. Use 'ON' to switch it on 
                           or 'OFF' to switch it off.                        
                                                                             
        $cap:...         = Switches capslock status. Use 'ON' to switch it   
                           on or 'OFF' to switch it off.                     
                                                                             
        $slp:...         = This is a vertical retrace delay. You can adjust  
                           the time by changing the ... value. This value is 
                           an integer value, so large sizes will be          
                           truncated.                                        
                                                                             
        $inc:...         = Includes script ... into the current script.      
                           Note: This could be handy for a LOGO.SCR with     
                                 your synonymous or groupname.               
                                 You may include as much include files as    
                                 you like, but include files may NOT contain 
                                 include files. (With other words, include   
                                 file may not be nested).                    
                                                                             
        $fnt:...         = Load the ... fontfile. The fontfile layout is a   
                           standard binary raw format. Depending on the      
                           filesize, the correct textmode will be set.       
                           Note: Remember to change to a full dosbox within  
                                 Windows95/98/NT, because the font is        
                                 emulated within a dosbox, so that the new   
                                 font wouldn't be visible.                   
                                                                             
        $run:...         = Executes the '...' files or command.              
                           Note: This could be a internal/external or        
                                 Windows 95 command. You will return to the  
                                 compiled script afterwards. When the command
                                 is not executed the program quits with      
                                 errorlevel 3 and the 'File is not executed!'
                                 string.                                     
                                                                             
        $far:xx>yy       = Find xx and replace it with yy.                   
                           The xx and yy must be hex.                        
                           Example: In an executable you'll like to change   
                                    the string Abba into Fija. Well, first   
                                    you run PCOM /t to determine the hex     
                                    values of the chars, then you create a   
                                    script with the following line:          
                                    $far:41626261>46696a                     
                                    Run the script and the patch is done!    
                                    Notice that the length of the strings do 
                                    need to have the same length.            
                           Technical: The routine recognizes the stream,     
                                      moves the file pointer back to the     
                                      beginning of the stream and overwrites 
                                      it.                                    
                                                                             
        $sound:x,y       = Play sound x for y periods of time.               
                                                                             
        $nosound         = Switch off the sound.                             
                                                                             
        ansi             = Define a ANSI screen. See ANSI method.            
                                                                             
 A script command line may start with spaces or tabs, those charakters will  
 be skipped by the compiler. So you're able to make a fancy layout (pshaw).  
 You can comment the commands without the '...' or ':???' i.e. -, ., $key,   
 $cls, $snd, $con, $cof, $prn and $chr.                                      
                                                                             
-- -             - -Ĵ
                                                                             
 ANSI method:                                                                
                                                                             
 - Single line                                                               
   Example: ansi                                                             
             x:0                                                             
             y:0                                                             
             w:4                                                             
             h:1                                                             
             raw                                                             
             541E651E731E741E                                                
                                                                             
   This routine will draw the text 'Test' in BLUE and YELLOW at potition     
   1,1 of your screen.                                                       
                                                                             
   Note: w:4 means 4 charakters. But 4 charakters are 8 bytes because they   
         have there color attribute.                                         
                                                                             
 - Image                                                                     
   Example: ansi                                                             
             x:20                                                            
             y:0                                                             
             w:40                                                            
             h:10                                                            
             inc                                                             
             IMAGE.BIN                                                       
                                                                             
   This routine will draw the image in file 'IMAGE.BIN' at position 21,1.    
   The image has a size of 40*10*2=800 bytes.                                
                                                                             
   The IMAGE.BIN file is build with the following format:                    
   charakter value, textcolor, backgroundcolor and this for each charakter.  
   A file in this format can be generated with almost all ANSI editors. We   
   used 'TheDraw' for the example.                                           
                                                                             
   For those who want to draw in ASCII, reread this manual and find out that 
   you can use the @... command.                                             
                                                                             
-- -             - -Ĵ
                                                                             
 About the PCOM.CFG configuration file.                                      
                                                                             
| When you always use the -e -i arguments (or any other) you can use a        
| PCOM.CFG file. This file can be on two places, 1) in the directory where    
: the PCOM.EXE rehides, somewhere in your seachpath, 2) in the current        
: directory. When a PCOM.CFG file is found in the current directory it will   |
: be used, the one in the searchpath will be ignored.                         :
|                                                                             :
| The .CFG file is just a plain text file. You can use the ';' command for    :
| comments in this file. The commandline options may be on one line or on     :
| multiple lines. The following NET.CFG examples can be used:                 :
|                                                                             |
|       ;                               ;                                     |
|       ; Example #1                    ; Example #2                          |
|       ; My default config             ;                                     |
|       ; in my searchpath              -d-a-e-i                              |
|       ;                               ;                                     |
|       -e -i                           ; done                                |
|       ; create .exe                   ;                                     |
|       -x                                                                    |
|       ;                                                                     |
|       ; End of my config                                                    |
       ;                                                                     |
                                                                             
 What to do if you are using example #1 and you want to create a .COM file?  
 Well, the PCOM.CFG rehides in the searchpath, so you can create a config-   
 file in the current directory. You can also run PCOM with the -x- argument. 
 By adding a '-'-sign you can overrule the settings in a .CFG file. So if you
 are using exmaple #1 and you want to create an .COM file and a .ASM file you
 can run PCOM in the following way: PCOM <file> -x- -a.                      
                                                                             
 It is possible the check the argument result using the /g option. When you  
 run: PCOM /g -x- -a, PCOM will respond with the found configuration. Replace
 the /g with the sourcefile and PCOM will compile it the way you want.       
                                                                             
-- -             - -Ĵ
                                                                             
 With this version of PCOM you can create text-files. To do this use the     
 following commands:                                                         
|                                                                             
|       $del:TEST.DOX                                                         
:       #TEST.DOX                                                             
:       .                                                                     |
|       "Hi dudes...                                                          :
|       .                                                                     :
       -                                                                     |
                                                                             
 After running the .COM/.EXE, type TYPE TEST.DOX.                            
                                                                             
-- -             - -Ĵ
                                                                             
 More about the ?... command.                                                
                                                                             
 This command creates the ability to use variables within PCOM. This routine 
 uses a 134 bytes buffer, where 132 bytes are used for storing the user data 
 and 2 bytes for the stringlength counter. The routine supports the backspace
 functionality and will end after a return. To create the possibility for    
 using this routine for all functions within PCOM the string ends with both  
 ending characters 0x00 and '$'. The <enter> character will NOT be included. 
 Therefore you have to use a @ after the @%variable% command, otherwise the  
 output will be overwritten.                                                 
                                                                             
 The following example will create a registry key file which will be imported
 into the Windows(TM) registry.                                              
                                                                             
             ;                                                               
             ; Identification key                                            
             ;                                                               
             @Enter your name:                                               
             ?Name                                                           
             @                                                               
             @Enter your birthdate:                                          
             ?Date                                                           
             @                                                               
             ; Create the key                                                
             #IDENT.REG                                                      
             "REGEDIT4                                                       
             .                                                               
             .                                                               
             "[HKEY_LOCAL_MACHINE\Ident]                                     
             .                                                               
             ""What is this"="A PCOM Example!"                               
             .                                                               
             .                                                               
             "[HKEY_LOCAL_MACHINE\Ident\User]                                
             .                                                               
             ""Username"="                                                   
             "%Name%                                                         
             ""                                                              
             .                                                               
             ""Birthdate"="                                                  
             "%Date%                                                         
             ""                                                              
             .                                                               
             .                                                               
             -                                                               
             ;                                                               
             ; Enter the key in the registry                                 
             ;                                                               
             $run:REGEDIT /s IDENT.REG                                       
             @Done!                                                          
             ;                                                               
                                                                             
 After running this compiled script check the result using: REGEDIT.EXE and  
 remove the key.                                                             
                                                                             
-- -             - -Ĵ
                                                                             
 Loop example:                                                               
                                                                             
 ;                                                                           
 $rep:4                                                                      
     {                                                                       
     @Hello:                                                                 
     $rep:4                                                                  
         {                                                                   
         @world!                                                             
         }                                                                   
     }                                                                       
 ;                                                                           
                                                                             
 Try it and you would be surprised about the result!                         
                                                                             
-- -              - -Ĵ
                                                                             
 Sound table:                                                                
                                                                             
 3td Octave                                                                  
                                                                             
 C=9121 Cis=8609 D=8126 Dis=7670 E=7239 F=6833 Fis=6449 G=6087 Gis=5746      
 A=5423 Ais=5119 B=4831                                                      
                                                                             
 4th Octave                                                                  
                                                                             
 C=4560 Cis=4304 D=4063 Dis=3834 E=3619 F=3416 Fis=3224 G=3043 Gis=2873      
 A=2711 Ais=2559 B=2415                                                      
                                                                             
 5th Octave                                                                  
                                                                             
 C=2280 Cis=2152 D=2031 Dis=1917 E=1809 F=1715 Fis=1612 G=1521 Gis=1436      
 A=1355 Ais=1292 B=1207                                                      
                                                                             
-- -              - -Ĵ
                                                                             
 To obtain the highest security level in your output file use both -e and -i 
 options.                                                                    
                                                                             
 The protection is valid for both .COM and .EXE files, but will increase the 
 filesize.                                                                   
                                                                             
-- -              - -Ĵ
                                                                             
 PCOM can generate some warnings and errors while compiling:                 
                                                                             
         MAIN                                                              
|                                                                             
|        Could not open '????????.???'. . .                                   
|        expl.: The file named as argument doesn't exists.                    
|               Check it's existence.                                         
|                                                                             
|        Could not create '????????.???'. . .                                 
|        expl.: If you're working on a floppy drive, the disk may be          
|               write protected. Perhaps the file already exists and          
|               it's attribute is read-only.                                  
|                                                                             
|         ERRORS                                                            
|                                                                             
|        Undefined command!                                                   |
:        expl.: You used the a unrecognized command. Check the spelling of the|
:               command.                                                      |
:                                                                             |
:        Undefined '$' command!                                               |
:        expl.: You used the a unrecognized '$' command. Check the spelling of|
:               the command.                                                  |
:                                                                             |
:        You did not close the open file!                                     |
:        expl.: You used the + command, but not the - command.                |
:                                                                             |
:        Open a file first!                                                   |
:        expl.: You use a >,|," or ' option, but you did not open a file.     :
|                                                                             :
|        Incorrect format!                                                    :
|        expl.: This can occure with different commands. For example the      :
|               >XXXX:YYYY or $ren:X>Y etc.                                   :
|               ( Check the spelling ).                                       :
|                                                                             :
|        Maximum of one footer exceeded!                                      |
|        expl.: You have used the * command more than once.                   |
|                                                                             |
|        Invalid length, must be even!                                        |
        expl.: You've used the ' command, but made a type mismatch. Each     |
               instructions is based on byte length.                         |
               So: mov ax is translated as 0xB8. The hex value of B8 is      
                   one byte long. If the originale is 0x38 and you want to   
                   change it into 0xB8, you may not write 'B, but you must   
                   write 'B8.                                                
                                                                             
        No file(s) open to close!                                            
        expl.: You've used the '-' command, but did not open a file. Well,   
               most of the time you're just forgotten to open one, so thats  
               way I made it as an error, which will stop the compiler.      
                                                                             
        Byte value needed!                                                   
        expl.: You've used the =... command, but did not gave a byte as      
              compare value. The value must be hex.                          
                                                                             
        Open a file with +... first!                                         
        expl.: You've used the =... command, but did not open the file       
               in the read/write/append mode. You must open a file with '... 
                                                                             
        Incorrect attribute format!                                          
        expl.: You've tried to change a file attribute, but did not use the  
               correct command notation.                                     
               The notation is: &RHS:... where ... stands for the filename.  
                                                                             
        Error in draw routine!                                               
        expl.: Check the format of the given draw command.                   
                                                                             
        Error in draw data!                                                  
        expl.: Your included file has an incorrect format.                   
                                                                             
        Included draw file not found!                                        
        expl.: The file you wanted to use as ANSI screen is not found.       
                                                                             
        Incorrect included data size!                                        
        expl.: The ansi/ascii paint routine has found a filesize mismatch.   
               If you've written w:10 and h:10, the filesize must be         
               10*10*2=200 bytes.                                            
                                                                             
        Incorrect value entered!                                             
        expl.: The $num or $cap routine did not found a valid 'ON' or 'OFF'  
               string.                                                       
                                                                             
        Include file not found!                                              
        expl.: The specified $inc:<file> is not found.                       
                                                                             
        Include file cannot be nested!                                       
        expl.: In your used $inc:... file stands the $inc:... command.       
               Include files may not be nested.                              
                                                                             
        Maximum numbers of variables exceeded!                               
        expl.: You used the ?... command to many times.                      
                                                                             
        Duplicate variable name used!                                        
        expl.: A variable must be unique. If you have used a command like    
               ?String in your script and further on in the script you use   
               the ?String command again you'll created an multiple          
               declaration of the variable %String%. In this case you'll     
               better use ?String1 and ?String2 for unique identification.   
                                                                             
        Use after $REP:X a single { line!                                    
        expl.: Use the correct layout for the $REP command.                  
                                                                             
        You did not finish a loop!                                           
        expl.: The code $REP:X <nl> { is used, but no } command was found.   
                                                                             
        Fontfile not found!                                                  
        expl.: The $FNT:... command is used, but the ... file was not found. 
                                                                             
         WARNINGS                                                          
                                                                             
        You already switched to a full windowed dos box!                     
        expl.: You used the $fdb more than once. Doing this will not harm    
               the functionality of your program, but is quite useless       
                                                                             
        '$'-sign is used!                                                    
        expl.: The '$'-sign is used by DOS as end of line charakter. The     
               warning only occurs with the @... and the @~xx:... commands.  
                                                                             
-- -             - -Ĵ
                                                                             
 PCOM is ment to create independent executables, so it may be clear that     
 all commands are supported for building executables. The .ASM support is    
 just a feature of PCOM.                                                     
                                                                             
               Command     .ASM support   Variable support                   
               ;...              Y               n/a                         
               @...              Y                Y                          
               @~xx:...          n                n                          
               +...              Y                Y                          
               #...              Y                Y                          
               .                 n               n/a                         
               -                 Y               n/a                         
               >xxxx:xxxx        Y                n                          
               |xxxx:xxxx        Y                n                          
               )                 Y               n/a                         
               (                 Y               n/a                         
               "...              Y                Y                          
               '...              Y                n                          
               *...             n/a              n/a                         
               =...              n                n                          
               ?...              n               n/a                         
               !...:...          n                n                          
|               &RHS:...          n                n                          
|               $key              Y               n/a                         |
|               $snd              Y               n/a                         |
|               $con              Y               n/a                         |
|               $cof              Y               n/a                         |
|               $cls              Y               n/a                         |
               $chr              Y               n/a                         |
               $chl              Y               n/a                         
               $lck              Y               n/a                         
               $y/n              Y               n/a                         
               $sbd              Y               n/a                         
               $prn              Y               n/a                         
               $fdb              Y               n/a                         
               $dsk:x            Y               n/a                         
               $ccs:xx           Y               n/a                         
               $cur:x,y          Y               n/a                         
               $ren:x>y          Y                n                          
               $cdr:...          Y                n                          
               $rdr:...          Y                n                          
               $mdr:...          Y                n                          
               $del:...          Y                n                          
               $num:...          Y               n/a                         
               $cap:...          Y               n/a                         
               $slp:...          Y               n/a                         
               $inc:...         n/a              n/a                         
               $run:...          n                n                          
               $far:xx>yy        n                n                          
               $sound:x,y        n                n                          
               $nosound          Y               n/a                         
                                                                             
 Y=Yes, this is supported, n=Nope, this is NOT supported, n/a=This would be  
 useless, so it's not available.                                             
                                                                             
-- -             - -Ĵ
                                                                             
 To find the right spot to patch can be difficult sometimes, because of the  
 fact that some programs are exe-compressed. There are some programs         
 available which are able to decompress the compressed files. Some names of  
 these programs: Unp, Tron, Sbust etc... But you can do it yourself, if      
 you're a programmer of course, by using int 21h function 4bh and AL loaded  
 with 01h. Step until the decompression routine is done and write down the   
| decompressed program.                                                       
|                                                                             
| This problem is less difficult if you want to patch your own product. You   
| can change a particular piece of the source and recompile it. Now the only  
| thing you have to do is to find the differences ( using DOS fc ) and write  |
| a script file.                                                              |
|                                                                             |
| If you want to add a part to your .EXE/.COM you can use to MicroSoft        |
| methode used with the DOS 6.0 -> 6.2 upgrade. Here is the idea:             |
|                                                                             |
|        Original code (hex):                                                 |
|                                                                             |
:        xor       dx,dx          ; some code                                 |
:        call      3432:3423      ; get dos version                           |
:        jne       4e             ; jump not equal                            :
:        mov       ax,es[54]      ; more code                                 :
:        ...                      ;                                           :
:        mov       ax,4c00        ; back to dos                               :
:        int       21h                                                        :
:                                                                             :
:        New code (hex):                                                      :
:                                                                             :
|        xor       dx,dx          ; some code                                 :
|        call      4444:5555      ; overwitten new call                       :
|        jne       4e             ; jump not equal                            |
|        mov       ax,es[54]      ; more code                                 |
|        ...                      ;  ,,   ,,                                  |
|        mov       ax,es[54]      ; back to dos                               |
|    4444:5555:                                                               |
|        call      3432:3423      ; get dos version                           |
|        pushf                    ; save flags                                |
        mov       ah,9           ; new code                                  |
        ...                      ;  ,,  ,,                                   
        rol       cx,3           ;  ,,  ,,                                   
        popf                     ; restore flags                             
        ret                      ; return to original position               
                                                                             
-- -             - -Ĵ
*****************************************************************************
* WELL, FINALLY, I'M NOT RESPONSABLE FOR ANY DAMAGE DONE USING PCOM AND I'M *
*            NOT RESPONSABLE FOR THE PROGRAMS MADE WITH PCOM!               *
*****************************************************************************
-- -             - -Ĵ
                                                                             
                                                                             
-- -             - -Ĵ
                                                                             
          You can try to contact me at the following ExEd! address:          
|                                                                             |
|                                 exed@dds.nl                                 |
:                                                                             :
:                    Scripts and updates can be found at:                     :
|                                                                             |
|                         http://huizen.dds.nl/~exed/                         |
|                                                                             |
                            HQ:::The Netherlands                             
                                                                             
-- -             - -Ĵ
                                                                             
                                                                             
-- -             - -Ĵ
                                                                             
|                                  GreetZ                                     |
                             Edward C Willemsen                              
Ŀ              -  ExEd!  -             
                                       --ķ
 --- --Ľ
 ---                           ---ķ
 --- --Ľ
     Ľ

                                  1998 (c++)

