[top] [prev]

Index

# operator,  * 
& operator,  * 
(* *) (comment),  * 
* operator,  * 
+ operator,  * 
- operator,  * 
. operator,  * 
.. in set and array constructors,  *  * 
/ operator,  * 
<* *> (pragma),  * 
<: declaration,  *  * 
= operator,  *
^ operator,  *

A

ABS,  * 
abstract type,  * 
Ada programming language,  *  *  *
addition,  * 
ADDRESS,  * 
ADDRESS, assignment of,  *  * 
ADR,  * 
ADRSIZE,  * 
aggregate, see records or arrays
Algol programming language,  * 
aliasing, of VAR parameters,  *
alignment, see packed types
allocated type,  * 
allocation,  * 
AND,  * 
arithmetic operations,  * 
arrays,  * 
arrays, assigning,  *  *  *  *  *  *  *  *  *  * 
ASCII, see ISO-Latin-1
assignable,  * 
assignable, READONLY/VALUE formals,  *  *  *  *  *  *  *  *  *  * 
assignment statements,  * 
automatic dereferencing,  * 

B

B programming language,  * 
backslash, in literals,  * 
base type,  * 
BCPL programming language,  * 
binding power, of operators,  * 
bindings, in procedure call,  * 
bit operations,  * 
BITS FOR,  *  *  *  * 
BITSIZE,  * 
Bliss programming language,  * 
block,  * 
block, module,  *  *  * 
body, of procedure,  * 
BOOLEAN,  * 
BOOLEAN, operations on,  * 
BRANDED,  * 
BYTESIZE,  * 

C

C programming language,  * 
C++ programming language,  * 
call, procedure,  * 
CARDINAL,  * 
carriage return, in literals,  * 
CASE statement,  * 
case, in keywords,  *  * 
Cedar programming language,  * 
CEILING,  * 
CHAR,  * 
character literals,  *  * 
checked runtime error,  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  * 
circularities, in imports lists,  *  * 
CLU programming language,  *
coercions, checked,  *  * 
comments,  * 
comments, tokenizing,  * 
comparison operation,  * 
complete revelation,  * 
concatenating texts,  * 
concrete types,  * 
constant expression,  *  * 
constants,  * 
constants, declarations,  *  *  * 
constructors, array,  *  *  * 
contain (value in type),  * 
conversion, enumerations and integers,  *  * 
covers, for procedure signatures,  * 
cyclic imports,  * 

D

dangling pointer,  * 
data record, of object,  * 
deallocation,  * 
DEC,  * 
DEC, on addresses (unsafe),  * 
declaration,  * 
declaration, recursive,  *  * 
default values, in record fields,  *  *  * 
delimiters, complete list,  * 
dereferencing,  * 
designators,  * 
designators, operators allowed in,  *  *  * 
dimension,  * 
DISPOSE,  * 
DIV,  * 
division by zero,  * 
division, real,  * 
double quote, in literals,  * 

E

element type, of array,  * 
empty type,  * 
enumerations,  * 
enumerations, first and last elements,  *  *  *  * 
environment, of procedure,  * 
equality operator,  * 
errors, static and runtime,  * 
escape sequences, in literals,  * 
EVAL,  * 
example, pathological,  *  * 
exceptions,  *  * 
exceptions, RAISE,  *  *  *  *  *  * 
EXIT,  * 
exit-exception,  *  *  * 
expanded definition (of type),  * 
exporting an interface,  * 
EXPORTS clause,  * 
expression,  *  * 
expression, constant,  *  *  * 
EXTENDED,  * 
EXTENDED, literals,  * 
EXTERNAL,  * 

F

FALSE,  * 
field selection, records/objects,  * 
fields, of record,  * 
FIRST,  * 
fixed arrays,  *  *  * 
FLOAT,  * 
floating point numbers,  * 
floating-point interfaces,  * 
FLOOR,  * 
Fmt interface,  * 
FOR statement,  * 
fork (of a thread),  *
form feed, in literals,  * 
formatting data as texts,  * 
FROM ... IMPORT,  * 
function procedures,  *  *  * 

G

garbage collection,  *  * 
generic interface,  *  *  * 
generics,  *  *

H

handlers, for exceptions,  * 
hash tables, see Table interface  * 
hexadecimal literal,  * 

I

identifiers,  * 
identifiers, lexical structure,  *  *  *  *  * 
IF,  * 
import cycle,  * 
imports,  * 
IN (a set),  * 
INC,  *  * 
index type, of array,  * 
inheritance,  * 
initialization, during allocation,  *  *  *  * 
INLINE,  * 
INTEGER,  * 
interfaces,  *  * 
interfaces, exporting,  *  *  *  * 
intersection, set,  * 
intrinsically safe,  * 
ISO-Latin-1,  * 
ISTYPE,  * 

J

join (of a thread),  *

K

keyword binding,  * 
keywords, complete list,  * 

L

LAST,  * 
Lisp programming language,  * 
literals, character,  *  *  *  * 
local procedures,  *  *  * 
location,  * 
LOCK statement,  *
Long interface,  * 
LONGINT,  *
LONGREAL,  * 
LONGREAL, literals,  * 
LOOP,  * 
LOOPHOLE,  * 

M

main module,  * 
masked field,  * 
MAX,  * 
member (value in type),  * 
Mesa programming language,  * 
method suite,  * 
methods,  * 
methods, declaring,  *  *  *  * 
MIN,  * 
ML programming language,  *
MOD,  * 
mode, see parameter mode
Modula-2 programming language,  *
Modula-3 Abstract Syntax Trees,  * 
modules,  *  * 
modules, initialization,  *  * 
monitor,  *
multi-dimensional arrays,  * 
multiplication,  * 
MUTEX,  *  *

N

NARROW,  * 
NEW,  * 
newline, in literals,  * 
NIL,  * 
normal outcome,  * 
NOT,  * 
NULL,  * 
NUMBER,  * 
numbers, literal,  * 

O

Oberon programming language,  * 
objects,  *  * 
objects, accessing fields and methods,  *  *  *  *  *  *  *  *  * 
octal literal,  * 
opaque types,  * 
open arrays,  *  *  *  *  * 
operators, complete list,  *  *  * 
OR,  * 
ORD,  * 
order (<, >, ...),  *  * 
ordinal types,  *  *  *  * 
overflow,  * 
overloading, of operation,  * 
overriding,  *  * 

P

package, see module
packed types,  *  * 
parameter mode,  *  * 
partial expansion (of type),  *  *  * 
partially opaque type,  *  *
Pascal programming language,  * 
persistent storage, see Pkl interface  * 
Pkl (pickle) interface,  * 
pointer, see reference
positional binding,  * 
pragmas,  * 
precedence, of operators,  * 
procedural operator,  * 
procedure call,  * 
procedures,  * 
procedures, RETURN,  *  *  *  *  *  *  *  *  *  *  *  *  * 
process algebra,  * 
process, see thread
program, definition of,  * 
proper procedure,  * 

Q

qualified identifier,  * 

R

RAISE,  *
RAISES,  * 
raises set, of procedure,  * 
RAISES, dangling,  *  *
readonly designator,  *  * 
READONLY parameters,  * 
REAL,  * 
real division,  * 
REAL, conversions to,  *  *  * 
records,  * 
records, constructors for,  *  *  * 
recursive declarations,  * 
REFANY,  * 
reference class,  * 
references,  * 
references, TYPECASE,  *  *  *  *  *  *  *  * 
referent,  *  * 
reflexive relation,  * 
relational operators,  * 
remainder, see MOD
REPEAT statement,  * 
required interfaces,  * 
result type, of procedure,  * 
RETURN,  * 
return-exception,  *  * 
REVEAL,  * 
revelations,  * 
revelations, imported,  * 
ROOT,  * 
ROUND,  * 
rounding of arithmetic operations,  * 
runtime error,  * 

S

safety,  *  * 
scale factors, in numeric literals,  * 
scope,  * 
scope, block statement,  *  *  *  *  *  *  *  *  *  *  * 
selection of fields,  * 
sequential composition,  * 
sets,  * 
sets, IN operator,  *  *  *  *  *  *  *  * 
shape, of array,  * 
shared variables,  * 
sign inversion,  * 
signature,  *  * 
signature, covers,  * 
single quote, in literals,  * 
size, of type,  * 
Smalltalk programming language,  * 
statements,  * 
static error,  *  * 
storage allocation,  *  *  * 
strings,  * 
strings, see texts  * 
structural equivalence,  *
SUBARRAY,  * 
subranges,  * 
subranges, subtyping rules,  * 
subscript operator,  * 
subset operation,  * 
subtraction,  * 
subtype relation,  * 
supertype (subtyping relation),  * 
symmetric set difference,  * 
syntax,  * 

T

tab, in literals,  * 
Table interface,  * 
task, see thread
termination of program,  * 
TEXT,  * 
Text interface,  *
texts,  * 
texts, concatenating,  *  *  * 
Thread creation,  *
threads,  * 
tokenizing,  * 
top-level procedure,  * 
Topaz system,  * 
traced, object types,  *  *  * 
transitive relation,  * 
TRUE,  * 
TRUNC,  * 
TRY EXCEPT,  *  * 
type,  *  *  *  *  * 
type, assignable,  *  *  *  *  *  *  *  * 
TYPECASE,  * 
TYPECODE,  * 

U

unchecked runtime errors,  *  *
undefined procedure,  * 
underflow,  * 
union, of sets,  * 
UNSAFE,  * 
unsafe features,  * 
unsigned integers,  *  * 
UNTRACED ROOT,  * 
UNTRACED, in reference declarations,  *  * 

V

VAL,  * 
value,  * 
VALUE parameters,  *  * 
VAR declarations,  *  *  * 
variables,  *  * 
variables, initialization,  *  *  * 
variant records,  * 
visibility, see scope

W

WHILE statement,  * 
WITH statement,  * 
Word interface,  * 
word size, of type,  * 
writable designator,  *  * 

X

Y

Z

zero, division by,  *

[top] [prev]