Syntax summary:

Instructions:

variable = expression

result = functionName( [ argumentExpression [ , argumentExpression [ , ...etc ] ] )

1. address environmentName
2. address [ VALUE ] environmentExpression
3. address
4. address environmentName commandExpression

arg [ template ]

call procedureName [ argumentExpression [ , argumentExpression [ , ...etc ] ]

call ON conditionName [ NAME trapLabel ]
  

---


call OFF conditionName

commandExpression

do
  instruction
  instruction
  ...etc
  end

do [ repetitorClause ] [ conditionalClause ]
  instruction
  instruction
  ...etc
  end [ name ]
  

---

the repetitorClause can be one of the following:

controlVariable = initialValue [ to limitValue ] [ by stepValue ] [ for repetitionValue ]

repetitionValueExpression

forever

  

---

the conditionalClause can be one of the following:

while booleanExpression

until booleanExpression

drop variableList

end [ loopControlVariableName ]

exit [ valueExpression ]

if booleanExpression then ... else ...

if booleanExpression then   instruction if booleanExpression then   instruction else   instruction if booleanExpression then do   instruction   instruction   ...etc   end if booleanExpression then   instruction else do   instruction   instruction   ...etc   end if booleanExpression then do   instruction   instruction   ...etc   end else do   instruction   instruction   ...etc   end if booleanExpression then do   instruction   instruction   ...etc   end else   instruction

interpret sourceExpression

iterate [ loopControlVariableName ]

leave [ loopControlVariableName ]

  nop

numeric DIGITS [ digitsExpression ]

---

numeric SCIENTIFIC

---

numeric ENGINEERING

---

numeric FORM [ VALUE ] formValueExpression

---

numeric FUZZ [ fuzzExpression ]

options optionSetting(s)

parse [ upper ] valueToParse [ template ]
  

---

Where, valueToParse is one of the following:

  arg

  linein

  pull

  source

  value [ expression ] with

  var variableName

  version

procedureNameLabel : [ procedure [ expose variableList ] ]

pull [ template ]

push [ valueExpression ]

queue [ valueExpression ]

return [ valueExpression ]

SAY [expression]

select
when booleanExpression then instruction(s)
when booleanExpression then instruction(s)
...etc.
[ otherwise [ instructions ] ]
end

signal labelName
  

---

signal [ VALUE ] labelExpression

signal ON conditionName [ NAME trapLabel ]
  

---


signal OFF conditionName

The conditionName in the signal ON or OFF is one of the following:

• ERROR

• FAILURE

• HALT

• NOTREADY

• NOVALUE

• SYNTAX

1. trace setting
2. trace [ VALUE ] settingExpression
3. trace

Built-in functions

  result = Abbrev( information, info [, length ] ] )

  result = Abs( number )

  result = Address()

  result = Arg( [ n [, option ] ] )

  result = B2X( binary-string )

  result = BitAnd( [ string1 [, [string2] [, pad ] ] ] )

  result = BitOr( [ string1 [, [string2] [, pad ] ] ] )

  result = BitXor( [ string1 [, [string2] [, pad ] ] ] )

  result = C2D( string [, n ] )

  result = C2X( string )

  result = Centre( string, length [, pad ] )

  result = Center( string, length [, pad ] )

  result = Charin( [ stream ] [, [ start ] [, length ] ] )

  result = Charout( [ stream ] [, [ string ] [, start ] ] )

  result = Chars( [ stream ] )

  result = Compare( string1, string2 [, pad ] ] )

  result = Condition( [ option ] )

  result = Copies( string, n )

  result = D2C( number [, length ] )

  result = D2X( number [, length ] )

  result = Datatype( string [, type ] )

  result = Date( [ format ] )

  result = Delstr( string, offset [, length ] )

  result = Delword( string, offset [, length ] )

  result = Digits()

  result = Errortext( number )

  result = Form()

  result = Format( number [, [ before ] [, [ after ] [, [ expp ] [, [ expt ] ] ] ] )

  result = Fuzz()

  result = Insert( new, target [, [ offset ] [, [ length ] [, pad ] ] ] )

  result = Lastpos( needle, haystack [, offset ] )

  result = Left( string, length [, pad ] )

  result = Length( string )

  result = Linein( [ stream ] [, [ line# ] [, count ] ] )

  result = Lineout( [ stream ] [, [ string ] [, line# ] ] )

  result = Lines( [ stream ] )

  result = Max( n1 [, n2 ] [, ... ] )

  result = Min( n1 [, n2 ] [, ... ] )

  result = Overlay( new, target [, [ offset ] [, [ length ] [, pad ] ] ] )

  result = Pos( needle, haystack [, offset ] )

  result = Queued()

  result = Random( [ minOrMax ] [, [ max ] ] [, seed ] ] )

  result = Reverse( string )

  result = Right( string, length [, pad ] )

  result = Sign( number )

  result = Sourceline( [ line# ] )

  result = Space( string [, [ n ] [, pad ] ] )

  result = Stream( name, [, operation [, command ] ] )

  result = Strip( string [, [ option ] [, character ] ] )

  result = Substr( string, n [, [ length ] [, pad ] ] )

  result = Subword( string, n [, [ length ] )

  result = Symbol( name )

  result = Time( [ format ] )

  result = Trace( [ setting ] )

  result = Translate( string [, [after] [, [before] [, pad ] ] ] )

  result = Trunc( number [, n ] )

  result = Value( symbol [, [ newvalue ] [, pool ] ] )

  result = Verify( string, charSet [, [ option ] [, start ] ] )

  result = Word( string, n )

  result = Wordindex( string, n )

  result = Wordlength( string, n )

  result = Wordpos( phrase, string [, ] )

  result = Words( string )

  result = X2B( hexadecimalString )

  result = X2C( hexadecimalString )

  result = X2D( hexadecimalString [, n ] )

  result = Xrange( [ start ] [, end ] )

Expression operators:

(space)	date() time()	the space between the functions is a space concatenation operator
||	date() || time()	the '||' operator is an explicit concatenation operator
(abuttal)	date()' at 'time()	the quoted string is implicitly concatenated to the adjacent terms

+	Add	21 + 21
-	Subtract	44 - 2
*	Multiply	6 * 7
/	Divide	84 / 2
%	Integer divide	85 % 2
//	Remainder	42 // 50	similar to modulo but the result can be negative
**	Power (exponent)	2 ** 4
Prefix +	(0 + number)	+ 42
Prefix -	(0 - number)	- 42

=	equal
¬=, \=, ><, <>	not equal
>	greater than
<	less than
>=, ¬<, \<	greater than or equal; not less than
<=, ¬>, \>	less than or equal; not greater than

==	strictly equal
¬==, \==	strictly not equal
>>	strictly greater than
<<	strictly less than
>>=, ¬<<, \<<	strictly greater than or equal; strictly not less than
<<=, ¬>>, \>>	strictly less than or equal; strictly not greater than

&	And	returns '1' when both terms are true, and '0' otherwise
|	Or	returns '1' when either term is true, and '0' otherwise
&&	Exclusive or	returns '1' when one of the terms is true (but not both), and '0' otherwise
Prefix ¬, Prefix \	Logical not	returns '1' when the term is '0', and '0' when the term is '1'.