```Search                        Top                                  Index
```
```HELP SYSWORDS                             Updated Aaron Sloman, Nov 1986

See HELP *HELPFILES for an overview of documentation files.

CONTENTS - (Use <ENTER> g to access sections)

-- Introduction
-- Arithmetic operators
-- Logical bitwise operators (all of precedence 4)
-- Bitwise comparisons (precedence 6)
-- Other non-alphanumeric symbols
-- Datawords of built in data-types
-- Syntax words and macros

-- Introduction -------------------------------------------------------

Non-alphanumeric symbols and operations are listed immediately
below. They are followed by POP11 SYNTAX words and the words which
are used as datawords of system objects. E.g.

dataword(99) = "integer".

Some of the entries have separate HELP or TEACH files, or both.
Names of HELP files are preceded by asterisks.

Infix operation identifiers are listed with their precedences in
HELP *PRECEDENCE

REF *POPSYNTAX gives POP-11 syntax diagrams

-- Arithmetic operators ------------------------------------------

See REF *NUMBERS
+       Add one number to another, eg 4 + 5 = 9
-       Subtract one number from another, eg 5 - 3 = 2
if at start of expression is unary minus, eg -5 * 4 = -20
*       Multiply two numbers, eg 4 * 5 = 20
**      Raise one number to the power of another, eg 2 ** 3 = 8
/       Divide one number by another, eg 8 / 4 = 2
//      Divide one integer by another to get dividend and remainder,
eg 10 // 3 -> dividend -> remainder;
<       Compare two numbers; result true if first smaller
<=      Compare two numbers; result true if first smaller or equal
>       Compare two numbers; result true if first greater
>=      Compare two numbers; result true if first greater or equal
==#     Compare two items; result true if they are identical (i.e. ==)
or numbers of same type and value

-- Logical bitwise operators (all of precedence 4) ----------------

&&      Logical 'and' on two integers treated as bitstrings,
eg 27 && 22 = 18
&&~~    Logical 'and_not' on two integers treated as bitstrings
~~      Logical 'negate' on an integer treated as a bitstring,
eg ~~ 5 = 6
||      Logical 'or' on integers treated as bit strings,
eg 27 || 22 = 31
||/&    Logical exclusive OR on two integers
<<      Logical 'shift left' on integer as bitstring,
eg 12 << 2 = 48
>>      Logical 'shift right', on integer as bitstring,
eg 48 >> 2 = 12

-- Bitwise comparisons (precedence 6) ---------------------------------

x &&=_0 y -> <boolean>
True if bitwise logical "and" of X and Y is equal to 0

x &&/=_0 y -> <boolean>
True if bitwise logical "and" of X and Y is not equal to 0

For more on bitwise operations on integers see REF * NUMBERS

See REF *FASTPROCS for non-type-checking versions of arithmetic and
logical operators (i.e. fi_+ fi_-, fi_~~, etc.)

-- Other non-alphanumeric symbols -------------------------------------

'       String constructor, eg 'string', see *STRINGS and REF ITEMISE
`       Quote a character, eg `a`, see *ASCII, and REF ITEMISE
"       Word quote, eg "word", see *WORDS
%       For unquoting in lists and vectors, see *PERCENT,
and for partial application, see *PARTAPPLY
(       Used in procedure calls, forming expressions etc, see *ROUNDBRA
)       Closing bracket for '('
{       Vector constructor, eg {vector}, see  *TWIDDLYBRA
}       Closing bracket for Vector expressions.
,       Separates expressions, variables in declarations etc
-->     Pattern matched assignment, mishap if it fails, see  *MATCHES
->      Assignment arrow, eg 3 -> X (notice goes left to right)
->>     Assign and leave on stack, eg 0 ->> X -> Y (sets X and Y to zero)
.       Infix version of 'apply', eg [a b c].hd = "a"
/=      Not equal (works recursively on structures)
/==     Not identical (doesn't work recursively on structures)
/* ... */
Comment brackets
:       Use after a word to make it a label, see  *GOTO
::      Create a new list link, eg "a" :: [b c d] = [a b c d]
Second argument must be a list (possibly empty)
;       Separate commands, terminate procedure headers etc
<>      Concatenate two structures; works on strings, lists, words,
vectors, procedures, eg 'abc' <> 'def' = 'abcdef',
[a b c] <> [d e f] = [a b c d e f], "abc" <> "def" = "abcdef",
{a b c} <> {d e f} = {a b c d e f}
nc_<>   like <> but on lists does not copy first argument.
=       Equal (works recursively on structures)
==      Identical (doesn't recurse on structures)
==>     Pretty printer for lists and vectors. Does indentation, etc.
=>      Print Arrow
><      String concatenator, combines any two printable things to a string,
see  *STRINGS.
dir_><  String concatenator for directory names and file names. Copes
with either Unix or VMS formats, depending on operating system.
?       Match one list element, see  *MATCHES
??      Match arbitrarily many list elements, see  *MATCHES
[       List constructor, eg [a list], see  *SQUAREBRA
]       List closing bracket
^       Insert value of next word into list or vector, see TEACH *ARROW
^^      Merge value of next word into list or vector, see TEACH *ARROW
#_< ... code  >_#
execute code at compile time see * HASH_
#_IF <condition1>
<code>
#_ELSEIF <condition2>
<code>
#_ELSE
<code>
#_ENDIF
Used for conditional compilation. Conditions evaluated at compile
time.

-- Datawords of built in data-types -----------------------------------

biginteger  Dataword of big integers (e.g. 2**99).
boolean     Dataword of *TRUE and *FALSE
complex     Dataword of complex numbers
ddecimal    Dataword of double precision decimals
decimal     Dataword of singe precision decimals
device      Dataword of device records
ident       Dataword of identifiers
integer     Dataword of integers
intvec      Dataword of invects - see REF * INTVEC
key         Dataword of keys, see  *KEYS.
nil         Dataword of nil i.e. []
pair        Dataword of pairs, see  *CONSPAIR
procedure   Dataword of procedures
process     Dataword of processes, see  *PROCESS
prologterm  Dataword of Prolog terms
prologvar   Dataword of prolog vars
ratio       Dataword of ratios (e.g. 3/4)
ref         Dataword of items created by CONSREF. Also a macro for using the
VED editor to read REFerence files.
section     Dataword of sections
string      Dataword for strings
termin      dataword of *TERMIN
undef       Dataword of undef objects
vector      Dataword for vectors
word        Dataword of words.

-- Syntax words and macros --------------------------------------------

active      identprops of active variables
and         Boolean 'and', combines two booleans, see  *AND
andcase     See  *SWITCHON
by          See  *FOR
case        See  *SWITCHON
constant    For declaring constant identifiers. See  *CONSTANT.
cons_with <expression> { ... }
For building arbitrary structures.
constant    identifier declaration
define      Used for procedure definitions, see  *DEFINE
dlocal      For declaring dynamic locals. See HELP * DLOCAL
dlvars      See *DLVARS
do          A synonym for THEN, see  *UNTIL,  *WHILE, and  *FOR
else        Used in conditionals, see  *IF
elseif      See  *IF
elseunless  See  *IF
enddefine   End of procedure definition
endfast_for See REF * FASTPROCS
endfor      End of a FOR loop, see  *FOR
endforeach  End of a FOREACH loop, see  *FOREACH
endforevery End of a FOREVERY loop, see  *FOREVERY
endform     See *FORMS
endif       End of an IF statement, see  *IF
endprefix   End of PREFIX section, see  *PREFIX
endprocedure End of anonymous procedure, see  *PROCEDURE
endrecord   Switch off recording, see  *RECORD
endrepeat   End of a REPEAT loop, see  *REPEAT
endswitchon End of a SWITCHON, see  *SWITCHON
endsection  End of a section see *SECTIONS
endunless   End of an UNLESS statement, see  *UNLESS
enduntil    End of an UNTIL loop, see  *UNTIL
endwhile    End of a WHILE loop, see  *WHILE
fast_for    See REF * FASTPROCS
for         Start of an iterative loop, see  *FOR
foreach     Start of a database iteration loop, see  *FOREACH
forever     Used in REPEAT FOREVER.....ENDREPEAT. Endless iteration.
forevery    Start of iteration over combinations of database items,
see  *FOREVERY
form        Start of new syntax specification. See *FORMS
from        Used with FOR, see  *FOR
global      Used with vars and sections. See *GLOBAL
go_on <expression> to <labels.....> else <label> ;
Computed goto. See  *GO_ON. See  *SWITCH
goto        Archaic, used to transfer control to a label
if          Start of conditional statement, see  *IF
in          Used with FOR, see  *FOR
lconstant   Used with lexical variables. See HELP * LEXICAL REF *VMCODE
lvars       For lexically scoped local variables. see *LVARS, REF *VMCODE
macro       Used when declaring or defining macros, see  *MACRO
nextif(condition)
For loop control. Equivalent to:
if condition the nextloop endif;
nextloop    Terminate this iteration and start next, see  *NEXTLOOP
nextloop(N) Terminate Nth nested iteration and start next, see NEXTLOOP
nextunless(condition) - see nextif
nonactive   Can preced an active variable to deactivate it.
nonmac      Prevents a macro being expanded, see  *NONMAC
nonop       Prevents an infix procedure being applied, see  *NONOP
nonsyntax   Preceding a syntax word prevents it being applied.
notcase     Used with SWITCHON, see  *SWITCHON
on          Used in FOR loops, see  *FOR
or          Boolean 'or' on conditions, see  *OR
prefix      protect variables by preceding them with prefix, see  *PREFIX
procedure   Introduces anonymous procedure, see  *PROCEDURE
pwd         Macro to print out current_directory
quitif(condition)
Terminate current iteration if satisfied, see  *QUITIF
quitif(condition)(N)
As QUITIF, but leaves Nth enclosing iteration
quitloop    Terminate current iteration, see  *QUITLOOP
quitloop(N) As QUITLOOP but terminates Nth enclosing iteration
quitunless(condition)
As QUITIF except condition must be FALSE to terminate
record      Switches on recording of terminal interaction, see  *RECORD
recordclass Macro for defining new structures, see  *RECORDCLASS
repeat      Start a fixed number of iterations, see  *REPEAT
return(item) As above, but leave item on stack.
section     start a section. See *SECTIONS
step        Used with FOR, see  *FOR
switch      Go to one of a number of labels, see  *SWITCH
switchon    A generalised 'case' facility, see  *SWITCHON
syntax      Identprops of syntax words, see REF *IDENT
then        Used with IF and UNLESS
till        Used with FOR, see  *FOR
times       Used with REPEAT, see  *REPEAT
to          Used with FOR, see  *FOR
trace       used to switch on tracing of procedures
unless      Start conditional statement, see  *UNLESS
until       Start iteration, terminated when condition met, see  *UNTIL
untrace     Switch off tracing of procedures.
updaterof   Syntax word used with *DEFINE for defining updaters.