The User Interface Commands

Upon startup, applications will present a list of parameters to which it is sensitive. This will be in the form of various keywords. The values of all these keywords will be empty, unless the keywords was set on the command-line in the format <KeyWord>=[<Val0>[,<Val1>[...]]].

Following are the commands available from this interactive shell:

 cd       : Change working directory
 inp      : To see the various keywords and their values
 go       : To run the application
 gob      : To run the application in background
 help     : This help
 ?        : Information on the type of the keywords
 edit     : Use an editor to (un)set values
 save <F> : Save the values in the file <F>
 load <F> : Load the values from the file <F>
 explain  : Help on the meaning of the various keywords
 quit     : Quit the application

These commands form the standard set of shell commands that all applications will normally understand. There may be a few extra commands which may be application dependant and will change from application to application. However, the ``help'' command is always expected to show all the commands that the application can understand.

The keywords can be set/reset from this shell by commands of the type <KeyWord>=<Val>. For recognizing the names of the keywords in such commands, the shell uses the minimum match algorithm - minimum

The user interface of all application programs by default presents a list of keywords to which the application is sensitive. This is presented as a list of variables of an embedded interactive shell. The user can set, reset, load, save, etc. the values of these keywords using the basic shell commands in an interactive shell. In general, keywords can be assigned a list of comma-separated values. The number of values that a keyword expects can be found via the shell-command '?'. The value of a keyword can be set by a command of type <KeyWord>=[<Val0>[,<Val1>[...]]] and can be reset by omitting the values in such commands (command <KeyWord>=). The shell-command help provides the basic help about the shell itself and prints following on the screen:

   Commands in the interactive mode:

   Use <Key>=<Val1,Val2,..> to set value(s) for a keyword
   Use <Key>=<RETURN> to unset value(s) for a keyword

    inp         : To see the various keywords and their values
    go          : To run the application
    gob         : To run the application in background
    cd          : Change working directory
    help        : This help
    ?           : Information on the type of the keyword
    explain     : Detailed help, optionally of keywords/task [[Key][:Task]]
    save        : Save the values, optionally in a file
    load        : Load the values, optionally from a file
    edit        : Use an editor to (un)set the values
    quit        : Quit the application

   Any other input will be passed to the system shell

These commands form the standard set of shell-commands available from all applications. However, the user interface libraries provide mechanisms for application programmers to add application specific shell-commands as well as alter the behavior of the basic shell-commands. Hence, there may be a few extra commands which may be application dependent and will change from application to application. However, the help command will automatically always show all the commands available for a given application.

Following is a short description of the shell commands:

• Command inp displays the current setting of the keywords.

• Command go signifies the end of the interactive session. After this commands is issued, the values of the keywords set by the users are used by the application internally and the execution of the main program proceeds.

• Command gob is similar to go except that it will run the application in the background and print the process ID (PID) number of the background process on the screen (also see section 3).

• Command cd changes the current working directory within the interactive shell.

• Command '?' gives some basic information about the type and the number of values the keywords expects.

• Command explain gives as detailed a help about the application and the keywords as the author of the application has cared to write in the help file. These help files are located in the directory specified by the environment variable GDOC (see section 3).

• Command save saves the current setting of the keywords in a file. By default, these values are saved in a file named ./<Application Name>.def. If a file name is supplied as an argument of this command, the values will be saved in the file. this command.

• Command load is the conjugate of save - by default it loads the settings for the keywords from the file ./<Application Name>.def. If this file is already present when the application is started, it is loaded automatically. Alternatively, it can load settings from a file provided as an argument to the load command.

• Command edit allows user to edit the keyword values in an editor of choice specified by the environment variable EDITOR (see section 3).

• Command quit quits the interactive session without executing the application.

All inputs to the interactive shell, which are not any of the above mentioned commands or any of the application specific commands, are passed to the underlying Operating System (OS) user shell. Hence, most of the native OS commands shall still be available from this shell. (Users however must be aware that certain OS shell commands like ``setenv'' (for csh users) or ``export'' (for bash/sh users) will seem to work, but will not have the desired effect).

As mentioned earlier, the values of the keywords can be a list of comma-separated values. The expected number of values will be reported by the shell-command '?' along with the type of the values, enclosed in '[ ' and '] ' pairs. A blank set of square brackets (``[]'') will be printed for keywords which can accept any number of values. Some keywords may accept values of mixed types (e.g., string, floats, integers). For such keywords, the reported type will be ``UNKNOWN''.

Comma is treated as a separator in a list of values for a keyword. To suppress its interpretation as a separator, it can to be ``escaped'' using the backslash ('$\backslash$') before the comma. For example, if the value of a keyword key has to be set to a string ``Funny, value with a comma'', it can be done using

                key=Funny\, value with a comma

The characters '$\backslash$', '[', ']', '=', which are part of the shell-command syntax, must also be escaped similarly to be used as part of the values of the keywords.

Numeric values of keywords can be arbitrary mathematical expressions. Following functions and constants can be used in these expression:

• Functions

  sin,cos,tan,asin,acos,atan,atan2,sinh,cosh,tanh,
  exp,ln,log,flog10,sqrt,fabs,floor,ceil,rint

• Constants
  1. PI: value of $\pi$
  2. C: speed of light in meters per second.
  3. R2D,D2R: multiplicative constants for conversion from Radians to Deg. and vice versa
  4. H2R,R2H: multiplicative constants for conversion from Hours to Radians and vice versa
  5. SOL2SID,SID2SOL: multiplicative constants for conversion from Solar to Sidreal time and vice versa

Numbers in the expression can be in any of the following representations:

• Integer format, real (float) format

• 1.0E-1 or 1.0e-1 (=0.1)

• 1.0D-1 or 1.0d-1 (=0.1)

• 1h10m0.1s: the time format - converts the number to seconds before using it.
• $1d1{^\prime}1{^{\prime\prime}}$: The angular format - converts to arc seconds before using it.

  ( $1d1{^\prime}= 3660.0{^{\prime\prime}}$ and $-1d1{^\prime}= -3660.0{^{\prime\prime}}$)

De-referencing mechanism

The user interface system allows the application programmers to define shell symbols which are treated as constants (i.e. their values cannot be modified by the user). These symbols are referred to as the const symbols. Some applications may load a number of frequently used values of various keywords as const symbols (e.g., the list of symbols reported by the showfmt command of the xtract program). However, by default, none of the const symbols are presented to the user and its the responsibility of application program to add extra shell-commands for viewing the list of const symbols.

Values can be transfered from one keyword or a const symbol to another keyword. E.g. to transfer the $i^{th}$ value from keyword Key1 to a keyword Key2, one could use Key2 = $Key1[i]. Key2=$Key1 will transfer all values of Key1 to Key2.

File name convention

Most off-line applications can perform I/O using UNIX pipes. If the input file name begins with '<', the rest of the file name is treated as a command, the output of which becomes the input of the application. For example, to supply the output of a program tmac as the input of the program xtract, the ``in'' keyword of xtract must be set to `<tmac''. After the shell-command go is issued for xtract, the interface of tmac will be started and the keywords of tmac can then be set in the normal fashion. When the shell-command go is issued again, tmac will begin execution, and the output of tmac becomes the input of xtract. Till this time, execution of xtract would remain blocked, waiting for input from tmac.

Similarly, if the output file name begins with the '|' character, the rest of the file name is treated as a command, the input of which becomes the output of the off-line program.

By convention, a blank output file name implies that the output would go to the standard output stream (usually your screen) and a blank input file name implies that the input would be read from the standard input stream (usually your keyboard).