DIRECTORY
AMTypes USING[UnderType, Error, Index, Class, NComponents, IndexToType],
Basics USING[bitsPerWord],
BrandXSymbolDefs USING[SymbolConstructorIndex, SymbolIdIndex, nullSymbolIndex,
typeCodeForCHAR, StandardSymbolContextIndex, typeCodeForINT],
BrandYSymbolDefs USING[SymbolConstructorIndex, SymbolIdIndex, nullSymbolIndex,
typeCodeForCHAR, StandardSymbolContextIndex, typeCodeForINT],
Rope USING [ROPE, Text],
RTCommon USING [ShortenLongCardinal],
RTSymbolDefs USING
[SymbolTableBase, SymbolConstructorIndex, Brand, SymbolIdIndex, SymbolIndex],
RTSymbolOps USING
[EnumerateCtxIseis, SEUnderType, ISEConstant, IDCardinalValue, SETagIDP],
RTSymbols USING [GetTypeSymbols, ReleaseSTB],
RTTCache USING[RefEntry, LookupRef, FillRefEntry, IntEntry, LookupInt, FillIntEntry],
RTTypesPrivate USING [],
SafeStorage USING[Type, nullType, fhType, gfhType, unspecType, GetCanonicalType];

AMTypesBImpl: PROGRAM
IMPORTS AMTypes, RTCommon, RTTCache, RTSymbolOps, RTSymbols, SafeStorage
EXPORTS AMTypes, RTTypesPrivate
= BEGIN OPEN AMTypes, Basics, bx: BrandXSymbolDefs, by: BrandYSymbolDefs,
Rope, RTSymbolDefs, RTSymbolOps, RTSymbols, SafeStorage;

BitsForTypeInfo: TYPE = RECORD
[bft: LONG CARDINAL, argumentRecord, interfaceRecord: BOOLEAN];


VariableType: PUBLIC SAFE PROC[type: Type] RETURNS [v: Type, c: Class] = TRUSTED
{type _ UnderType[type];
IF TypeClass[type] # record AND TypeClass[type] # structure
THEN RETURN[v: nullType, c: nil];

{nc: Index = NComponents[type];
IF nc = 0 THEN RETURN[v: nullType, c: nil];
v _ UnderType[IndexToType[type, nc]]};

c _ TypeClass[v];
SELECT c FROM
union, sequence => RETURN;
ENDCASE => RETURN[v: nullType, c: nil];
};

Size: PUBLIC SAFE PROC[type: Type, length: CARDINAL _ 0--for sequence-containing records--]
RETURNS[ans: CARDINAL _ 0 --number of words--] = TRUSTED
{stb: SymbolTableBase;
uType: Type = UnderType[type];
sei: SymbolIndex;

entry: RTTCache.IntEntry _ NIL;
int: INT;
IF type = nullType THEN RETURN[2];
SELECT type FROM fhType, gfhType => ERROR Error[reason: typeFault, type: type]; ENDCASE;
IF length = 0 THEN
{entry _ RTTCache.LookupInt[type, Size];
int _ entry.int;
IF int >= 0 THEN RETURN [int]};

[stb, sei] _ GetTypeSymbols[type];
WITH stb SELECT FROM
t: SymbolTableBase.x =>
{ENABLE UNWIND => ReleaseSTB[stb];
csei: bx.SymbolConstructorIndex = t.e.UnderType[NARROW[sei, SymbolIndex.x].e];

WITH ser: t.e.seb[csei] SELECT FROM
record =>
IF ser.argument
THEN { FOR isei: bx.SymbolIdIndex _ t.e.FirstCtxSe[ser.fieldCtx], t.e.NextSe[isei]
UNTIL isei = bx.nullSymbolIndex
DO ans _ MAX[ans,
t.e.FnField[isei].offset.wd*bitsPerWord + t.e.seb[isei].idInfo]
ENDLOOP;
ReleaseSTB[stb];
ans _ ans/bitsPerWord + (IF ans MOD bitsPerWord # 0 THEN 1 ELSE 0);
IF entry # NIL THEN [] _ RTTCache.FillIntEntry[entry, ans];
RETURN[ans]};
definition =>
{proc: PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[stop: BOOLEAN] =
{IF NARROW[stb,
SymbolTableBase.x].e.LinkMode[NARROW[isei, SymbolIdIndex.x].e]
# manifest THEN ans _ MAX[ans, IDCardinalValue[stb, isei]];
RETURN[FALSE]};
[] _ EnumerateCtxIseis[stb, [x[ser.defCtx]], proc];
ReleaseSTB[stb];
ans _ ans + 1;
IF entry # NIL THEN [] _ RTTCache.FillIntEntry[entry, ans];
RETURN[ans]};
ENDCASE;  -- not argument record or interface record

SELECT TypeClass[uType] FROM
union, sequence=> ERROR Error[reason: typeFault, type: type];
record, structure =>
{sType: Type;
sClass: Class;
[v: sType, c: sClass] _ VariableType[uType];
SELECT sClass FROM
sequence=>
{sstb: SymbolTableBase;
ssei: SymbolIndex;
[sstb, ssei] _ GetTypeSymbols[sType];
{ENABLE UNWIND => ReleaseSTB[sstb];
scsei: bx.SymbolConstructorIndex
= NARROW[SEUnderType[sstb, ssei], SymbolConstructorIndex.x].e;
WITH ser: NARROW[sstb, SymbolTableBase.x].e.seb[scsei] SELECT FROM
sequence =>
{bpe: LONG CARDINAL =
NARROW[sstb,
SymbolTableBase.x].e.BitsPerElement[type: ser.componentType,
packed: ser.packed];
ans _ RTCommon.ShortenLongCardinal
[(bpe*length+bitsPerWord-1)/bitsPerWord]};
ENDCASE=>ERROR;
ReleaseSTB[sstb]}};
ENDCASE};
ENDCASE;
ans _ ans + t.e.WordsForType[csei];
ReleaseSTB[stb]};  -- end ENABLE UNWIND
t: SymbolTableBase.y =>
{ENABLE UNWIND => ReleaseSTB[stb];
csei: by.SymbolConstructorIndex = t.e.UnderType[NARROW[sei, SymbolIndex.y].e];

WITH ser: t.e.seb[csei] SELECT FROM
record =>
IF ser.argument
THEN { FOR isei: by.SymbolIdIndex _ t.e.FirstCtxSe[ser.fieldCtx], t.e.NextSe[isei]
UNTIL isei = by.nullSymbolIndex
DO ans _ MAX[ans,
t.e.FnField[isei].offset.wd*bitsPerWord + t.e.seb[isei].idInfo]
ENDLOOP;
ReleaseSTB[stb];
ans _ ans/bitsPerWord + (IF ans MOD bitsPerWord # 0 THEN 1 ELSE 0);
IF entry # NIL THEN [] _ RTTCache.FillIntEntry[entry, ans];
RETURN[ans]};
definition =>
{proc: PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[stop: BOOLEAN] =
{IF NARROW[stb,
SymbolTableBase.y].e.LinkMode[NARROW[isei, SymbolIdIndex.y].e]
# manifest THEN ans _ MAX[ans, IDCardinalValue[stb, isei]];
RETURN[FALSE]};
[] _ EnumerateCtxIseis[stb, [y[ser.defCtx]], proc];
ReleaseSTB[stb];
ans _ ans + 1;
IF entry # NIL THEN [] _ RTTCache.FillIntEntry[entry, ans];
RETURN[ans]};
ENDCASE;  -- not argument record or interface record

SELECT TypeClass[uType] FROM
union, sequence=> ERROR Error[reason: typeFault, type: type];
record, structure =>
{sType: Type;
sClass: Class;
[v: sType, c: sClass] _ VariableType[uType];
SELECT sClass FROM
sequence=>
{sstb: SymbolTableBase;
ssei: SymbolIndex;
[sstb, ssei] _ GetTypeSymbols[sType];
{ENABLE UNWIND => ReleaseSTB[sstb];
scsei: by.SymbolConstructorIndex
= NARROW[SEUnderType[sstb, ssei], SymbolConstructorIndex.y].e;
WITH ser: NARROW[sstb, SymbolTableBase.y].e.seb[scsei] SELECT FROM
sequence =>
{bpe: LONG CARDINAL =
NARROW[sstb,
SymbolTableBase.y].e.BitsPerElement[type: ser.componentType,
packed: ser.packed];
ans _ RTCommon.ShortenLongCardinal
[(bpe*length+bitsPerWord-1)/bitsPerWord]};
ENDCASE=>ERROR;
ReleaseSTB[sstb]}};
ENDCASE};
ENDCASE;
ans _ ans + t.e.WordsForType[csei];
ReleaseSTB[stb]};  -- end ENABLE UNWIND
ENDCASE => ERROR;

IF entry # NIL THEN [] _ RTTCache.FillIntEntry[entry, ans];
};  -- end Size

IsPainted: PUBLIC SAFE PROC[type: Type] RETURNS[ans: BOOLEAN] = TRUSTED {
RETURN[SELECT TypeClass[UnderType[type]] FROM
enumerated, record => TRUE,
ENDCASE => FALSE]};

TypeClass: PUBLIC SAFE PROC[type: Type] RETURNS[ans: Class] = TRUSTED {
stb: SymbolTableBase;
sei: SymbolIndex;

entry: RTTCache.IntEntry;
int: INT;
SELECT type FROM
fhType => RETURN[localFrame];
nullType => RETURN[nil];
gfhType => RETURN[globalFrame];
unspecType => RETURN[unspecified];
ENDCASE;
entry _ RTTCache.LookupInt[type, TypeClass];
int _ entry.int;
IF int >= 0 THEN {card: CARDINAL _ int; RETURN [LOOPHOLE[card]]};

[stb, sei] _ GetTypeSymbols[type];
{ ENABLE UNWIND => ReleaseSTB[stb];

IF SETagIDP[stb, sei] THEN {ans _ definition; GO TO answer};
IF GetCanonicalType[type] = GetCanonicalType[CODE[ROPE]]
OR GetCanonicalType[type] = GetCanonicalType[CODE[Text]]
THEN {ans _ rope; GO TO answer};
WITH stb SELECT FROM
t: SymbolTableBase.x =>
ans _ 
(WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.x].e]] SELECT FROM
basic => SelectBasicClass[x, ser.code],
record => (IF ser.painted THEN record ELSE structure),
definition => record,
real => real,
union => union,
array => array,
opaque => opaque,
sequence => sequence,
relative => relativePointer,
ref => (IF ser.counted OR ser.basing THEN ERROR ELSE pointer),
arraydesc => descriptor,
long =>
(WITH rse: t.e.seb[t.e.UnderType[ser.rangeType] ] SELECT FROM
ref => (IF rse.counted
THEN (IF rse.list
THEN list
ELSE WITH z: t.e.seb[t.e.UnderType[rse.refType]] SELECT FROM
opaque =>
IF t.e.seb[z.id].idCtx IN bx.StandardSymbolContextIndex
THEN atom ELSE ref
ENDCASE => ref)
ELSE (IF rse.basing THEN basePointer ELSE longPointer)),
basic => (IF rse.code = bx.typeCodeForINT THEN longInteger ELSE ERROR),
arraydesc => longDescriptor,
subrange =>
(WITH rrse: t.e.seb[t.e.UnderType[rse.rangeType] ] SELECT FROM
basic => (IF rrse.code = bx.typeCodeForINT AND rse.origin = 0
AND rse.range = LAST[CARDINAL]
THEN longCardinal ELSE ERROR),
ENDCASE => ERROR),
ENDCASE => ERROR),
enumerated => enumerated,
subrange =>
(WITH rse: t.e.seb[t.e.UnderType[ser.rangeType] ] SELECT FROM
basic => (IF rse.code = bx.typeCodeForINT AND ser.origin = 0
AND ser.range = LAST[CARDINAL]
THEN cardinal ELSE subrange),
ENDCASE => subrange),
subrange => subrange,
transfer => (SELECT ser.mode FROM
proc => procedure,
port => port,
signal => signal,
error => error,
process => process,
program => program,
ENDCASE => ERROR),
zone => (IF ser.counted THEN countedZone ELSE uncountedZone),
mode => type,
any => any,
ENDCASE => ERROR Error[reason: typeFault, type: type]);
t: SymbolTableBase.y =>
ans _ 
(WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.y].e]] SELECT FROM
basic => SelectBasicClass[y, ser.code],
record => (IF ser.painted THEN record ELSE structure),
definition => record,
real => real,
union => union,
array => array,
opaque => opaque,
sequence => sequence,
relative => relativePointer,
ref => (IF ser.counted OR ser.basing THEN ERROR ELSE pointer),
arraydesc => descriptor,
long =>
(WITH rse: t.e.seb[t.e.UnderType[ser.rangeType] ] SELECT FROM
ref => (IF rse.counted
THEN (IF rse.list
THEN list
ELSE WITH z: t.e.seb[t.e.UnderType[rse.refType]] SELECT FROM
opaque =>
IF t.e.seb[z.id].idCtx IN by.StandardSymbolContextIndex
THEN atom ELSE ref
ENDCASE => ref)
ELSE (IF rse.basing THEN basePointer ELSE longPointer)),
basic => (IF rse.code = by.typeCodeForINT THEN longInteger ELSE ERROR),
arraydesc => longDescriptor,
subrange =>
(WITH rrse: t.e.seb[t.e.UnderType[rse.rangeType] ] SELECT FROM
basic => (IF rrse.code = by.typeCodeForINT AND rse.origin = 0
AND rse.range = LAST[CARDINAL]
THEN longCardinal ELSE ERROR),
ENDCASE => ERROR),
ENDCASE => ERROR),
enumerated => enumerated,
subrange =>
(WITH rse: t.e.seb[t.e.UnderType[ser.rangeType] ] SELECT FROM
basic => (IF rse.code = by.typeCodeForINT AND ser.origin = 0
AND ser.range = LAST[CARDINAL]
THEN cardinal ELSE subrange),
ENDCASE => subrange),
subrange => subrange,
transfer => (SELECT ser.mode FROM
proc => procedure,
port => port,
signal => signal,
error => error,
process => process,
program => program,
ENDCASE => ERROR),
zone => (IF ser.counted THEN countedZone ELSE uncountedZone),
mode => type,
any => any,
ENDCASE => ERROR Error[reason: typeFault, type: type]);
ENDCASE => ERROR;
ReleaseSTB[stb];
EXITS
answer => ReleaseSTB[stb]};
[] _ RTTCache.FillIntEntry[entry, LOOPHOLE[ans, CARDINAL]];
};  -- end TypeClass

IsInterface: PUBLIC SAFE PROC[type: Type] RETURNS[ans: BOOL _ FALSE] = TRUSTED{
stb: SymbolTableBase;
sei: SymbolIndex;
entry: RTTCache.RefEntry;
info: REF BOOL;
IF type = nullType THEN RETURN[FALSE];
entry _ RTTCache.LookupRef[type, LOOPHOLE[IsInterface]];
info _ NARROW[entry.ref, REF BOOL];
IF info # NIL THEN RETURN[info^];

[stb, sei] _ GetTypeSymbols[type];
{ENABLE UNWIND => ReleaseSTB[stb];
csei: SymbolConstructorIndex = SEUnderType[stb, sei];
WITH stb SELECT FROM
t: SymbolTableBase.x =>
WITH ser: t.e.seb[NARROW[csei, SymbolConstructorIndex.x].e] SELECT FROM
definition => ans _ TRUE;
ENDCASE;
t: SymbolTableBase.y =>
WITH ser: t.e.seb[NARROW[csei, SymbolConstructorIndex.y].e] SELECT FROM
definition => ans _ TRUE;
ENDCASE;
ENDCASE => ERROR;
};  -- end ENABLE UNWIND
ReleaseSTB[stb];
[] _ RTTCache.FillRefEntry[entry, NEW[BOOL _ ans]];
};

BitsForType: PUBLIC PROC[type: Type]
RETURNS [bft: LONG CARDINAL, argumentRecord, interfaceRecord: BOOL] = {
stb: SymbolTableBase;
sei: SymbolIndex;

entry: RTTCache.RefEntry;
info: REF BitsForTypeInfo;
IF type = nullType THEN RETURN[2*bitsPerWord, FALSE, FALSE];  -- NIL
entry _ RTTCache.LookupRef[type, LOOPHOLE[BitsForType]];
info _ NARROW[entry.ref];
IF info # NIL THEN RETURN [info.bft, info.argumentRecord, info.interfaceRecord];

[stb, sei] _ GetTypeSymbols[type];
{ ENABLE UNWIND => ReleaseSTB[stb];
csei: SymbolConstructorIndex = SEUnderType[stb, sei];
WITH stb SELECT FROM
t: SymbolTableBase.x =>
WITH ser: t.e.seb[NARROW[csei, SymbolConstructorIndex.x].e] SELECT FROM
record =>
{w: LONG CARDINAL = t.e.WordsForType[NARROW[csei, SymbolConstructorIndex.x].e];
argumentRecord _ ser.argument;
interfaceRecord _ FALSE;
IF w > 1
THEN bft _ w * bitsPerWord
ELSE bft _ t.e.BitsForType[NARROW[csei, SymbolConstructorIndex.x].e]};
definition => {
ans: CARDINAL _ 0;
proc: PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[stop: BOOL] = {
IF NOT ISEConstant[stb, isei]
THEN ans _ MAX[ans, IDCardinalValue[stb, isei]];
RETURN[FALSE];
};
[] _ EnumerateCtxIseis[stb, [x[ser.defCtx]], proc];
argumentRecord _ FALSE;
interfaceRecord _ TRUE;
bft _ (ans + 1)*bitsPerWord;
};
subrange => {
w: LONG CARDINAL
= t.e.WordsForType[NARROW[csei, SymbolConstructorIndex.x].e];
argumentRecord _ FALSE;
interfaceRecord _ FALSE;
IF w > 1
THEN bft _ w * bitsPerWord
ELSE bft _ t.e.BitsForType[NARROW[csei, SymbolConstructorIndex.x].e];
IF bft = 0 THEN {
IF ser.empty THEN bft _ bitsPerWord
ELSE ERROR Error[reason: typeFault, type: type];
};
};
ENDCASE => {
w: LONG CARDINAL
= t.e.WordsForType[NARROW[csei, SymbolConstructorIndex.x].e];
argumentRecord _ FALSE;
interfaceRecord _ FALSE;
IF w > 1
THEN bft _ w * bitsPerWord
ELSE bft _ t.e.BitsForType[NARROW[csei, SymbolConstructorIndex.x].e];
IF bft = 0 THEN ERROR Error[reason: typeFault, type: type];
};
t: SymbolTableBase.y =>
WITH ser: t.e.seb[NARROW[csei, SymbolConstructorIndex.y].e] SELECT FROM
record =>
{w: LONG CARDINAL = t.e.WordsForType[NARROW[csei, SymbolConstructorIndex.y].e];
argumentRecord _ ser.argument;
interfaceRecord _ FALSE;
IF w > 1
THEN bft _ w * bitsPerWord
ELSE bft _ t.e.BitsForType[NARROW[csei, SymbolConstructorIndex.y].e]};
definition =>
{ans: CARDINAL _ 0;
proc: PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[stop: BOOLEAN] =
{IF NOT ISEConstant[stb, isei] THEN ans _ MAX[ans, IDCardinalValue[stb, isei]];
RETURN[FALSE]};
[] _ EnumerateCtxIseis[stb, [y[ser.defCtx]], proc];
argumentRecord _ FALSE;
interfaceRecord _ TRUE;
bft _ (ans + 1)*bitsPerWord};
subrange => {
w: LONG CARDINAL
= t.e.WordsForType[NARROW[csei, SymbolConstructorIndex.y].e];
argumentRecord _ FALSE;
interfaceRecord _ FALSE;
IF w > 1
THEN bft _ w * bitsPerWord
ELSE bft _ t.e.BitsForType[NARROW[csei, SymbolConstructorIndex.y].e];
IF bft = 0 THEN {
IF ser.empty THEN bft _ bitsPerWord
ELSE ERROR Error[reason: typeFault, type: type];
};
};
ENDCASE =>
{w: LONG CARDINAL = t.e.WordsForType[NARROW[csei, SymbolConstructorIndex.y].e];
argumentRecord _ FALSE;
interfaceRecord _ FALSE;
IF w > 1
THEN bft _ w * bitsPerWord
ELSE bft _ t.e.BitsForType[NARROW[csei, SymbolConstructorIndex.y].e];
IF bft = 0 THEN ERROR Error[reason: typeFault, type: type]};
ENDCASE => ERROR;
ReleaseSTB[stb]};  -- end ENABLE UNWIND

info _ NEW[BitsForTypeInfo _ [bft, argumentRecord, interfaceRecord]];
[] _ RTTCache.FillRefEntry[entry, info];
};  -- end BitsForType

IsOverlaid: PUBLIC SAFE PROC
[type: Type--union--] RETURNS [ans: BOOL _ FALSE] = TRUSTED {
stb: SymbolTableBase;
sei: SymbolIndex;
class: Class = TypeClass[UnderType[type]];
entry: RTTCache.IntEntry _ NIL;

IF class = nil THEN RETURN;
entry _ RTTCache.LookupInt[type, IsOverlaid];
IF entry.int # -1 THEN RETURN[entry.int = 1];  -- 1 => TRUE, 2 => FALSE
IF class = record OR class = structure THEN type _ IndexToType[type, NComponents[type]];
[stb, sei] _ GetTypeSymbols[type];
{ ENABLE UNWIND => ReleaseSTB[stb];
WITH stb SELECT FROM
t: SymbolTableBase.x =>
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.x].e]] SELECT FROM
union => ans _ ser.overlaid;
ENDCASE;
t: SymbolTableBase.y =>
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.y].e]] SELECT FROM
union => ans _ ser.overlaid;
ENDCASE;
ENDCASE => ERROR;
ReleaseSTB[stb];
};
IF entry # NIL THEN [] _ RTTCache.FillIntEntry[entry, (IF ans THEN 1 ELSE 2)];
};

IsComputed: PUBLIC SAFE PROC
[type: Type--union, sequence--] RETURNS [ans: BOOL _ FALSE] = TRUSTED {
stb: SymbolTableBase;
sei: SymbolIndex;
class: Class = TypeClass[UnderType[type]];
entry: RTTCache.IntEntry _ NIL;

IF class = nil THEN RETURN;
entry _ RTTCache.LookupInt[type, IsComputed];
IF entry.int # -1 THEN RETURN[entry.int = 1];  -- 1 => TRUE, 2 => FALSE
IF class = record OR class = structure THEN type _ IndexToType[type, NComponents[type]];
[stb, sei] _ GetTypeSymbols[type];
{ ENABLE UNWIND => ReleaseSTB[stb];
WITH stb SELECT FROM
t: SymbolTableBase.x =>
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.x].e]] SELECT FROM
union => ans _ NOT ser.controlled;
sequence => ans _ NOT ser.controlled;
ENDCASE;
t: SymbolTableBase.y =>
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.y].e]] SELECT FROM
union => ans _ NOT ser.controlled;
sequence => ans _ NOT ser.controlled;
ENDCASE;
ENDCASE => ERROR;
ReleaseSTB[stb];
};
IF entry # NIL THEN [] _ RTTCache.FillIntEntry[entry, (IF ans THEN 1 ELSE 2)];
};

IsOrdered: PUBLIC SAFE PROC[type: Type]
RETURNS [ans: BOOLEAN] = TRUSTED {
stb: SymbolTableBase;
sei: SymbolIndex;
[stb, sei] _ GetTypeSymbols[type];
{ ENABLE UNWIND => ReleaseSTB[stb];
WITH stb SELECT FROM
t: SymbolTableBase.x =>
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.x].e]] SELECT FROM
long => ans _ WITH rse: t.e.seb[t.e.UnderType[ser.rangeType]] SELECT FROM
ref => rse.ordered,
enumerated => rse.ordered,
basic => rse.ordered,
ENDCASE => ERROR Error[reason: typeFault, type: type];
ref => ans _ ser.ordered;
enumerated => ans _ ser.ordered;
basic => ans _ ser.ordered;
ENDCASE => ERROR Error[reason: typeFault, type: type];
t: SymbolTableBase.y =>
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.y].e]] SELECT FROM
long => ans _ WITH rse: t.e.seb[t.e.UnderType[ser.rangeType]] SELECT FROM
ref => rse.ordered,
enumerated => rse.ordered,
basic => rse.ordered,
ENDCASE => ERROR Error[reason: typeFault, type: type];
ref => ans _ ser.ordered;
enumerated => ans _ ser.ordered;
basic => ans _ ser.ordered;
ENDCASE => ERROR Error[reason: typeFault, type: type];
ENDCASE => ERROR;
ReleaseSTB[stb];
}};


IsMachineDependent: PUBLIC SAFE PROC
[type: Type--record, structure, union, enumerated, sequence--]
RETURNS[ans: BOOLEAN] = TRUSTED {
stb: SymbolTableBase;
sei: SymbolIndex;
[stb, sei] _ GetTypeSymbols[type];
{ ENABLE UNWIND => ReleaseSTB[stb];
WITH stb SELECT FROM
t: SymbolTableBase.x =>
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.x].e]] SELECT FROM
union => ans _ ser.machineDep;
definition => ans _ FALSE;
enumerated => ans _ ser.machineDep;
record => ans _ ser.machineDep;
sequence => ans _ ser.machineDep;
ENDCASE => ERROR Error[reason: typeFault, type: type];
t: SymbolTableBase.y =>
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.y].e]] SELECT FROM
union => ans _ ser.machineDep;
definition => ans _ FALSE;
enumerated => ans _ ser.machineDep;
record => ans _ ser.machineDep;
sequence => ans _ ser.machineDep;
ENDCASE => ERROR Error[reason: typeFault, type: type];
ENDCASE => ERROR;
ReleaseSTB[stb];
}};

SelectBasicClass: PROC[brand: Brand, code: [0..16)] RETURNS[Class] =
{ SELECT brand FROM
x => SELECT code FROM
bx.typeCodeForINT => RETURN[integer];
bx.typeCodeForCHAR => RETURN[character];
ENDCASE => ERROR;
y => SELECT code FROM
by.typeCodeForINT => RETURN[integer];
by.typeCodeForCHAR => RETURN[character];
ENDCASE => ERROR;
ENDCASE => ERROR;
};



END.




òAMTypesBImpl.Mesa
Paul Rovner, November 16, 1983 8:39 pm
NOTE do Equal, AsGoodAs
try to avoid acquisition of already acquired symbol tables
status stuff is wrong. 
T Y P E S
must be the same as the return type of BitsForType
P U B L I C   P R O C E D U R E S
max for unions
Could overflow!
check for argument records and interface records
check for argument records and interface records
the Type itself is the color. Record and enumerated types are painted.
MOVE
break up and MOVE
MOVE
MOVE
�Ê&˜J˜J˜Jš
œ™Jš
œ&™&š
œ™Jš
œ:™:Jš
œ™J˜—š
Ïk	˜	Jšœ�œ;˜HJšœ�œ˜šœ�œ8˜NJ˜=—šœ�œ8˜NJ˜=—Jšœ�œ�œ˜Jšœ	�œ˜%šœ
�˜J˜M—šœ�˜J˜I—Jšœ
�œ˜-Jšœ	�œG˜UJšœ�œ˜Jšœ�œ@˜QJ˜—šœ�˜Jš�œA˜HJš�œ˜šœ�œ
�œ=˜IJ˜8J˜——Jš
œ	™	šœ�œ�˜Jšœ�œ
�œ#�œ˜?Jš
œ2™2J˜—Jš
œ!™!J˜JšÏnœ�œ
�œ
�œ
�œ�˜P˜š�œ�œ˜;Jš�œ
�œ˜!J˜—˜Jš�œ�œ
�œ˜+J˜&J˜—J˜š�œ�˜
Jšœ�œ
˜Jš�œ�œ˜'——J˜˜Jš
œ™Jš
œ™—šžœ�œ
�œ
�œ�œÏc#œ
˜[Jš�œ�œŸœ�˜8—˜J˜J˜J˜Jšœ�œ
˜Jšœ�œ
˜	Jš�œ�œ
�œ˜"Jš�œ�œ�œ'�œ
˜Xš�œ�˜˜(J˜Jš�œ
�œ
�œ˜J˜——J˜"š�œ�œ
�˜˜šœ
�œ
�œ˜"Jšœ0�œ˜N˜Jš
œ0™0—š�œ�œ
�˜#˜	š�œ
˜š�œ�œH˜RJš�œ˜š�œ�œ˜J˜?—Jš�œ
˜J˜Jš	œ�œ�œ�œ�œ˜CJš�œ	�œ
�œ(˜;Jš�œ˜
———˜
šœ�œ,�œ�œ˜Ošœ
�œ
�œ˜Jšœ�œ˜>Jšœ�œ�œ"˜;Jš�œ
�œ˜—J˜3J˜J˜Jš�œ	�œ
�œ(˜;Jš�œ˜
——Jš�œŸ*˜4J˜—š�œ�˜Jšœ�œ&˜=˜˜
J˜J˜,š�œ�˜˜
˜J˜J˜%šœ
�œ
�œ˜#˜ Jšœ�œ6˜>—š�œ�œ'�œ
�˜B˜šœ�œ
�œ˜š�œ˜˜<J˜——˜"J˜*———Jš�œ�œ
˜—J˜———Jš�œ˜	———Jš�œ
˜—J˜#JšœŸ˜'——˜šœ
�œ
�œ˜"Jšœ0�œ˜N˜Jš
œ0™0—š�œ�œ
�˜#˜	š�œ
˜š�œ�œH˜RJš�œ˜š�œ�œ˜J˜?—Jš�œ
˜J˜Jš	œ�œ�œ�œ�œ˜CJš�œ	�œ
�œ(˜;Jš�œ˜
———˜
šœ�œ,�œ�œ˜Ošœ
�œ
�œ˜Jšœ�œ˜>Jšœ�œ�œ"˜;Jš�œ
�œ˜—J˜3J˜J˜Jš�œ	�œ
�œ(˜;Jš�œ˜
——Jš�œŸ*˜4J˜—š�œ�˜Jšœ�œ&˜=˜˜
J˜J˜,š�œ�˜˜
˜J˜J˜%šœ
�œ
�œ˜#˜ Jšœ�œ6˜>—š�œ�œ'�œ
�˜B˜šœ�œ
�œ˜š�œ˜˜<J˜——˜"J˜*———Jš�œ�œ
˜—J˜———Jš�œ˜	———Jš�œ
˜—J˜#JšœŸ˜'——Jš�œ�œ
˜J˜Jš�œ	�œ
�œ(˜;JšœŸ˜˜Jš
œF™F———šž	œ�œ
�œ
�œ
�œ�œ�œ˜Iš�œ
�œ�˜-Jšœ�œ
˜Jš�œ�œ˜J˜——Jš
œ™šž	œ�œ
�œ
�œ
�œ�œ˜GJ˜J˜J˜J˜Jšœ�œ
˜	š�œ�˜Jšœ
�œ
˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜"Jš�œ
˜—J˜,J˜Jš
�œ
�œ�œ�œ�œ	˜AJ˜J˜"Jšœ�œ
�œ˜#˜Jš�œ�œ�œ
�œ	˜<š�œ+�œ
�œ˜8Jš�œ+�œ˜8Jš�œ�œ
�œ	˜ —š�œ�œ
�˜˜J˜šœ
�œ�œ�œ
�˜KJ˜'Jšœ�œ
�œ�œ˜6J˜J˜
J˜J˜J˜J˜J˜Jšœ�œ
�œ�œ
�œ
�œ
˜>J˜˜šœ
�œ-�œ
�˜=šœ�œ˜š�œ�œ	˜Jš�œ˜	š�œ
�œ(�œ
�˜<˜	š�œ�œ˜7Jš�œ�œ˜——Jš�œ˜——Jš�œ�œ�œ
�œ˜8—Jš	œ
�œ�œ
�œ
�œ˜GJ˜˜šœ
�œ.�œ
�˜>šœ
�œ�œ˜=Jš�œ
�œ
�œ
˜Jš�œ�œ
�œ˜—Jš�œ�œ˜——Jš�œ�œ˜——J˜˜šœ
�œ-�œ
�˜=šœ
�œ�œ˜<Jš�œ
�œ
�œ
˜Jš�œ
�œ˜—Jš�œ˜——J˜šœ
�œ
�˜!J˜J˜
J˜J˜J˜J˜Jš�œ�œ˜—Jšœ	�œ
�œ
�œ˜=J˜
J˜Jš�œ�œ'˜7——˜J˜šœ
�œ�œ�œ
�˜KJ˜'Jšœ�œ
�œ�œ˜6J˜J˜
J˜J˜J˜J˜J˜Jšœ�œ
�œ�œ
�œ
�œ
˜>J˜˜šœ
�œ-�œ
�˜=šœ�œ˜š�œ�œ	˜Jš�œ˜	š�œ
�œ(�œ
�˜<˜	š�œ�œ˜7Jš�œ�œ˜——Jš�œ˜——Jš�œ�œ�œ
�œ˜8—Jš	œ
�œ�œ
�œ
�œ˜GJ˜˜šœ
�œ.�œ
�˜>šœ
�œ�œ˜=Jš�œ
�œ
�œ
˜Jš�œ�œ
�œ˜—Jš�œ�œ˜——Jš�œ�œ˜——J˜˜šœ
�œ-�œ
�˜=šœ
�œ�œ˜<Jš�œ
�œ
�œ
˜Jš�œ
�œ˜—Jš�œ˜——J˜šœ
�œ
�˜!J˜J˜
J˜J˜J˜J˜Jš�œ�œ˜—Jšœ	�œ
�œ
�œ˜=J˜
J˜Jš�œ�œ'˜7——Jš�œ�œ
˜—J˜š
�˜J˜——Jšœ"�œ�œ˜;JšœŸ˜J˜—šžœ�œ
�œ
�œ
�œ�œ�œ�œ
˜OJ˜J˜J˜Jšœ�œ
�œ
˜Jš�œ�œ
�œ
�œ˜&Jšœ!�œ˜8Jšœ�œ�œ
�œ˜#Jš�œ�œ
�œ
�œ˜!J˜J˜"šœ
�œ
�œ˜"J˜5š�œ�œ
�˜˜š�œ�œ$�œ
�˜GJšœ�œ
˜Jš�œ
˜——˜š�œ�œ$�œ
�˜GJšœ�œ
˜Jš�œ
˜——Jš�œ�œ
˜—šœŸ˜J˜Jšœ"�œ
�œ	˜3—J˜J˜——šžœ�œ
�œ˜$Jš�œ�œ
�œ#�œ˜GJ˜J˜J˜J˜Jšœ�œ˜Jš�œ�œ
�œ�œ�œŸ˜DJšœ!�œ˜8Jšœ�œ˜Jš�œ�œ
�œ
�œ7˜PJ˜J˜"šœ
�œ
�œ˜#J˜5š�œ�œ
�˜˜š�œ�œ$�œ
�˜G˜	šœ�œ
�œ�œ$˜OJ˜Jšœ�œ
˜š�œ˜Jš�œ˜Jš�œ�œ%˜F———š
œ˜Jšœ�œ˜šÏbœ�œ,�œ�œ˜Mš�œ
�œ˜Jš�œ�œ"˜0—Jš�œ
�œ˜Jš
œ˜—J˜3Jšœ�œ
˜Jšœ�œ
˜J˜J˜—š
œ
˜
šœ�œ
�˜Jšœ�œ$˜=—Jšœ�œ
˜Jšœ�œ
˜š�œ˜Jš�œ˜Jš�œ�œ$˜E—š�œ	�œ˜š�œ�œ˜#Jš�
œ&˜0—J˜—Jš
œ˜—š�œ˜šœ�œ
�˜Jšœ�œ$˜=—Jšœ�œ
˜Jšœ�œ
˜š�œ˜Jš�œ˜Jš�œ�œ$˜E—Jš�œ	�
œ&˜;Jš
œ˜———˜š�œ�œ$�œ
�˜G˜	šœ�œ
�œ�œ$˜OJ˜Jšœ�œ
˜š�œ˜Jš�œ˜Jš�œ�œ%˜F———˜
šœ�œ˜šœ�œ,�œ�œ˜Nš	œ
�œ
�œ�œ�œ"˜OJš�œ
�œ˜——J˜3Jšœ�œ
˜Jšœ�œ
˜J˜——š
œ
˜
šœ�œ
�˜Jšœ�œ$˜=—Jšœ�œ
˜Jšœ�œ
˜š�œ˜Jš�œ˜Jš�œ�œ$˜E—š�œ	�œ˜š�œ�œ˜#Jš�
œ&˜0—J˜—Jš
œ˜—š�œ˜
šœ�œ
�œ�œ$˜OJšœ�œ
˜Jšœ�œ
˜š�œ˜Jš�œ˜Jš�œ�œ$˜E—Jš�œ	�œ
�œ'˜<————Jš�œ�œ
˜—JšœŸ˜'J˜Jšœ�œ;˜EJ˜(JšœŸ˜—˜šž
œ�œ
�œ
�˜JšœŸ	œ�œ�œ�œ�œ˜=J˜J˜J˜*Jšœ�œ
˜J˜Jš�œ
�œ
�œ
˜J˜-Jš�œ�œ
�œŸ˜GJš�œ�œ�œ-˜XJ˜"šœ�œ
�œ˜#š�œ�œ
�˜˜š�œ�œ�œ
�˜JJ˜Jš�œ
˜——˜š�œ�œ�œ
�˜JJ˜Jš�œ
˜——Jš�œ�œ
˜—J˜—J˜Jš�œ	�œ
�œ$�œ�œ�œ˜NJ˜J˜———Jš
œ™šž
œ�œ
�œ
�˜JšœŸœ�œ�œ�œ�œ˜GJ˜J˜J˜*Jšœ�œ
˜J˜Jš�œ
�œ
�œ
˜J˜-Jš�œ�œ
�œŸ˜GJš�œ�œ�œ-˜XJ˜"šœ�œ
�œ˜#š�œ�œ
�˜˜š�œ�œ�œ
�˜JJšœ�œ˜"Jšœ�œ˜%Jš�œ
˜——˜š�œ�œ�œ
�˜JJšœ�œ˜"Jšœ�œ˜%Jš�œ
˜——Jš�œ�œ
˜—J˜—J˜Jš�œ	�œ
�œ$�œ�œ�œ˜NJ˜J˜—Jš
œ™šž	œ�œ
�œ
�œ˜'Jš�œ�œ�œ˜"J˜J˜J˜"šœ�œ
�œ˜#š�œ�œ
�˜˜š�œ�œ�œ
�˜Jšœ�œ,�œ
�˜IJ˜J˜J˜Jš�œ�œ&˜6—J˜J˜ J˜Jš�œ�œ&˜6——˜š�œ�œ�œ
�˜Jšœ�œ,�œ
�˜IJ˜J˜J˜Jš�œ�œ&˜6—J˜J˜ J˜Jš�œ�œ&˜6——Jš�œ�œ
˜—J˜J˜J˜J˜——Jš
œ™šžœ�œ
�œ
�˜$JšœŸ2œ
˜>Jš�œ�œ�œ˜!J˜J˜J˜"šœ�œ
�œ˜#š�œ�œ
�˜˜š�œ�œ�œ
�˜JJ˜Jšœ�œ
˜J˜#J˜J˜!Jš�œ�œ&˜6——˜š�œ�œ�œ
�˜JJ˜Jšœ�œ
˜J˜#J˜J˜!Jš�œ�œ&˜6——Jš�œ�œ
˜—J˜J˜J˜——šžœ�œ�œ	˜Dšœ�œ�˜šœ�œ�˜Jšœ�œ
˜%Jšœ�œ˜(Jš�œ�œ
˜—šœ�œ�˜Jšœ�œ
˜%Jšœ�œ˜(Jš�œ�œ
˜—Jš�œ�œ
˜—J˜J˜J˜J˜—Jš�œ
˜J˜J˜J˜—…—JÌcä