File [Ivy]<Nelson>Lupine>LupineSymbolTable.mesa.
Last edited by BZM on 2-May-82 22:47:03.
Last Edited by: Birrell, September 8, 1983 3:39 pm
DIRECTORY
FS USING [OpenFile],
Rope USING [ROPE],
Symbols USING [SEIndex, SENull, ISEIndex, ISENull],
SymbolTable USING [Base],
BasicTime USING [GMT],
TimeStamp USING [Stamp];
LupineSymbolTable: DEFINITIONS = BEGIN
This is a FRAME handle for all symbol table variables and procedures.
STBase: PRIVATE TYPE = SymbolTable.Base ← NIL | NULL;
This is a nonRope string alternative suitable for SDD.
String: TYPE = Rope.ROPE ← StringNIL;
StringNIL: String = NIL; -- Need nonNIL symbol so INLINEs compile OK.
GMT: TYPE = BasicTime.GMT;
VersionStamp: TYPE = TimeStamp.Stamp;
Interface file operations.
OpenInterface:
PROCEDURE [
interfaceFilename: String,
interfaceCapability:
FS.OpenFile ];
! OpenError[...].
OpenError:
ERROR [fileOrModuleName: String, why: OpenErrorCode];
This ERROR can come back from OpenError or EnumerateXXX.
OpenErrorCode:
TYPE =
{badFileFormat, badFileName, badFileVersion, notInterfaceModule};
CloseInterface: PROCEDURE;
InterfaceInfo:
TYPE =
RECORD [
types, variables: BOOLEAN←FALSE,
transfers: PACKED ARRAY TransferTypes OF BOOLEAN ← ALL[FALSE] ];
GetInterfaceInfo:
PROCEDURE
RETURNS [
contents: InterfaceInfo,
moduleName, fileName: String,
moduleVersion: VersionStamp,
moduleCreateTime, sourceCreateTime: GMT ];
MaxVersionStampStringLength: INTEGER = 19;
VersionStampString:
PROCEDURE [stamp: VersionStamp]
RETURNS [stampString: String];
Symbols, types, and their enumerators.
SymbolHandle:
TYPE =
PRIVATE
RECORD [
base: STBase, symbol: Symbols.ISEIndex] ← SymbolHandleNIL | NULL;
SymbolHandleNIL: SymbolHandle = [NIL, Symbols.ISENull];
TypeHandle:
TYPE =
PRIVATE
RECORD [
base: STBase, type: Symbols.SEIndex] ← TypeHandleNIL | NULL;
TypeHandleNIL: TypeHandle = [NIL, Symbols.SENull];
Index: TYPE = INTEGER[0..LAST[INTEGER]]; -- Meaningful user origin is 1.
All enumerators can raise OpenError[...] when an implicitly
referenced module is not found. Be sure to ENABLE!
DirectoryProcedure:
TYPE =
PROCEDURE [
moduleName, fileName: String,
imported: BOOLEAN,
directoryIndex: Index ]
RETURNS [stop: BOOLEAN←FALSE];
EnumerateDirectory:
PROCEDURE [proc: DirectoryProcedure]
RETURNS [stopped: BOOLEAN←FALSE];
TransferProcedure:
TYPE =
PROCEDURE [
transfer: SymbolHandle,
transferType: TypeHandle,
kind: TransferTypes,
argumentRecordType, resultRecordType: TypeHandle,
transferIndex: Index]
RETURNS [stop: BOOLEAN←FALSE];
EnumerateTransfers:
PROCEDURE [
proc: TransferProcedure,
all, procs, signals, errors: BOOLEAN ← FALSE]
RETURNS [stopped: BOOLEAN←FALSE];
ComponentProcedure:
TYPE =
PROCEDURE [
component: SymbolHandle,
componentType: TypeHandle,
componentIndex: Index]
RETURNS [stop: BOOLEAN←FALSE];
EnumerateRecord:
PROCEDURE [
recordType: TypeHandle, proc: ComponentProcedure]
RETURNS [stopped: BOOLEAN←FALSE];
VariantProcedure:
TYPE =
PROCEDURE [
variantTag: SymbolHandle,
variantNumber: INTEGER[0..LAST[INTEGER]], -- Assigned by compiler.
variantRecordType: TypeHandle,
variantIndex: Index ]
RETURNS [stop: BOOLEAN←FALSE];
EnumerateVariants:
PROCEDURE [
variantPartType: TypeHandle, proc: VariantProcedure]
RETURNS [stopped: BOOLEAN←FALSE];
Declarations of detailed type information.
Types:
TYPE = {
Definition,
Basic, Transfer,
Record, VariantPart,
Pointer, Ref, Any, List, RelativePtr,
Text, String, StringBody, Rope, Atom,
Array, Descriptor, Sequence,
Zone, Opaque,
Null, Other};
TransferTypes:
TYPE = {
Procedure, Error, Signal, Port, Program, Process, Other};
BasicTypes:
TYPE = {
Unspecified, Integer, Cardinal, Nat,
Word, Character, Boolean, Real,
Subrange, Enumeration, Other};
ParamPassingMethod: TYPE = {standard, var, value, result, handle};
TypeInfo:
TYPE =
RECORD [
self: TypeHandle,
long: BOOLEAN ← FALSE,
readonly: BOOLEAN ← FALSE,
passingMethod: ParamPassingMethod ← standard,
info:
SELECT type: Types
FROM
Null => [], -- Empty parameter records are Null.
Definition => [], -- Not needed or implemented.
Basic => [
kind: BasicTypes,
origin: LONG INTEGER, -- Incorrect for Real.
cardinality: LONG INTEGER], -- Incorrect for LONG INT & CARD, Real.
Transfer => [
kind: TransferTypes,
safe: BOOLEAN,
argumentType, resultType: TypeHandle],
Record => [
paramRecord, painted, monitored: BOOLEAN,
uniField, hasVariants, hasSequences: BOOLEAN],
VariantPart => [
tag:
SELECT kind: *
FROM
Computed => [],
Star => [name: SymbolHandle],
Named => [name: SymbolHandle, type: TypeHandle],
ENDCASE],
Text => [],
String => [],
StringBody => [],
Rope => [--Rope.ROPE--],
Atom => [],
Pointer => [referentType: TypeHandle],
Ref => [referentType: TypeHandle],
Any => [],
List => [firstType, restType: TypeHandle],
RelativePtr => [baseType, offsetType, resultType: TypeHandle],
Array => [
packed: BOOLEAN,
indexType, elementType: TypeHandle],
Descriptor => [
packed: BOOLEAN,
indexType, elementType: TypeHandle],
Sequence => [
packed: BOOLEAN,
indexType, elementType: TypeHandle,
tagName:
SELECT kind: *
FROM
Computed => [],
Named => [name: SymbolHandle],
ENDCASE],
Zone => [
allocation: {Counted, Uncounted},
mdsZone: BOOLEAN ],
Opaque => [lengthKnown: BOOLEAN],
Other => []
ENDCASE ← Other[] ];
Type and symbol operations.
SymbolName:
PROCEDURE [symbol: SymbolHandle]
RETURNS [name: String];
IsAnonymous: PROCEDURE [symbol: SymbolHandle] RETURNS [yes: BOOLEAN];
If TRUE, SymbolName will return a null string.
SymbolType: PROCEDURE [symbol: SymbolHandle] RETURNS [type: TypeHandle];
SymbolUniqueID: PROCEDURE [symbol: SymbolHandle] RETURNS [uniqueID: SymbolID];
SymbolID: TYPE = LONG CARDINAL;
GetTypeInfo: PROCEDURE [type: TypeHandle] RETURNS [info: TypeInfo];
PutTypeName:
PROCEDURE [
putProc: PROC[CHARACTER],
type: TypeHandle,
includeReadonly: BOOLEAN←TRUE,
rootInterfaceOpenName: String←StringNIL ];
FullTypeName: TYPE = RECORD [module, name: String]; -- module.name.
SearchTypeDefinition:
PROCEDURE [
rootDef: TypeHandle,
candidateDefs: LONG DESCRIPTOR FOR READONLY ARRAY OF FullTypeName ]
RETURNS [indexOfMatch: INTEGER ← -1 --No match--];
Size returns the compiler's size for a type. For variant records,
it is size of the largest variant. For sequences, the size is zero.
For sequence-containing records, the record's size assumes a sequence
of zero size. For these sequences cases, and for descriptor bodies
with bounded index types, use ComputeArraySize.
Words: TYPE = LONG INTEGER;
Size: PROCEDURE [type: TypeHandle] RETURNS [size: Words];
ComputeArraySize:
PROCEDURE [index, elements: TypeHandle, packed:
BOOLEAN]
RETURNS [size: Words];
END. -- LupineSymbolTable.