Sirocco.ThreeC4
Copyright © 1986 by Xerox Corporation. All rights reserved.
Bhargava, August 12, 1986 11: 24: 02 pm PDT
Bill Jackson (bj) August 18, 1986 4:13:16 pm PDT
Demers, December 29, 1986 8:05:56 pm PST
SiroccoParser: Control Module;
Wart: Module = Begin
Generic: EnumeratedBaseType = {array, boolean, bulkDataSink, bulkDataSource, cardinal, choice, enumeration, error, integer, longCardinal, longInteger, procedure, record, sequence, string, unspecified};
Tokens
identifier: GenericToken = "tokenID";
numberD: GenericToken = "tokenDECIMAL";
numberO: GenericToken = "tokenOCTAL";
numberH: GenericToken = "tokenHEX";
Rope: GenericToken = "tokenROPE";
Types
Primitive Types
BOOLEAN: CedarType;
CARDINAL: CedarType;
CARD: CedarType;
NAT: CedarType;
INT: CedarType;
Imported Types
CComponent: CedarType From SiroccoPrivate;
CType: CedarType From SiroccoPrivate;
EqualProc: CedarType From HashTable;
FunctionList: CedarType From SiroccoPrivate;
HashProc: CedarType From HashTable;
Key: CedarType From HashTable;
ROPE: CedarType From Rope;
SeqIndex: CedarType From HashTable;
Table: CedarType From HashTable;
TABLES: CedarType From SiroccoPrivate;
Value: CedarType From HashTable;
Imported Procs
Cat: CedarFunction [ROPE.a, ROPE.b, ROPE.c] Returns [ROPE.d] From Rope;
SharedReps [ROPE.a, ROPE.b, ROPE.c, ROPE.d];
Concat: CedarFunction [ROPE.a, ROPE.b] Returns [ROPE.c] From Rope;
Equal: CedarFunction [ROPE.a, ROPE.b] Returns [BOOLEAN] From Rope;
Fetch: CedarFunction [Table, ROPE] Returns [BOOLEAN, Value] From HashTable;
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;
End;
ParserPrivate: Module = Begin
Since Casaba only understands INTs
card: BaseFunction [INT] Returns [CARD];
int: BaseFunction [CARD] Returns [INT];
nat: BaseFunction [INT] Returns [NAT];
Get values from tokens
GetCardFromDecimal: BaseFunction [numberD] Returns [CARD];
GetCardFromOctal: BaseFunction [numberO] Returns [CARD];
GetCardFromHex: BaseFunction [numberH] Returns [CARD];
RopeTokenToROPE: BaseFunction [Rope] Returns [ROPE];
Convince Casaba that things are not damaged
CopyRope: BaseFunction [ROPE.a] Returns [ROPE.b];
CopyTables: BaseFunction [TABLES.ARG] Returns [TABLES.RES];
CopyAll: BaseFunction [ROPE.ARG, FunctionList.ARG, TABLES.ARG] Returns [ROPE.RES, FunctionList.RES, TABLES.RES];
Hash Key Functions
CreateCanonicalKey: BaseFunction [identifier, numberD.prog, numberD.val] Returns [ROPE];
CreateKey: BaseFunction [identifier] Returns [ROPE];
Hash Table Operations
CopyFunctionList: BaseFunction [FunctionList.ARG] Returns [FunctionList.RES];
CreateTables: BaseFunction Returns [TABLES];
DiskToTable: BaseFunction [TABLES.ARG, identifier, numberD.progno, numberD.verno] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
FetchFromGlobalTable: BaseFunction [TABLES.ARG, ROPE] Returns [Table];
Type Tree (lists) Operations
CheckCanonicalType: BaseFunction [ROPE.type, ROPE.constant, TABLES.ARG] Returns [TABLES.RES];
CheckResultsForSourceAndSink: BaseFunction [CComponent] Returns [INT]; -- actually BOOLEAN
CompareTypes: BaseFunction [CType.a, CType.b, TABLES] Returns [INT]; -- actually BOOLEAN
GetCType: BaseFunction [identifier, CComponent, TABLES] Returns [CType, ROPE];
GetLengthOfCComponentList: BaseFunction [CComponent, INT.arg] Returns [INT.res];
SeeIfArrOrSeq: BaseFunction [CType.arg, INT, TABLES] Returns [CType.res, ROPE];
Arithmetic Operations
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];
Canonical Type manipulation
CopyCComponent: BaseFunction [CComponent.arg] Returns [CComponent.res];
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];
Narrowing from Values from Hash Tables
ValueToConstant: BaseFunction [Value] Returns [Constant];
ValueToRope: BaseFunction [Value] Returns [ROPE];
ValueToRopeConstant: BaseFunction [Value] Returns [ROPE];
Utility Functions
Copy: BaseFunction [ROPE.arg, CType.arg, Constant.arg, TABLES.arg] Returns [ROPE.res, CType.res, Constant.res, TABLES.res];
FetchFromTypeTable: BaseFunction [TABLES.ARG, ROPE] Returns [CType];
GetObjectName: BaseFunction [ROPE.type, TABLES] Returns [ROPE.typeobject];
Remove: BaseFunction [identifier, TABLES.ARG] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
SendError: BaseFunction [ROPE] Returns [CARD];
Insert Key, Value pairs into Tables
IntoUnresolvedConstantTable: BaseFunction [TABLES.ARG, ROPE.key, Type.value, Constant.value] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
IntoUnresolvedTypeTable: BaseFunction [TABLES.ARG, ROPE.key, Type.value] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
Work Table Functions
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];
Misc Functions
LocalConstantToRope: BaseFunction [identifier, ROPE.constantType, TABLES.arg]
Returns [ROPE.constant, TABLES.res] DamagedReps [TABLES.arg];
CanonicaliseLocalReferenceType: BaseFunction [identifier, TABLES.ARG] Returns [ROPE, CType, TABLES.RES] DamagedReps [TABLES.ARG];
GetConstantType: BaseFunction [identifier, TABLES.arg] Returns [ROPE, CType, Constant, TABLES.res] DamagedReps [TABLES.arg];
TryToCoerceNumber: BaseFunction [CType, CARD] Returns [INT];
Predicates
Array: BaseFunction [ROPE.type, TABLES] Returns [BOOLEAN];-- Sees if type is array
CheckIfEmpty: BaseFunction [TABLES.ARG] Returns [TABLES.RES];
CompareClass: BaseFunction [CType, Generic.b] Returns [CComponent];
InsureErrorType: BaseFunction [identifier, TABLES.ARG] Returns [TABLES.RES];
IsEnumerationConstant: BaseFunction [CType, identifier] Returns [INT];
NotEnumeration: BaseFunction [CType] Returns [BOOLEAN];
SeeIfDuplicated: BaseFunction [TABLES.ARG, identifier, CARD] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
SeeIfInt: BaseFunction [CType] Returns [BOOLEAN];
Unknown Purpose...
AddFunctionList: BaseFunction [Value, FunctionList.ARG] Returns [FunctionList.RES] DamagedReps [FunctionList.ARG];
AddFunctionToTable: BaseFunction [Value, FunctionList, TABLES.ARG] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
ConsFunctionList: BaseFunction [FunctionList.arg, ROPE] Returns [FunctionList.res] DamagedReps [FunctionList.arg];
GetTypeOfComponent: BaseFunction [identifier, ROPE.arg, TABLES] Returns [ROPE.TypeOfComponent];
GetTypeOfElement: BaseFunction [ROPE.arg, TABLES] Returns [ROPE.TypeOfElement];
TypeOfSequence: BaseFunction [ROPE.sequenceName, TABLES] Returns [ROPE.TypeOfSequence];
End;
AbstractTypes: Module = Begin
Abstract Types
Program: AbstractType [MakeSymbolTable];
ReferencedProgramList: AbstractType [ReadInTable];
ReferencedProgram: AbstractType [ReadInTable];
DeclarationList: AbstractType [BuildTable, RecordNames];
Declaration: AbstractType [BuildTable, RecordNames];
Type: AbstractType [CanonicaliseType];
CorrespondenceList: AbstractType [CanonicaliseCorrespondenceList, CheckCorrespondenceList];
CandidateList: AbstractType [CanonicaliseCandidateList, EmptyWorkTableOfNames];
FieldList: AbstractType [CanonicaliseFieldList]; -- I want a FIELD type (ajd)
Constant: AbstractType [Coerce, GetCARDINAL, ConstantToRope];
ElementList: AbstractType [CoerceElementList, ElementListConstantToRope, Size];
ComponentList: AbstractType [CoerceComponents, ConstantToRope, CheckAllNames];
Component: AbstractType [CoerceComponents, ConstantToRope, CheckAllNames];
NameList: AbstractType [CheckIfErrorNames, CanonicaliseFieldsFromNameList, CoerceComponentNameList, NameListToRope, EmptyWorkTableOfNames, TypeOfNameList];
number: AbstractType [GetCARDINAL, NumberToCard];
Abstract Type Operations
BuildTable: TreeRecursiveFunction [Tree, TABLES.ARG] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
CanonicaliseCandidateList: TreeRecursiveFunction [Tree, CComponent.arg, CType, TABLES.ARG] Returns [CComponent.res, TABLES.RES] DamagedReps [TABLES.ARG] SharedReps [CComponent.arg, CComponent.res];
CanonicaliseCorrespondenceList: TreeRecursiveFunction [Tree, CComponent.arg, TABLES.ARG] Returns [CComponent.res, TABLES.RES] DamagedReps [TABLES.ARG] SharedReps [CComponent.arg, CComponent.res];
CanonicaliseFieldList: TreeRecursiveFunction [Tree, CComponent.arg, TABLES.ARG] Returns [CComponent.res, TABLES.RES] DamagedReps [TABLES.ARG] SharedReps [CComponent.arg, CComponent.res];
CanonicaliseFieldsFromNameList: TreeRecursiveFunction [Tree, ROPE.arg, CComponent.arg, TABLES.ARG] Returns [CComponent.res, TABLES.RES] DamagedReps [TABLES.ARG] SharedReps [CComponent.arg, CComponent.res];
NOTE: THIS PROBABLY DOES NOT NEED THE TABLES ARGUMENT/RESULT
CanonicaliseType: TreeRecursiveFunction [Tree, TABLES.ARG] Returns [ROPE, CType, TABLES.RES] DamagedReps [TABLES.ARG];
CheckAllNames: TreeRecursiveFunction [Tree, TABLES.ARG] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
CheckCorrespondenceList: TreeRecursiveFunction [Tree, TABLES.ARG] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
CheckIfErrorNames: TreeRecursiveFunction [Tree, TABLES.ARG] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
Coerce: TreeRecursiveFunction [Tree, CType, ROPE, TABLES.ARG] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
CoerceComponentNameList: TreeRecursiveFunction [Tree, Constant, CComponent, TABLES.ARG] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
CoerceComponents: TreeRecursiveFunction [Tree, CComponent, TABLES.ARG] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
CoerceElementList: TreeRecursiveFunction [Tree, CType, ROPE, TABLES.ARG] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
ConstantToRope: TreeRecursiveFunction [Tree, ROPE.arg, TABLES.arg]
Returns [ROPE.res, TABLES.res] DamagedReps [TABLES.arg];
ElementListConstantToRope: TreeRecursiveFunction [Tree, ROPE.arg, TABLES.arg]
Returns [ROPE.res, INT.length, TABLES.res] DamagedReps [TABLES.arg];
EmptyWorkTableOfNames: TreeRecursiveFunction [Tree, TABLES.ARG] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
GetCARDINAL: TreeRecursiveFunction [Tree, TABLES.ARG] Returns [CARD, TABLES.RES] DamagedReps [TABLES.ARG];
MakeSymbolTable: TreeRecursiveFunction [Tree] Returns [TABLES.RES];
NumberToCard: TreeRecursiveFunction [Tree] Returns [CARD];
NameListToRope: TreeRecursiveFunction [Tree, ROPE.const] Returns [ROPE.res];
ReadInTable: TreeRecursiveFunction [Tree, TABLES.ARG] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
RecordNames: TreeRecursiveFunction [Tree, TABLES.ARG] Returns [TABLES.RES] DamagedReps [TABLES.ARG];
ReturnNodeClass: TreeRecursiveFunction [Tree] Returns [Generic];
Size: TreeRecursiveFunction [Tree, INT.arg] Returns [INT.res] DamagedReps [INT.arg]; --Gets Size of Element List
TypeOfNameList: TreeRecursiveFunction [Tree, ROPE.constantType, TABLES] Returns [ROPE.typeOf];
End;
AbstractProductions: Module = Begin
Program: AbstractType [MakeSymbolTable];
Program: AbstractProduction [identifier, numberD.progno, numberD.verno, ReferencedProgramList, DeclarationList];
ReferencedProgramList: AbstractType [ReadInTable];
ReferencedProgramList.empty: AbstractProduction [];
ReferencedProgramList.more: AbstractProduction [ReferencedProgramList, ReferencedProgram];
ReferencedProgram: AbstractType [ReadInTable];
ReferencedProgram: AbstractProduction [identifier, numberD.progno, numberD.verno];
DeclarationList: AbstractType [BuildTable, RecordNames];
DeclarationList.empty: AbstractProduction [];
DeclarationList.more: AbstractProduction [DeclarationList, Declaration];
Declaration: AbstractType [BuildTable, RecordNames];
Declaration.type: AbstractProduction [identifier, Type];
Declaration.constant: AbstractProduction [identifier, Type, Constant];
Type: AbstractType [CanonicaliseType];
Type.array: AbstractProduction [Constant, Type];
Type.boolean: AbstractProduction [];
Type.bulkDataSink: AbstractProduction [];
Type.bulkDataSource: AbstractProduction [];
Type.cardinal: AbstractProduction [];
Type.choice: AbstractProduction [Type, CandidateList];
Type.emptyRecord: AbstractProduction [];
Type.enumeration: AbstractProduction [CorrespondenceList];
Type.error: AbstractProduction [FieldList];
Type.integer: AbstractProduction [];
Type.localReference: AbstractProduction [identifier];
Type.longCardinal: AbstractProduction [];
Type.longInteger: AbstractProduction [];
Type.procedure: AbstractProduction [FieldList.arg, FieldList.res, NameList];
Type.record: AbstractProduction [FieldList];
Type.remoteReference: AbstractProduction [identifier.a, identifier.b];
Type.sequence: AbstractProduction [Constant, Type];
Type.string: AbstractProduction [];
Type.unspecified: AbstractProduction [];
CorrespondenceList: AbstractType [CanonicaliseCorrespondenceList, CheckCorrespondenceList];
CorrespondenceList.one: AbstractProduction [identifier, Constant];
CorrespondenceList.more: AbstractProduction [CorrespondenceList.value, CorrespondenceList.next];
CandidateList: AbstractType [CanonicaliseCandidateList, EmptyWorkTableOfNames];
CandidateList.one: AbstractProduction [NameList, Type];
CandidateList.more: AbstractProduction [CandidateList.value, CandidateList.next];
FieldList: AbstractType [CanonicaliseFieldList]; -- I want a FIELD type (ajd)
FieldList.empty: AbstractProduction [];
FieldList.one: AbstractProduction [NameList, Type];
FieldList.more: AbstractProduction [FieldList.value, FieldList.rest];
Constant: AbstractType [Coerce, GetCARDINAL, ConstantToRope];
Constant.choice: AbstractProduction [identifier, Constant];
Constant.componentlist: AbstractProduction [ComponentList];
Constant.elementList: AbstractProduction [ElementList];
Constant.empty: AbstractProduction [];
Constant.false: AbstractProduction [];
Constant.id: AbstractProduction [identifier];
Constant.negativeNumber: AbstractProduction [number];
Constant.number: AbstractProduction [number];
Constant.remoteReference: AbstractProduction [identifier.left, identifier.right];
Constant.string: AbstractProduction [Rope];
Constant.true: AbstractProduction [];
Constant.unbounded: AbstractProduction [];
ElementList: AbstractType [CoerceElementList, ConstantToRope, Size];
ElementList.one: AbstractProduction [Constant];
ElementList.more: AbstractProduction [Constant, ElementList];
ComponentList: AbstractType [CoerceComponents, ConstantToRope, CheckAllNames];
ComponentList.one: AbstractProduction [Component];
ComponentList.more: AbstractProduction [Component, ComponentList];
Component: AbstractType [CoerceComponents, ConstantToRope, CheckAllNames];
Component: AbstractProduction [NameList, Constant];
NameList: AbstractType [CheckIfErrorNames, CanonicaliseFieldsFromNameList, CoerceComponentNameList, NameListToRope, EmptyWorkTableOfNames, TypeOfNameList];
NameList.empty: AbstractProduction [];
NameList.one: AbstractProduction [identifier];
NameList.more: AbstractProduction [identifier, NameList];
number: AbstractType [GetCARDINAL, NumberToCard];
number.decimal: AbstractProduction [numberD];
number.hex: AbstractProduction [numberH];
number.octal: AbstractProduction [numberO];
End;
AbstractSyntax: Module = Begin
Program: AbstractType [MakeSymbolTable];
for Program: AbstractProduction [identifier, numberD.progno, numberD.verno, ReferencedProgramList, DeclarationList]
let MakeSymbolTable[tree] ← BuildTable[DeclarationList, tables2]
where tables2 ← ReadInTable[ReferencedProgramList, tables1]
where programKey ← CreateCanonicalKey[identifier, numberD.progno, numberD.verno]
where tables1 ← RecordNames[DeclarationList, tables]
where tables ← CreateTables[]
;
ReferencedProgramList: AbstractType [ReadInTable];
for ReferencedProgramList.empty: AbstractProduction []
let ReadInTable[tree, tables] ← CopyTables[tables]
;
for ReferencedProgramList.more: AbstractProduction [ReferencedProgramList, ReferencedProgram]
let ReadInTable[tree, tables] ← ReadInTable[ReferencedProgram, tables1]
where tables1 ← ReadInTable[ReferencedProgramList, tables]
;
ReferencedProgram: AbstractType [ReadInTable];
for ReferencedProgram: AbstractProduction [identifier, numberD.progno, numberD.verno]
let ReadInTable[tree, tables] ← DiskToTable[tables, identifier, numberD.progno, numberD.verno]
;
DeclarationList: AbstractType [BuildTable, RecordNames];
for DeclarationList.empty: AbstractProduction []
let BuildTable[tree, tables] ← CopyTables[tables]
let RecordNames[tree, tables] ← CopyTables[tables]
;
for DeclarationList.more: AbstractProduction [DeclarationList, Declaration]
let BuildTable[tree, tables] ← tables2
where tables2 ← BuildTable[DeclarationList, tables1]
where tables1 ← BuildTable[Declaration, tables]
let RecordNames[tree, tables] ← RecordNames[DeclarationList, RecordNames[Declaration, tables]]
;
Declaration: AbstractType [BuildTable, RecordNames];
for Declaration.type: AbstractProduction [identifier, Type]
let BuildTable[tree, tables] ← tables1
where < canonicalType, typeTree, tables1 > ← CanonicaliseLocalReferenceType[identifier, tables]
let RecordNames[tree, tables] ← IntoUnresolvedTypeTable[tables, CreateKey[identifier], Type]
;
for Declaration.constant: AbstractProduction [identifier, Type, Constant]
let BuildTable[tree, tables] ← tables1
where < canonicalType, constantTree, value, tables1 > ← GetConstantType[identifier, tables]
let RecordNames[tree, tables] ← IntoUnresolvedConstantTable[tables, CreateKey[identifier], Type, Constant]
;
Type: AbstractType [CanonicaliseType];
for Type.array: AbstractProduction [Constant, Type]
let CanonicaliseType[tree, tables] ← < "DEFAULT", cType2, tables2 >
where cType2 ← MkCType[Generic.array, int[bound], cComponent]
where < bound, tables2 > ← GetCARDINAL[Constant, tables1]
where cComponent ← MkCComponent["", 0, cName1, MkNILCComponent[]]
where < cName1, cType1, tables1 > ← CanonicaliseType[Type, tables]
N.B. Type is a simple type, so no need to check if cName1 = "DEFAULT"
;
for Type.boolean: AbstractProduction []
let CanonicaliseType[tree, tables] ← < "BOOLEAN", MkCType[Generic.boolean, 0, MkNILCComponent[]], CopyTables[tables] >
;
for Type.bulkDataSink: AbstractProduction []
let CanonicaliseType[tree, tables] ← < "SINK", MkCType[Generic.bulkDataSink, 0, MkNILCComponent[]], CopyTables[tables] >
;
for Type.bulkDataSource: AbstractProduction []
let CanonicaliseType[tree, tables] ← < "SOURCE", MkCType[Generic.bulkDataSource, 0, MkNILCComponent[]], CopyTables[tables] >
;
for Type.cardinal: AbstractProduction []
let CanonicaliseType[tree, tables] ← < "CARDINAL", MkCType[Generic.cardinal, 0, MkNILCComponent[]], CopyTables[tables] >
;
for Type.choice: AbstractProduction [Type, CandidateList]
let CanonicaliseType[tree, tables] ← < "DEFAULT", cType2, tables5 >
where cType2 ← MkCType[Generic.choice, 0, cComponent2]
where cComponent2 ← MkCComponent["", 0, cName1, cComponent1] -- the tag type
where < cComponent1, tables5 > ← CanonicaliseCandidateList[CandidateList, MkNILCComponent[], cType1, tables3]
Check that cType1 is enumerated type - Done
where junk ← CheckIfEmpty[tables3]
where tables3 ← EmptyWorkTableOfNames[CandidateList, tables2]
where tables2 ← FillWorkTable[cType1, tables1]
where match ← CompareClass[cType1, Generic.enumeration]
where < cName1, cType1, tables1 > ← CanonicaliseType[Type, tables]
;
for Type.emptyRecord: AbstractProduction []
let CanonicaliseType[tree, tables] ← < "DEFAULT", cType, CopyTables[tables] >
where cType ← MkCType[Generic.record, 0, MkNILCComponent[]]
;
for Type.enumeration: AbstractProduction [CorrespondenceList]
let CanonicaliseType[tree, tables] ← < "DEFAULT", cType, tables2 >
where cType ← MkCType[Generic.enumeration, 0, cComponent]
where < cComponent, tables2 > ← CanonicaliseCorrespondenceList[CorrespondenceList, MkNILCComponent[], tables1]
where tables1 ← CheckCorrespondenceList[CorrespondenceList, ClearWorkTable[tables]]
;
for Type.error: AbstractProduction [FieldList]
let CanonicaliseType[tree, tables] ← < "DEFAULT", cType, tables1 >
where cType ← MkCType[Generic.error, 0, cComponent]
where < cComponent, tables1 > ← CanonicaliseFieldList[FieldList, MkNILCComponent[], tables]
;
for Type.integer: AbstractProduction []
let CanonicaliseType[tree, tables] ← < "INTEGER", MkCType[Generic.integer, 0, MkNILCComponent[]], CopyTables[tables] >
;
for Type.localReference: AbstractProduction [identifier]
let CanonicaliseType[tree, tables] ← CanonicaliseLocalReferenceType[identifier, tables]
;
for Type.longCardinal: AbstractProduction []
let CanonicaliseType[tree, tables] ← < "LONGCARDINAL", MkCType[Generic.longCardinal, 0, MkNILCComponent[]], CopyTables[tables] >
;
for Type.longInteger: AbstractProduction []
let CanonicaliseType[tree, tables] ← < "LONGINTEGER", MkCType[Generic.longInteger, 0, MkNILCComponent[]], CopyTables[tables] >
;
for Type.procedure: AbstractProduction [FieldList.arg, FieldList.res, NameList]
let CanonicaliseType[tree, tables] ← < "DEFAULT", cType, tables3 >
where cType ← MkCType[Generic.procedure, nArgs, cComponent]
where nArgs ← GetLengthOfCComponentList[cComponent, nResults]
where < cComponent, tables3 > ← CanonicaliseFieldList[FieldList.arg, resultCComponent, tables2]
where nResults ← GetLengthOfCComponentList[resultCComponent, 0]
where okay ← CheckResultsForSourceAndSink[resultCComponent]
where < resultCComponent, tables2 > ← CanonicaliseFieldList[FieldList.res, MkNILCComponent[], tables1]
where tables1 ← CheckIfErrorNames[NameList, tables]
;
for Type.record: AbstractProduction [FieldList]
let CanonicaliseType[tree, tables] ← < "DEFAULT", cType, tables1 >
where cType ← MkCType[Generic.record, 0, cComponent]
where < cComponent, tables1 > ← CanonicaliseFieldList[FieldList, MkNILCComponent[], tables]
;
for Type.remoteReference: AbstractProduction [identifier.a, identifier.b]
let CanonicaliseType[tree, tables] ← < canonicalName, cType, CopyTables[tables] >
where cType ← FetchFromTypeTable[tables, canonicalName]
where canonicalName ← ValueToRope[DirectoryEntry]
N.B. NEED TO CHECK SUCCESSFUL !!!! - Done
where okay ← if successful then 0 else int[SendError["Undeclared Remote Identifier"]]
where < successful, DirectoryEntry > ← Fetch[remoteDirectory, CreateKey[identifier.b]]
where remoteDirectory ← FetchFromGlobalTable[tables, CreateKey[identifier.a]]
;
for Type.sequence: AbstractProduction [Constant, Type]
let CanonicaliseType[tree, tables] ← < "DEFAULT", cType2, tables2 >
where cType2 ← MkCType[Generic.sequence, int[bound], cComponent]
where < bound, tables2 > ← GetCARDINAL[Constant, tables1]
where cComponent ← MkCComponent["", 0, cName1, MkNILCComponent[]]
where < cName1, cType1, tables1 > ← CanonicaliseType[Type, tables]
N.B. Type is a simple type, so no need to check if cName1 = "DEFAULT"
;
for Type.string: AbstractProduction []
let CanonicaliseType[tree, tables] ← < "STRING", MkCType[Generic.string, 0, MkNILCComponent[]], CopyTables[tables] >
;
for Type.unspecified: AbstractProduction []
let CanonicaliseType[tree, tables] ← < "UNSPECIFIED", MkCType[Generic.unspecified, 0, MkNILCComponent[]], CopyTables[tables] >
;
CorrespondenceList: AbstractType [CanonicaliseCorrespondenceList, CheckCorrespondenceList];
for CorrespondenceList.one: AbstractProduction [identifier, Constant]
let CanonicaliseCorrespondenceList[tree, cComponentArg, tables] ← < cComponent, tables1 >
where cComponent ← MkCComponent[CreateKey[identifier], int[value], "", cComponentArg]
where < value, tables1 > ← GetCARDINAL[Constant, tables]
Check that no id or Constant appears twice -Done
let CheckCorrespondenceList[tree, tables] ← SeeIfDuplicated[tables1, identifier, value]
where < value, tables1 > ← GetCARDINAL[Constant, tables]
;
for CorrespondenceList.more: AbstractProduction [CorrespondenceList.value, CorrespondenceList.next]
INVARIANT: CorrespondenceList.value is expanded as CorrespondenceList.one.
let CanonicaliseCorrespondenceList[tree, cComponentArg, tables] ← CanonicaliseCorrespondenceList[CorrespondenceList.value, cComponent1, tables1]
where < cComponent1, tables1 > ← CanonicaliseCorrespondenceList[CorrespondenceList.next, cComponentArg, tables]
let CheckCorrespondenceList[tree, tables] ← CheckCorrespondenceList[CorrespondenceList.next, CheckCorrespondenceList[CorrespondenceList.value, tables]]
;
CandidateList: AbstractType [CanonicaliseCandidateList, EmptyWorkTableOfNames];
for CandidateList.one: AbstractProduction [NameList, Type]
let CanonicaliseCandidateList[tree, cComponentArg, cTypeTag, tables] ← CanonicaliseFieldsFromNameList[NameList, variantCName, cComponentArg, tables1]
Check if all members are of enumeration
& all members of enumeration are listed
also ascertain that the enumeration is continous - Done
where < variantCName, variantCType, tables1 > ← CanonicaliseType[Type, tables]
let EmptyWorkTableOfNames[tree, tables] ← EmptyWorkTableOfNames[NameList, tables]
;
for CandidateList.more: AbstractProduction [CandidateList.value, CandidateList.next]
INVARIANT: CandidateList.value is expanded as CandidateList.one.
let CanonicaliseCandidateList[tree, cComponentArg, cTypeTag, tables] ← CanonicaliseCandidateList[CandidateList.value, cComponent1, cTypeTag, tables1]
where < cComponent1, tables1 > ← CanonicaliseCandidateList[CandidateList.next, cComponentArg, cTypeTag, tables]
let EmptyWorkTableOfNames[tree, tables] ← EmptyWorkTableOfNames[CandidateList.next, EmptyWorkTableOfNames[CandidateList.value, tables]]
;
FieldList: AbstractType [CanonicaliseFieldList]; -- I want a FIELD type (ajd)
for FieldList.empty: AbstractProduction []
let CanonicaliseFieldList[tree, CComponentArg, tables] ← < CopyCComponent[CComponentArg], CopyTables[tables] >
;
for FieldList.one: AbstractProduction [NameList, Type]
let CanonicaliseFieldList[tree, cComponentArg, tables] ← CanonicaliseFieldsFromNameList[NameList, cName, cComponentArg, tables1]
where < cName, cType, tables1 > ← CanonicaliseType[Type, tables]
;
for FieldList.more: AbstractProduction [FieldList.value, FieldList.rest]
INVARIANT: FieldList.value is expanded as FieldList.one.
let CanonicaliseFieldList[tree, CComponentArg, tables] ← CanonicaliseFieldList[FieldList.value, cComponent1, tables1]
where < cComponent1, tables1 > ← CanonicaliseFieldList[FieldList.rest, CComponentArg, tables]
;
Constant: AbstractType [Coerce, GetCARDINAL, ConstantToRope];
for Constant.choice: AbstractProduction [identifier, Constant]
let GetCARDINAL[tree, tables] ← < SendError["Expected CARDINAL found Choice"], CopyTables[tables] >
let Coerce[tree, typeCtype, typeTypeName, tables] ← Coerce[Constant, cType, ctypeName, tables]
where < cType, ctypeName > ← GetCType[identifier, cComponent, tables]
where cComponent ← GetCTypeFirstChild[typeCtype]
let ConstantToRope[tree, constantType, tables] ←
< Cat[CreateKey[identifier], " ", value], tables1 >
where < value, tables1 > ← ConstantToRope[Constant, constantType1, tables]
where constantType1 ← GetTypeOfComponent[identifier, constantType, tables]
;
for Constant.componentlist: AbstractProduction [ComponentList]
let GetCARDINAL[tree, tables] ← < SendError["Expected CARDINAL found Record"], CopyTables[tables] >
let Coerce[tree, typeCtype, typeTypeName, tables] ← CoerceComponents[ComponentList, cComponent, tables2]
N.B. Add Code to Check If All Names are Declared => CheckAllNames[ComponentList, typeCtype, tables]; - Done
where junk ← CheckIfEmpty[tables2]
where tables2 ← CheckAllNames[ComponentList, tables1]
where tables1 ← EnterNamesIntoWorkTable[typeCtype, tables]
where cComponent ← CompareClass[typeCtype, Generic.record]
let ConstantToRope[tree, constantType, tables] ←
ConstantToRope[ComponentList, constantType, tables]
;
for Constant.elementList: AbstractProduction [ElementList]
let GetCARDINAL[tree, tables] ← < SendError["Expected CARDINAL found ElementList"], CopyTables[tables] >
let Coerce[tree, typeCtype, typeTypeName, tables] ← CoerceElementList[ElementList, cType, cName, tables]
where < cType, cName > ← SeeIfArrOrSeq[typeCtype, numberOfElementInList, tables]
where numberOfElementInList ← Size[ElementList, 0]
let ConstantToRope[tree, constantType, tables] ←
< Cat[lengthRope, " ", valueRope], tables1 >
where lengthRope ← RopeFromInt[length]
where < valueRope, length, tables1 > ←
ElementListConstantToRope[ElementList, elementType, tables]
where elementType ← GetTypeOfElement[constantType, tables]
;
for Constant.empty: AbstractProduction []
let GetCARDINAL[tree, tables] ← < SendError["Expected CARDINAL found Empty ElementList"], CopyTables[tables] >
let Coerce[tree, typeCtype, typeTypeName, tables] ← tables1
where junk ← CheckIfEmpty[tables1]
where tables1 ← EnterNamesIntoWorkTable[typeCtype, tables]
where cComponent ← CompareClass[typeCtype, Generic.record]
let ConstantToRope[tree, constantType, tables] ← < "", CopyTables[tables] >
;
for Constant.false: AbstractProduction []
let GetCARDINAL[tree, tables] ← < SendError["Expected CARDINAL found Boolean"], CopyTables[tables] >
let Coerce[tree, type, typeTypeName, tables] ← CheckCanonicalType[typeTypeName, "BOOLEAN", tables]
let ConstantToRope[tree, constantType, tables] ← < "FALSE ", CopyTables[tables] >
;
for Constant.id: AbstractProduction [identifier]
let GetCARDINAL[tree, tables] ← GetCARDINAL[value, tables1]
where < constantType, constantTree, value, tables1 > ← GetConstantType[identifier, tables]
let Coerce[tree, typeCtype, typeTypeName, tables] ← tables1
where match ←
if Equal[typeTypeName, constantTypeName]
then 0
else CompareTypes[typeCtype, ConstantCType, tables1]
where < constantTypeName, ConstantCType, value, tables1 > ←
if NotEnumeration[typeCtype]
then GetConstantType[identifier, tables]
else <
Copy[typeTypeName, typeCtype, tree, tables]
where junk ← IsEnumerationConstant[typeCtype, identifier]
>
let ConstantToRope[tree, constantType, tables] ←
LocalConstantToRope[identifier, constantType, tables]
;
for Constant.negativeNumber: AbstractProduction [number]
let GetCARDINAL[tree, tables] ← < SendError["Expected CARDINAL found Negative Number"], CopyTables[tables] >
let Coerce[tree, ctype, typeName, tables] ← tables1
where okay ← TryToCoerceNumber[ctype, value]
where < value, tables1 > ← GetCARDINAL[number, tables]
where junk ← SeeIfInt[ctype]
let ConstantToRope[tree, constantType, tables] ←
< Cat["-", RopeFromCard[NumberToCard[number]], " "], CopyTables[tables] >
;
for Constant.number: AbstractProduction [number]
let GetCARDINAL[tree, tables] ← GetCARDINAL[number, tables]
let Coerce[tree, ctype, typeName, tables] ← tables1
where okay ← TryToCoerceNumber[ctype, value]
where < value, tables1 > ← GetCARDINAL[number, tables]
let ConstantToRope[tree, constantType, tables] ←
< Concat[RopeFromCard[NumberToCard[number]], " "], CopyTables[tables] >
;
for Constant.remoteReference: AbstractProduction [identifier.left, identifier.right]
let GetCARDINAL[tree, tables] ← GetCARDINAL[value, tables]
where value ← ValueToConstant[DirectoryEntry]
where constantType ← ValueToRope[DirectoryEntry]
where okay ← if successful
then 0
else int[SendError["Undeclared Remote Identifier"]]
where < successful, DirectoryEntry > ← Fetch[remoteDirectory, CreateKey[identifier.right]]
where remoteDirectory ← FetchFromGlobalTable[tables, CreateKey[identifier.left]]
let Coerce[tree, typeCtype, typeTypeName, tables] ← CopyTables[tables]
where match ← if Equal[typeTypeName, constantTypeName]
then 0
else CompareTypes[ConstantCType, typeCtype, tables]
where value ← ValueToConstant[DirectoryEntry]
where ConstantCType ← FetchFromTypeTable[tables, constantTypeName]
where constantTypeName ← ValueToRope[DirectoryEntry]
where < successful2, DirectoryEntry > ← Fetch[remoteDirectory, CreateKey[identifier.right]]
where remoteDirectory ← FetchFromGlobalTable[tables, CreateKey[identifier.left]]
let ConstantToRope[tree, constantType, tables] ←
< ValueToRopeConstant[directoryEntry], CopyTables[tables] >
where < successful2, directoryEntry > ← Fetch[remoteDirectory, CreateKey[identifier.right]]
where remoteDirectory ← FetchFromGlobalTable[tables, CreateKey[identifier.left]]
;
for Constant.string: AbstractProduction [Rope]
let GetCARDINAL[tree, tables] ← < SendError["Expected CARDINAL found String"], CopyTables[tables] >
let Coerce[tree, type, canonicalType, tables] ← CheckCanonicalType[canonicalType, "STRING", tables]
let ConstantToRope[tree, constantType, tables] ←
< Cat[lengthRope, " ", value], CopyTables[tables] >
where lengthRope ← RopeFromInt[Subtract[Length[value], 3]] -- 3 = 2 quotes + trailing space
where value ← Concat[RopeTokenToROPE[Rope], " "]
;
for Constant.true: AbstractProduction []
let GetCARDINAL[tree, tables] ← < SendError["Expected CARDINAL found Boolean"], CopyTables[tables] >
let Coerce[tree, type, typeTypeName, tables] ← CheckCanonicalType[typeTypeName, "BOOLEAN", tables]
let ConstantToRope[tree, constantType, tables] ← < "TRUE ", CopyTables[tables] >
;
for Constant.unbounded: AbstractProduction []
let GetCARDINAL[tree, tables] ← < card[65536], CopyTables[tables] >
let Coerce[tree, type, canonicalType, tables] ← CheckCanonicalType[canonicalType, "UNBOUNDED", tables]
let ConstantToRope[tree, constantType, tables] ← < "65536 ", CopyTables[tables] >
;
ElementList: AbstractType [CoerceElementList, ConstantToRope, Size];
for ElementList.one: AbstractProduction [Constant]
let CoerceElementList[tree, cType, ctypeName, tables] ← Coerce[Constant, cType, ctypeName, tables]
let Size[tree, numberOfElementInList] ← AddOne[numberOfElementInList]
let ElementListConstantToRope[tree, elementType, tables] ←
< value, 1, tables1 >
where < value, tables1 > ← ConstantToRope[Constant, elementType, tables]
;
for ElementList.more: AbstractProduction [Constant, ElementList]
let CoerceElementList[tree, cType, ctypeName, tables] ← CoerceElementList[ElementList, cType, ctypeName, tables1]
where tables1 ← Coerce[Constant, cType, ctypeName, tables]
let Size[tree, numberOfElementInList] ← Size[ElementList, AddOne[numberOfElementInList]]
let ElementListConstantToRope[tree, elementType, tables] ←
< Concat[first, rest], AddOne[size], tables2 >
where < rest, size, tables2 > ←
ElementListConstantToRope[ElementList, elementType, tables1]
where < first, tables1 > ←
ConstantToRope[Constant, elementType, tables]
;
ComponentList: AbstractType [CoerceComponents, ConstantToRope, CheckAllNames];
for ComponentList.one: AbstractProduction [Component]
let CoerceComponents[tree, cComponent, tables] ← CoerceComponents[Component, cComponent, tables]
let ConstantToRope[tree, componentListType, tables] ←
ConstantToRope[Component, componentListType, tables]
let CheckAllNames[tree, tables] ← CheckAllNames[Component, tables]
;
for ComponentList.more: AbstractProduction [Component, ComponentList]
let CoerceComponents[tree, cComponent, tables] ← CoerceComponents[ComponentList, cComponent, tables1]
where tables1 ← CoerceComponents[Component, cComponent, tables]
let ConstantToRope[tree, componentListType, tables] ←
< Concat[first, rest], tables2 >
where < rest, tables2 > ←
ConstantToRope[ComponentList, componentListType, tables1]
where < first, tables1 > ←
ConstantToRope[Component, componentListType, tables]
let CheckAllNames[tree, tables] ← CheckAllNames[ComponentList, CheckAllNames[Component, tables]]
;
Component: AbstractType [CoerceComponents, ConstantToRope, CheckAllNames];
for Component: AbstractProduction [NameList, Constant]
let CoerceComponents[tree, cComponent, tables] ← CoerceComponentNameList[NameList, Constant, cComponent, tables]
let ConstantToRope[tree, componentListType, tables] ←
< NameListToRope[NameList, value], tables1 >
where < value, tables1 > ← ConstantToRope[Constant, componentType, tables]
where componentType ← TypeOfNameList[NameList, componentListType, tables]
let CheckAllNames[tree, tables] ← EmptyWorkTableOfNames[NameList, tables]
;
NameList: AbstractType [CheckIfErrorNames, CanonicaliseFieldsFromNameList, CoerceComponentNameList, NameListToRope, EmptyWorkTableOfNames, TypeOfNameList];
for NameList.empty: AbstractProduction []
let CheckIfErrorNames[tree, tables] ← CopyTables[tables]
let CanonicaliseFieldsFromNameList[tree, cName, cComponentArg, tables] ← < MkNILCComponent[], CopyTables[tables] >
let CoerceComponentNameList[tree, constant, cComponent, tables] ← CopyTables[tables]
let NameListToRope[tree, constantRope] ← ""
let EmptyWorkTableOfNames[tree, tables] ← CopyTables[tables]
let TypeOfNameList[tree, constantType, tables] ← CopyRope[constantType] -- Should Yield Error
;
for NameList.one: AbstractProduction [identifier]
let CheckIfErrorNames[tree, tables] ← InsureErrorType[identifier, tables]
let CanonicaliseFieldsFromNameList[tree, cName, cComponentArg, tables] ← < cComponentres, CopyTables[tables] >
where cComponentres ← MkCComponent[CreateKey[identifier], 0, cName, cComponentArg]
let CoerceComponentNameList[tree, constant, cComponent, tables] ← Coerce[constant, cType, ctypeName, tables]
where < cType, ctypeName > ← GetCType[identifier, cComponent, tables]
let NameListToRope[tree, constantRope] ←
Cat[CreateKey[identifier], " ", constantRope]
let EmptyWorkTableOfNames[tree, tables] ← Remove[identifier, tables]
let TypeOfNameList[tree, constantType, tables] ← GetTypeOfComponent[identifier, constantType, tables]
;
for NameList.more: AbstractProduction [identifier, NameList]
let CheckIfErrorNames[tree, tables] ← CheckIfErrorNames[NameList, tables1]
where tables1 ← InsureErrorType[identifier, tables]
let CanonicaliseFieldsFromNameList[tree, cName, cComponentArg, tables] ← < cComponentres, CopyTables[tables1] >
where cComponentres ← MkCComponent[CreateKey[identifier], 0, cName, cComponent1]
where < cComponent1, tables1 > ← CanonicaliseFieldsFromNameList[NameList, cName, cComponentArg, tables]
let CoerceComponentNameList[tree, constant, cComponent, tables] ← tables2
where tables2 ← CoerceComponentNameList[NameList, constant, cComponent, tables1]
where tables1 ← Coerce[constant, cType, ctypeName, tables]
where < cType, ctypeName > ← GetCType[identifier, cComponent, tables]
let NameListToRope[tree, constantRope] ← Concat[first, rest]
where rest ← NameListToRope[NameList, constantRope]
where first ← Cat[CreateKey[identifier], " ", constantRope]
let EmptyWorkTableOfNames[tree, tables] ← EmptyWorkTableOfNames[NameList, Remove[identifier, tables]]
let TypeOfNameList[tree, constantType, tables] ← GetTypeOfComponent[identifier, constantType, tables]
;
number: AbstractType [GetCARDINAL, NumberToCard];
for number.decimal: AbstractProduction [numberD]
let GetCARDINAL[tree, tables] ← < GetCardFromDecimal[numberD], CopyTables[tables] >
let NumberToCard[tree] ← GetCardFromDecimal[numberD]
;
for number.hex: AbstractProduction [numberH]
let GetCARDINAL[tree, tables] ← < GetCardFromHex[numberH], CopyTables[tables] >
let NumberToCard[tree] ← GetCardFromHex[numberH]
;
for number.octal: AbstractProduction [numberO]
let GetCARDINAL[tree, tables] ← < GetCardFromOctal[numberO], CopyTables[tables] >
let NumberToCard[tree] ← GetCardFromOctal[numberO]
;
End;
ConcreteSyntax: Module = Begin
Simple Tokens
{
"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;
{
"(" ")"
"[" "]"
"{" "}"
":"
"."
";"
"="
"=>"
","
"-"
}: SimpleTokens;
The Courier Program in Question:
OuterProgram: NonTerminal Builds Program;
for OuterProgram ← Program "."
Build Program;
Program: NonTerminal Builds Program;
for Program ← identifier ":" "PROGRAM" numberD.a "VERSION" numberD.b "="
"BEGIN" DependencyList DeclarationList "END"
Build Program[identifier, numberD.a, numberD.b, DependencyList, DeclarationList];
DependencyList: NonTerminal Builds ReferencedProgramList;
for DependencyList.empty ←
Build ReferencedProgramList.empty[];
for DependencyList.more← "DEPENDS" "UPON" ReferencedProgramList ";"
Build ReferencedProgramList;
ReferencedProgramList: NonTerminal Builds ReferencedProgramList;
for ReferencedProgramList.one ← ReferencedProgram
Build ReferencedProgramList.more[ReferencedProgramList.empty[[ReferencedProgram,
ReferencedProgram)], ReferencedProgram];
for ReferencedProgramList.more ← ReferencedProgramList "," ReferencedProgram
Build ReferencedProgramList.more[ReferencedProgramList, ReferencedProgram];
ReferencedProgram: NonTerminal Builds ReferencedProgram;
for ReferencedProgram ← identifier "(" numberD.a ")" "VERSION" numberD.b
Build ReferencedProgram[identifier, numberD.a, numberD.b];
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 ← identifier ":" "TYPE" "=" Type";"
Build Declaration.type[identifier, Type];
for Declaration.constant ← identifier ":" Type "=" Constant ";"
Build Declaration.constant[identifier, Type, Constant];
for Declaration.id ← identifier.name ":" Type "=" identifier.constant ";"
Build Declaration.constant[identifier.name, Type, Constant.id[identifier.constant]];
Type Declaration
Type: NonTerminal Builds Type;
for Type.simple ← SimpleType
Build SimpleType;
for Type.ConstructedType ← ConstructedType
Build ConstructedType;
SimpleType: NonTerminal Builds Type;
for SimpleType.predefinedType ← PredefinedType
Build PredefinedType;
for SimpleType.referencedType ← ReferencedType
Build ReferencedType;
PredefinedType: NonTerminal Builds Type;
for PredefinedType.boolean ← "BOOLEAN"
Build Type.boolean[];
for PredefinedType.Cardinal ← "CARDINAL"
Build Type.cardinal[];
for PredefinedType.longCardinal ← "LONG" "CARDINAL"
Build Type.longCardinal[];
for PredefinedType.integer← "INTEGER"
Build Type.integer[];
for PredefinedType.longInteger ← "LONG" "INTEGER"
Build Type.longInteger[];
for PredefinedType.string ← "STRING"
Build Type.string[];
for PredefinedType.unspecified ← "UNSPECIFIED"
Build Type.unspecified[];
for PredefinedType.bulkDataSource ← "SOURCE"
Build Type.bulkDataSource[];
for PredefinedType.bulkDataSink ← "SINK"
Build Type.bulkDataSink[];
ConstructedType: NonTerminal Builds Type;
for ConstructedType.enumeration ← "{" CorrespondenceList "}"
Build Type.enumeration[CorrespondenceList];
for ConstructedType.array ← "ARRAY" MandatoryNumber "OF" SimpleType
Build Type.array[MandatoryNumber, SimpleType];
for ConstructedType.sequence ← "SEQUENCE" OptionalNumber "OF" SimpleType
Build Type.sequence[OptionalNumber, SimpleType]; --Can be empty
for ConstructedType.record ← "RECORD" "[" FieldList"]"
Build Type.record[FieldList];
for ConstructedType.emptyRecord ← "RECORD" "[" "]"
Build Type.emptyRecord[];
for ConstructedType.choice ← "CHOICE" ReferencedType "OF" "{" CandidateList "}"
Build Type.choice[ReferencedType, CandidateList];
for ConstructedType.procedure ← "PROCEDURE" ArgumentList ResultList ErrorList
Build Type.procedure[ArgumentList, ResultList, ErrorList];
for ConstructedType.error ← "ERROR" ArgumentList
Build Type.error[ArgumentList];
ReferencedType: NonTerminal Builds Type;
for ReferencedType.localReference ← identifier
Build Type.localReference[identifier];
for ReferencedType.remoteReference ← identifier.remote "." identifier.id
Build Type.remoteReference[identifier.remote, identifier.id];
CorrespondenceList: NonTerminal Builds CorrespondenceList;
for CorrespondenceList.one ← Correspondence
Build Correspondence;
for CorrespondenceList.more ← Correspondence "," CorrespondenceList
Build CorrespondenceList.more[Correspondence, CorrespondenceList];
Correspondence: NonTerminal Builds CorrespondenceList;
for Correspondence ← identifier "(" MandatoryNumber ")"
Build CorrespondenceList.one[identifier, MandatoryNumber];
OptionalNumber: NonTerminal Builds Constant;
for OptionalNumber.nonEmpty ← Constant
Build Constant;
for OptionalNumber.localReference ← identifier
Build Constant.id[identifier];
for OptionalNumber.empty ←
Build Constant.unbounded[];
MandatoryNumber: NonTerminal Builds Constant;
for MandatoryNumber.value ← Constant
Build Constant;
for MandatoryNumber.localReference ← identifier
Build Constant.id[identifier];
CandidateList: NonTerminal Builds CandidateList;
for CandidateList.one ← Candidate
Build Candidate;
for CandidateList.more ← Candidate "," CandidateList
Build CandidateList.more[Candidate, CandidateList];
Candidate: NonTerminal Builds CandidateList;
for Candidate.one ← NameList "=>" SimpleType
Build CandidateList.one[NameList, SimpleType];
for Candidate.two ← NameList "(" number ")" "=>" SimpleType
Build CandidateList.one[NameList, SimpleType];
ArgumentList: NonTerminal Builds FieldList;
for ArgumentList.a ←
Build FieldList.empty[];
for ArgumentList.b ← "[" FieldList "]"
Build FieldList;
for ArgumentList.c ← "[" "]"
Build FieldList.empty[];
ResultList: NonTerminal Builds FieldList;
for ResultList.a ←
Build FieldList.empty[];
for ResultList.b ← "RETURNS" "[" FieldList "]"
Build FieldList;
for ResultList.c ← "RETURNS" "[" "]"
Build FieldList.empty[];
ErrorList: NonTerminal Builds NameList;
for ErrorList.a ←
Build NameList.empty[];
for ErrorList.b ← "REPORTS" "[" NameList "]"
Build NameList;
FieldList: NonTerminal Builds FieldList;
for FieldList.a ← Field
Build FieldList.more[Field, FieldList.empty[[Field, Field)]];
for FieldList.b ← Field "," FieldList
Build FieldList.more[Field, FieldList];
Field: NonTerminal Builds FieldList;
for Field ← NameList ":" SimpleType
Build FieldList.one[NameList, SimpleType];
Constant
Constant: NonTerminal Builds Constant;
for Constant.predefined ← PredefinedConstant
Build PredefinedConstant;
for Constant.constructed ← ConstructedConstant
Build ConstructedConstant;
for Constant.choiceConstant ← identifier Constant
Build Constant.choice[identifier, Constant];
for Constant.choiceIdentifier ← identifier.first identifier.next
Build Constant.choice[identifier.first, Constant.id[identifier.next]];
for Constant.remoteReference ← identifier.left "." identifier.right
Build Constant.remoteReference[identifier.left, identifier.right];
RefConst (id.id) as well as id id ... id.id
PredefinedConstant: NonTerminal Builds Constant;
for PredefinedConstant.true ← "TRUE"
Build Constant.true[];
for PredefinedConstant.false ← "FALSE"
Build Constant.false[];
for PredefinedConstant.number ← number
Build Constant.number[number];
for PredefinedConstant.negativeNumber ← "-" number
Build Constant.negativeNumber[number];
for PredefinedConstant.string ← Rope
Build Constant.string[Rope];
ConstructedConstant: NonTerminal Builds Constant;
for ConstructedConstant.elementList ← "[" ElementList "]"
Build Constant.elementList[ElementList];
for ConstructedConstant.componentlist ← "[" ComponentList "]"
Build Constant.componentlist[ComponentList];
for ConstructedConstant.empty ← "[" "]"
Build Constant.empty[];
ElementList: NonTerminal Builds ElementList;
for ElementList.one ← Constant
Build ElementList.one[Constant];
for ElementList.more ← Constant "," ElementList
Build ElementList.more[Constant, ElementList];
for ElementList.id ← identifier
Build ElementList.one[Constant.id[identifier]];
for ElementList.idAndMore ← identifier "," ElementList
Build ElementList.more[Constant.id[identifier], ElementList];
ComponentList: NonTerminal Builds ComponentList;
for ComponentList.one ← Component
Build ComponentList.one[Component];
for ComponentList.more ← Component "," ComponentList
Build ComponentList.more[Component, ComponentList];
Component: NonTerminal Builds Component;
for Component.more ← NameList ":" Constant
Build Component[NameList, Constant];
for Component.one ← NameList ":" identifier
Build Component[NameList, Constant.id[identifier]];
NameList: NonTerminal Builds NameList;
for NameList.one ← identifier
Build NameList.one[identifier];
for NameList.more ← identifier "," NameList
Build NameList.more[identifier, NameList];
number: NonTerminal Builds number;
for number.a ← numberD
Build number.decimal[numberD];
for number.b ← numberO
Build number.octal[numberO];
for number.c ← numberH
Build number.hex[numberH]
End.