[ivy]<Satterthwaite>Mimosa>SymbolOps.mesa!4

SymbolOps.mesa

Satterthwaite, June 18, 1986 10:12:35 am PDT

Rovner, July 6, 1983 1:36 pm

Russ Atkinson (RRA) January 31, 1985 1:07:20 pm PST

Sweet June 4, 1986 10:11:29 am PDT

DIRECTORY

Alloc: TYPE USING [Handle],

BcdDefs: TYPE USING [Link, VersionStamp],

ConvertUnsafe: TYPE USING [SubString],

Symbols: TYPE,

Target: TYPE MachineParms USING [PackedBitCount, packedFieldSize],

Tree: TYPE USING [Index, Info, Link, Map];

SymbolOps: DEFINITIONS = {

OPEN Symbols;

from/to UNSPEC and Tree.Info

DecodeBitAddr: PROC[ba: UNSPEC] RETURNS[BitAddress] = INLINE {

RETURN[LOOPHOLE[ba, BitAddress]]};

DecodeBti: PROC[bti: UNSPEC] RETURNS[CBTIndex] = INLINE {

RETURN[LOOPHOLE[bti, CBTIndex]]};

DecodeCard: PROC[n: UNSPEC] RETURNS[CARD] = INLINE {RETURN[LOOPHOLE[n, CARD]]};

DecodeLink: PROC[l: UNSPEC] RETURNS[BcdDefs.Link] = INLINE {

RETURN[LOOPHOLE[l, BcdDefs.Link]]};

DecodeTreeIndex: PROC[node: UNSPEC] RETURNS[Tree.Index] = INLINE {

RETURN[LOOPHOLE[node, Tree.Index]]};

DecodeType: PROC[t: UNSPEC] RETURNS[Type] = INLINE {RETURN[LOOPHOLE[t, Type]]};

EncodeBitAddr: PROC[ba: BitAddress] RETURNS[UNSPEC] = INLINE {

RETURN[LOOPHOLE[ba, UNSPEC]]};

EncodeBti: PROC[bti: CBTIndex] RETURNS[UNSPEC] = INLINE {

RETURN[LOOPHOLE[bti, UNSPEC]]};

EncodeCard: PROC[n: CARD] RETURNS[UNSPEC] = INLINE {RETURN[LOOPHOLE[n, UNSPEC]]};

EncodeLink: PROC[l: BcdDefs.Link] RETURNS[UNSPEC] = INLINE {

RETURN[LOOPHOLE[l, UNSPEC]]};

EncodeTreeIndex: PROC[node: Tree.Index] RETURNS[UNSPEC] = INLINE {

RETURN[LOOPHOLE[node, UNSPEC]]};

EncodeType: PROC[t: Type] RETURNS[UNSPEC] = INLINE {RETURN[LOOPHOLE[t, UNSPEC]]};

ToBti: PROC[bti: Tree.Info] RETURNS[BTIndex] = INLINE {

RETURN[LOOPHOLE[bti, BTIndex]]};

ToCtx: PROC[ctx: Tree.Info] RETURNS[CTXIndex] = INLINE {

RETURN[LOOPHOLE[ctx, CTXIndex]]};

ToType: PROC[type: Tree.Info] RETURNS[Type] = INLINE {

RETURN[LOOPHOLE[type, Type]]};

FromBti: PROC[bti: BTIndex] RETURNS[Tree.Info] = INLINE {

RETURN[LOOPHOLE[bti, Tree.Info]]};

FromCtx: PROC[ctx: CTXIndex] RETURNS[Tree.Info] = INLINE {

RETURN[LOOPHOLE[ctx, Tree.Info]]};

FromType: PROC[type: Type] RETURNS[Tree.Info] = INLINE {

RETURN[LOOPHOLE[type, Tree.Info]]};

implemented by SymbolPack

hash manipulation

FindString: PROC[ConvertUnsafe.SubString] RETURNS[Name];

HashValue: PROC[ConvertUnsafe.SubString] RETURNS[HVIndex];

SubStringForName: PROC[Name] RETURNS[ConvertUnsafe.SubString];

context management

CtxEntries: PROC[CTXIndex] RETURNS[CARDINAL];

FirstCtxSe: PROC[CTXIndex] RETURNS[ISEIndex];

NextSe: PROC[ISEIndex] RETURNS[ISEIndex];

SearchContext: PROC[name: Name, ctx: CTXIndex] RETURNS[ISEIndex];

SeiForValue: PROC[value: Symbols.UNSPEC, ctx: CTXIndex] RETURNS[ISEIndex];

module management

FindMdi: PROC[BcdDefs.VersionStamp] RETURNS[MDIndex];

type manipulation

ArgCtx: PROC[CSEIndex] RETURNS[CTXIndex];

ArgRecord: PROC[CSEIndex] RETURNS[RecordSEIndex];

ClusterSe: PROC[Type] RETURNS[Type];

EqTypes: PROC[Type, Type] RETURNS[BOOL];

NormalType: PROC[Type] RETURNS[CSEIndex];

RecordLink: PROC[RecordSEIndex] RETURNS[RecordSEIndex];

RecordRoot: PROC[RecordSEIndex] RETURNS[RecordSEIndex];

ReferentType: PROC[Type] RETURNS[Type];

TransferTypes: PROC[Type] RETURNS[typeIn, typeOut: RecordSEIndex];

TypeForm: PROC[Type] RETURNS[TypeClass];

TypeLink: PROC[Type] RETURNS[Type];

TypeRoot: PROC[Type] RETURNS[Type];

UnderType: PROC[Type] RETURNS[CSEIndex];

XferMode: PROC[Type] RETURNS[TransferMode];

information returning procedures

AUsForType: PROC[Type] RETURNS[CARD];

BitsForRange: PROC[CARD] RETURNS[CARD];

BitsForType: PROC[Type] RETURNS[BitCount];

BitsPerElement: PROC[type: Type, packed: BOOL] RETURNS[BitCount];

Cardinality: PROC[Type] RETURNS[CARD];

FindExtension: PROC[sei: ISEIndex] RETURNS[type: ExtensionType, tree: Tree.Link];

FnField: PROC[ISEIndex] RETURNS[offset: BitAddress, size: BitCount];

LinkMode: PROC[sei: ISEIndex] RETURNS[Linkage];

NameForSe: PROC[ISEIndex] RETURNS[Name];

PackedSize: ARRAY Target.PackedBitCount OF NAT = Target.packedFieldSize;

RecField: PROC[ISEIndex] RETURNS[offset: BitAddress, size: BitCount];

RCType: PROC[Type] RETURNS[RefClass];

VariantField: PROC[CSEIndex] RETURNS[ISEIndex];

body table management

EnumerateBodies: PROC[root: BTIndex, proc: PROC[BTIndex] RETURNS[stop: BOOL]]

RETURNS[BTIndex];

ParentBti: PROC[BTIndex] RETURNS[BTIndex];

SiblingBti: PROC[BTIndex] RETURNS[BTIndex];

SonBti: PROC[BTIndex] RETURNS[BTIndex];

implemented by SymbolPackExt (extensions for building tables)

Initialize: PROC[Alloc.Handle, UNCOUNTED ZONE];

Reset, Finalize: PROC;

hash manipulation

EnterString: PROC[ConvertUnsafe.SubString] RETURNS[Name];

HashBlock: PROC RETURNS[LONG POINTER TO HashVector];

context management

NextLevel: PROC[ContextLevel] RETURNS[ContextLevel];

CtxLevel: PROC[CTXIndex] RETURNS[ContextLevel];

SetCtxLevel: PROC[CTXIndex, ContextLevel];

BlockLevel: PROC[ContextLevel] RETURNS[ContextLevel];

NewCtx: PROC[ContextLevel] RETURNS[CTXIndex];

SetMainCtx: PROC[CTXIndex];

ResetCtxList: PROC[CTXIndex];

FirstVisibleSe: PROC[CTXIndex] RETURNS[ISEIndex];

NextVisibleSe: PROC[ISEIndex] RETURNS[ISEIndex];

VisibleCtxEntries: PROC[CTXIndex] RETURNS[CARDINAL];

CtxVariant: PROC[CTXIndex] RETURNS[ISEIndex];

StaticNestError: SIGNAL;

MakeCtxSe: PROC[name: Name, ctx: CTXIndex] RETURNS[ISEIndex];

MakeNonCtxSe: PROC[CARDINAL] RETURNS[CSEIndex];

MakeSeChain: PROC[CTXIndex, CARDINAL, BOOL] RETURNS[ISEIndex];

FillCtxSe: PROC[ISEIndex, Name, BOOL];

NameClash: SIGNAL [name: Name];

EnterExtension: PROC[sei: ISEIndex, type: ExtensionType, tree: Tree.Link];

SetSeLink: PROC[sei, next: ISEIndex];

body table utilities

LinkBti: PROC[bti, parent: BTIndex];

DelinkBti: PROC[BTIndex];

copying within current table

CopyArgSe: PROC[copy, master: ISEIndex];

CopyBasicType: PROC[CSEIndex] RETURNS[CSEIndex];

CopyXferType: PROC[CSEIndex, Tree.Map] RETURNS[CSEIndex];

attribute extraction

ConstantId: PROC[ISEIndex] RETURNS[BOOL];