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
load Used to compile files. See *LOAD
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 Jump to end of current procedure, see *RETURN
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.
uses For secretly loading library programs if not already loaded.
vars Declare variables, see *VARS
vectorclass Macro for defining new classes of vectors. See *VECTORCLASS
while Start iteration, continue while condition met, see *WHILE
with_nargs Use in procedure definition to specify number of arguments
See *WITH_NARGS
with_props Use in procedure definition to specify initial *PDPROPS
See REF *SYNTAX
--- C.all/help/syswords
--- Copyright University of Sussex 1992. All rights reserved. ----------