Command Arguments
Following a command keyword, there can be zero, one, or multiple arguments that specify the object(s) or the scope of the command. If a command takes one or more arguments, you must include exactly one space between the command keyword and the first argument. For example:
SET x = 2
Spaces can appear within arguments or between arguments, so long as the first character of the first argument is separated from the command itself by exactly one space (as appears above). Thus the following are all valid:
SET a = 1
SET b=2
SET c=3,d=4
SET e= 5 , f =6
SET g
= 7
WRITE a,b,c,d,e,f,g
If a command takes a postconditional expression, there must be no spaces between the command keyword and the postconditional, and there must be exactly one space between the postconditional and the beginning of the first argument. Thus, the following are all valid forms of the QUIT command:
QUIT x+y
QUIT x + y
QUIT:x<0
QUIT:x<0 x+y
QUIT:x<0 x + y
No spaces are required between arguments, but multiple blank spaces can be used between arguments. These blank spaces have no effect on the execution of the command. Line breaks, tabs, and comments can also be included within or between command arguments with no effect on the execution of the command. For further details, see White Space.
Multiple Arguments
Many commands allow you to specify multiple independent arguments. The delimiter for command arguments is the comma ,. That is, you specify multiple arguments to a single command as a comma-separated list following the command. For example:
SET x=2,y=4,z=6
This command uses three arguments to assign values to the three specified variables. In this case, these multiple arguments are repetitive; that is, the command is applied independently to each argument in the order specified. Internally, InterSystems IRIS® data platform parses this as three separate SET commands. When debugging, each of these multiple arguments is a separate step.
In the command syntax provided in the command reference pages, arguments that can be repeated are followed by a comma and ellipsis: ,.... The comma is a required delimiter character for the argument, and the ellipsis (...) indicates that an unspecified number of repetitive arguments can be specified.
Repetitive arguments are executed in strict left-to-right order. Therefore, the following command is valid:
SET x=2,y=x+1,z=y+x
but the following command is not valid:
SET y=x+1,x=2,z=y+x
Because execution is performed independently on each repetitive argument, in the order specified, valid arguments are executed until the first invalid argument is encountered. In the following example, SET x assigns a value to x, SET y generates an <UNDEFINED> error, and because SET z is not evaluated, the <DIVIDE> (divide-by-zero) error is not detected:
KILL x,y,z
SET x=2,y=z,z=5/0
WRITE "x is:",x
Arguments with Parameters and Postconditionals
Some command arguments accept parameters (not to be confused with function parameters). If a given argument can take parameters, the delimiter for the parameters is the colon :).
The following sample command shows the comma used as the argument delimiter and the colon used as the parameter delimiter. In this example, there are two arguments, with four parameters for each argument.
VIEW X:y:z:a,B:a:y:z
For a few commands (DO, XECUTE, and GOTO), a colon following an argument specifies a postconditional expression that determines whether or not that argument should be executed.
Argumentless Commands
Commands that do not take an argument are referred to as argumentless commands. A postconditional expression appended to the keyword is not considered an argument.
There are a small number of commands that are always argumentless. For example, HALT, CONTINUE, TRY, TSTART, and TCOMMIT are argumentless commands.
Several commands are optionally argumentless. For example, BREAK, CATCH, FOR, GOTO, KILL, LOCK, NEW, QUIT, RETURN, TROLLBACK, WRITE, and ZWRITE all have argumentless syntactic forms. In such cases, the argumentless command may have a slightly different meaning than the same command with an argument.
If you use an argumentless command at the end of the line, trailing spaces are not required. If you use an argumentless command on the same code line as other commands, you must place two (or more) spaces between the argumentless command and any command that follows it. For example:
QUIT:x=10 WRITE "not 10 yet"
In this case, QUIT is an argumentless command with a postconditional expression, and a minimum of two spaces is required between it and the next command.
Argumentless Commands and Curly Braces
Argumentless commands when used with command blocks delimited by curly braces do not have whitespace restrictions:
-
An argumentless command that is immediately followed by an opening curly brace has no whitespace requirement between the command name and the curly brace. You can specify none, one, or more than one spaces, tabs, or line returns. This is true both for argumentless commands that can take an argument, such as FOR, and argumentless commands that cannot take an argument, such as ELSE.
FOR {
WRITE !,"Quit out of 1st endless loop"
QUIT
}
FOR{
WRITE !,"Quit out of 2nd endless loop"
QUIT
}
FOR
{
WRITE !,"Quit out of 3rd endless loop"
QUIT
}
-
An argumentless command that is immediately followed by a closing curly brace does not require trailing spaces, because the closing curly brace acts as a delimiter. For example, the following is a valid use of the argumentless QUIT:
IF 1=2 {
WRITE "Math error"}
ELSE {
WRITE "Arthmetic OK"
QUIT}
WRITE !,"Done"
