unary address operators
The unary address operators are & and &&.
& returns the memory address of the following variable, array, array node, array data element, or composite element. Applying & to numeric AUTO variables may produce compile-time "Bad Scope" errors because AUTO variables may be assigned space in CPU registers, which do not have addresses. String and composite variables are always located in memory, so applying & to strings and composites is always valid. The valid forms of & are:
&array-node &token[func, ]
&array-data &token[func, line, element]
&string-array-node &name$[dept, ]
&string-array-data &name$[dept, stationNumber]
&& returns the handle address of the following string variable , composite variable, whole array, or string array element. Numeric variables and components of composite variables do not have handles, so applying && to them produces compile-time errors. Applying && to AUTO strings, arrays, and composites produces compile-time errors because they may be assigned space in CPU registers, which do not have addresses. The valid forms of && are:
&&string-variable (non-AUTO) &&name$
&&whole-array (non-AUTO) &&token
&&whole-string-array (non-AUTO) &&symbols$
&&string-array-data &&name$[dept, stationNumber]
...(same result as above) &name$[dept, stationNumber,]
unary arithmetic operators
The unary arithmetic operators are + and - .
+, when a unary operator, is the unary positive operator, which performs no operation on the following operand. It makes sign visible and explicit where appropriate for program clarity.
-, when a unary operator, is the unary negative operator which changes the sign of the following operand. The sign bit of the operand value is inverted, or the operand value is subtracted from zero, whichever is appropriate for the operand data type.