Instruction elements

A Rexx instruction consists of one or more syntax elements. Multiple elements within an instruction are separated by spaces, comments, special characters, or expression operators until an instruction terminator is encountered. Some elements are keywords, which either determine the current instruction's type, or are significant within the instruction's context. An instruction is classified by a series of rules. The remaining elements in an instruction are tokens.

Here is an example of a Rexx instruction:

if ( name = 'Jane' ) & ( password = 'shazam' ) then /* check user and password */

  if
  (
  name
  =
  'Jane'
  )
  &
  (
  password
  =
  'shazam'
  )
  then
  /* check user and password */

• the space characters are element separators

• if and then are keywords

• the parentheses, =, and & characters are expression operator characters

• a comment appears at the end of the instruction, beginning with the /* characters and concluding with the */ characters

• the following elements are tokens:
  • name
  • 'Jane'
  • password
  • 'shazam'

Tokens

A token is one of the following:

• literal string -- a sequence of characters in quotes

• hexadecimal string -- a sequence of hexadecimal digits, in quotes, followed by an 'X' (or an 'x')

• binary string -- a sequence of binary digits, in quotes, followed by a 'B' (or a 'b')

• symbol

Warning: a left parenthesis that immediately follows a literal string, or a symbol reference, alters the syntactic meaning of the term. It becomes a function call instead. n = length( 'shazam' ) The word length above is considered to be a function invocation. n = 'LENGTH'( 'shazam' ) The literal string 'LENGTH' above is considered to be a function invocation.

Literal string

A literal string is delimited by a pair of quote characters. Either single or double quotes can be used to delimit the string.

  'This is a fine literal string'
  "This is another fine literal string"
  "Isn't the weather nice!"

 'thisIsNotALabel : abra * ca + dabra, or shazam ; and more...'

  'Don''t even think about it!'
  """To be, or not to be, that is the question."""

say length( '' ) shows, 0

Hexadecimal string

When a quoted string is immediately followed by an 'X' (or an 'x'), then the string is a hexadecimal string. Between the quotes a series of zero or more hexadecimal digits (0-9, a-f, A-F) are specified.

  '22bad'x
  "22BAD"X

 '2  2b  ad'x

  '2 2bad'X

  '22b ad'x

  '2 2ba d'X

Hexadecimal literal value

The value of a hexadecimal string is a literal string, which is a packed series of bytes. If the number of hexadecimal digits in the hexadecimal string is odd, it is prefixed by a leading hexadecimal '0'x. Then, pairs of hexadecimal digits are packed into the resulting literal string from left to right. Thus, the value

'22BAD'x

'02 2B AD'x

  +----+----+----+
  | 02 | 2B | AD |
  +----+----+----+
  +0   +1   +2

'22BAD'x

When there are no hexadecimal digits between the quotes, the length of the string is 0.

say length( ''x ) shows, 0

Binary string

When a quoted string is immediately followed by a 'B' (or a 'b'), then the string is a binary string. Between the quotes a series of zero or more binary digits (0 or 1) are specified.

  '10111'b
  "10111"B

  '1  0111'b

  '1  0111  1100'B

  '10111  1100'b

  '1 01111  100'B

Binary literal value

The value of a binary string is a literal string, which is a packed series of bytes. If the number of binary digits in the binary string is not a multiple of 8, it is prefixed by sufficient leading '0'b binary digits. The binary digits are then converted to a hexadecimal string, four bits per hexadecimal digit. Then, the hexadecimal string is converted to a literal string as described in the hexadecimal string section above. The value

'11101'b

'0001 1101'b

'1D'x

The length of the binary string

'11101'b

When there are no binary digits between the quotes, the length of the string is 0.

say length( ''b ) shows, 0

Symbol

Rexx symbols are sequences of numbers, letters, and the characters: . ! ? and _. These are either numeric values or potential variable references. These are described in detail on a separate page -- click here.

Operator characters

A Rexx expression operator is formed from one or more of the following characters:

  +  -  *  /  %  |  =  ¬  \  <  >  &  (  )

In some contexts a space character can also be a concatenation operator.

Special characters

The following characters are treated specially within an instruction.

  ,  ;  :

A comma is used for multiple purposes:

• as a parameter delimiter in subroutine and function calls
• as a template delimiter in parse arg and arg instructions
• as an instruction continuation character

A semicolon is an instruction terminator

A colon is used in labels

In addition a right parenthesis is special -- denoting the end of an expression, or function call.

Tabs and spaces -- implementation-dependent note

Text values that contain tab characters can be problematic for Rexx programs. When printed, a tab character may appear as one or more spaces. At the end of a text value, the tab character is invisible. In the following contexts difficulties ensue if a tab character is not considered equivalent to a space character.

• various built-in functions -- especially compare, subword, word, wordlength, etc.
• string comparison
• parsing

Special implementation support is required to treat a tab character equivalent to a space. Some implementations never consider a tab character to be equal to a space. Some implementations always consider a tab character equivalent to a space.