SiroccoParser: Control Module;

SiroccoCG: Module = Begin

BaseTypeKind: EnumeratedBaseType =
{ bool, card16, card32, int16, int32, sink, source, string, unspec };

Generic: EnumeratedBaseType =
{ array, bool, card16, card32, choice, enum, error, int16, int32, proc, record, seq, sink, source, string, unspec };
ItemKind: EnumeratedBaseType =
{ type, const };
ValueKind: EnumeratedBaseType =
{ bool, constructor, grouping, negation, null, number, string, variant };
{ "ARRAY" "BEGIN" "BOOLEAN" "CARDINAL" "CHOICE" "DEPENDS" "END" "ERROR" "FALSE" "INTEGER" "LONG" "OF" "PROCEDURE" "PROGRAM" "RECORD" "REPORTS" "RETURNS" "SEQUENCE" "SINK" "SOURCE" "STRING" "TRUE" "TYPE" "UNSPECIFIED" "UPON" "VERSION"
"(" ")"
"[" "]"
"{" "}"
":" "." ";" "=" "=>" "," "-" }: SimpleTokens;

id:	GenericToken = "tokenID";
decimal:	GenericToken = "tokenDECIMAL";
hex:	GenericToken = "tokenHEX";
octal:	GenericToken = "tokenOCTAL";
rope:	GenericToken = "tokenROPE";
export:	NonTerminal Builds Program;

for export	_ program "."
Build	program;

program:	NonTerminal Builds Program;

for program	_ id ":" "PROGRAM" decimal.pgm "VERSION" decimal.version "="  "BEGIN" dependency declarationlist "END" 
Build	Program.export[id, decimal.pgm, decimal.version, dependency, declarationlist];

dependency:	NonTerminal Builds ImportList;

for dependency.empty	_ 
Build	ImportList.empty[];
for dependency.imports _ "DEPENDS" "UPON" importlist ";"
Build	importlist;

importlist:	NonTerminal Builds ImportList;

for importlist.one	_ import
Build	ImportList.more[ImportList.empty[ [import, import) ], import];
for importlist.more	_ importlist "," import
Build	ImportList.more[importlist, import];

import:	NonTerminal Builds Import;

for import	_ id "(" decimal.pgm ")" "VERSION" decimal.version
Build	Import.interface[id, decimal.pgm, decimal.version];

declarationlist:	NonTerminal Builds DeclarationList; 

for declarationlist.a	_ 
Build	DeclarationList.empty[];
for declarationlist .b _ declarationlist declaration
Build	DeclarationList.more[declarationlist, declaration];

declaration:	NonTerminal Builds Declaration;

for declaration.type	_ id ":" "TYPE" "=" type";"
Build	Declaration.type[id, type];
for declaration.constant	_ id ":" type "=" constant ";"
Build	Declaration.constant[id, type, constant];
for declaration.id	_ id.name ":" type "=" id.constant ";"
Build	Declaration.constant[id.name, type, Constant.deref[id.constant]];

type:	NonTerminal Builds Type; 

for type.simple	_ simpletype
Build	simpletype;
for type.construction	_ construction
Build	construction;

simpletype:	NonTerminal Builds Type;

for simpletype.reference	_ reference
Build	reference;
for simpletype.primitive	_ primitive
Build	primitive;

reference:	NonTerminal Builds Type; 

for reference.alias	_ id
Build	Type.alias[id];
for reference.import	_ id.interface "." id.item
Build	Type.import[id.interface, id.item];

primitive:	NonTerminal Builds Type;

for primitive.bool	_ "BOOLEAN"
Build	Type.bool[];
for primitive.card16	_ "CARDINAL"
Build	Type.card16[];
for primitive.card32	_ "LONG" "CARDINAL"
Build	Type.card32[];
for primitive.int16_ "INTEGER"
Build	Type.int16[];
for primitive.int32	_ "LONG" "INTEGER"
Build	Type.int32[];
for primitive.sink	_ "SINK"
Build	Type.sink[];
for primitive.source	_ "SOURCE" 
Build	Type.source[];
for primitive.string	_ "STRING"
Build	Type.string[];
for primitive.unspec	_ "UNSPECIFIED"
Build	Type.unspec[];

construction:	NonTerminal Builds Type;

for construction.array	_ "ARRAY" mandatory "OF" simpletype
Build	Type.array[mandatory, simpletype];
for construction.choice	_ "CHOICE" reference "OF" "{" union "}"
Build	Type.choice[reference, union];
for construction.enum	_ "{" enumeration "}"
Build	Type.enum[enumeration];
for construction.error	_ "ERROR" arguments
Build	Type.error[arguments];
for construction.proc	_ "PROCEDURE" arguments results errors
Build	Type.proc[arguments, results, errors];
for construction.record	_ "RECORD" "[" fieldlist"]"
Build	Type.record[fieldlist];
for construction.null	_ "RECORD" "[" "]"
Build	Type.null[];
for construction.seq	_ "SEQUENCE" optional "OF" simpletype
Build	Type.seq[optional, simpletype]; --Can be empty

constant:	NonTerminal Builds Constant; 

for constant.value	_ value
Build	value;
for constant.complex	_ complexvalue
Build	complexvalue;
for constant.choiceconstant	_ id constant
Build	Constant.choice[id, constant];
for constant.choiceid	_ id.choice id.value
Build	Constant.choice[id.choice, Constant.deref[id.value]];
for constant.import	_ id.interface "." id.item
Build	Constant.import[id.interface, id.item];

value:	NonTerminal Builds Constant;

for value.true	_ "TRUE"
Build	Constant.true[];
for value.false	_ "FALSE"
Build	Constant.false[];
for value.number	_ number
Build	Constant.number[number];
for value.inverted	_ "-" number
Build	Constant.inverted[number];
for value.string	_ rope
Build	Constant.string[rope];

complexvalue:	NonTerminal Builds Constant;

for complexvalue.grouping	_ "[" grouping "]"
Build	Constant.grouping[grouping];
for complexvalue.constructor	_ "[" constructor "]"
Build	Constant.constructor[constructor];
for complexvalue.null	_ "[" "]"
Build	Constant.empty[];

optional:	NonTerminal Builds Constant; 

for optional.nonempty	_ constant
Build	constant;
for optional.alias	_ id
Build	Constant.deref[id];
for optional.empty	_
Build	Constant.unbounded[];

mandatory:	NonTerminal Builds Constant; 

for mandatory.value	_ constant
Build	constant;
for mandatory.alias	_ id
Build	Constant.deref[id];

enumeration:	NonTerminal Builds Enumeration;

for enumeration.one	_ keyindexpair
Build	keyindexpair;
for enumeration.more	_ keyindexpair "," enumeration
Build	Enumeration.more[keyindexpair, enumeration];

keyindexpair:	NonTerminal Builds Enumeration;

for keyindexpair	_ id "(" mandatory ")"
Build	Enumeration.one[id, mandatory];

union:	NonTerminal Builds Union;

for union.one	_ selector
Build	selector;
for union.more	_ selector "," union
Build	Union.more[selector, union];

selector:	NonTerminal Builds Union;

for selector.one	_ namelist "=>" simpletype
Build	Union.one[namelist, simpletype];
for selector.two	_ namelist "(" number ")" "=>" simpletype
Build	Union.one[namelist, simpletype];

fieldlist:	NonTerminal Builds FieldList;

for fieldlist.field	_ field
Build	FieldList.more[field, FieldList.empty[ [field, field) ]];
for fieldlist.more	_ field "," fieldlist
Build	FieldList.more[field, fieldlist];

field:	NonTerminal Builds FieldList;

for field	_ namelist ":" simpletype
Build	FieldList.one[namelist, simpletype];

grouping:	NonTerminal Builds Grouping;

for grouping.const	_ constant
Build	Grouping.one[constant];
for grouping.id	_ id
Build	Grouping.one[Constant.deref[id]];
for grouping.cmore	_ constant "," grouping 
Build	Grouping.more[constant, grouping];
for grouping.imore	_ id "," grouping
Build	Grouping.more[Constant.deref[id], grouping];

constructor:	NonTerminal Builds Constructor; 

for constructor.one	_ binding
Build	Constructor.one[binding];
for constructor.more	_ binding "," constructor 
Build	Constructor.more[binding, constructor];

binding:	NonTerminal Builds Binding;

for binding.id	_ namelist ":" id
Build	Binding[namelist, Constant.deref[id]];
for binding.const	_ namelist ":" constant
Build	Binding[namelist, constant];

arguments:	NonTerminal Builds FieldList;

for arguments.empty	_ 
Build	FieldList.empty[];
for arguments.list	_ "[" fieldlist "]"
Build	fieldlist;
for arguments.null	_ "[" "]"
Build	FieldList.empty[];

results:	NonTerminal Builds FieldList;

for results.empty	_ 
Build	FieldList.empty[];
for results.list	_ "RETURNS" "[" fieldlist "]"
Build	fieldlist;
for results.null	_ "RETURNS" "[" "]"
Build	FieldList.empty[];

errors:	NonTerminal Builds NameList;

for errors.empty	_ 
Build	NameList.empty[];
for errors.list	_ "REPORTS" "[" namelist "]"
Build	namelist;
namelist:	NonTerminal Builds NameList;

for namelist.one	_ id
Build	NameList.one[id];
for namelist.more	_ id "," namelist 
Build	NameList.more[id, namelist];

number:	NonTerminal Builds Number;

for number.decimal	_ decimal
Build	Number.decimal[decimal];
for number.octal	_ octal
Build	Number.octal[octal];
for number.hex	_ hex
Build	Number.hex[hex]

End;

SiroccoAG1: Module = Begin
Program.export:	AbstractProduction [ id.export, decimal.pgm, decimal.version, ImportList, DeclarationList ];
ImportList.empty:	AbstractProduction [] ;
ImportList.more:	AbstractProduction [ ImportList, Import ];
Import.interface:	AbstractProduction [ id.interface, decimal.pgm, decimal.version ];
DeclarationList.empty:	AbstractProduction [ ];
DeclarationList.more:	AbstractProduction [ DeclarationList, Declaration ];
Declaration.type:	AbstractProduction [ id, Type ];
Declaration.constant:	AbstractProduction [ id, Type, Constant ];
Type.alias:	AbstractProduction [ id ];
Type.import:	AbstractProduction [ id.interface, id.item ];
Type.bool:	AbstractProduction [ ];
Type.card16:	AbstractProduction [ ];
Type.card32:	AbstractProduction [ ];
Type.int16:	AbstractProduction [ ];
Type.int32:	AbstractProduction [ ];
Type.sink:	AbstractProduction [ ];
Type.source:	AbstractProduction [ ];
Type.string:	AbstractProduction [ ];
Type.unspec:	AbstractProduction [ ];
Type.array:	AbstractProduction [ Constant, Type ];
Type.seq:	AbstractProduction [ Constant, Type ];
Type.enum:	AbstractProduction [ Enumeration ];
Type.error:	AbstractProduction [ FieldList ];
Type.record:	AbstractProduction [ FieldList ];
Type.null:	AbstractProduction [ ];
Type.proc:	AbstractProduction [ FieldList.arg, FieldList.res, NameList ];
Type.choice:	AbstractProduction [ Type, Union ];
End;

SiroccoAG2: Module = Begin
Constant.deref:	AbstractProduction [ id ];
Constant.import:	AbstractProduction [ id.interface, id.item ];
Constant.empty:	AbstractProduction [ ];
Constant.false:	AbstractProduction [ ];
Constant.true:	AbstractProduction [ ];
Constant.unbounded:	AbstractProduction [ ];
Constant.inverted:	AbstractProduction [ Number ];
Constant.number:	AbstractProduction [ Number ];
Constant.string:	AbstractProduction [ rope ];
Constant.choice:	AbstractProduction [ id, Constant ];
Constant.constructor:	AbstractProduction [ Constructor ];
Constant.grouping:	AbstractProduction [ Grouping ];
Enumeration.one:	AbstractProduction [ id, Constant ];
Enumeration.more:	AbstractProduction [ Enumeration.value, Enumeration.next ];
Union.one:	AbstractProduction [ NameList, Type ];
Union.more:	AbstractProduction [ Union.value, Union.next ];
FieldList.empty:	AbstractProduction [ ];
FieldList.one:	AbstractProduction [ NameList, Type ];
FieldList.more:	AbstractProduction [ FieldList.value, FieldList.rest ];
Grouping.one:	AbstractProduction [ Constant ];
Grouping.more:	AbstractProduction [ Constant, Grouping ];
Constructor.one:	AbstractProduction [ Binding ];
Constructor.more:	AbstractProduction [ Binding, Constructor ];
Binding:	AbstractProduction [ NameList, Constant ];
NameList.empty:	AbstractProduction [ ];
NameList.one:	AbstractProduction [ id ];
NameList.more:	AbstractProduction [ id, NameList ];
Number.decimal:	AbstractProduction [ decimal ];
Number.hex:	AbstractProduction [ hex ];
Number.octal:	AbstractProduction [ octal ];

End;

SiroccoAT: Module = Begin

Program:	AbstractType [ MakeSymbolTable ]; 
ImportList:	AbstractType [ BuildRIB ];
Import:	AbstractType [ BuildScope ];
DeclarationList:	AbstractType [ BuildItemTable, BuildTypeGraph ];
Declaration:	AbstractType [ BuildItem, BuildNamedItem ];
Type:	AbstractType [ BuildTGN ];
Enumeration:	AbstractType [ BuildTGN ];
Union:	AbstractType [ BuildTGN ];
FieldList:	AbstractType [ BuildTGN ]; -- I want a FIELD type (ajd)
Constant:	AbstractType [ BuildAbstractValue ];
Grouping:	AbstractType [ BuildAbstractValue ];
Constructor:	AbstractType [ BuildAbstractValue ];
Binding:	AbstractType [ BuildAbstractValue ];
NameList:	AbstractType [ BuildTGN ];
Number:	AbstractType [ BuildAbstractValue ];
MakeSymbolTable: TreeRecursiveFunction [ Tree ]
Returns [ ROPE.name, CARD.pgm, CARD.version, TypeGraph.flat ];

BuildRIB: TreeRecursiveFunction [ Tree ]
Returns [ RIB.rib ];

BuildScope: TreeRecursiveFunction [ Tree ]
Returns [ SCOPE.scope ];

BuildItemTable: TreeRecursiveFunction [ Tree ]
Returns [ SCOPE.scope ];

BuildItem: TreeRecursiveFunction [ Tree ]
Returns [ ITEM.item ];

BuildTypeGraph: TreeRecursiveFunction [ Tree, CONTEXT.context ]
Returns [ TypeGraph.graph ];

BuildNamedItem: TreeRecursiveFunction [ Tree, CONTEXT.context ]
Returns [ ROPE.name, TypeGraphNode.node, AbstractValue.value ];

BuildTGN: TreeRecursiveFunction [ Tree, CONTEXT.context ]
Returns [ TypeGraphNode.node ];

BuildAbstractValue: TreeRecursiveFunction [ Tree, CONTEXT.context ]
Returns [ AbstractValue.value ];

End;

SiroccoBase: Module = Begin
BOOLEAN:	CedarType;
CARDINAL:	CedarType;
CARD:	CedarType;
NAT:	CedarType;
INT:	CedarType;
AbstractValue:	CedarType From SiroccoPrivate;
CComponent:	CedarType From SiroccoPrivate;
CONTEXT:	CedarType From SiroccoPrivate;
CType:	CedarType From SiroccoPrivate;
FunctionList:	CedarType From SiroccoPrivate;
InterfaceItem:	CedarType From SiroccoPrivate;
ITEM:	CedarType From SiroccoPrivate;
MEMO:	CedarType From SiroccoPrivate;
MemoList:	CedarType From SiroccoPrivate;
Key:	CedarType From SymTab;
ROPE:	CedarType From Rope;
Ref:	CedarType From SymTab;
RIB:	CedarType From SiroccoPrivate;
SCOPE:	CedarType From SiroccoPrivate;
TABLES:	CedarType From SiroccoPrivate;
TypeGraph:	CedarType From SiroccoPrivate;
TypeGraphNode:	CedarType From SiroccoPrivate;
Val:	CedarType From SymTab;
ValueGraph:	CedarType From SiroccoPrivate;
Cat:	CedarFunction [ROPE.a, ROPE.b, ROPE.c] Returns [ROPE.d] From Rope;
Concat:	CedarFunction [ROPE.a, ROPE.b] Returns [ROPE.c] From Rope;
Equal:	CedarFunction [ROPE.a, ROPE.b] Returns [BOOLEAN] From Rope;
Length:	CedarFunction [ROPE] Returns [INT] From Rope;
Nest:	CedarFunction [ROPE.a, NAT.level] Returns [ROPE.b] From SiroccoPrivate;
NewFcn:	CedarFunction [ROPE.name, ROPE.obj, INT.size] Returns [ROPE.out] From SiroccoPrivate;
RopeFromCard:	CedarFunction [CARD] Returns [ROPE] From Convert;
RopeFromInt:	CedarFunction [INT] Returns [ROPE] From Convert;
card:	BaseFunction [INT] Returns [CARD];
int:	BaseFunction [CARD] Returns [INT];
nat:	BaseFunction [INT] Returns [NAT];
TextFromID:	BaseFunction [id] Returns [ROPE];
CardFromDecimal:	BaseFunction [decimal] Returns [CARD];
CardFromOctal:	BaseFunction [octal] Returns [CARD];
CardFromHex:	BaseFunction [hex] Returns [CARD];
GetRopeFromRope:	BaseFunction [rope] Returns [ROPE];
False:	BaseFunction [ ] Returns [BOOLEAN];
True:	BaseFunction [ ] Returns [BOOLEAN];
AddOne:	BaseFunction [INT.arg] Returns [INT.res];
Add:	BaseFunction [INT.a, INT.b] Returns [INT.c];
Subtract:	BaseFunction [INT.a, INT.b] Returns [INT.c];
Copy:	BaseFunction [ROPE.arg, CType.arg, Constant.arg, TABLES.arg] Returns [ROPE.res, CType.res, Constant.res, TABLES.res];
CopyAll:	BaseFunction [ROPE.arg, FunctionList.arg, TABLES.arg]
Returns [ROPE.res, FunctionList.res, TABLES.res];
CopyCComponent:	BaseFunction [CComponent.arg] Returns [CComponent.res];
CopyFunctionList:	BaseFunction [FunctionList.arg] Returns [FunctionList.res];
CopyRope:	BaseFunction [ROPE.a] Returns [ROPE.b];
CopyTables:	BaseFunction [TABLES.arg] Returns [TABLES.res];
CreateKey:	BaseFunction [id] Returns [Key];
RopeFromKey:	BaseFunction [Key] Returns [ROPE];
ImportItem:	BaseFunction [TABLES, Key.interface, Key.item] Returns [InterfaceItem.enty];
TypeNameForItem:	BaseFunction [InterfaceItem.item] Returns [ROPE.type];
ConstantForItem:	BaseFunction [InterfaceItem.item] Returns [ROPE.constant];
ValueFromName:	BaseFunction [ROPE.constant] Returns [CARD.value];

CreateTables:	BaseFunction Returns [TABLES];
DiskToTable:	BaseFunction [ROPE.id, CARD.pgm, CARD.version] Returns [SCOPE.scope];
TableMerge:	BaseFunction [TABLES.t1, TABLES.t2] Returns [TABLES]
SharedReps [TABLES.t1, TABLES.t2];
UpdateItem:	BaseFunction [ TypeGraph.left, ROPE.name, TypeGraphNode.node, AbstractValue.value ] Returns [ TypeGraph.new ]
SharedReps [ TypeGraphNode.node, AbstractValue.value ]
DamagedReps [ TypeGraph.left ];
CreateContext:	BaseFunction [ RIB.rib, SCOPE.scope, ROPE.name, CARD.pgm, CARD.version] Returns [ CONTEXT.context ];
ItemFromContext:	BaseFunction [ CONTEXT.context, ROPE.name ] Returns [ ITEM.item ]
SharedReps [ ITEM.item ];
EmptyScope:	BaseFunction [ ] Returns [ SCOPE.new ];
MakeItem:	BaseFunction [ ROPE.name, INT.position, ItemKind.kind ]
Returns [ ITEM.item ] SharedReps [ ROPE.name ];
ItemConcat:	BaseFunction [ SCOPE.old, ITEM.item ] Returns [ SCOPE.new ]
SharedReps [ ITEM.item ] DamagedReps [ SCOPE.old ];
ItemFromScope:	BaseFunction [ SCOPE.scope, ROPE.name ] Returns [ ITEM.item ]
SharedReps [ ITEM.item ];
EmptyRIB:	BaseFunction [ ] Returns [ RIB.new ];
ScopeConcat:	BaseFunction [ RIB.old, SCOPE.scope ] Returns [ RIB.new ]
SharedReps [ SCOPE.scope ] DamagedReps [ RIB.old ];
ScopeFromRIB:	BaseFunction [ RIB.rib, ROPE.name ] Returns [ SCOPE.scope ]
SharedReps [ SCOPE.scope ];
CreateBaseTypeTGN:
BaseFunction [ BaseTypeKind.kind ]
Returns [ TypeGraphNode.node ];

CreateEmptyTGN:	BaseFunction [ CONTEXT.context ] Returns [ TypeGraph.new ];
CreatePrimitiveTGN:	BaseFunction [ Generic.class ] Returns [ TypeGraphNode.node ];
CreateArrayTGN:
BaseFunction [ AbstractValue.length, TypeGraphNode.subtype ]
Returns [ TypeGraphNode.node ];
CreateChoiceTGN:
BaseFunction [ TypeGraphNode.ktype, TypeGraphNode.union ]
Returns [ TypeGraphNode.node ];
CreateDerefTGN:
BaseFunction [ CONTEXT.context, ROPE.item ]
Returns [ TypeGraphNode.node ];
CreateEnumerationTGN:
BaseFunction [ TypeGraphNode.enum ]
Returns [ TypeGraphNode.node ];
CreateErrorTGN:
BaseFunction [ TypeGraphNode.fieldlist ]
Returns [ TypeGraphNode.node ];
CreateLinkTGN:
BaseFunction [ CONTEXT.context, ROPE.interface, ROPE.item ]
Returns [ TypeGraphNode.node ];
CreateProcTGN:
BaseFunction [ TypeGraphNode.args, TypeGraphNode.results, TypeGraphNode.errors ]
Returns [ TypeGraphNode.node ];
CreateRecordTGN:
BaseFunction [ TypeGraphNode.fieldlist ]
Returns [ TypeGraphNode.node ];
CreateSequenceTGN:
BaseFunction [ AbstractValue.maxlength, TypeGraphNode.subtype ]
Returns [ TypeGraphNode.node ];
CreateFieldListTGN:
BaseFunction [ ROPE.tag, AbstractValue.ordinal ]
Returns [ TypeGraphNode.node ];
CreateUnionTGN:
BaseFunction [ TypeGraphNode.namelist, TypeGraphNode.type ]
Returns [ TypeGraphNode.node ];
CreateFieldTGN:
BaseFunction [ TypeGraphNode.namelist, TypeGraphNode.type ]
Returns [ TypeGraphNode.node ];
CreateEmptyFieldTGN:
BaseFunction [ ]
Returns [ TypeGraphNode.node ];
FieldListTGNConcat:
BaseFunction [ TypeGraphNode.value, TypeGraphNode.next ]
Returns [ TypeGraphNode.node ];
UnionTGNConcat:
BaseFunction [ TypeGraphNode.value, TypeGraphNode.next ]
Returns [ TypeGraphNode.node ];
FieldTGNConcat:
BaseFunction [ TypeGraphNode.value, TypeGraphNode.next ]
Returns [ TypeGraphNode.node ];
CreateNullAVN:
BaseFunction [ ]
Returns [AbstractValue.value];

CreateLogicalAVN:
BaseFunction [ BOOLEAN.b ]
Returns [ AbstractValue.value ];
CreateNumericalAVN:
BaseFunction [ CARD.num ]
Returns [ AbstractValue.value ];
CreateRopeAVN:
BaseFunction [ ROPE.r1 ]
Returns [ AbstractValue.value ];
CreateBindingAVN:
BaseFunction [ TypeGraphNode.node, AbstractValue.node ]
Returns [ AbstractValue.value ];
CreateConstructorAVN:
BaseFunction [ AbstractValue.node ]
Returns [ AbstractValue.value ];
CreateDerefAVN:
BaseFunction [ CONTEXT.context, ROPE.item ]
Returns [ AbstractValue.value ];
CreateGroupingAVN:
BaseFunction [ AbstractValue.node ]
Returns [ AbstractValue.value ];
CreateLinkAVN:
BaseFunction [ CONTEXT.context, ROPE.interface, ROPE.item ]
Returns [ AbstractValue.value ];
CreateNegativeAVN:
BaseFunction [ AbstractValue.old ]
Returns [ AbstractValue.value ];
CreateVariantAVN:
BaseFunction [ ROPE.id, AbstractValue.node ]
Returns [ AbstractValue.value ];

ConstructorAVNConcat:
BaseFunction [ AbstractValue.value, AbstractValue.next ]
Returns [ AbstractValue.node ];
GroupingAVNConcat:
BaseFunction [ AbstractValue.value, AbstractValue.next ]
Returns [ AbstractValue.node ];
AssertTypeGraphAcyclic:
BaseFunction [ TypeGraph.graph ]
Returns [BOOLEAN.acyclic];
AssertValueGraphAcyclic:
BaseFunction [ TypeGraph.graph  ]
Returns [ BOOLEAN.acyclic ];
CheckCanonicalType:	BaseFunction [ROPE.r1, ROPE.r2] Returns [BOOLEAN.same];
CheckResultsForSourceAndSink:	BaseFunction [CComponent.results] Returns [BOOLEAN.ok];
CompareTypes:	BaseFunction [CType.a, CType.b, TABLES] Returns [INT]; -- actually BOOLEAN
GetCType:	BaseFunction [ROPE.id, CComponent, TABLES] Returns [CType, ROPE];
GetLengthOfCComponentList:	BaseFunction [CComponent, INT.arg] Returns [INT.res];
SeeIfArrOrSeq:	BaseFunction [CType.arg, INT, TABLES] Returns [CType.res, ROPE];
GetCTypeFirstChild:	BaseFunction [CType] Returns [CComponent];
MkCComponent:	BaseFunction [ROPE.name, INT.valBinding, ROPE.typeBinding, CComponent.sibling] Returns [CComponent];
MkCType:	BaseFunction [Generic.class, INT.bound, CComponent.firstChild]
Returns [CType];
MkNILCComponent:	BaseFunction [] Returns [CComponent];
MkPrimitiveCType:	BaseFunction [Generic.class] Returns [CType, ROPE.name];
FetchFromTypeTable:	BaseFunction [TABLES.arg, ROPE] Returns [CType];
GetObjectName:	BaseFunction [ROPE.type, TABLES] Returns [ROPE.typeobject];
Remove:	BaseFunction [ROPE.id, TABLES.arg] Returns [TABLES.res] DamagedReps [TABLES.arg];
SendError:	BaseFunction [ROPE] Returns [CARD]; 
ClearWorkTable:	BaseFunction [TABLES.arg] Returns [TABLES.res] DamagedReps [TABLES.arg];
EnterNamesIntoWorkTable:	BaseFunction [CType, TABLES.arg] Returns [TABLES.res] DamagedReps [TABLES.arg];
FillWorkTable:	BaseFunction [CType, TABLES.arg] Returns [TABLES.res] DamagedReps [TABLES.arg];
LocalConstantToRope:	BaseFunction [ROPE.id, ROPE.constantType, TABLES.arg]
Returns [ROPE.constant, TABLES.res] DamagedReps [TABLES.arg];
CanonicalLocalReferenceType:	BaseFunction [ROPE.id, TABLES.arg] Returns [ROPE, CType, TABLES.res] DamagedReps [TABLES.arg];
GetConstantType:	BaseFunction [ROPE.id, TABLES.arg] Returns [ROPE, CType, Constant, TABLES.res] DamagedReps [TABLES.arg];
TryToCoerceNumber:	BaseFunction [CType, CARD] Returns [INT];
Array:	BaseFunction [ROPE.type, TABLES] Returns [BOOLEAN];-- Sees if type is array
CheckIfEmpty:	BaseFunction [TABLES.arg] Returns [BOOLEAN.empty];
CompareClass:	BaseFunction [CType, Generic.b] Returns [CComponent];
InsureErrorType:	BaseFunction [ROPE.id, TABLES.arg] Returns [TABLES.res];
IsEnumerationConstant:	BaseFunction [CType, ROPE.id] Returns [INT];
NotEnumeration:	BaseFunction [CType] Returns [BOOLEAN];
SeeIfDuplicated:	BaseFunction [TABLES.arg, ROPE.id, CARD] Returns [TABLES.res] DamagedReps [TABLES.arg];
SeeIfInt:	BaseFunction [CType] Returns [BOOLEAN];
AddFunctionList:	BaseFunction [Val, FunctionList.arg] Returns [FunctionList.res] DamagedReps [FunctionList.arg];
AddFunctionToTable:	BaseFunction [Val, FunctionList, TABLES.arg] Returns [TABLES.res] DamagedReps [TABLES.arg];
ConsFunctionList:	BaseFunction [FunctionList.arg, ROPE] Returns [FunctionList.res] DamagedReps [FunctionList.arg];
GetTypeOfComponent:	BaseFunction [ROPE.id, ROPE.arg, TABLES] Returns [ROPE.typeOf];
GetTypeOfElement:	BaseFunction [ROPE.arg, TABLES] Returns [ROPE.TypeOfElement];
TypeOfSequence:	BaseFunction [ROPE.sequenceName, TABLES] Returns [ROPE.typeOf];

End.

|Sirocco.ThreeC4
Copyright Σ 1986, 1987 by Xerox Corporation. All rights reserved.
Bhargava, August 12, 1986 11: 24: 02 pm PDT
Demers, December 29, 1986 8:05:56 pm PST
Bill Jackson (bj) August 26, 1987 3:34:17 pm PDT

These types are defined here as a convienience;
because of circularity, placing it here reduces the interface count by one.

Tokens
Productions
RefConst (id.id) as well as id id ... id.id
for errors.null	_ "REPORTS" "[" "]"
Build	NameList.empty[];

Program
ImportList
Import
DeclarationList
Declaration
Type
References
Primitives
Constructions
Constant
References
Primitives
Constructions
Enumeration
Union
FieldList
Grouping
Constructor
Binding
NameList
Number
Operations
Types

Procs
SharedReps [ROPE.a, ROPE.b, ROPE.c, ROPE.d];
DupOps (Inline Implementions)
Since Casaba only understands INTs
values from tokens
values / constant fcns
Arithmetic Operations
Convince Casaba that things are undamaged
Hash Keys
your basic noop!
Hash Table Operations
grumpf! Fetch is in Rope, and Casaba does OPEN Rope, SymTab;
Scopes, Ribs & Contexts
Context
Scope
Ribs
Type Graph/Node Creators
Primitive Creators
Primary Creators
Secondary Creators
Concatination operators
Abstract Value Node Creators
Primary Creators
Secondary Creators
Graph Searching
Type Tree (lists) Operations
Canonical Type manipulation
Utility Functions
Work Table Functions
Misc Functions
Predicates
Unknown Purpose...
Κ ²•StyleDef‡BeginStyle (cedar) AttachStyle (code30) (set up the fancy tabs) {code clearTabStops 30 mm flushLeft tabStop} StyleRule (code35) (set up the fancy tabs) {code clearTabStops 35 mm flushLeft tabStop} StyleRule (code40) (set up the fancy tabs) {code clearTabStops 40 mm flushLeft tabStop} StyleRule (code45) (set up the fancy tabs) {code clearTabStops 45 mm flushLeft tabStop} StyleRule EndStyle˜
code40™Kš
œA™AKšœ(Οk™+Kšœ%™(Kš
œ0™0—K™KšΟn
ΟtΠizŸ
 Ÿ
˜K˜šž	œ œ ˜K˜K™{K™Kšžœ œH˜hK˜Kšžœ œw˜’
Kšžœ œ˜/Kšž	œ œL˜i
headš
Οz™˜ι
Kš
œ˜Kš
œ˜Kš
œ˜Kšœ  œ
˜-—K˜Kšœ œ
˜Kšœ	 œ˜'Kšœ œ˜Kšœ œ˜#Kšœ œ˜!—š
‘™šœ œ
 œ	˜#K˜š œ˜Kš œ	˜—K˜—šœ	 œ
 œ	˜$K˜š œp˜sKš œO˜T—K˜—šœ œ
 œ˜*K˜š œ˜Kš œ˜—š œ5˜8Kš œ˜—K˜—šœ œ
 œ˜*K˜š œ˜Kš œ?˜D—š œ(˜+Kš œ%˜*—K˜—šœ œ
 œ˜"K˜š œ:˜=Kš œ4˜9—K˜—šœ œ
 œ˜5K˜š œ˜Kš œ˜—š œ1˜4Kš œ4˜9—K˜—šœ
 œ
 œ
˜,K˜š œ-˜0Kš œ˜!—š œ4˜7Kš œ*˜/—š œ6˜9Kš œB˜G——K˜šœ œ
 œ˜K˜š œ˜Kš œ˜—š œ!˜$Kš œ˜—K˜—šœ œ
 œ˜$K˜š œ!˜$Kš œ˜—š œ!˜$Kš œ˜—K˜—šΟb	œ œ
 œ˜$K˜š œ˜Kš œ˜—š œ,˜/Kš œ$˜)—K˜—šœ œ
 œ˜#K˜š œ˜Kš œ
˜—š œ˜!Kš œ˜—š œ%˜(Kš œ˜—š œ˜Kš œ˜—š œ#˜&Kš œ˜—š œ˜Kš œ
˜—š œ˜ Kš œ˜—š œ˜Kš œ˜—š œ!˜$Kš œ˜—K˜—šœ œ
 œ˜&K˜š œ7˜:Kš œ#˜(—š œ<˜?Kš œ˜$—š œ(˜+Kš œ˜—š œ'˜*Kš œ˜—š œ9˜<Kš œ'˜,—š œ0˜3Kš œ˜—š œ%˜(Kš œ
˜—š œ7˜:Kš œ!Οc˜4—K˜—šœ
 œ
 œ˜'K˜š œ˜Kš œ˜—š œ ˜#Kš œ˜—š œ&˜)Kš œ˜$—š œ'˜*Kš œ6˜;—š œ+˜.š œ(˜-Kš
œ+™+——K˜—šœ œ
 œ
˜#K˜š œ˜Kš œ˜—š œ˜Kš œ˜—š œ˜Kš œ˜—š œ˜Kš œ˜ —š œ˜Kš œ˜—K˜—šœ œ
 œ
˜*K˜š œ)˜,Kš œ˜"—š œ/˜2Kš œ#˜(—š œ˜Kš œ˜—K˜—šœ
 œ
 œ˜'K˜š œ˜ Kš œ
˜—š œ˜Kš œ˜—š œ˜Kš œ˜—K˜—šœ œ
 œ˜(K˜š œ˜Kš œ
˜—š œ˜Kš œ˜——K˜šœ
 œ
 œ
˜,K˜š œ˜"Kš œ˜—š œ0˜3Kš œ-˜2—K˜—šœ œ
 œ
˜-K˜š œ$˜'Kš œ ˜%—K˜—šœ œ
 œ˜ K˜š œ˜Kš œ
˜—š œ ˜#Kš œ˜"—K˜—šœ
 œ
 œ˜#K˜š œ(˜+Kš œ!˜&—š œ7˜:Kš œ!˜&—K˜—šœ œ
 œ˜(K˜š œ˜Kš œ:˜?—š œ%˜(Kš œ"˜'—K˜—šœ œ
 œ˜$K˜š œ ˜#Kš œ%˜*—K˜—šœ
 œ
 œ
˜&K˜š œ˜Kš œ˜—š œ˜Kš œ"˜'—š œ(˜+Kš œ#˜(—š œ!˜$Kš œ-˜2—K˜—šœ
 œ
 œ˜-K˜š œ˜Kš œ˜—š œ,˜/Kš œ(˜-—K˜—šœ	 œ
 œ	˜$K˜š œ˜ Kš œ'˜,—š œ&˜)Kš œ˜"——K˜šœ œ
 œ˜(K˜š œ˜Kš œ˜—š œ#˜&Kš œ˜—š œ˜Kš œ˜—K˜—šœ	 œ
 œ˜&K˜š œ˜Kš œ˜—š œ+˜.Kš œ˜—š œ!˜$Kš œ˜—K˜—šœ œ
 œ
˜$K˜š œ˜Kš œ˜—š œ)˜,Kš œ
˜—š œ ™#Kš œ™—K™—šœ
 œ
 œ
˜&K˜š œ˜Kš œ˜—š œ!˜$Kš œ˜"—K˜—š’œ œ
 œ˜"K˜š œ˜Kš œ˜—š œ˜Kš œ˜—š œ˜Kš œ˜——K˜—Kš œ
˜K˜—šž
Ÿ Ÿ ˜š
‘™Kšœ œJ˜l—š
‘
™
Kšœ œ˜)Kšœ œ˜;—š
‘™Kšœ œ0˜T—š
‘™Kšœ œ˜.Kšœ œ"˜J—š
‘™Kšœ œ˜2Kšœ œ˜@—š
‘™š
‘
™
Kšœ œ˜&Kšœ
 œ˜:—š
‘
™
Kšœ œ˜"Kšœ
 œ˜$Kšœ
 œ˜$Kšœ œ˜#Kšœ œ˜#Kšœ œ˜"Kšœ
 œ˜$Kšœ
 œ˜$Kšœ
 œ˜$—š
‘
™
Kšœ œ˜2Kšœ
 œ˜0Kšœ œ˜.Kšœ œ˜-Kšœ
 œ˜.Kšœ œ˜"Kšœ œ,˜IKšœ
 œ˜0——Kš œ
˜K˜—šž
Ÿ Ÿ ˜š
‘™š
‘
™
Kšœ œ˜*Kšœ œ˜>—š
‘
™
Kšœ œ˜'Kšœ œ˜'Kšœ œ˜&Kšœ œ˜+Kšœ œ˜1Kšœ œ˜/Kšœ œ
˜-—š
‘
™
Kšœ œ˜5Kšœ œ˜9Kšœ œ˜3——š
‘™Kšœ œ˜5Kšœ œ)˜M—š
‘™Kšœ œ˜1Kšœ œ˜;—š
‘	™	Kšœ œ˜(Kšœ œ˜5Kšœ œ%˜G—š
‘™Kšœ œ˜.Kšœ œ˜9—š
‘™Kšœ œ
˜0Kšœ œ˜>—š
‘™Kšžœ œ˜3—š
‘™Kšœ œ˜'Kšœ œ˜(Kšœ œ˜3—š
‘™Kšœ œ
˜/Kšœ œ	˜'Kšœ œ˜+K˜—Kš œ
˜K˜—šž	Ÿ Ÿ ˜
code45˜Mšžœ œ˜+Mšž
œ œ˜&Mšžœ œ˜$Mšžœ œ$˜AMšžœ œ˜8Mšžœ œ˜ Mšžœ œ˜'Mšžœ œ˜!Mšž	œ œ£˜BMšžœ œ˜.Mšžœ œ˜.Mšžœ œ˜1Mšžœ œ˜-Mšžœ œ˜$MšΠbnœ œ˜,—š
‘
™
Kšžœ œ	 œœœœ˜nK˜Kšžœ œ	 œœ˜=K˜Kšž
œ œ	 œœ	˜CK˜Kšžœ œ	 œœ	˜GK˜Kšž	œ œ	 œœ˜@K˜Kšžœ œ	œ
 œ˜\K˜Kš
žœ œ	œ
 œœ1˜K˜Kšžœ œ	œ
 œ˜YK˜Kšžœ œ	œ
 œ˜dK˜—Kš œ
˜K˜—šžœ œ ˜š
‘™Kšœ 	œ
˜Kšœ 	œ
˜Kšœ 	œ
˜Kšœ 	œ
˜Kšœ 	œ
˜K™Kšž
œ 	œ
 œ˜-Kšž
œ 	œ
 œ˜*KšΠbkœ 	œ
 œ˜'Kšžœ 	œ
 œ˜%Kšžœ 	œ
 œ˜,Kšž
œ 	œ
 œ˜-Kš₯œ 	œ
 œ˜$Kš₯œ 	œ
 œ˜$Kš€œ 	œ
 œ˜(Kšžœ 	œ
 œ˜Kš₯œ 	œ
 œ˜Kšžœ 	œ
 œ˜Kš₯œ 	œ
 œ˜#Kš₯œ 	œ
 œ˜%Kš₯œ 	œ
 œ˜&Kšž	œ 	œ
 œ˜)Kšž
œ 	œ
 œ˜-Kšžœ 	œ
 œ˜Kšž
œ 	œ
 œ˜*—š
‘™šžœ 
œœœœ œœ œ˜GKš
 
œœœœœ™,—Kšžœ 
œœœ œœ œ˜BKšžœ 
œœœ œœ œ˜BKšžœ 
œœ œœ œ˜5Kšžœ 
œœœ œœ œ˜MKšžœ 
œœœœ œœ œ˜]Kšžœ 
œœ œœ œ	˜?Kšžœ 
œœ œœ œ	˜=—š
‘™š
‘"™"Kš
’œ œœ œœ˜(Kš
’œ œœ œœ˜'Kš
’œ œœ œœ˜&—š
‘™Kšž
œ œ œœ˜-Kšžœ œ œœ˜7Kšž
œ œ	 œœ˜3Kšžœ œ œœ˜/Kšžœ œ œœ˜4—š
‘™Kšžœ œ œœ˜*Kšžœ œ œœ˜)—š
‘™Kš
žœ œœ œœ˜1Kšžœ œœœ œœ˜1Kšžœ œœœ œœ˜6—š
‘)™)Kšžœ œœœ œœœ˜{Kšžœ œœœ œœœ˜pKšžœ œ œ˜GKšžœ œ œ˜MKš
žœ œœ œœ˜1Kš
ž
œ œœ œœ˜;—š
‘	™	Kšž	œ œ œ˜+šžœ œ œœ˜/Kš
œ™———š
‘™šž
œ œœ œ˜XKšœ œœ™<—Kšžœ œ œœ˜GKšžœ œ œœ˜KKš
ž
œ œœ œœ˜AK˜Kšžœ œ
 œœ˜,Kšžœ œœœœ
 œœ˜RKšž
œ œœœ œœ
 œœœ˜c—š
‘™Kšž
œ œœ1 œ œ, œ˜Π
š
‘™Kšž
œ œœœœœœ
 œœ˜sKšžœ œœ
œ œœ œœ˜l—š
‘™Kšž
œ œ œœ˜3Kšžœ œœœ œœ 
œœ˜qKšž
œ œœœ œœ 
œœ œœ˜{Kšž
œ œœœ œœ œœ˜f—š
‘™Kšžœ œ œœ˜/Kšžœ œœœ	 œœ œœ	 œœ˜zKšžœ œœœ œœ œœ	˜e——š
‘™Lš
‘™Kšžœ
 
œ œ˜UK˜Kšžœ œœ œ˜KKšžœ œ œ˜RLš
‘™š’œ
˜Kš œ0˜<Kš œ˜—š’œ
˜Kš œ-˜9Kš œ˜—š’œ
˜Kš œœ
œ˜+Kš œ˜—š’œ
˜Kš œ˜#Kš œ˜—š’œ
˜Kš œ˜(Kš œ˜—š’
œ
˜Kš œœ
œ
œ˜;Kš œ˜—š’
œ
˜Kš œD˜PKš œ˜—š’œ
˜Kš œ˜(Kš œ˜—š’œ
˜Kš œ3˜?Kš œ˜—Lš
‘™š’œ
˜Kš œœ˜0Kš œ˜—š’œ
˜Kš œ/˜;Kš œ˜—š’œ
˜Kš œ/˜;Kš œ˜—š’œ
˜Kš œ˜Kš œ˜—Lš
‘™š’œ
˜Kš œ,˜8Kš œ˜—š’œ
˜Kš œ,˜8Kš œ˜—š’œ
˜Kš œ,˜8Kš œ˜——š
‘™Lš
‘™šž
œ
˜Kš œ˜Kš œ˜K˜—š’œ
˜Kš œœ˜Kš œ˜ —š’œ
˜Kš œœ˜Kš œ˜ —š’
œ
˜Kš œœ˜Kš œ˜ —Lš
‘™š’œ
˜Kš œ+˜7Kš œ˜ —š’œ
˜Kš œ˜#Kš œ˜ —š’œ
˜Kš œœ
œ˜+Kš œ˜ —š’œ
˜Kš œ˜#Kš œ˜ —š’
œ
˜Kš œœ
œ
œ˜;Kš œ˜ —š’œ
˜Kš œ˜"Kš œ˜ —š’œ
˜Kš œœ˜,Kš œ˜ —K˜š’œ
˜Kš œ,˜8Kš œ˜—š’œ
˜Kš œ,˜8Kš œ˜——š
‘™š’œ
˜Kš œ˜ Kš œœ
˜—š’œ
˜Kš œ˜!Kš œœ˜——š
‘™Kšžœ œœœ œœ˜KKšžœ œ œœ˜UKšžœ œœ œœ£˜XKšžœ œœœ œ	œ˜KKš
žœ œœ œœ˜PKšž
œ œ
œœ œ
œ˜O—š
‘™Kšžœ œ	 œ˜>Kšžœ œœœ
œ" œ˜rKšžœ œœ œ	˜XKšžœ œ œ˜6Kšžœ œ œ	œ˜J—š
‘™Kš
žœ œœœ œ	˜DKšž
œ œœœ œœ
˜JKšžœ œœœ œœ œœ˜YKš
ž	œ œœ œœ˜/—š
‘™Kšžœ œœ œœ œœ˜XKšžœ œ	œ œœ œœ˜hKšž
œ œ	œ œœ œœ˜^—š
‘™Kšžœ œœœœ œœœ œœ˜ˆ
Kšžœ œœœ œœ	œ œœ˜{Kšžœ œœœ œœœ œœ˜yKš
žœ œ	œ œœ˜<—š
‘
™
Kšžœ œœœ œœ£Ρciz£˜RKš
žœ œœ œœ˜@Kšžœ œ œ˜CKšžœ œœœ œœ˜IKš
žœ œ	œ œœ˜CKšžœ œ	 œœ˜7Kšžœ œœœœ œœ œœ˜hKšžœ œ	 œœ˜1—š
‘™Kšžœ œ œ œ˜pKšžœ œœ œœ œœ˜oKš
žœ œœ œ œ˜rKšžœ œœœœ œœ	˜SKšžœ œœœ œœ˜OKšžœ œœœ œœ	˜OK˜—Kš œ
˜K˜——…—Zj€˜