home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 2: PC / frozenfish_august_1995.bin / bbs / d09xx / d0957.lha / PARex / PARex.doc < prev    next >
Text File  |  1993-11-24  |  80KB  |  1,985 lines
  2.                   __
  3.                  / ////
  4.           __    ///
  5.           \ \  ///          < < <<<  PARex v3.00  >>> > >
  6.            \ \///
  7.             \__////        USER MANUAL - Release : 22-Nov-93
  8.  
  9.                  Copyright ⌐1991-1993 Chris P. Vandierendonck, [AmiSYS].
  10.  
  11.        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  12.  
  13.        Copyright Notice
  14.        ~~~~~~~~~~~~~~~~
  15.          PARex is released  as  SHAREWARE, not excluding the copyright and
  16.          all  other  rights,  which  remain  with  the  author  Chris   P.
  17.          Vandierendonck. If you use  PARex then you must pay the shareware
  18.          fee and register. 
  19.  
  20.          Prior  written  permission  from  the  author  is   required   to
  21.          distribute  PARex  and  to  use  PARex in commercial releases, on
  22.          shareware disks, coverdisks or diskmagazines.  When  distributed,
  23.          all files must be kept together,  in  their  original  unmodified
  24.          form.
  25.  
  26.          (AmigaDOS and Workbench are trademarks of Commodore Amiga Inc.)
  27.  
  28.        Disclaimer
  29.        ~~~~~~~~~~
  30.          PARex  is provided "AS IS", WITHOUT ANY WARRANTY to its  quality,
  31.          performance or fitness for a  particular  purpose.  In  no  event
  32.          shall the author be liable or responsible  to  the  user  or  any
  33.          other person, for any kind of damage caused by the  use  of  this
  34.          software.
  35.  
  36.          Shareware registration,  suggestions,  remarks  and  bug  reports
  37.          about this program can be send to the following address :
  38.  
  39.               Chris Vandierendonck
  40.               Koning Albertstraat 188
  41.             B-8210   VELDEGEM
  42.               BELGIUM
  43.  
  44.        SHAREWARE information
  45.        ~~~~~~~~~~~~~~~~~~~~~
  46.          This DEMO  version  of  PARex only processes the first 4096 bytes
  47.          of the source file!! To receive the unlimited  version  you  must
  48.          pay  the  shareware  fee of 15 US dollars (DEM 20 or GBP 10). The
  49.          ModulaII source code is also available,  see  the  "RegForm"  for
  50.          more info.
  51.  
  52.          If possible, use a printout  of  the  'RegForm' file to register.
  53.          Send this  form  along  with  the  shareware  fee  to  the  above
  54.          address. You can send the money in  cash  (fastest  and  cheapest
  55.          way),  or  by  (international)  money  order  payable  to   Chris
  56.          Vandierendonck. (DO NOT send  bankcheques,  since  they  are  too
  57.          expensive to clear!)
  58.  
  59.  
  60.  
  61.  
  62.  
  63.  
  64.                                           PARex v3.0x User Manual - Page 1
  65.  
  66.        Preface
  67.        ~~~~~~~
  68.          PARex is a program to replace certain  strings  in  a  file.  The
  69.          result can be saved to any file, or  back  to  the  source  file.
  70.          PARex takes its replace data from the  command  line  or  from  a
  71.          script file (here an unlimited number of replace strings  can  be
  72.          defined). Generally  PARex will be used on text files, but binary
  73.          files can also be processed.
  74.  
  75.          The  power  of  PARex is found in its data script. Here  you  can
  76.          define as many replace strings as  you  want.  By  which  strings
  77.          they should be replaced, can  depend  on  commands  used  on  the
  78.          command line. You can  divide  the  script  into  several  parts,
  79.          which can then be selected at startup.
  80.  
  81.          PARex can be  used  to  replace  strings  in  (text)files,  strip
  82.          comments  from  source  code,  convert  files  between  different
  83.          computer systems, discard all  print  control  sequences  from  a
  84.          text file, convert an  AmigaGuide  file  to  a  normal  textfile,
  85.          etc... 
  86.  
  87.          PARex is reentrant, so it can be made resident. During  execution
  88.          you can terminate PARex by pressing 'CTRL-C'.
  89.  
  90.        System Requirements
  91.        ~~~~~~~~~~~~~~~~~~~
  92.          PARex requires AmigaDOS v1.2 or higher to "perform".  
  93.  
  94.        Program Usage  (Shell/CLI only)
  95.        ~~~~~~~~~~~~~
  96.         ("?" gets the program format, and "⌐" the program's copyright  and
  97.          version.)
  98.  
  99.        [[FROM] <file|dir|pat>] [[TO] <file|dir>] [CONVERT]  [PRT|PAR|SER]
  100.        [NOSCRIPT] [SCRIPT <file[.pxs]>] [GLOBAL] [MODE <name|pat]>] [ALL]
  101.        [READ <#bytes>] [TOUCH <#bytes>] [BUFFER <#bytes>]  [LOAD]  [STAT]
  102.        [HEXDUMP [<fmtstr>]] [CASECHECK] [UCASE] [LCASE]  [TRACE] [SILENT]
  103.        [NOVERSION]
  104.  
  105.        [WHEN <name|pat>] [CAP|DECAP] [WILD] [CONTEXT] [NEST] [FIT] [ZERO]
  106.        [MINSIZE <#bytes>] [MAXSIZE <#bytes>] [LEFTFILL|RIGHTFILL <0.255>]
  107.        [TIMES <#>] [EVERY <#>] [AFTER <#>] [WORD]
  108.  
  109.        [[{] INIT  <str> [<cmds> }]]          [[{] CLOSE <str> [<cmds> }]]
  110.        [[{] REPL  <str> BY <str> [<cmds> }]] [[{] CAP   <str> [<cmds> }]]
  111.        [[{] STRIP <str> TO <str> [<cmds> }]] [[{] DECAP <str> [<cmds> }]]
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120.  
  121.  
  122.  
  123.  
  124.  
  125.  
  126.  
  127.  
  128.                                           PARex v3.0x User Manual - Page 2
  129.  
  130.        TABLE OF CONTENTS
  131.        ~~~~~~~~~~~~~~~~~
  132.        1. Source and destination file ................................  3
  133.           1.1. Source file/directory .................................  3
  134.           1.2. Destination file/directory ............................  3
  135.           1.3. Advanced options ......................................  5
  136.                1.3.1. Reading part of the source file ................  5
  137.                1.3.2. Writing directly into the source file ..........  5
  138.                1.3.3. Buffer sizing ..................................  6
  139.  
  140.        2. Global converting options ..................................  7
  141.           2.1. Hexadecimal output ....................................  7
  142.           2.2. Case conversion .......................................  8
  143.  
  144.        3. Program information ........................................  9
  145.           3.1. Before processing .....................................  9
  146.           3.2. During processing .....................................  9
  147.           3.3. After processing ......................................  9
  148.           3.4. Suppressing information ............................... 10
  149.  
  150.        4. Main replace commands ...................................... 11
  151.           4.1. INIT  : inserting a string at the beginning of a file . 11
  152.           4.2. CLOSE : adding a string to the end of a file .......... 12
  153.           4.3. REPL  : replacing one string by another ............... 12
  154.           4.4. STRIP : removing characters between two strings ....... 13
  155.           4.5. CAP   : putting found string in upper case ............ 14
  156.           4.6. DECAP : putting found string in lower case ............ 14
  157.           4.7. Formatting of the searchStr and replStr ............... 14
  158.  
  159.        5. Search control ............................................. 17
  160.           5.1. Case-sensitive searching .............................. 17
  161.           5.2. Wildcard searching .................................... 17
  162.           5.3. Context remembering ................................... 18
  163.           5.4. Word-only searching ................................... 19
  164.  
  165.        6. Program variables .......................................... 20
  166.           6.1. PARex information ..................................... 20
  167.           6.2. Inserting files ....................................... 20
  168.           6.3. Inserting date and time ............................... 21
  169.           6.4. Inserting path and name of source & destination file .. 22
  170.  
  171.        7. Using PARex data scripts ................................... 23
  172.           7.1. Setting up scripts .................................... 23
  173.           7.2. Script commands ....................................... 23
  174.           7.3. Script options ........................................ 24
  175.  
  176.        8. Additional sub-commands .................................... 26
  177.           8.1. Limit replacing ....................................... 26
  178.           8.2. Defining the size of the replace string ............... 26
  179.           8.3. Case conversion ....................................... 28
  180.           8.4. Making sub-commands to work on all main-commands ...... 28
  181.         
  182.        9. Option reference ........................................... 29
  183.  
  184.        10. Command reference ......................................... 30
  185.            10.1. Main commands ....................................... 30
  186.            10.2. Sub-Commands ........................................ 30
  187.            10.3. Script Commands ..................................... 30
  188.  
  189.        11. Variables ................................................. 31
  190.  
  191.  
  192.                                           PARex v3.0x User Manual - Page 3
  193.  
  194.        1. Source and destination file.
  195.  
  196.        1.1. Source file/directory.
  197.  
  198.          Option: [FROM] <file|dir|pattern>
  199.  
  200.           ╗ This  is  the  file  to  be converted. You can also specify  a
  201.             directory, which implicates that all files of  that  directory
  202.             will   be   processed.   If   you   don't   give   a    source
  203.             file/directory,  then  PARex will process  all  files  in  the
  204.             current directory!
  205.  
  206.           ╗ A pattern can be given in order to only process  certain  file
  207.             of  a  given  directory  or  of  the  current  directory.  The
  208.             following  wildcards  are  supported  : "#", "?", "*" (same as
  209.             "#?"),  "'"  and  "|"  (refer  to   your Amiga  systemsoftware
  210.             manual for more information on these wildcards).
  211.  
  212.               | 'PARex RAM:T/*.doc|*.txt' -> only  process  files  in  the
  213.               | "RAM:T" directory with the ".doc" or ".txt" suffix.  
  214.  
  215.           ╗ The FROM keyword is optional. 
  216.  
  217.        !! ╗ If no source file  is  given,  then  PARex  will  process  all
  218.             files of the current directory!
  219.  
  220.          NOTE: the source files can  be  plain  text  files,  as  well  as
  221.                binary files, such as programs. 
  222.  
  223.  
  224.        1.2. Destination file/directory.
  225.  
  226.          WARNING: only one of the following  destination  options  can  be
  227.                   used.
  228.  
  229.          Option: [TO] <file|dir>  
  230.  
  231.           ╗ This is the destination (target)  file.  It's  the  result  of
  232.             the  converting  process.  As  with  the  source   file,   you
  233.             can also specify a directory in which to  save  the  converted
  234.             files.
  235.  
  236.           ╗ If  no  target  file/directory  is  given  (and  [CONVERT]  or
  237.             [TOUCH] isn't used), then the target  file(s)  will  have  the
  238.             same  name  as  the  source  file(s)  except  for  the  ".prx"
  239.             suffix.
  240.  
  241.        !! ╗ The TO keyword is optional, provided a source  name  has  been
  242.             given before this option.
  243.  
  244.           NOTE: the   file   attributes   (protection   flags)   of    the
  245.                 sourcefile(s)  are   preserved.   In   other   words   the
  246.                 destination file(s)  have  the  same  file  attributes  as
  247.                 their source file.
  248.  
  249.           TIP: use "*" to output processed file to the Shell window.
  250.  
  251.                  | ' PARex RAM:source * ' 
  252.                  | Will dump the RAM:source file to the Shell window. 
  253.  
  254.  
  255.  
  256.                                           PARex v3.0x User Manual - Page 4
  257.  
  258.          Option: CONVERT  
  259.  
  260.           ╗ With this option the source itself will be  converted.  To  do
  261.             this  PARex works as follows, first the results are  saved  to
  262.             a new file. When the processing is finished, the  source  file
  263.             is deleted and the  newly  created  file is renamed as the old
  264.             source file. 
  265.  
  266.           ╗ Since  PARex works in this way, you can safely  terminate  the
  267.             converting process with  CTRL-C.  Your  original  source  file
  268.             will still be intact!
  269.  
  270.          Option: PRT|PAR|SER 
  271.  
  272.           ╗ One  of  these  option  keywords  sends  the  output  to   the
  273.             printer: - PRT uses "PRT:" to output;
  274.                      - PAR uses "PAR:" to output;
  275.                      - SER uses "SER:" to output.
  276.  
  277.           ╗ You must use one of the last two if  your  text  contains  raw
  278.             printer commands, which only your printer understands.
  279.  
  280.        1.3. Advanced options.
  281.  
  282.        The options discussed in the following  points,  are  intended  for
  283.        more advanced users, who know what they're doing.
  284.  
  285.        1.3.1. Reading part of the source file.
  286.  
  287.          Option: READ <# bytes>
  288.  
  289.           ╗ The  READ  option  forces  PARex to  only  process  the  given
  290.             number of bytes of the source file.
  291.            
  292.                | ' PARex RAM:source READ 500 REPL a BY b '
  293.                | In this case PARex  will  only  read  500  bytes  of  the
  294.                | source file 'RAM:source', convert all  a's  to  b's,  and
  295.                | write the result to 'RAM:source.prx'.
  296.  
  297.           WARNING: don't ever use an  option  which  writes  back  to  the
  298.                    source file, unless you know  what  you're  doing.  The
  299.                    rest of your source file will definitely be lost!
  300.  
  301.        1.3.2. Writing directly into to the source file.
  302.  
  303.          Option: TOUCH <# bytes>
  304.  
  305.           ╗ This option is intended to convert only  a  small  section  at
  306.             the beginning of a large file, without having to  process  the
  307.             whole  file.  PARex will  read  the  given  number  of  bytes,
  308.             process them, and write back the same amount of bytes!
  309.  
  310.                | ' PARex RAM:source TOUCH 500 REPL a BY b '
  311.                | In this case PARex will read 500 bytes  from  the  source
  312.                | file, convert all  a's  to  b's  and  write  exactly  500
  313.                | bytes back to the  source  file! This means, that all a's
  314.                | in the first 500 bytes of  the  file  will  be  b's  now,
  315.                | while the rest still remain a's. 
  316.  
  317.  
  318.  
  319.  
  320.                                           PARex v3.0x User Manual - Page 5
  321.  
  322.           ╗ An example of the use of the TOUCH  option  can  be  found  in
  323.             the  program  script  "AutoVERS". This script was  written  to
  324.             install  a  header  at  the  beginning  of   a   source   file
  325.             (ModulaII, Oberon, C, Assembler, ARexx  or  AmigaDOS).  Before
  326.             each compilation  of  the  source  file,  AutoVERS can then be
  327.             called again to update the header. 
  328.  
  329.           NOTE: PARex will always write the same amount of bytes  back  to
  330.                 the source file, as it has read in the first place!
  331.  
  332.           WARNING: only use this option if you really know what  PARex  is
  333.                    going to do!
  334.  
  335.        1.3.3. Buffer sizing.
  336.  
  337.          Option: BUFFER <# bytes>
  338.  
  339.           ╗ By default, PARex uses 4096 bytes for each  buffer  it  needs.
  340.             With this option one can enlarge the size  of  these  buffers,
  341.             as far as memory allows you to.  If  you're  a  harddisk  user
  342.             then this option really doesn't speed up processing. 
  343.  
  344.           ╗ If PARex can't allocate the desired size, then  it  will  fall
  345.             back to the default size of 4096 bytes.
  346.  
  347.           ╗ The following buffers are affected :
  348.              - the read buffer (stores source file; always present)
  349.              - the write buffer (only used if replace commands are used)
  350.              - the hexdump write buffer (only used if HEXDUMP is used)
  351.              - the insert file buffer (only used if &FILE:& is used)
  352.              - the context buffer (only used if CONTEXT is used)
  353.  
  354.          Option: [LOAD]
  355.  
  356.           ╗ This option forces PARex to load the entire source  file  into
  357.             memory, and thus to speed up the processing in case  of  large
  358.             files. If memory doesn't allow  this,  then  PARex  will  fall
  359.             back on the default buffer size. 
  360.  
  361.           NOTE: Using this option is recommended for  floppy  disk  users,
  362.                 and certainly when wildcard searching is needed.
  363.  
  364.  
  365.  
  366.  
  367.  
  368.  
  369.  
  370.  
  371.  
  372.  
  373.  
  374.  
  375.  
  376.  
  377.  
  378.  
  379.  
  380.  
  381.  
  382.  
  383.  
  384.                                           PARex v3.0x User Manual - Page 6
  385.  
  386.        2. Global converting options.
  387.  
  388.        2.1. Hexadecimal output.
  389.  
  390.          Option: HEXDUMP [<fmtstr>]
  391.  
  392.           ╗ Using   this   option   will   result   in    a    hexadecimal
  393.             representation of the processed file. You  can  do  everything
  394.             as if  HEXDUMP  wasn't  used,  since  PARex will only save the
  395.             processed bytes in a hexadecimal text  just  before  it  saves
  396.             them to the destination file. 
  397.  
  398.           ╗ If no format string is given, then the  (default)  hexadecimal
  399.             output will look something like this:
  400.  
  401.            00000000: E3100001 00000000 001B000F 004D0012 πññññññññññññMññ
  402.            00000010: 00060003 000107C6 DF0007C6 E1080000 ñññññññ╞▀ññ╞ßñññ
  403.            00000020: 00000000 00000000 00000000 00000001 ññññññññññññññññ
  404.            00000030: 01180000 00000000 00000000 00170000 ññññññññññññññññ
  405.            00000040: 000707C6 98A00000 00000000 00000000 ñññ╞ñáññññññññññ
  406.            00000050: 0015016A 003FFFFF 00000000 0200127F ñññjñ?  ñññññññ
  407.            00000060: 0029AEF2 00000000 0026115C 00000000 ñ)«≥ñññññ&ñ\ññññ
  408.            ...
  409.  
  410.           ╗ One can change  the  format  of  this  output  by  defining  a
  411.             formatstring, using the following codes:  
  412.  
  413.               %Px : byte position, where x is the width [1..8]
  414.  
  415.               %Bx : byte value where 'x' is number of bytes on one line
  416.               %Wx : word value where 'x' is number of words on one line
  417.               %Lx : long value where 'x' is number  of  longwords  on  one
  418.                     line
  419.  
  420.               %Ax : ASCII text, where 'x' is the value of the character
  421.                     used to represent non-printable characters
  422.  
  423.               NOTE: the  value  'x'  can  be  given  in  decimal  (can  be
  424.                     introduced by "\d"), in hexadecimal  (introduced  with
  425.                     "\x") or in octal (introduced with "\o") notation! 
  426.  
  427.               NOTE: the formatting codes are interpreted case-sensitive!
  428.                
  429.           ╗ The used default format looks like : "%P8: %L4 %A\d164"
  430.  
  431.           ╗ A  format  string  like  "%W5 \"%A\d186\" :%P4" would give the
  432.             following output: 
  433.  
  434.                E310 0001 0000 0000 001B "π║║║║║║║║║" :0000
  435.                000F 004D 0012 0006 0003 "║║║M║║║║║║" :000A
  436.                0001 07C6 DF00 07C6 E108 "║║║╞▀║║╞ß║" :0014
  437.                0000 0000 0000 0000 0000 "║║║║║║║║║║" :001E
  438.                0000 0000 0000 0001 0118 "║║║║║║║║║║" :0028
  439.                0000 0000 0000 0000 0000 "║║║║║║║║║║" :0032
  440.                0017 0000 0007 07C6 98A0 "║║║║║║║╞║á" :003C
  441.                0000 0000 0000 0000 0000 "║║║║║║║║║║" :0046
  442.                0015 016A 003F FFFF 0000 "║║║j║?  ║║" :0050
  443.                ...
  444.  
  445.  
  446.  
  447.  
  448.                                           PARex v3.0x User Manual - Page 7
  449.  
  450.        2.2. Case conversion.
  451.  
  452.        The following two options affect all bytes saved to a file. 
  453.  
  454.          Option: UCASE
  455.  
  456.           ╗ This option will convert all bytes to upper case characters.
  457.  
  458.          Option: LCASE
  459.  
  460.           ╗ This option will convert all bytes to lower case characters.
  461.  
  462.          WARNING: don't use these options on binary files, since not  only
  463.                   text will be affected, but also the programming code!
  464.  
  465.  
  466.  
  467.  
  468.  
  469.  
  470.  
  471.  
  472.  
  473.  
  474.  
  475.  
  476.  
  477.  
  478.  
  479.  
  480.  
  481.  
  482.  
  483.  
  484.  
  485.  
  486.  
  487.  
  488.  
  489.  
  490.  
  491.  
  492.  
  493.  
  494.  
  495.  
  496.  
  497.  
  498.  
  499.  
  500.  
  501.  
  502.  
  503.  
  504.  
  505.  
  506.  
  507.  
  508.  
  509.  
  510.  
  511.  
  512.                                           PARex v3.0x User Manual - Page 8
  513.  
  514.        3. Program information.
  515.  
  516.        3.1. Before processing.
  517.  
  518.        Before  PARex starts processing a file,  it  prints  the  following
  519.        information :
  520.  
  521.           - name of the used PARex script (<none> if none used);
  522.           - name of the used script mode(s) (<none> if none used);
  523.           - 'GLOBAL' if the GLOBAL mode was also used;
  524.           - number of replace commands used (0..x);
  525.           - 'I' if a INIT command is used;
  526.           - 'C' if a CLOSE command is used.
  527.  
  528.        Maybe this information seems a bit strange to you  now,  but  later
  529.        everything will become clear.
  530.  
  531.        3.2. During processing.
  532.  
  533.          Option: TRACE
  534.  
  535.           ╗ By  default   PARex  doesn't  output  any  information  during
  536.             processing of the source file. Using this  option  will  force
  537.             PARex to output how many percent of the  source  file  already
  538.             has been processed.
  539.  
  540.           TIP: using TRACE will  keep  your  mind  at  rest,  seeing  that
  541.                PARex is doing some heavy duty for you!
  542.  
  543.           NOTE: most   of   the   program   scripts   supplied   in    the
  544.                 "ParexScripts" directory use the TRACE option.
  545.  
  546.        3.3. After processing.
  547.  
  548.          After  PARex has finished with processing the  source  file,  the
  549.          following information is given: 
  550.  
  551.            - number of bytes used by the destination file;
  552.            - number of replacements done on the file.
  553.  
  554.          Option: STAT
  555.  
  556.           ╗ Users  who  want  more  detailed  information  can  use   this
  557.             option. The following information is then given:
  558.  
  559.             * General info: 
  560.                - number of ticks and seconds PARex needed;
  561.                - size of the source and  the  destination  file,  as  well
  562.                  as the difference between the two sizes.
  563.  
  564.             * Command info:
  565.                - number of REPL  commands  used,  and  percentage  of  the
  566.                  total number of replacements; 
  567.                - number of STRIP commands used, and percentage of total;
  568.                - number of CAP commands used, and percentage of total;
  569.                - number of DECAP commands used, and percentage of total.
  570.  
  571.             * Variable info:
  572.                - number of &FILE& variables used;
  573.                - number of &TIME& variables used;
  574.  
  575.  
  576.                                           PARex v3.0x User Manual - Page 9
  577.  
  578.                - number of &SRCPATH& variables used;
  579.                - number of &SRCNAME& variables used;
  580.                - number of &DSTPATH& variables used;
  581.                - number of &DSTNAME& variables used.
  582.  
  583.        3.4. Suppressing information.
  584.  
  585.          Option: NOVERSION
  586.  
  587.           ╗ Suppresses the output of the programs  copyright  and  version
  588.             prompt.
  589.  
  590.          Option: SILENT
  591.  
  592.           ╗ All program  messages  are  suppressed  when  this  option  is
  593.             selected. In other words, TRACE or STAT won't work.
  594.  
  595.  
  596.  
  597.  
  598.  
  599.  
  600.  
  601.  
  602.  
  603.  
  604.  
  605.  
  606.  
  607.  
  608.  
  609.  
  610.  
  611.  
  612.  
  613.  
  614.  
  615.  
  616.  
  617.  
  618.  
  619.  
  620.  
  621.  
  622.  
  623.  
  624.  
  625.  
  626.  
  627.  
  628.  
  629.  
  630.  
  631.  
  632.  
  633.  
  634.  
  635.  
  636.  
  637.  
  638.  
  639.  
  640.                                          PARex v3.0x User Manual - Page 10
  641.  
  642.        4. Main replace commands.
  643.  
  644.        Currently  PARex supports several replace commands. But  before  we
  645.        start with explaining them some words on used terms:
  646.  
  647.          - main command: refers to the following replace  commands:  INIT,
  648.                          CLOSE, REPL, STRIP, CAP, DECAP.
  649.                          As many of these commands  can  be  used  on  the
  650.                          command line as AmigaDOS allows. If you  need  to
  651.                          use many commands than it's better  to  create  a
  652.                          PARex script, which may contain as  many  as  you
  653.                          need. When no replace  commands  are  used,  then
  654.                          PARex will just copy the source file!
  655.  
  656.                          NOTE: the order  in  which  you  enter  different
  657.                                replace commands is important, since  PARex
  658.                                will always start searching with the  first
  659.                                one,  then  the  second,  and  so  on.  The
  660.                                replace commands  entered  on  the  command
  661.                                line, are used before the ones in the  data
  662.                                scripts! In other  words,  first  found  is
  663.                                first served! This hierarchy doesn't  apply
  664.                                to INIT and CLOSE.
  665.  
  666.          - sub command : a command that can only be used in relation  with
  667.                          a  main  command.  A  sub-command  redirects  the
  668.                          working of the main command. These  commands  are
  669.                          explained throughout this manual.
  670.  
  671.                          NOTE: as  a  general  rule,  always  enclose  the
  672.                                main-command and its  sub-commands  between
  673.                                curly brackets ("{"   &  "}")  if  you  use
  674.                                them on the command line. 
  675.  
  676.          - searchStr   : the string (text or other) PARex has to find.
  677.  
  678.          - replStr     : the string  which  comes  in  the  place  of  the
  679.                          searchStr. The  replStr  can  also  be  an  empty
  680.                          string, which is then defined as ' "" '!
  681.  
  682.        When describing the main commands, examples  will  be  given  where
  683.        the searchStr and/or the replStr will contain strange codes.  These
  684.        codes are later explained in point 4.7.
  685.  
  686.        4.1. INIT : inserting a string at the beginning of a file.
  687.  
  688.          Command: INIT <str>
  689.  
  690.           ╗ This command will put the <str> at the very beginning  of  the
  691.             destination file. Only  when  this  string  has  been  written
  692.             will  PARex commence with the actual processing of the  source
  693.             file.
  694.  
  695.               | ' PARex ram:source INIT "I will be the first line!" '
  696.               | The ram:source.prx (destination) file  will  be  the  same
  697.               | as the source file, except that the given string  will  be
  698.               | the first line.
  699.  
  700.           NOTE: this command is only used once!
  701.  
  702.  
  703.  
  704.                                          PARex v3.0x User Manual - Page 11
  705.  
  706.           WARNING: when this command is used on  the  command  line,  then
  707.                    any such commands in a used data script are ignored.
  708.  
  709.          Sub-cmds: [CAP|DECAP] [MINSIZE <# bytes>] [MAXSIZE <# bytes>]
  710.                    [LEFTFILL|RIGHTFILL <0..255>]
  711.  
  712.        4.2. CLOSE : adding a string to the end of a file.
  713.  
  714.          Command: CLOSE <str>
  715.  
  716.           ╗ This  command  will  append  the  <str>  at  the  end  of  the
  717.             destination  file.  Thus  only  after  PARex has finished with
  718.             the source file, will this string be written.
  719.  
  720.               | ' PARex ram:source PRT CLOSE \f '
  721.               | After the source file has been  send  to  the  printed,  a
  722.               | page-eject code will be send.
  723.  
  724.           NOTE: this command is only used once!
  725.  
  726.           WARNING: when this command is used on  the  command  line,  then
  727.                    any such commands in a used data script are ignored.
  728.  
  729.          Sub-cmds: [CAP|DECAP] [MINSIZE <# bytes>] [MAXSIZE <# bytes>]
  730.                    [LEFTFILL|RIGHTFILL <0..255>]
  731.  
  732.        4.3. REPL : replacing one string by another.
  733.  
  734.          Command: REPL <str> BY <str>
  735.  
  736.           ╗ This command searches for  the  first  <str>,  and  if  found,
  737.             replaces it with the second <str>.
  738.  
  739.               | ' PARex ram:source REPL hello BY hi '
  740.               | All "hello" strings will be  replaced  by  hi.  Note  that
  741.               | "hello" is search non-case sensitive  here.  If  you  only
  742.               | want to replace  "hello"  and  not  "HeLLo"  for  example,
  743.               | then use the CASECHECK option.
  744.  
  745.          Sub-cmds: [OR <str> WHEN <name>] [WILD] [WORD] [CONTEXT] 
  746.                    [TIMES <#>] [EVERY <#>] [AFTER <#>] [CASE] [NOCASE]
  747.                    [FIXCASE] [CAP|DECAP] [FIT] [ZERO] 
  748.                    [MINSIZE <# bytes>] [MAXSIZE <# bytes>]
  749.                    [LEFTFILL|RIGHTFILL <0..255>]
  750.  
  751.          Sub-cmd: OR <str> WHEN <name>
  752.  
  753.           ╗ This sub-command is only of use when the REPL  is  used  in  a
  754.             script (see chapter 7 on the use of scripts).  It  enables  us
  755.             to  define  two  replStr's.  The  second replStr, which is the
  756.             <str> after the OR keyword, will  only  be  used  (instead  of
  757.             the first <str>), if  the  name  given  with the WHEN (command
  758.             line) option, matches the WHEN name of this sub-command.
  759.  
  760.             Look at the program format again, which  was  printed  at  the
  761.             beginning of this  manual.  There  you'll  see  the  following
  762.             option: [WHEN  <name|pattern>]. It's with this option that  we
  763.             can decide if we're going to use the  second  replStr.  We  do
  764.             this by entering a name, or  a  pattern.  This  name  is  then
  765.             compared with the name  given  in  the  WHEN  sub-command.  If
  766.  
  767.  
  768.                                          PARex v3.0x User Manual - Page 12
  769.  
  770.             they match then the  second  replStr  is  used,  if  not,  the
  771.             first is used.
  772.  
  773.               | ' REPL hello BY hi OR bye WHEN quit '
  774.               | If we just use ' PARex ram:source ' then "hello" will be
  775.               | replace by "hi".
  776.               |  But  if  we   use   ' PARex ram:source WHEN quit ',  then
  777.               | "hello" will be replaced by "bye" and not by "hi"! 
  778.  
  779.           NOTE: only the WHEN option name may be a pattern, not  the  name
  780.                 in the sub-command!
  781.  
  782.        4.4. STRIP : removing characters between two strings.
  783.  
  784.          Command: STRIP [+|-]<str> TO [+|-]<str>
  785.  
  786.           ╗ This command is used to discard  all  characters  between  the
  787.             two given  strings,  including  the  strings  themselves.  The
  788.             most  common  use  for  this   command   is the  stripping  of
  789.             comments in source files. Note that both string  arguments  of
  790.             the STRIP command are searchstrings.
  791.  
  792.               | ' PARex ram:source { STRIP /* TO */ } '
  793.               | This  will  remove  all  C-comments  from  the  ram:source
  794.               | file. Note that this doesn't catch  nested  comments,  and
  795.               | can therefore result in stripping  non-comment  text!  But
  796.               | a sub-command is provided to solve this problem! 
  797.  
  798.           ╗ If you don't want to strip the searchstrings  themselves  then
  799.             you must type a minus sign (-) before the searchstring.
  800.  
  801.               | ' STRIP -/* TO */ ' will strip the text between  "/*"  and
  802.               | "*/", including the last "*/"  string.  The  first  string
  803.               | "/*" isn't stripped!
  804.  
  805.             If a searchStr should begin with a minus sign, then  you  must
  806.             type  a  minus  sign  (-)  first  if  you  want  to  keep  the
  807.             searchStr after stripping, or a plus sign  (+)  if  you  don't
  808.             want to keep it.
  809.  
  810.               | ' STRIP +-[ TO --] '  The  first  string  "-["   will   be
  811.               | stripped, but the second string "-]" will be kept. 
  812.  
  813.          Sub-cmds: [NEST] [WILD] [WORD] [TIMES <#>] [EVERY <#>] 
  814.                    [AFTER <#>] [CASE] [NOCASE] [FIXCASE] [CAP|DECAP] 
  815.  
  816.          Sub-cmd: NEST
  817.  
  818.           ╗ As mentioned earlier, the bare STRIP command  doesn't  account
  819.             for  nested  comments.  Some  languages  don't  allow   nested
  820.             comments, such as assemblers or even AmigaDOS. Here  all  text
  821.             after the semi-colon (";") upto the end-of-line  character  is
  822.             regarded as a comment. But most  programming  languages  allow
  823.             nested  comments.  The  NEST  sub-command  is  used  to  strip
  824.             nested  comments  from  source  files,  without  harming   the
  825.             actual source.
  826.  
  827.               | ' PARex ram:source { STRIP /* TO */ NEST } '
  828.               | Does the same as the previous  example,  but  now  without
  829.               | the risque of losing valuable source code. 
  830.  
  831.  
  832.                                          PARex v3.0x User Manual - Page 13
  833.  
  834.           RULE: if a programming language  allows  nested  comments,  then
  835.                 always  use  the  NEST  sub-command! This is the case with
  836.                 ModulaII, Oberon, C and even ARexx scripts.
  837.  
  838.        4.5. CAP : putting found string in upper case.
  839.  
  840.          Command: CAP <str>
  841.  
  842.           ╗ This command will  put  the  found  searchStr  in  upper  case
  843.             characters.
  844.  
  845.               | ' PARex ram:source LOAD { CAP p#?x WILD } '
  846.               | This will put all text which matches  the  "p#?x"  pattern
  847.               | in upper case.
  848.  
  849.          Sub-cmds: [WILD] [WORD] [TIMES <#>] [EVERY <#>] [AFTER <#>] 
  850.                    [CASE] [NOCASE] [FIXCASE]
  851.  
  852.        4.6. DECAP : putting found string in lower case.
  853.  
  854.          Command: DECAP <str>
  855.  
  856.           ╗ This command will  put  the  found  searchStr  in  upper  case
  857.             characters.
  858.  
  859.               | ' PARex ram:source LOAD { CAP p#?x WILD } '
  860.               | This will put all text which matches  the  "p#?x"  pattern
  861.               | in upper case.
  862.  
  863.          Sub-cmds: [WILD] [WORD] [TIMES <#>] [EVERY <#>] [AFTER <#>] 
  864.                    [CASE] [NOCASE] [FIXCASE]
  865.  
  866.        4.7. Formatting of the searchStr and replStr.
  867.  
  868.        ╗ Always enclose the string between double quotation  marks  if  it
  869.          contains spaces, or if it begins with a semi-colon!
  870.  
  871.            | "Hello there"
  872.            | If no quotation marks would be used, then  PARex will see two
  873.            | strings, instead of one.
  874.  
  875.        ╗ In  some  cases  the  datastring  will  have  to  contain  double
  876.          quotation marks. In order to introduce such  a  double  quotation
  877.          mark in your datastring you must enter a  backslash  followed  by
  878.          the quotation mark (\").
  879.  
  880.            | REPL \e[2\"z BY NLQ_on 
  881.            | This  command  will  search  for  the  nlq  printer   control
  882.            | sequence ( ESC[2"z ) and replace it with "NLQ_on" if found.
  883.  
  884.        ╗ Besides the double  quotation  mark  PARex supports other special
  885.          characters (they're all introduced by a backslash '\') :
  886.  
  887.             \0 : null
  888.             \e : ESCape
  889.             \n : new line
  890.             \t : horizontal tab
  891.             \v : vertical tab
  892.             \f : form feed
  893.             \r : return
  894.  
  895.  
  896.                                          PARex v3.0x User Manual - Page 14
  897.  
  898.             \b : backspace
  899.             \" : double quotation mark
  900.             \\ : backslash 
  901.             \& : ampersand 
  902.  
  903.        ╗ All   the   CTRL-codes  in  the  ASCII  range  0..31   are   also
  904.          supported. Below is a table of the codes and their name :
  905.  
  906.             CODE CHARACTER  DEC DESCRIPTION
  907.             ---- ---------- --- -----------
  908.             \c@  CTRL-@       0 NUL (null)  
  909.             \cA  CTRL-A       1 SOH (start of heading)  
  910.             \cB  CTRL-B       2 STX (start of text)  
  911.             \cC  CTRL-C       3 ETX (end of text; break)  
  912.             \cD  CTRL-D       4 EOT (end of transmission)   
  913.             \cE  CTRL-E       5 ENQ (enquiry)  
  914.             \cF  CTRL-F       6 ACK (acknowledge)  
  915.             \cG  CTRL-G       7 BEL (beep)  
  916.             \cH  CTRL-H       8 BS  (backspace)  
  917.             \cI  CTRL-I       9 HT  (horizontal tabulation)  
  918.             \cJ  CTRL-J      10 LF  (line feed)  
  919.             \cK  CTRL-K      11 VT  (vertical tabulation)  
  920.             \cL  CTRL-L      12 FF  (form feed)   
  921.             \cM  CTRL-M      13 CR  (carriage return)  
  922.             \cN  CTRL-N      14 SO  (shift out)  
  923.             \cO  CTRL-O      15 SI  (shift in)  
  924.             \cP  CTRL-P      16 DLE (data link escape)  
  925.             \cQ  CTRL-Q      17 DC1 (device control 1 or X-ON)  
  926.             \cR  CTRL-R      18 DC2 (device control 2)  
  927.             \cS  CTRL-S      19 DC3 (device control 3 or X-OFF)  
  928.             \cT  CTRL-T      20 DC4 (device control 4)  
  929.             \cU  CTRL-U      21 NAK (negative acknowledge)  
  930.             \cV  CTRL-V      22 SYN (synchronous idle)  
  931.             \cW  CTRL-W      23 ETB (end of transmission block)  
  932.             \cX  CTRL-X      24 CAN (cancel)  
  933.             \cY  CTRL-Y      25 EM  (end of medium)  
  934.             \cZ  CTRL-Z      26 SUB (substitute)  
  935.             \c[  CTRL-[      27 ESC (escape)  
  936.             \c\  CTRL-\      28 FS  (file separator)  
  937.             \c]  CTRL-]      29 GS  (group separator)  
  938.             \c^  CTRL-^      30 RS  (record separator)  
  939.             \c_  CTRL-_      31 US  (unit separator)  
  940.  
  941.        ╗ All  ASCII-codes [0..255] can also be  inserted  by  using  their
  942.          ASCII  value.  This  value  can   be   in   decimal,   octal   or
  943.          hexadecimal.  To  introduce  an  ASCII  value  you  must  us  the
  944.          following :
  945.  
  946.             \d# : decimal value, where # is a number in the 0..255  range.
  947.                   The value can have no more than 3 characters.
  948.             \o# : octal value, where # is a number in  the  0..377  range.
  949.                   The value can no more than 3 characters. 
  950.             \x# : hexadecimal value, where # is  a  number  in  the  0..FF
  951.                   range. The value can have no more than 2 characters.
  952.  
  953.           NOTE: preceding  zeros  aren't   needed,   unless   PARex  could
  954.                 interprete a character  of  the  string  as  part  of  the
  955.                 number. If this is the case then your value must have  the
  956.                 maximum character width.
  957.  
  958.  
  959.  
  960.                                          PARex v3.0x User Manual - Page 15
  961.  
  962.                   | '\d94 wheels'   -> interpreted as '^ wheels' ('^'  has
  963.                   |                    ASCII-value 94)
  964.                   | '\d0094 wheels' -> interpreted as TAB+'4 wheels'  (TAB
  965.                   |                    has ASCII-value 9)
  966.  
  967.        ╗ Strings for binary files
  968.  
  969.          When processing binary files,  like  programs,...,  most  strings
  970.          are C-strings. This means that at the end of the  string  a  NULL
  971.          character (ASCII 0)  is  found.  The  strings  aren't  C-strings,
  972.          since plain text files don't include NULL codes.
  973.  
  974.          In  order  to  make  sure  that  the  replace  string   is   NULL
  975.          terminated, you must  include  such  a  code  when  defining  the
  976.          string.  (Assuming  that  the  search   string   is   also   NULL
  977.          terminated.)
  978.  
  979.             | Assume we are processing a program, and at  a  certain  time
  980.             | it prints "string". 
  981.             | 'REPL string BY STR' -> the  program  will  print  "STRing",
  982.             |                         which wasn't our intention. 
  983.             | 'REPL string BY STR\o' -> now   the   program   will   print
  984.             |                           "STR" ('\o' inserts a NULL code).
  985.            
  986.          Suppose the string to search is found  two  times  in  the  file,
  987.          once NULL terminated and once not. If you only  want  to  replace
  988.          the NULL terminated one, then you must also include a  NULL  code
  989.          when defining your search string.
  990.  
  991.             | Assume we have two strings in a  program  :  "string\o"  and
  992.             | "this string of \o"
  993.             | 'REPL string\o BY STR\o' -> after  replacing  we  will  have
  994.             |                             "STR\o" and "this string of\o"
  995.             | 'REPL string BY STR\o' -> after  replacing  we   will   have
  996.             |                           "STR\o" and "this STR\o"
  997.  
  998.  
  999.  
  1000.  
  1001.  
  1002.  
  1003.  
  1004.  
  1005.  
  1006.  
  1007.  
  1008.  
  1009.  
  1010.  
  1011.  
  1012.  
  1013.  
  1014.  
  1015.  
  1016.  
  1017.  
  1018.  
  1019.  
  1020.  
  1021.  
  1022.  
  1023.  
  1024.                                          PARex v3.0x User Manual - Page 16
  1025.  
  1026.        5. Search control.
  1027.  
  1028.        5.1. Case-sensitive searching.
  1029.  
  1030.          Option: CASECHECK
  1031.  
  1032.           ╗ By  default,  PARex uses a non-case  sensitive  search.  Using
  1033.             this option  forces  the  program  to  search  case-sensitive.
  1034.             This option has effect on all main commands!
  1035.  
  1036.               | default  : "hello" = "HeLLo", "heLLO", "HELLO", ...
  1037.               | CASECHECK: "hello" only equals "hello"
  1038.  
  1039.           NOTE: in previous versions, this option was called 'CASE'!
  1040.  
  1041.          Sub-cmd: CASE
  1042.  
  1043.           ╗ With this sub-command you can make a  main-command  to  search
  1044.             case-sensitive. All other main-commands won't be  affected  by
  1045.             this.
  1046.  
  1047.                | 'PARex ram:src { REPL aa BY bb CASE } { REPL cc BY dd }'
  1048.                | This will replace two strings, the first string  (aa)  is
  1049.                | searched case-sensitive, while the second string (cc)  is
  1050.                | searched non-case-sensitive!
  1051.  
  1052.          Sub-cmd: NOCASE
  1053.  
  1054.           ╗ The same as CASE, but now  to  make  the  main-command  search
  1055.             non-case sensitive.
  1056.  
  1057.           NOTE: using the CASECHECK  option,  which  works  on  all  main-
  1058.                 commands, will override this sub-command!
  1059.          
  1060.          Sub-cmd: FIXCASE
  1061.  
  1062.           ╗ Using program options, such as  CASECHECK,  can  override  the
  1063.             effect of CASE and NOCASE sub-commands. To prevent  this  from
  1064.             happening, you must use the FIXCASE sub-command. 
  1065.            
  1066.               | { REPL aa BY bb NOCASE } : searches non-case sensitive.
  1067.               | If you would use CASECHECK,  then  PARex  would  start  to
  1068.               | search  case-sensitive  again.  Using  FIXCASE  will  make
  1069.               | sure  that PARex keeps searching non-case  sensitive  with
  1070.               | this command: { REPL aa BY bb NOCASE FIXCASE }.
  1071.  
  1072.        5.2. Wildcard searching.
  1073.  
  1074.          Sub-cmd: WILD
  1075.  
  1076.           ╗ By  default  PARex will interprete the searchStr literally. In
  1077.             some cases, it's more useful to  search  with  wildcards.  The
  1078.             following wildcards are supported by PARex:
  1079.  
  1080.               - "#" : the character following occurs none or more times.
  1081.               - "?" : represents one character.
  1082.               - "*" : this is the true wildcard, and  is  equal  to  "#?".
  1083.                       Note that if you use  "#?",  PARex will translate it
  1084.                       into "*".
  1085.               - "'" : interprete  the  character  following  as  a  normal
  1086.  
  1087.  
  1088.                                          PARex v3.0x User Manual - Page 17
  1089.  
  1090.                       character, and not as a wildcard character.
  1091.               - "|" : allows defining of several patterns in one string.
  1092.  
  1093.         !! ╗ In order for a main-command to use these wildcards, you  must
  1094.              add the sub-command WILD to it, else the wildcards  would  be
  1095.              interpreted as normal characters.
  1096.  
  1097.                | ' PARex ram:src { REPL h#?o BY hi WILD } '
  1098.                | Will replace all strings  that  fall  under  the  pattern
  1099.                | "h#?o". So  "hello",  "ho"  or  "help  me  to"  would  be
  1100.                | replaced by "hi".
  1101.  
  1102.          WARNING: when doing wildcard searching, it's recommended  to  use
  1103.                   the LOAD option, especially with "#?" or  "*"  wildcards
  1104.                   since these can otherwise give wrong results.
  1105.  
  1106.          NOTE: you can use the supplied WildPARex  program  to  experiment
  1107.                with the use of wildcards.
  1108.  
  1109.          Usage: REPL <STR> BY <str> / STRIP <STR> TO <STR> 
  1110.                 CAP <STR> / DECAP <STR>
  1111.  
  1112.        5.3. Context remembering.
  1113.  
  1114.          Sub-cmd: CONTEXT
  1115.  
  1116.           ╗ In  some  cases  it  could  be  interesting   to   save   some
  1117.             characters which fall under the searchStr,  in  order  to  use
  1118.             them again in  the  replStr.  The  CONTEXT  sub-command  makes
  1119.             this reality. Worth mentioning is  the  fact  that  this  sub-
  1120.             command will automatically set the WILD sub-command too.
  1121.  
  1122.           ╗ Upto twenty contexts can be remembered, for a  total  of  upto
  1123.             4096 bytes.  When  the  BUFFER  option  was  used,  then  this
  1124.             buffer will also be enlarged.  
  1125.  
  1126.           ╗ The following codes are  used  to  define  a  context  in  the
  1127.             searchStr : 
  1128.               - the opening curly bracket ("{") to open a context;
  1129.               - the closing curly bracket ("}") to close a context.
  1130.             All characters that fall between  these  curly  brackets  will
  1131.             be remembered.  
  1132.  
  1133.                | ' h{#?}o ' would remember "ell"  if  "hello"  was  found,
  1134.                | or "elp this t" when "help this to" was found... 
  1135.  
  1136.             Any  wildcards  or  characters  can  be  used  between   these
  1137.             context codes. An empty context like  "{}"  is  translated  to
  1138.             "{#?}" by PARex.
  1139.  
  1140.                | Some examples: {p#?x}, p{#A??}x, pa{#?#x}, p{}x, ...
  1141.  
  1142.           ╗ To insert the saved characters in the replStr,  you  type  the
  1143.             two curly brackets at the  desired  place,  thus  "{}".  Every
  1144.             "{}" in the replStr corresponds  to  the  defined  context  in
  1145.             the searchStr. Thus  the  second  "{}"  in  the  replStr  will
  1146.             insert the characters which were saved in the  second  context
  1147.             of the searchStr.
  1148.  
  1149.                | the replStr "H{}I" would be like  "HellI"  if  "ell"  was
  1150.  
  1151.  
  1152.                                          PARex v3.0x User Manual - Page 18
  1153.  
  1154.                | remembered, and like "Help this tI" if "elp this  t"  was
  1155.                | remembered... 
  1156.  
  1157.                | ' PARex ram:src { REPL  "PROCEDURE  {#?}\n"  BY  "ROUTINE
  1158.                | {}\n '  would  convert  "PROCEDURE  Print(str:  ARRAY  OF
  1159.                | CHAR)\n" TO "ROUTINE Print(str: ARRAY OF CHAR)\n"; ...
  1160.  
  1161.           ╗ If you want to  insert  a  curly  bracket  as  a  normal  text
  1162.             character, and not as a context code, you must preceed  it  by
  1163.             the literal wildcard code "'"!
  1164.  
  1165.          Usage: REPL <STR> BY <str> / STRIP <STR> TO <STR> 
  1166.                 CAP <STR> / DECAP <STR>
  1167.  
  1168.        5.4. Word-only searching.
  1169.  
  1170.          Sub-cmd: WORD
  1171.  
  1172.           ╗ By default PARex will just search  for  a  string,  regardless
  1173.             if this string is a word or part of  a  word.  In  some  cases
  1174.             only words may be replaced.  To  make  sure  that  PARex  only
  1175.             finds words, you must use the WORD sub-command.
  1176.  
  1177.                | ' { REPL hi BY hello  WORD  }  ';  this  main-command  is
  1178.                | only executed if "hi" is found as  a  word,  and  not  as
  1179.                | part of a word. Thus "ships" won't do, but " hi " will.
  1180.  
  1181.           ╗ A string is regarded as a word, if  the  ASCII  value  of  the
  1182.             character  before  the string, and  the  ASCII  value  of  the
  1183.             character after the  string  fall  in  one  of  the  following
  1184.             ranges :
  1185.  
  1186.                -   0..47
  1187.                -  58..63
  1188.                -  91..96
  1189.                - 123..191  
  1190.  
  1191.          Usage: REPL <STR> BY <str> / STRIP <STR> TO <STR> 
  1192.                 CAP <STR> / DECAP <STR>
  1193.  
  1194.  
  1195.  
  1196.  
  1197.  
  1198.  
  1199.  
  1200.  
  1201.  
  1202.  
  1203.  
  1204.  
  1205.  
  1206.  
  1207.  
  1208.  
  1209.  
  1210.  
  1211.  
  1212.  
  1213.  
  1214.  
  1215.  
  1216.                                          PARex v3.0x User Manual - Page 19
  1217.  
  1218.        6. Program variables.
  1219.  
  1220.        ╗ As of version 3 some variables  are  supported.  These  variables
  1221.          can be anywhere in the searchStr or replStr. They can be  divided
  1222.          in two types : fixed  variables  and  volatile  variables.  While
  1223.          fixed variables can  be  used  in  both  the  searchStr  and  the
  1224.          replStr, volatile variables are only allowed in the replStr.
  1225.  
  1226.          Fixed variables are variables where the value is  defined  before
  1227.          the source  file  is  processed,  while  the  value  of  volatile
  1228.          variables is only known at the time of  replacing  the  searchStr
  1229.          by the replStr. 
  1230.  
  1231.          These variables are inserted in  the  searchStr  or  the  replStr
  1232.          between two "&" characters.  Everything  between  such  ampersand
  1233.          characters is regarded as being part of the variable.
  1234.  
  1235.          NOTE: if you want to insert "&" characters as normal  text,  then
  1236.                you must use "\&".
  1237.  
  1238.        ╗ These variables can be used in all the  main  commands,  so  with
  1239.          INIT, CLOSE, REPL, STRIP, CAP and DECAP!
  1240.  
  1241.        ╗ The strings in which you can use  a  variable,  are  accented  in
  1242.          bold text in the "Usage:" line.
  1243.  
  1244.        6.1. PARex information.
  1245.  
  1246.          Variable: &NAME&
  1247.  
  1248.           ╗ Inserts the  name  of  the  program  (thus  "PARex"),  in  the
  1249.             string.
  1250.  
  1251.               | ' PARex ram:source REPL ">&NAME&<" BY "xeRAP" '
  1252.               | Replaces all ">PARex<"  strings  in  the  source  file  by
  1253.               | "xeRAP".
  1254.  
  1255.          Variable: &VERSION&
  1256.  
  1257.           ╗ Inserts the version of PARex in the string.
  1258.  
  1259.               | ' PARex ram:source REPL "v&VERSION&" BY "V=&VERSION&" '
  1260.               | Replaces  all  "v3.00"  strings  in  the  source  file  by
  1261.               | "v=3.00".
  1262.  
  1263.          Usage: INIT <STR> / CLOSE <STR> / CAP <STR> / DECAP <STR>
  1264.                 REPL <STR> BY <STR> OR <STR> / STRIP <STR> TO <STR>
  1265.         
  1266.        6.2. Inserting files.
  1267.  
  1268.          Variable: &FILE:<name>&
  1269.  
  1270.           ╗ With this variable you  can  insert  a  file  in  the  desired
  1271.             place in the string. You can use  as  many  &FILE:&  variables
  1272.             in a string as you want. The name of the  file  to  insert  is
  1273.             given directly after the  colon.  No  double  quotation  marks
  1274.             have to be used if the filename  should  include  spaces,  but
  1275.             remember  to  enclose  the  entire   string   between   double
  1276.             quotation marks!
  1277.  
  1278.  
  1279.  
  1280.                                          PARex v3.0x User Manual - Page 20
  1281.  
  1282.           ╗ This variable can for example be used to insert the  value  of
  1283.              environment variables!
  1284.            
  1285.               | SETENV test xerap
  1286.               | ' PARex ram:src REPL parex BY file->&FILE:env:test& '
  1287.               | This will replace  all  "parex"  strings  in  the  ram:src
  1288.               | file with "file->xerap".
  1289.  
  1290.           WARNING: if the file can't be found then "<file not  found>"  is
  1291.                    inserted in the string instead.
  1292.  
  1293.          Usage: INIT <STR> / CLOSE <STR> / REPL <str> BY <STR> OR <STR> 
  1294.  
  1295.        6.3. Inserting date and time.
  1296.  
  1297.          Variable: &FIXTIME:[<formatstr>]&
  1298.  
  1299.           ╗ This variable will insert the time, where  the  used  time  is
  1300.             the one at program startup. If  no  format  string  is  given,
  1301.             then the  default  AmigaDOS  format  (dd-mmm-yy  hh:mm:ss)  is
  1302.             used.
  1303.  
  1304.               | ' PARex ram:source REPL parex BY date=&FIXTIME:& '
  1305.               | All  "parex"  strings  in  the  ram:source  file  will  be
  1306.               | replaced by e.g. "date=20-Nov-93 22:43:42"
  1307.  
  1308.           ╗ The following format codes can be used to construct  a  custom
  1309.             formatted timestring:
  1310.  
  1311.              DATE CODES : %w -> a two character day name ('Mo'..'Su')
  1312.                           %W -> the full day name ('Monday'..'Sunday')   
  1313.                           %d -> two digit day in month (00..31)   
  1314.                           %m -> two digit month (01..12)   
  1315.                           %M -> short month name ('Jan'..'Dec')   
  1316.                           %O -> full month name ('Januray'..'December')
  1317.                           %y -> two digit year (e.g. '93')   
  1318.                           %Y -> four digit year (e.g. '1998')
  1319.           
  1320.              TIME CODES : %h -> hours in 12 hour mode (00..11)   
  1321.                           %H -> hours in 24 hour mode (00..23)   
  1322.                           %i -> minutes (00..59)   
  1323.                           %s -> seconds (00..59)   
  1324.                           %T -> 'AM' or 'PM'   
  1325.  
  1326.              DATESTAMP  : %D -> days since 1-jan-78
  1327.                           %U -> minutes since 00:00:00
  1328.                           %I -> ticks since last minute 
  1329.  
  1330.               | 'PARex ram:src REPL prx BY "date=&FIXTIME:%W, %d %O %Y&" 
  1331.               | All  "parex"  strings  in  the  ram:source  file  will  be
  1332.               | replaced by e.g. "date=Saturday, 20 November 1993".
  1333.  
  1334.             NOTE: these format codes are interpreted case-sensitive!
  1335.  
  1336.          Usage: INIT <STR> / CLOSE <STR> / CAP <STR> / DECAP <STR>
  1337.                 REPL <STR> BY <STR> OR <STR> / STRIP <STR> TO <STR>
  1338.         
  1339.  
  1340.  
  1341.  
  1342.  
  1343.  
  1344.                                          PARex v3.0x User Manual - Page 21
  1345.  
  1346.          Variable: &TIME:[<formatstr>]&
  1347.  
  1348.           ╗ The same as &FIXTIME:&, but now the time used is  the  one  at
  1349.             the moment the string is used! 
  1350.  
  1351.          Usage: INIT <STR> / CLOSE <STR> / REPL <str> BY <STR> OR <STR> 
  1352.         
  1353.        6.4. Inserting path and name of source & destination file.
  1354.  
  1355.          Variable: &SRCPATH& and &SRCNAME&
  1356.  
  1357.           ╗ Inserts the path  and/or  name  of  the  source  file  in  the
  1358.             string.
  1359.  
  1360.               | ' PARex RAM:source PRT INIT \e[1m&SRCNAME&\e[0m\n\n '
  1361.               | This will send ram:source to the printer,  where  first  a
  1362.               | line in bold text is printed with the  name  of  the  file
  1363.               | to print.
  1364.  
  1365.          Variable: &DSTPATH& and &DSTNAME&
  1366.  
  1367.           ╗ Inserts the path and/or name of the destination  file  in  the
  1368.             string.
  1369.  
  1370.               | 'PARex ram:src TO ram:dest INIT &DSTPATH&->&DSTNAME&\n'
  1371.               | This will copy ram:src to ram:dest, where the  first  line
  1372.               | of the ram:dest file will be "ram:->dest".
  1373.  
  1374.          Usage: INIT <STR> / CLOSE <STR> / REPL <str> BY <STR> OR <STR>
  1375.         
  1376.  
  1377.  
  1378.  
  1379.  
  1380.  
  1381.  
  1382.  
  1383.  
  1384.  
  1385.  
  1386.  
  1387.  
  1388.  
  1389.  
  1390.  
  1391.  
  1392.  
  1393.  
  1394.  
  1395.  
  1396.  
  1397.  
  1398.  
  1399.  
  1400.  
  1401.  
  1402.  
  1403.  
  1404.  
  1405.  
  1406.  
  1407.  
  1408.                                          PARex v3.0x User Manual - Page 22
  1409.  
  1410.        7. Using PARex data scripts.
  1411.  
  1412.        Using the main-commands on the command line  has  its  limitations.
  1413.        For example, using one or two  main-commands  gives  now  problems,
  1414.        but suppose you'll need to use  more  than  twenty  commands!  Then
  1415.        it's better to put these main-commands in a script.
  1416.  
  1417.        7.1. Setting up scripts.
  1418.  
  1419.           ╗ PARex scripts, like AmigaDOS scripts, are  plain  text  files,
  1420.             that can be created and edited with any texteditor. 
  1421.  
  1422.           ╗ A comment is  inserted  in  the  same  way  as  with  AmigaDOS
  1423.             scripts. Thus everything after a semi-colon upto  the  end  of
  1424.             the line is regarded as the comment.  You  may  type  comments
  1425.             on the same line as the command.
  1426.  
  1427.                | ' REPL aa BY bb ; this is the comment '
  1428.  
  1429.           ╗ Only one main-command (including  all  its  sub-commands)  can
  1430.             be typed on a line. 
  1431.  
  1432.                | REPL a#?a BY bb OR cc WHEN name CASE WILD
  1433.  
  1434.           ╗ You  can  type  them  on  several  lines   by     using  curly
  1435.             brackets, just as you do on the command line.  In    this case
  1436.             everything after an opening curly bracket upto  the    closing
  1437.             curly  bracket  is  regarded  as  being  part  of  the   main-
  1438.             command. There's one  limitation,  when  a  command  needs  an
  1439.             argument, then both the keyword and the argument  must  be  on
  1440.             the same line!
  1441.  
  1442.                | ' { REPL aa BY bb         ; comments are allowed here
  1443.                |       OR cc WHEN name     ; another comment
  1444.                |       CASE
  1445.                |       CAP } '             ; even here!
  1446.  
  1447.        7.2. Script commands.
  1448.  
  1449.        If needed, you can divide your data script  in  blocks,  which  can
  1450.        then  be  selected  later  from  the  PARex program. The  following
  1451.        commands allow you to do this.
  1452.  
  1453.          Command: GLOBAL
  1454.  
  1455.           ╗ This block of replace commands will be used when you  use  the
  1456.             following options at program  startup  :  GLOBAL  or  ALL. The
  1457.             end of the block is reached when  a  the  MODE  or  a  EXITPXS
  1458.             command is found.
  1459.  
  1460.           ╗ A GLOBAL block can only be defined once in a script!
  1461.  
  1462.          Command: MODE <name>
  1463.  
  1464.           ╗ This command also defines a block  of  replace  commands,  but
  1465.             now the block is named. As many MODE commands can be  used  as
  1466.             needed. Such a block  can  only  be  selected  with  the  MODE
  1467.             (command line) option at  program  startup.  The  name  (or  a
  1468.             pattern) given with the MODE  option  at  program  startup  is
  1469.             used to  search  for  the  corresponding  MODE  block  in  the
  1470.  
  1471.  
  1472.                                          PARex v3.0x User Manual - Page 23
  1473.  
  1474.             script.
  1475.  
  1476.               | Suppose we have the following script :
  1477.               | ' MODE test
  1478.               |     REPL aa BY bb 
  1479.               |     REPL cc BY dd 
  1480.               |   MODE text
  1481.               |     REPL oo BY pp 
  1482.               |     REPL uu BY vv '
  1483.               | Using   ' PARex ram:source MODE text '  will  convert  the
  1484.               | source file with "REPL oo BY pp" and "REPL uu BY vv".
  1485.               | Using   ' PARex   ram:source MODE  te?t ' would  use  both
  1486.               | MODEs since the pattern name "te?t"  matches  both  "test"
  1487.               | and "text".
  1488.  
  1489.           ╗ As with the GLOBAL command, the  block  is  ended  by  another
  1490.             MODE command, a GLOBAL command or a EXITPXS command.
  1491.  
  1492.          Command: EXITPXS
  1493.  
  1494.           ╗ This  command  informs  PARex that it can  stop  scanning  the
  1495.             script. This means  that  everything  after  this  command  is
  1496.             ignored by PARex,  provided  the  block  of  replace  commands
  1497.             where EXITPXS belongs to is used.
  1498.  
  1499.               | Suppose we have the following script :
  1500.               | ' MODE test
  1501.               |     REPL aa BY bb 
  1502.               |     REPL cc BY dd 
  1503.               |     EXITPXS
  1504.               |   MODE text
  1505.               |     REPL oo BY pp 
  1506.               |     REPL uu BY vv 
  1507.               |     EXITPXS '
  1508.               | Using  ' PARex  ram:source MODE  text ' would only use the
  1509.               | "text" mode. The first EXITPXS has no effect  since  PARex
  1510.               | wasn't  reading  that  block  of  replace  commands!   The
  1511.               | second EXITPXS had effect since its block was read.
  1512.  
  1513.        7.3. Script options.
  1514.  
  1515.          Option: SCRIPT <file[.pxs]>
  1516.  
  1517.           ╗ Uses the named  script  file.  It's  not  needed  to  add  the
  1518.             ".pxs" suffix,  since  PARex  will  do  this  for  you  if  it
  1519.             couldn't open the file under the given name. 
  1520.  
  1521.          Option: NOSCRIPT
  1522.  
  1523.           ╗ Forces PARex not to  open  a  scriptfile.  Primarily  used  in
  1524.             earlier    versions of   PARex   to   disable   the    default
  1525.             "S:PARex.pxs" script usage.
  1526.  
  1527.          Option: GLOBAL
  1528.  
  1529.           ╗ Selects the GLOBAL block of a script.
  1530.  
  1531.           ╗ If  no  script  file   was   specified,   then   the   default
  1532.             "S:PARex.pxs" is used (if present).
  1533.  
  1534.  
  1535.  
  1536.                                          PARex v3.0x User Manual - Page 24
  1537.  
  1538.          Option: MODE <name|pattern>
  1539.  
  1540.           ╗ Selects the named  MODE  block(s).  As  mentioned  above,  the
  1541.             name can be a pattern.
  1542.  
  1543.           ╗ If  no  script  file   was   specified,   then   the   default
  1544.             "S:PARex.pxs" is used (if present).
  1545.  
  1546.          Option: ALL
  1547.  
  1548.           ╗ Selects all replace commands in a scripts, thus  ignoring  the
  1549.             MODE and GLOBAL script commands.  But  the  EXITPXS  is  still
  1550.             recognised!
  1551.  
  1552.           ╗ If  no  script  file   was   specified,   then   the   default
  1553.             "S:PARex.pxs" is used (if present).
  1554.  
  1555.  
  1556.  
  1557.  
  1558.  
  1559.  
  1560.  
  1561.  
  1562.  
  1563.  
  1564.  
  1565.  
  1566.  
  1567.  
  1568.  
  1569.  
  1570.  
  1571.  
  1572.  
  1573.  
  1574.  
  1575.  
  1576.  
  1577.  
  1578.  
  1579.  
  1580.  
  1581.  
  1582.  
  1583.  
  1584.  
  1585.  
  1586.  
  1587.  
  1588.  
  1589.  
  1590.  
  1591.  
  1592.  
  1593.  
  1594.  
  1595.  
  1596.  
  1597.  
  1598.  
  1599.  
  1600.                                          PARex v3.0x User Manual - Page 25
  1601.  
  1602.        8. Additional sub-commands.
  1603.  
  1604.        In this chapter the rest of the sub-commands  are  explained.  They
  1605.        give  more  control  over  the  searching  and  over  the  replStr.
  1606.        Remember that a sub-command only affects one  main-command,  except
  1607.        when they're being used as a global working (command line)  option.
  1608.        The latter is explained in point 8.5.
  1609.  
  1610.        8.1. Limit replacing.
  1611.  
  1612.        By  default  PARex  will  replace  every  string  that  matches   a
  1613.        searchStr. The  following  sub-commands  can  alter  this.  In  the
  1614.        example "N" (no replace) and "Y" (replace) are used to explain  the
  1615.        function. These sub-commands are supported by REPL, STRIP, CAP  and
  1616.        DECAP.
  1617.  
  1618.          Sub-cmd: TIMES <#>
  1619.  
  1620.           ╗ The searchStr will only be used the given number of times.
  1621.  
  1622.                | ' REPL hello BY hi TIMES 5 ' -> Y Y Y Y Y N N N...
  1623.  
  1624.          Sub-cmd: EVERY <#>
  1625.  
  1626.           ╗ The searchStr will only be replaced every 'x'th occurence.
  1627.  
  1628.                | ' REPL hello BY hi EVERY 2 ' -> N Y N Y N Y...
  1629.  
  1630.          Sub-cmd: AFTER <#>
  1631.  
  1632.           ╗ Only replace the searchStr after the 'x'th occurence.
  1633.  
  1634.                | ' REPL hello BY hi AFTER 3 TIMES 2 ' -> N N N Y Y N...
  1635.  
  1636.        8.2. Defining the size of the replace string.
  1637.  
  1638.        The size of the string that replaces  the  searchStr  can  also  be
  1639.        altered. 
  1640.  
  1641.        ╗ The following sub-commands relate the size of the replStr to  the
  1642.          size of the searchStr. These commands are useful when working  on
  1643.          binary files, where you don't want  to  insert  a  string  larger
  1644.          than the searchStr, since  this  can  have  disasterous  effects.
  1645.          They're only supported with the REPL command.
  1646.  
  1647.          Sub-cmd: FIT
  1648.  
  1649.           ╗ This command makes sure that the  length  of  the  replStr  is
  1650.             not longer than the found string to replace.  If  the  replStr
  1651.             is shorter, then nothing is done.
  1652.  
  1653.               | ' REPL hi BY hello FIT ' will replace "hi"  by  "he",  not
  1654.               | "hello", since it's too long. 
  1655.  
  1656.          Sub-cmd: ZERO
  1657.  
  1658.           ╗ This command makes sure that the  length  of  the  replStr  is
  1659.             as long as the found string to  replace.  Should  the  replStr
  1660.             be shorter, then it's appended with ASCII NULL codes  (or  the
  1661.             code defined with LEFTFILL or RIGHTFILL). If  the  replStr  is
  1662.  
  1663.  
  1664.                                          PARex v3.0x User Manual - Page 26
  1665.  
  1666.             longer, than nothing is done.
  1667.  
  1668.               | ' REPL hello BY hi ZERO '   will   replace   "hello"    by
  1669.               | "hi\o\o\o" (note that "\o' is used here to  represent  the
  1670.               | NULL code). 
  1671.  
  1672.          TIP: if working on binary files, always use FIT and ZERO to  play
  1673.               safe!
  1674.  
  1675.        The following two sub-commands define  directly  the  size  of  the
  1676.        replStr. Here the size is directly defined, and  thus  not  related
  1677.        to the searchStr! These commands won't work when  FIT  or  ZERO  is
  1678.        used! These sub-commands are supported with INIT, CLOSE and REPL.
  1679.  
  1680.          Sub-cmd: MINSIZE <# bytes>
  1681.  
  1682.           ╗ Defines that the replStr must hold at least the  given  number
  1683.             of bytes. If this  isn't  the  case,  then  the  replStr  will
  1684.             appended  with  ASCII  NULL  codes  (or  the code defined with
  1685.             LEFTFILL or RIGHTFILL). Should  the  string  be  longer,  then
  1686.             nothing is done. 
  1687.  
  1688.               | ' REPL hello BY hi MINSIZE  4 ' will  replace  "hello"  by
  1689.               | "hi\o\o" (note that "\o' is used  here  to  represent  the
  1690.               | NULL code). 
  1691.  
  1692.          Sub-cmd: MAXSIZE <# bytes>
  1693.  
  1694.           ╗ Defines the maximum size that the replStr may  have.  If  it's
  1695.             longer then only the given  number  of  bytes  are  used,  the
  1696.             rest is ignored. Should the replStr be shorter,  then  nothing
  1697.             is done.
  1698.  
  1699.               | ' REPL hi BY hello MAXSIZE   3 '  will  replace  "hi"   by
  1700.               | "hel". 
  1701.  
  1702.        The  following  two  sub-commands  define  if  we  need  to  insert
  1703.        characters at the beginning of the replStr, or at the  end  of  it.
  1704.        The code used for inserting  or  appending  is  also  defined  with
  1705.        these commands. These commands are supported with INIT,  CLOSE  and
  1706.        REPL.
  1707.  
  1708.          Sub-cmd: LEFTFILL|RIGHTFILL <0..255>
  1709.  
  1710.           ╗ If the replStr needs to  be  appended  (in  case  of  ZERO  or
  1711.             MINSIZE) then by default PARex  appends  at  the  end  of  the
  1712.             string with  ASCII  NULL  codes.  These  commands  can  change
  1713.             this. The code to  append  with  must  be  given  as  a  value
  1714.             between 0 and 255. This value can be  given  in  decimal  (can
  1715.             be introduced with \d), in hexadecimal  (introduced  with  \x)
  1716.             or in octal (introduced with \o).
  1717.  
  1718.           ╗ LEFTFILL will lengthen the replStr  by  inserting  the  needed
  1719.             bytes at the beginning, while RIGHTFILL will do  this  at  the
  1720.             end of the string.
  1721.  
  1722.               | ' REPL hello BY hi MINSIZE  5 LEFTFILL \d64' will  replace
  1723.               | "hello" by "@@@hi" 
  1724.  
  1725.  
  1726.  
  1727.  
  1728.                                          PARex v3.0x User Manual - Page 27
  1729.  
  1730.           WARNING: the  LEFTFILL  sub-command  doesn't   work   when   the
  1731.                    HEXDUMP option is used!
  1732.  
  1733.        8.3. Case conversion.
  1734.  
  1735.        The following sub-commands are supported by REPL, STRIP,  INIT  and
  1736.        CLOSE.
  1737.  
  1738.          Sub-cmd: CAP|DECAP
  1739.  
  1740.           ╗ Will put all text of the replStr (including  all  bytes  which
  1741.             come from the program variables) into upper  case  (with  CAP)
  1742.             or into lower case (with DECAP) characters.
  1743.  
  1744.                | ' REPL aa BY hi CAP ' will replace "hello" by "HI"
  1745.  
  1746.                | ' REPL aa BY HI DECAP ' will replace "hello" by "hi"
  1747.  
  1748.        8.4. Making sub-commands to work on all main-commands.
  1749.  
  1750.           ╗ In some cases you'll want to make a sub-command  effective  on
  1751.             all used main-commands. To do this, you must  enter  the  sub-
  1752.             command as a program (command line)  option,  and  before  any
  1753.             main-command!
  1754.  
  1755.           ╗ In order to be sure that a sub-command  is  interpreted  as  a
  1756.             global working  option,  then  it's  best  to  place  a  main-
  1757.             command  (if  used  on  the  command   line)   between   curly
  1758.             brackets. 
  1759.  
  1760.               | ' PARex ram:src TIMES 2 { REPL aa BY bb TIMES 5 } '
  1761.               | You'll see that  TIMES  is  used  twice,  but  the  second
  1762.               | TIMES sub-command is ignored, since  the  first  (TIME  2)
  1763.               | one works globally!
  1764.  
  1765.           ╗ The following sub-commands  can  be  made  to  work  globally:
  1766.             CAP,  DECAP,  WILD,  CONTEXT,  NEST,   FIT,   ZERO,   MINSIZE,
  1767.             MAXSIZE, LEFTFILL, RIGHTFILL, TIME, EVERY, AFTER and WORD.
  1768.               
  1769.         
  1770.  
  1771.  
  1772.  
  1773.  
  1774.  
  1775.  
  1776.  
  1777.  
  1778.  
  1779.  
  1780.  
  1781.  
  1782.  
  1783.  
  1784.  
  1785.  
  1786.  
  1787.  
  1788.  
  1789.  
  1790.  
  1791.  
  1792.                                          PARex v3.0x User Manual - Page 28
  1793.  
  1794.        9. Option reference.
  1795.  
  1796.          ALL ....................................................... 25
  1797.          AFTER <#> ............................................. 26, 28
  1798.          BUFFER <# bytes> ..........................................  6
  1799.          CAP ....................................................... 28
  1800.          CASECHECK ................................................. 17
  1801.          CONTEXT ............................................... 18, 28
  1802.          CONVERT ...................................................  5
  1803.          DECAP ..................................................... 28
  1804.          EVERY <#> ............................................. 26, 28
  1805.          FIT ................................................... 26, 28
  1806.          [FROM] <file|dir|pattern> .................................  4
  1807.          GLOBAL .................................................... 24
  1808.          HEXDUMP [<fmtstr>] ........................................  7
  1809.          LCASE .....................................................  8
  1810.          LEFTFILL <0.255> ...................................... 27, 28
  1811.          LOAD ................................................... 6, 18
  1812.          MAXSIZE <# bytes> ..................................... 27, 28
  1813.          MINSIZE <# bytes> ..................................... 27, 28
  1814.          MODE <name|pattern]> .................................. 23, 25
  1815.          NEST .................................................. 13, 28
  1816.          NOSCRIPT .................................................. 24
  1817.          NOVERSION ................................................. 10
  1818.          PAR .......................................................  5
  1819.          PRT .......................................................  5
  1820.          READ <# bytes> ............................................  5
  1821.          RIGHTFILL <0.255> ..................................... 27, 28
  1822.          SCRIPT <file[.pxs]> ....................................... 24
  1823.          SER .......................................................  5
  1824.          SILENT .................................................... 10
  1825.          STAT ......................................................  9
  1826.          TIMES <#> ............................................. 26, 28
  1827.          [TO] <file|dir> ...........................................  4
  1828.          TOUCH <# bytes> ...........................................  5
  1829.          TRACE .....................................................  9
  1830.          UCASE .....................................................  8
  1831.          WHEN <name|pattern> ....................................... 12
  1832.          WILD .............................................. 17, 18, 28
  1833.          WORD .................................................. 19, 28
  1834.          ZERO .................................................. 26, 28
  1835.  
  1836.          [{] CAP   <str> [<cmds> }] ................................ 14
  1837.          [{] CLOSE <str> [<cmds> }] ................................ 12
  1838.          [{] DECAP <str> [<cmds> }] ................................ 14
  1839.          [{] INIT  <str> [<cmds> }] ................................ 11
  1840.          [{] REPL  <str> BY <str> [<cmds> }] ....................... 12
  1841.          [{] STRIP [+|-]<str> TO [+|-]<str> [<cmds> }] ............. 13
  1842.  
  1843.  
  1844.  
  1845.  
  1846.  
  1847.  
  1848.  
  1849.  
  1850.  
  1851.  
  1852.  
  1853.  
  1854.  
  1855.  
  1856.                                          PARex v3.0x User Manual - Page 29
  1857.  
  1858.        10. Command reference.
  1859.  
  1860.        10.1. Main commands.
  1861.  
  1862.          CAP <str> ................................................. 14
  1863.                [WILD] [WORD] [TIMES <#>] [EVERY <#>] [AFTER <#>] 
  1864.                [CASE] [NOCASE] [FIXCASE]
  1865.  
  1866.          CLOSE <str> ............................................... 12
  1867.                [CAP|DECAP] [MINSIZE <# bytes>] [MAXSIZE <# bytes>]
  1868.                [LEFTFILL|RIGHTFILL <0..255>]
  1869.  
  1870.          DECAP <str> ............................................... 14
  1871.                [WILD] [WORD] [TIMES <#>] [EVERY <#>] [AFTER <#>] 
  1872.                [CASE] [NOCASE] [FIXCASE]
  1873.  
  1874.          INIT <str> ................................................ 11
  1875.                [CAP|DECAP] [MINSIZE <# bytes>] [MAXSIZE <# bytes>]
  1876.                [LEFTFILL|RIGHTFILL <0..255>]
  1877.  
  1878.          REPL <str> BY <str> ....................................... 12
  1879.                [OR <str> WHEN <name>] [WILD] [WORD] [CONTEXT] 
  1880.                [TIMES <#>] [EVERY <#>] [AFTER <#>] [CASE] 
  1881.                [NOCASE] [FIXCASE] [CAP|DECAP] [FIT] [ZERO] 
  1882.                [MINSIZE <# bytes>] [MAXSIZE <# bytes>]
  1883.                [LEFTFILL|RIGHTFILL <0..255>]
  1884.  
  1885.          STRIP [+|-]<str> TO [+|-]<str> ............................ 13
  1886.                [NEST] [WILD] [WORD] [TIMES <#>] [EVERY <#>]
  1887.                [AFTER <#>] [CASE] [NOCASE] [FIXCASE] [CAP|DECAP]
  1888.  
  1889.        10.2. Sub-commands.
  1890.  
  1891.          AFTER <#> ................................................. 26
  1892.          CAP ....................................................... 28
  1893.          CASE ...................................................... 17
  1894.          CONTEXT ................................................... 18
  1895.          DECAP ..................................................... 28
  1896.          EVERY <#> ................................................. 26
  1897.          FIT ....................................................... 26
  1898.          FIXCASE ................................................... 17
  1899.          LEFTFILL <0.255> .......................................... 27
  1900.          MAXSIZE <# bytes> ......................................... 27
  1901.          MINSIZE <# bytes> ......................................... 27
  1902.          NEST ...................................................... 13
  1903.          NOCASE .................................................... 17
  1904.          RIGHTFILL <0.255> ......................................... 27
  1905.          TIMES <#> ................................................. 26
  1906.          WHEN <name> ............................................... 12
  1907.          WILD .................................................. 17, 18
  1908.          WORD ...................................................... 19
  1909.          ZERO ...................................................... 26
  1910.  
  1911.        10.3. Script-commands.
  1912.  
  1913.          EXITPXS ................................................... 24
  1914.          GLOBAL .................................................... 23
  1915.          MODE <name> ............................................... 23
  1916.  
  1917.  
  1918.  
  1919.  
  1920.                                          PARex v3.0x User Manual - Page 30
  1921.  
  1922.        11. Variables.
  1923.  
  1924.          NAME ...................................................... 20
  1925.          VERSION ................................................... 20
  1926.          FILE:<name> ............................................... 20
  1927.          FIXTIME:[<formatstr>] ..................................... 21
  1928.          TIME:[<formatstr>] ........................................ 22
  1929.          SRCNAME ................................................... 22
  1930.          SRCPATH ................................................... 22
  1931.          DSTNAME ................................................... 22
  1932.          DSTPATH ................................................... 22
  1933.  
  1934.  
  1935.  
  1936.  
  1937.  
  1938.  
  1939.  
  1940.  
  1941.  
  1942.  
  1943.  
  1944.  
  1945.  
  1946.  
  1947.  
  1948.  
  1949.  
  1950.  
  1951.  
  1952.  
  1953.  
  1954.  
  1955.  
  1956.  
  1957.  
  1958.  
  1959.  
  1960.  
  1961.  
  1962.  
  1963.  
  1964.  
  1965.  
  1966.  
  1967.  
  1968.  
  1969.  
  1970.  
  1971.  
  1972.  
  1973.  
  1974.  
  1975.  
  1976.  
  1977.  
  1978.  
  1979.  
  1980.  
  1981.  
  1982.  
  1983.  
  1984.                                          PARex v3.0x User Manual - Page 31
  1985.