DIRECTORY Basics, CirioMemory, IO, Rope;

CirioTypes: CEDAR DEFINITIONS
IMPORTS CirioMemory =
BEGIN

ROPE: TYPE ~ Rope.ROPE;
Nat: TYPE ~ INT[0..INT.LAST];

Code: TYPE = REF CodeBody;
CodeBody: TYPE;


TypedCode: TYPE = RECORD[code: Code, type: Type];


CC: TYPE = CompilerContext;
CompilerContext: TYPE = REF CompilerContextBody;
CompilerContextBody: TYPE = RECORD[
nameScope: Node,
moduleScope: ModuleScope,
ctc: CompilerTypeContext];
CompilerTypeContext: TYPE = REF CompilerTypeContextBody;
CompilerTypeContextBody: TYPE;


Type: TYPE = REF TypeBody;

TypeClass: TYPE = ATOM; -- {wrong, amnode, numeric, Boolean, record . . . etc}



NarrowToType: PROC[ref: REF ANY] RETURNS[Type];

TypeIsntNil: PROC [Type, CC] RETURNS [Type];

Node: TYPE = REF NodeBody;

ModuleScope: TYPE = REF ModuleScopeBody;
ModuleScopeBody: TYPE = RECORD [
GetModule: PROC [moduleScope: ModuleScope, name: ROPE, nToSkip: INT] RETURNS [Node],
GetInterfaceRecord: PROC [moduleScope: ModuleScope, name: ROPE] RETURNS [Node],
data: REF ANY];
BitAddr: TYPE ~ CirioMemory.BitAddr;

zeroBA: BitAddr ~ CirioMemory.zeroBA;
unspecdBA: BitAddr ~ CirioMemory.unspecdBA;
ptrSize: BitAddr ~ [4, 0];
bitsPerAu: Nat ~ 8;
bitsPerPtr: Nat ~ 32;

BaCons: PROC [aus: CARD, bits: INT] RETURNS [BitAddr]
~ INLINE {RETURN CirioMemory.BaCons[aus, bits]};

BaAsAbs: PROC [ba: BitAddr] RETURNS [BitAddr];

BaAdd: PROC [a, b: BitAddr] RETURNS [BitAddr]
~ INLINE {RETURN CirioMemory.BaAdd[a, b]};

BaAddOffset: PROC [ba: BitAddr, bits: INT] RETURNS [BitAddr]
~ INLINE {RETURN CirioMemory.BaAddOffset[ba, bits]};

BaSub: PROC [a, b: BitAddr] RETURNS [BitAddr]
~ INLINE {RETURN CirioMemory.BaSub[a, b]};

BaMul: PROC [ba: BitAddr, by: CARD] RETURNS [BitAddr]
~ INLINE {RETURN CirioMemory.BaMul[ba, by]};

BaCompare: PROC [a, b: BitAddr] RETURNS [Basics.Comparison];

BitsToBa: PROC [bits: INT] RETURNS [BitAddr]
~ INLINE {RETURN CirioMemory.BitsToBa[bits]};

BaToBits: PROC [ba: BitAddr] RETURNS [CARD]
~ INLINE {RETURN CirioMemory.BaToBits[ba]};

AusToBa: PROC [aus: CARD] RETURNS [BitAddr]
~ INLINE {RETURN CirioMemory.AusToBa[aus]};

BaToAus: PROC [ba: BitAddr] RETURNS [CARD]
~ INLINE {RETURN CirioMemory.BaToAus[ba]};

PtrToBa: PROC [ptr: CARD] RETURNS [BitAddr]
~ INLINE {RETURN CirioMemory.PtrToBa[ptr]};

BaToPtr: PROC [ba: BitAddr] RETURNS [CARD]
~ INLINE {RETURN CirioMemory.BaToPtr[ba]};

BitStretch: TYPE ~ CirioMemory.BitStretch;

BsCompose: PROC [main, inner: BitStretch] RETURNS [within: BOOL, compd: BitStretch]
~ INLINE {RETURN CirioMemory.BsCompose[main, inner]};

Mem: TYPE = CirioMemory.Mem;
noMem: Mem = CirioMemory.noMem;
PtrReg: TYPE ~ CirioMemory.PtrReg;

MemSubfield: PROC [mem: Mem, rel: BitStretch] RETURNS [Mem]
~ INLINE {RETURN  CirioMemory.MemSubfield[mem, rel]};

MemShift: PROC [mem: Mem, offset: BitAddr] RETURNS [Mem]
~ INLINE {RETURN CirioMemory.MemShift[mem, offset]};

MemIndirect: PROC [mem: Mem, size: BitAddr _ unspecdBA, offset: BitAddr _ zeroBA] RETURNS [Mem]
~ INLINE {RETURN CirioMemory.MemIndirect[mem, size, offset]};

MemGetStretch: PROC [mem: Mem] RETURNS [BitStretch]
~ INLINE {RETURN CirioMemory.MemGetStretch[mem]};

MemGetSize: PROC [mem: Mem] RETURNS [BitAddr]
~ INLINE {RETURN CirioMemory.MemGetSize[mem]};

MemGetStart: PROC [mem: Mem] RETURNS [BitAddr]
~ INLINE {RETURN CirioMemory.MemGetStart[mem]};

MemRead: PROC [mem: Mem, bitSize: CARD, offset: BitAddr] RETURNS [CARD]
~ INLINE {RETURN CirioMemory.MemRead[mem, bitSize, offset]};

MemWrite: PROC [mem: Mem, bits: CARD, bitSize: CARD, offset: BitAddr]
~ INLINE {CirioMemory.MemWrite[mem, bits, bitSize, offset]};

MemPtrRegIndirect: PROC [mem: Mem, ptrReg: PtrReg, size, offset: BitAddr, keepFrame: BOOL] RETURNS [Mem]
~ INLINE {RETURN CirioMemory.MemPtrRegIndirect[mem, ptrReg, size, offset, keepFrame]};

MemReadPtrReg: PROC [mem: Mem, ptrReg: PtrReg] RETURNS [BitStretch]
~ INLINE {RETURN CirioMemory.MemReadPtrReg[mem, ptrReg]};

MemReadSegReg: PROC [mem: Mem, segName: ROPE, segNum: INT] RETURNS [BitStretch]
~ INLINE {RETURN CirioMemory.MemReadSegReg[mem, segName, segNum]};

MemSelectSegment: PROC [mem: Mem, segName: ROPE, segNum: INT, keepFrame: BOOL] RETURNS [Mem]
~ INLINE {RETURN CirioMemory.MemSelectSegment[mem, segName, segNum, keepFrame]};


CirioAddress: TYPE = REF CirioAddressBody;
CirioAddressBody: TYPE = RECORD [
isNil: PROC [CirioAddress] RETURNS [BOOL],
readBits: PROC[byteOffset: CARD _ 0, bitOffset: CARD _ 0, bitSize: CARD, data: CirioAddress] RETURNS[CARD],
writeBits: PROC[byteOffset: CARD _ 0, bitOffset: CARD _ 0, bitSize: CARD, data: CirioAddress, bits: CARD],
followPointer: PROC[byteOffset: CARD _ 0, data: CirioAddress] RETURNS[CirioAddress],
asCard: PROC[data: CirioAddress] RETURNS[CARD],
data: REF ANY
];




TypeBody: PRIVATE TYPE ~ RECORD[
class: TypeClass,
procs: REF CCTypeProcs,
procData: REF ANY,
defaultType: Type,
indirectType: Type,
targetType: Type];

CCTypeProcs: TYPE = RECORD[
createIndirectNode: PROC [cc: CC, procData: REF ANY, indirectType, targetType: Type, mem: Mem] RETURNS [Node],
checkConformance: PROC[valType, varType: Type, cc: CC, procData: REF ANY] RETURNS[ConformanceCheck],
storable: PROC[valType, indirectType: Type, cc: CC, procData: REF ANY] RETURNS[BOOLEAN],
checkFamilyInclusion: PROC[valType, varType: Type, cc: CC, procData: REF ANY] RETURNS[BOOLEAN],
isASingleton: PROC[type: Type, cc: CC, procData: REF ANY] RETURNS[BOOLEAN],
binaryOperandTypes: PROC[op: Operator, left, right: Type, cc: CC, procData: REF ANY] RETURNS[BinaryTargetTypes],
isAnIndirect: PROC[type: Type, cc: CC, procData: REF ANY] RETURNS[BOOLEAN],
getRTargetType: PROC[type: Type, cc: CC, procData: REF ANY] RETURNS[Type],
getLTargetType: PROC[type: Type, cc: CC, procData: REF ANY] RETURNS[Type],
getFieldsType: PROC[rcdType: Type, cc: CC, procData: REF ANY] RETURNS[Type],
getRefType: PROC[rhs: Type, cc: CC, procData: REF ANY] RETURNS[Type],
hasIdField: PROC[id: ROPE, fieldContext: Type, cc: CC, procData: REF ANY] RETURNS[IdFieldCase],
containsVariance: PROC[type: Type, cc: CC, procData: REF ANY] RETURNS[BOOLEAN],
getNVariants: PROC[type: Type, cc: CC, procData: REF ANY] RETURNS[INT],
asIndexSet: PROC[type: Type, cc: CC, procData: REF ANY] RETURNS[Type],
operand: PROC[op: Operator, lr: LR, tc: TypedCode, cc: CC, procData: REF ANY] RETURNS[TypedCode],
applyOperand: PROC[operatorType: Type, operand: ParseTree, cc: CC, procData: REF ANY] RETURNS[TypedCode],
indexOperand: PROC[operatorType: Type, operand: ParseTree, cc: CC, procData: REF ANY] RETURNS[TypedCode],
coerceToType: PROC[targetType: Type, tc: TypedCode, cc: CC, procData: REF ANY] RETURNS[TypedCode],
binaryOp: PROC[op: Operator, left, right: TypedCode, cc: CC, procData: REF ANY] RETURNS[TypedCode],
unaryOp: PROC[op: Operator, arg: TypedCode, cc: CC, procData: REF ANY] RETURNS[TypedCode],
nAryOperandType: PROC[op: Operator, typeSoFar, nextType: Type, cc: CC, procData: REF ANY] RETURNS[Type],
nAryOp: PROC[op: Operator, args: LIST OF TypedCode, cc: CC, procData: REF ANY] RETURNS[TypedCode],
typeOp: PROC[op: Operator, type: Type, cc: CC, procData: REF ANY] RETURNS[TypedCode],
typeOp2OperandType: PROC[op: Operator, type: Type, cc: CC, procData: REF ANY] RETURNS[Type],
typeOp2: PROC[op: Operator, type: Type, arg: TypedCode, cc: CC, procData: REF ANY] RETURNS[TypedCode],
constructor: PROC[list: LIST OF ParseTree, targetType: Type, cc: CC, procData: REF ANY] RETURNS[TypedCode],
pairConstructor: PROC[list: LIST OF NameArgPair, targetType: Type, cc: CC, procData: REF ANY] RETURNS[TypedCode],
store: PROC[value: TypedCode, indirect: TypedCode, cc: CC, procData: REF ANY] RETURNS[TypedCode],
load: PROC[indirect: TypedCode, cc: CC, procData: REF ANY] RETURNS[TypedCode],
extractIdField: PROC[id: ROPE, fieldContext: Type, cc: CC, procData: REF ANY] RETURNS[TypedCode],
loadIdVal: PROC[id: ROPE, targetType: Type, cc: CC, procData: REF ANY] RETURNS[TypedCode],
selectIdField: PROC[id: ROPE, fieldIndirectContext: Type, cc: CC, procData: REF ANY] RETURNS[TypedCode],
loadIdField: PROC[id: ROPE, fieldIndirectContext: Type, cc: CC, procData: REF ANY] RETURNS[TypedCode],
apply: PROC[operator: TypedCode, operand: TypedCode, cc: CC, procData: REF ANY] RETURNS[TypedCode],
index: PROC[operator: TypedCode, operand: TypedCode, cc: CC, procData: REF ANY] RETURNS[TypedCode],
getTypeRepresentation: PROC[type: Type, cc: CC, procData: REF ANY] RETURNS[REF ANY],
getNElements: PROC[type: Type, cc: CC, procData: REF ANY] RETURNS[CARD],
getBitSize: PROC[indirectType, targetType: Type, cc: CC, procData: REF ANY] RETURNS[CARD],
getScopeIndex: PROC [type: Type, cc: CC, procData: REF ANY] RETURNS [CARD],
getGroundType: PROC[type: Type, cc: CC, procData: REF ANY] RETURNS[Type],
printType: PROC [to: IO.STREAM, type: Type, printDepth: INT, printWidth: INT, cc: CC, procData: REF ANY]
];

ConformanceCheck: TYPE = {yes, dontKnow, no};
Operator: TYPE = ATOM;
BinaryTargetTypes: TYPE = RECORD[tLeft, tRight: Type];
IdFieldCase: TYPE = {yes, possible, no};
LR: TYPE = {left, right, unary, nary};
NameArgPair: TYPE = RECORD[id: ROPE, arg: ParseTree];
ParseTree: TYPE ~ REF ParseTreeBody; ParseTreeBody: PRIVATE TYPE;

BasicTypeInfo: TYPE ~ REF BasicTypeInfoPrivate;
BasicTypeInfoPrivate: TYPE ~ RECORD [
createIndirectNode: PROC [bti: BasicTypeInfo, cc: CC, indirectType, targetType: Type, mem: Mem] RETURNS [Node],
getBitSize: PROC[bti: BasicTypeInfo, cc: CC, indirectType, targetType: Type] RETURNS[CARD],
btiData: REF ANY];

NodeBody: PRIVATE TYPE = RECORD[
ops: REF OperationsBody,
type: Type,
data: REF ANY];

OperationsBody: TYPE = RECORD[
makeAMNode: PROC[sourceType: Type, node: Node, cc: CC] RETURNS[Node],
examineBoolean: PROC[node: Node, cc: CC] RETURNS[BOOLEAN],
examineParseTree: PROC[node: Node, cc: CC] RETURNS[ParseTree],
getCurrentType: PROC[node: Node, cc: CC] RETURNS[Type],
getNameContext: PROC[scopeIndex: CARDINAL, node: Node, cc: CC] RETURNS[Node],
advanceNameScope: PROC[node: Node, cc: CC] RETURNS[Node],
coerce: PROC[sourceType, targetType: Type, node: Node, cc: CC] RETURNS[Node],
binaryOp: PROC[op: Operator, leftType, rightType: Type, leftNode, rightNode: Node, cc: CC] RETURNS[Node],
unaryOp: PROC[op: Operator, type: Type, node: Node, cc: CC] RETURNS[Node],
store: PROC[valType: Type, valNode: Node, indirectType: Type, indirectNode: Node, cc: CC],
load: PROC[indirectType: Type, indirectNode: Node, cc: CC] RETURNS[Node],
forceIn: PROC[type: Type, node: Node, cc: CC] RETURNS[Node],
extractField: PROC[id: ROPE, type: Type, node: Node, cc: CC] RETURNS[Node],
selectField: PROC[id: ROPE, indirectType: Type, indirectNode: Node, cc: CC] RETURNS[Node],
selectNestedBlock: PROC[set: INT, depth: INT, indirectType: Type, indirectNode: Node, cc: CC] RETURNS[Node],
apply: PROC[operatorType: Type, operandType: Type, operator: Node, operand: Node, cc: CC] RETURNS[Node],
index: PROC[indirectOperatorType: Type, operandType: Type, indirectOperator: Node, operand: Node, cc: CC] RETURNS[Node],
asIndex: PROC[type: Type, node: Node, cc: CC] RETURNS[CARD],

show: PROC[to: IO.STREAM, node: Node, depth: INT, width: INT, cc: CC],
getNodeRepresentation: PROC[node: Node, cc: CC] RETURNS[REF ANY]
];
END..

CirioTypes.Mesa
Copyright Σ 1990, 1991, 1992 by Xerox Corporation.  All rights reserved.
Sturgis, September 5, 1989 2:31:27 pm PDT
Last changed by Theimer on June 28, 1989 12:59:54 pm PDT
Last tweaked by Mike Spreitzer on January 8, 1992 11:51 am PST
Laurie Horton, February 24, 1992 4:36 pm PST
Philip James, February 24, 1992 1:35 pm PST
Started: November 5, 1988 3:31:42 pm PST
Sturgis: November 5, 1988 3:51:22 pm PST
It is really a bit of a  mess at the moment.  The implementation is essentially tied to Cedar.  Most of the relevant implementation is in CCTypesImpl.


If arg isn't NIL, returns arg; if arg is NIL, raises an error.

BitAddr
A BitAddr represents a position in or length of memory.

The first part is in Addressing Units (ie, increments of debuggee pointers).  ABS[bits] < bitsPerTargetAu.
Result is equivalent to arg, and has non-negative bits.
inner is interpreted relative to main; compd tells whether all of compd lies within main.
Mem

Cirio address definition
Are these defunct?
remark: This type is intended to provide binary access to the target world.  Further, sitting in CirioTypes makes it part of the root of the world.  The readBits and writeBits procedures expect that bitSize will always be <= 32.  The bits transfered are the bitSize low-order bits of the CARD.
Type details (exposed for debugging).
Invoked only on indirect types.
We only ask bitSize of indirect types; the answer is the size of the referent.
note: we include bitSize as a proc because in some cases it requires bitSize information from component types.  We wish to avoid analyzing the component types while constructing this AnalyzedSEHBody.  So, we compute the bitSize lazily and record it in private when we have it.  Hopefull, no call on bitSize will be made until the analysis is complete.
further note: The individual computations of bitSize are supposed to be inspired by [PCedar2.0]<Mimosa>SymbolOpsImpl.BitsForType.
RHS info for many Types:
Node details (exposed for debugging).
perhaps the following should be in a different group
Κ’•NewlineDelimiter

™
codeš
œ™K™HKš
œ)™)K™8K™>K™,K™+—K˜Kš
œ(™(Kš
œ(™(K˜KšΟk	œœ˜(K˜šΟn
œœ
˜Kšœ˜—Kš
˜K˜Kšœœœ
˜Kš	œœœœ
œ˜K˜Kš
œ–
™–
™Kšœœœ
˜Kšœ
œ
˜—K˜˜Kšœœœ˜1K˜K˜Kšœœ˜Kšœœœ˜0šœœœ
˜#K˜K˜K˜—Kšœœœ˜8Kšœœ
˜K™K˜—˜Kšœœœ
˜K˜KšœœœΟc6˜NK˜K˜K˜Kš
žœœœ
œœ˜/K˜šžœœœœ˜,K™>—K˜Kšœœœ
˜K˜Kšœ
œœ˜(šœœœ˜ Kš
ž	œœ"œœœ˜TKšžœœ"œœ˜OKšœœ
œ˜——K™™K™7K™šœ	œ˜$KšœNœ™j—K˜Kš
œ%˜%Kš
œ+˜+K˜Kš
œ˜Kš
œ˜K˜š
žœœœœœ
˜5Kšœœœ ˜0—K˜šžœœœ˜.Kšœ2Οeœ
™7—K˜šžœœœ
˜-Kšœœœ˜*—K˜šžœœœœ
˜<Kšœœœ$˜4K˜—šžœœœ
˜-Kšœœœ˜*—K˜šžœœœœ
˜5Kšœœœ˜,—K˜Kšž	œœœ˜<K˜šžœœœœ
˜,Kšœœœ˜-—K˜šžœœœœ
˜+Kšœœœ˜+—K˜šžœœœœ
˜+Kšœœœ˜+—K˜šžœœœœ
˜*Kšœœœ˜*—K˜šžœœœœ
˜+Kšœœœ˜+—K˜šžœœœœ
˜*Kšœœœ˜*—K˜Kšœœ˜*K˜šž	œœœ
œ˜SKš
 œ œ œ œ
 œ
™YKšœœœ%˜5—K˜—™K™Kšœœ˜Kš
œ˜Kšœœ˜"K˜šžœœœ˜;Kšœœœ%˜5—K˜šžœœœ˜8Kšœœœ$˜4—K˜šžœœAœ˜_Kšœœœ-˜=—K˜šž
œœœ
˜3Kšœœœ!˜1—K˜šž
œœœ
˜-Kšœœœ˜.—K˜šžœœœ
˜.Kšœœœ˜/—K˜š
žœœœœœ
˜GKšœœœ,˜<—K˜šžœœœœ˜EKšœœ4˜<—K˜šžœœ>œœ˜hKšœœœF˜V—K˜šž
œœœ
˜CKšœœœ)˜9—K˜š
ž
œœœ
œœ
˜OKšœœœ2˜B—K˜šžœœœ
œ
œœ˜\Kšœœœ@˜P—K˜—™K™K˜Kšœœœ˜*šœœœ˜!Kšœœœœ˜*Kš
œ
œ
œœœœ
œ˜kKšœœ
œœœœ˜jKšœœ
œœ˜TKšœœœ
œ˜/Kšœœ
˜
Kš
œ˜—K˜Kšœ œ
™₯K˜—K˜K˜™%šœ
œ
œœ
˜ K˜Kšœœ
˜Kšœ
œ
œ
˜K˜K˜K˜—K˜šœ
œœ
˜šœœœœ
œ,œ˜nK™—Kšœœœœ
œœ˜dKš
œ
œ"œœ
œœ
œ˜XKš
œœœœ
œœ
œ˜_Kš
œœœœ
œœ
œ˜KKšœœ&œœ
œœ˜pKš
œœœœ
œœ
œ˜KKšœœœœ
œœ˜JKšœœœœ
œœ˜JKšœœœœ
œœ˜LKšœœœœ
œœ˜EKš
œœœœœ
œœ˜_Kš
œœœœ
œœ
œ˜OKš
œœœœ
œœ
œ˜GKšœœœœ
œœ˜FKš
œ	œœœœ
œœ˜aKšœœ-œœ
œœ˜iKšœœ-œœ
œœ˜iKšœœ&œœ
œœ˜bKšœ
œ+œœ
œœ˜cKšœ	œ#œœ
œœ˜ZKšœœ.œœ
œœ˜hKšœœœ
œœœ
œœ˜bKšœœœœ
œœ˜UKšœœœœ
œœ˜\Kšœ	œ/œœ
œœ˜fKšœ
œœ
œ"œœ
œœ˜kKšœœœ
œ$œœ
œœ˜qKšœœ,œœ
œœ˜aKšœœœœ
œœ˜NKš
œœœœœ
œœ˜aKš
œœœœœ
œœ˜ZKš
œœœ"œœ
œœ˜hKš
œ
œœ"œœ
œœ˜fKšœœ.œœ
œœ˜cKšœœ.œœ
œœ˜cKšœœœœ
œœ
œ
œ˜TKš
œœœœ
œœ
œ˜Hš
œœ%œœ
œœ
œ˜ZK™NKš
œί™ίKš
œ
™
—Kš
œœœœ
œœœ˜KKšœœœœ
œœ˜IKšœœœ
œœœœœ
œ
˜hKš
œ˜—K˜Kšœœ˜-Jšœ
œœ
˜Kšœœœ˜6Kšœ
œ˜(Kšœœ˜&Kšœ
œœœ˜5Kš	œœœœ
œ
˜AK˜—™Kšœœœ˜/šœœœ˜%Kšœœœ,œ˜oKš	œœœ"œ
œ˜[Kšœ	œ
œ˜—K˜—™%šœ
œ
œœ
˜ Kšœœ˜K˜Kšœœ
œ˜—K˜šœœœ
˜Kšœœ#œœ˜EKš	œœœœ
œ˜:Kšœœœœ˜>Kšœœœœ˜7Kš	œœ
œœœ˜MKšœœœœ˜9Kšœœ/œœ˜MKšœ
œIœœ˜iKšœ	œ+œœ˜JKšœœKœ˜ZKšœœ-œœ˜IKšœ	œœœ˜<Kš	œœœœœ˜KKš	œ
œœ.œœ˜ZKšœœœ	œ.œœ˜lKšœœKœœ˜hKšœœ[œœ˜xKš	œ	œœœ
œ˜<K˜Kš
œ4™4Kš
œœœ
œœ	œœ˜FKšœœœœ
œ
œ
˜@K˜——Kšœ˜—…—+NBζ