AS/400 Command Language
|
|
The AS/400 command language (CL) is reminiscent of JCL and consists of an ever expanding set of command objects (*CMD) used to invoke traditional AS/400 programs and/or get help on what those programs do. CL can also be used to create CL programs (congruent to shell scripts) where there are additional commands that provide program-like functionality (GOTO, IF/ELSE, variable declaration, file input, etc.)
The vast majority of AS/400 commands were written by IBM developers to perform system level tasks like compiling programs, backing up data, changing system configurations, displaying system object details, or deleting them. Commands are not limited to systems level concerns and can be drafted for user applications as well.
| Contents |
Commands and programs
Parameters (aka arguments) defined in the main procedures of all traditional AS/400 programs are hard coded lists that are be made up of parameters that can be numeric, alphanumeric, boolean, etc and the order in which parameters are passed is important. This is a stark difference from the Unix & DOS worlds where the parameter list in Unix shell scripts and C programs is a set or array of character pointers and more often than not the parameters are not positionally dependent.
The AS/400 developer's solution to this problem was the command object (*CMD). Each parameter is defined to be passed in a specific order. The programmer can also define, among other things, the parameter's data type, unique parameter name, descriptive text (for prompting), default value (used only if the parameter isn't specified during execution), if the values are restricted to a certain set or range, if the data entered should be changed to another value before calling the program, etc.
At its most basic a command names a single program to call when the user types or prompts the command and presses the Enter key. The command takes all of the parameters typed by the user, and those not typed by the user, and builds a parameter list that it passes to the program when it's called.
Syntax
The BNF for a much simplified CL command syntax would be defined as follows:
<CL-command> ::= command-name [<positional-parameter-list>] [<named-parameter-list>]
<positional-parameter-list> ::= <parameter-value> [<positional-pararmeter-list>]
<named-parameter-list> ::= parameter-name"(" <parameter-element-list> ")" [<named-parameter-list>]
<parameter-element-list> ::= <parameter-value> [<parameter-element-list>]
<parameter-value> ::= CL-name |
qualified-CL-name |
"*"special-value |
generic-CL-name"*" |
"'"alphanumeric-value"'" |
numeric-value |
"X'"hexadecimal-value"'"
The items above that end in -name follow AS/400 object naming conventions which, generally speaking, means the name starts with a letter and can be up to ten characters in length. (CL commands are also case-insensitive.)
A good example of a typical CL command is the Change Program (CHGPGM) command below:
CHGPGM MYPGM OPTIMIZE(*FULL) RMVOBS(*BLKORD *PRCORD) TEXT('My program.')
The above command is passing four parameters to the program that does Change Program processing and they are:
- MYPGM: A positional parameter (PGM). (It also happens to be the only required parameter). In this case it's the name of the program being changed. Positional parameters are always first. Once a named parameter appears all parameters that follow must be named parameters.
- OPTIMIZE(*FULL): A named parameter specifying a single element which is a special value. In this case it will change the program to be fully optimize it.
- RMVOBS(*BLKORD *PRCORD): A named parameter (Remove Observability) specifying multiple special values. In this case telling it to remove two kinds of profiling data from the program.
- TEXT('My program.'): Another named parameter specifying a single alphanumeric value. In this case it's changing the descriptive text of the program.
In reality the AS/400 will pass many more parameters than the four specified above. This is because the rest of the CHGPGM command's parameters were not specified, so default values will be passed instead. For every parameter on this, aside from the PGM parameter, that default is *SAME, meaning don't change it.
Prompting
All AS/400 commands can be prompted directly from the command line or within CL program source by typing the command and pressing the F4 function key. The system will then present a screen with the set of parameters that the program accepts/requires (required parameters are usually highlighted).
Prompting is further enhanced to allow the user to find what values are valid for each parameter. To do this during prompting the user would move the cursor to the parameter field in question and press F4 again. The system would then display a screen describing the type of data required and an optional list of allowable values.
Command Help
Cursor sensitive help can also be provided on AS/400 commands but it's not required. If help has been provided one can view help for a parameter by moving the cursor to the desired parameter field and pressing F1 (help). To get help for the entire command itself (and all of its parameters) the user would press F1 anywhere on the prompt display and then press F2 (extended help).
Creating new commands
New commands can be created to call non-system programs and they will work exactly like the AS/400 variety. The Command Definition Language is described in the IBM iSeries CL Programmer's Guide (http://publib.boulder.ibm.com/iseries/v5r2/ic2924/books/sm14/c4157215.pdf). It's a good idea to create help screens for new commands and their parameters. All help screens use Panel Group objects (*PNLGRP) and these can be created using the UIM language described in the IBM AS/400 Application Display Programming manual (http://publib.boulder.ibm.com/iseries/v5r2/ic2924/books/c4157150.pdf).
Finding the right command
There are hundreds and hundreds of commands on the AS/400, but finding them isn't all that hard because of several designs of the system that make life easier. These labor saving designs are: Standardized TLA's, Command Grouping Menus, and Command Selection.
Standardized TLA's (Three Letter Acronyms)
The AS/400 developers standardized the Three Letter Acronyms used to create command names. Verbs likes change are always rendered as CHG, display as DSP, work as WRK, create as CRT, etc. Subjects like program are always PGM, user is USR, module is MOD, server is SVR, etc. You can see every possible verb and subject used on the AS/400 in the VERB and SUBJECT menus, just enter the commands GO VERB or GO SUBJECT.
Command Grouping Menus
The VERB and SUBJECT menus are part of what are called the Command Grouping Menus. For every Three (or four) Letter Acronym there is a menu devoted to it that starts with the letters CMD. So to see all CHG commands the user would execute the command GO CMDCHG. For program commands the menu would be CMDPGM.
There are other menus besides the Command Grouping Menus. The starting point for the menuing system can be accessed by pressing F4 on an empty command line.
Command Selection
If one only knows part of a command or if third party software is being used where the commands don't conform to the AS/400 TLA standard then you would enter that part of the command that is known, attach an asterisk (to make it generic), and press enter. The system will then display a list of commands in the job's library list that match the generic names just typed. One can then page through the list looking for the command needed and then select it using option 1.
In the background the system is using the SLTCMD command to perform this function. If one wants to select all commands in a library then prompt this command and enter the special value *ALL.
Sample Code
The following is a sample of CL programming. The program interactively converts dates from julian to mdy and vice versa. Results are displayed on line 24 of the terminal. It accepts two parameters. The &IN parameter which is the date string to be converted. If a julian string it should be in the format yynnn where yy is the year number and nnn is the day number of the year. If a MDY string it must be in the format mmddyy. The second parameter is &TYP which is the type of date to be converted to. It must be 'J' (julian) or 'M' (mdy). For example: the command CALL PGM(ICVTDATC) PARM('04180' 'M') will convert the julian date 04180 to 062804 (June 24, 2004).
PGM PARM(&IN &TYP)
DCL VAR(&IN) TYPE(*CHAR) LEN(6)
DCL VAR(&OUT) TYPE(*CHAR) LEN(8)
DCL VAR(&TYP) TYPE(*CHAR) LEN(1)
DCL VAR(&MSG) TYPE(*CHAR) LEN(80)
IF COND(&TYP = J) THEN(DO)
CVTDAT DATE(&IN) TOVAR(&OUT) FROMFMT(*MDY) +
TOFMT(*JUL) TOSEP(*NONE)
ENDDO
IF COND(&TYP = M) THEN(DO)
CVTDAT DATE(&IN) TOVAR(&OUT) FROMFMT(*JUL) +
TOFMT(*MDY) TOSEP(*NONE)
ENDDO
CHGVAR VAR(&MSG) VALUE('IN=' || &IN || ' OUT=' || +
&OUT)
SNDPGMMSG MSG(&MSG)
ENDPGM
Command line interpreter for OS/400. Accessed through the OS/400 menu system; in general, most places where a menu option can be supplied a CL command can be entered instead.
Its provision of a fill-in form interface (for 5250 block terminals or emulators), in which the system understands the syntax of commands and guides the user through their use, is particularly interesting.