The following commands do not exist that I know of.
Not being a programmer, I can only give the idea of what the
commands should do. As to the specific syntax, it could be
different in the final form.


AFI (Ask For Input or Information) command specs.

   This command would ask a user for a text string, filename,
   AmigaDos command, etc... To be passed to the command sequence.
   The (.) directive is any of the Execute command directives, such
   as .Key, .BRA, .KET, etc... And may use the AmigaDos Template
   qualifers /A, /K, /S .

Example 1)

AFI <input question> .Key <user defined directive subsitution name>

Command Sequence File:

AFI "Show which picture file?" .Key arg
show <arg>

Results in Cli output:

Show which picture file? [crusor ready for user input]

The substitution names/characters pass the arguments until given
another argument to pass or no argument to pass( "" ).

Example 2)

Command Sequence File:

AFI "Show Picture file?" .Key arg
show <arg>
AFI "Show Picture file?" .Key arg
show <arg>
AFI "Show Picture file?" .Key arg
show <arg>
AFI "Show Picture file?" .Key arg
show <arg>

Results in:

Show Picture file? cat.pic   {this pictures shows then
      user closes screen}

Show Picture file? dog.pic   {this pictures shows until
      user closes screen}

Show Picture file?   {no input  shows dog pic.}

Show Picture file? ""        {nothing to show!}

Like the Ask or Pause command the AFI command ask for input, but
unlike the Ask or Pause command the AFI command is not limited to
y/n input.


EXT command specs.

EXT <string><opt string>
   Compares string to the EXT-Ref file(s) being used and follows
   the process in the EXT-Ref. file according to the user defined
   process, passing the string to the EXT-Ref file. If no string is
   found in current user defined EXT-Ref. file then prints to screen
   "No string match found for <string>". The <opt string> is optional
   and is used instead of string in looking at the EXT-Ref file for
   a process to follow, but uses the orginal string in the process.

EXT -t <string>        ( -t = Tell )
   Determines if string is just a string, if so it follows the
   process in the EXT-String file marked "!S!" or if no process is
   marked "!S!" prints to screen "<string> is a string argument"
   If string is a Directory, it follows the process marked "!D!".
   If no process is marked "!D!" prints to screen "<string> is a
   Directory. If string is a file, and is a text type file (such as
   a Document, command sequence, script), it follows the process in
   the marked "!TT!". If no process is marked "!TT!" it prints to
   screen "<filename> is Text type file". If not a text type file
   does string(s) search of file in an effort to determine file
   type, via searching for user defined string(s), via the
   EXT-String file. If string found, follows user defined process.
   If no string found, follows process marked "!NS!" or if no
   process is marked "!NS!" prints to screen "No String match found
   for <Filename>".

EXT -c <match string>=<user defined process>  ( -c = Change )
    When the EXT command is first used it copies to RAM: the EXT-Ref.
    file "EXT-Ref.Default". The -c opt only changes or adds to the
    file in RAM:. If a <match string> is already being used in RAM:
    it replaces it with the new process to follow. EXT -c only act
    on the RAM: and if a <match string> is found elseware it adds
    the <match string> and new process to RAM: (which it looks at
    first for a <match string>.)

EXT -w <Ext-Referance filename>    ( -w = With )
    Changes the EXT-Ref.Default (RAM:) file to another user defined
    EXT-Ref. File. User can create as many EXT-Ref. files as needed.

EXT -p <EXT-Ref filename>      ( -p = path )
    Upon not finding a string match/process to follow in the RAM:
    EXT-Ref file, the EXT <string> command will look to any and all
    EXT-Ref files that have been given the EXT -p option. Looking
    at the most recent first and then the next most recent, etc...
    Last in first out style. The -p option has no effect on AmigaDos
    Path command, and is only used for EXT <match string> searches.

EXT -pd <EXT-Ref filename>      ( -pd = delete from path )
    Deletes the <EXT-Ref file> from the file list of files to search
    for <match string>.

EXT -s <filename>         ( -s = Save )
    Saves to disk the RAM:EXT-Ref. file as <filename>. If no filename
    is specified it saves it as the filename in RAM: overwriting file.
    The file is (unless otherwise noted) saved to the same Dir path.

EXT -d     ( -d = Delete )
    Deletes the EXT-Ref. file from RAM: releasing the memory used by
    the EXT-Ref. file.

EXT ?    (standard use of the ?)

EXT-String File format (User definable)

    The listing of File character strings to search for in specifed
    file is in the format of a text file and works on a line by line
    bases, in sequencial order until string match found or end of list
    is reached. Upon finding a string match, follows the given process.

<!D!> (see above) = <user defined process> (*return key*)
<!S!> (see above) = <user defined process>      "
<!TT!>(see above) = < "     "       "    >      "
<character string 1> = <  "     "   "    >      "
<   "        "    2> = <  "     "   "    >      "
<   "        "    3> = <  "     "   "    >  etc...
<!NS!>(see above) = < "     "       "    >      "

    Standard file formats, such as IFF, have common character strings
for the different formats (ie. IFF pictures file have a common string
amoung themselves but different than the common string of IFF sound
files.) However, different programs can use different or no file
extentions for the IFF files it uses. The EXT-String file is a
listing of character strings to look for, for the -t opt. Also giving
a process to follow if string found.

EXT-Referance File format (User definable)

    Like the EXT-String file, the EXT-Ref. file is a text file and
works on a line by line bases, also in sequencial order as follows:

<#?.extention 1> = <user defined process> (*return key*)
<    "      2> = < "      "     "     >
<    "      3> = < "      "     "     >  etc...

   Upon finding a string match, the EXT command simply
treats the <user defined process> as a standard Cli command line,
passing the string and any arguments to this command line. If more
than one line is needed, than the user would need to write a command
sequence file and have the <user defined process> read as an example:

       <execute (command seq. filename) >

Why AmigaDos can't Do it, yet!

   If the IF-ELSE-ENDIF statement would recognize pattern matching
characters as PATTERN MATCHING CHARACTERS, then it would be possible
to write a command sequence file that would act as an EXT command to
some degree. However this is not the case, the IF-ELSE-ENDIF
statement treats Pattern Matching Characters only as actual string
characters. (ie: #?.pic does not EQ dog.pic but does EQ #?.pic)

Usefullness of the EXT Command.

   Besides the basic use of determining what type of file a file is,
the following examples should give a much better idea of the uses of
such a command as EXT.

1)  EXT-Ref file:

.pic = copy <filename> to pictures:
.doc = copy <filename> to Documents:
.anim = copy <filename> to Animation:
.smus = copy <filename> to Music:

  This would not only copy the file to the proper Devs: (or disk) but
would also request the proper Devs: (or disk) if not present. This
EXT-Ref. file would make it easy to sort out files to the proper
place without sorting such a file as test.exp. unless the
       <opt .extname> is used.

2)  EXT-Ref file:

.pic = show <filename>
.doc = blitz <filename>
.anim = player <filename>
.smus = SMUS.player <filename> [args]

  This would automatically use the command needed to process the file.
Saving the user the time typing in the proper command or even
remembering the command. (a listing of C: takes time!)

3) This next example is in using the EXT command in a command sequence

command sequence file (named fun):

.K subname1,subname2,subname3,subname4,subname5,etc...
EXT <subname1>
EXT <subname2>
EXT <subname3>

EXT-Ref. file:

.pic = newcli from <show <filename>>
.doc = newcli from <con:hpos/vpos/width/height type <filename>>
.smus = smus.player <filename> [args-subname4 & 5]

Entered in the cli:

Execute fun cat.pic cat.doc cat.smus catsound1 catsound2

   What this would do is to first bring-up the cat.pic, then open a
cli window and type the cat.doc in it, then while you can both see
the .pic and read the .doc file it will play the cat.smus song.

   These are only a few simple examples of the use of such a command
as EXT (extention). One might first use the example #2 to determine
which file to use with the "fun" sequence file, then -c (change) to
the EXT-Ref file in example in #3 before executing "fun" file.

   Much more complex use of the EXT command and command sequence files
might be that of producing magizine disks or educational disk. The
use of such filename.extention as .quiz and .score might run a quiz
program and then show the .score file or compared scores.

   Lets not forget other commands as sort, wait, join, search, etc...
and the uses of EXT with these commands. The EXT command doesn't
have to use the filename in the <user defined process>!

Another useful command?

   How about a Prompt+ command. This command would simply change the
cli prompt to whatever (as prompt does), but would also type in the
command(s) specified by the user for the user. Exp.  Prompt+ 1> Run
would result in:

1> Run [crusor ready for user input]

Kinda like command history, but automatic.

    And another useful command.