[Indigo]<Casaba>7.0>Saffron3.0>Sources>SaffronPGMethods.ThreeC4!2

SaffronPGMethods.ThreeC4

James Rauen, June 13, 1988 1:02:49 pm PDT

Last edited by: James Rauen June 14, 1988 1:54:02 pm PDT

This file contains methods for the various tree-recursive functions related to Program Graph generation.

Include [ SaffronAG, SaffronPGDecls, SaffronTreeDecls, SaffronBaseDecls ];

SaffronPGMethods1: Module = Begin

for Top.modulep: AbstractProduction [ ModuleP ]

let GeneratePG [tree, env] ← GeneratePG [ModuleP, env];

for ModuleP.impl: AbstractProduction [ Directory, IdentList, Cedar, ProgHead, Checked, Block ]

let GeneratePG [tree, env] ← MakeBogusPGN[];

for ModuleP.def: AbstractProduction [ Directory, IdentList, Cedar, DefHead, DefBody ]

let GeneratePG [tree, env] ← GeneratePG [DefBody, env];

for DefBody: AbstractProduction [ BindList, DecList ]

let GeneratePG [tree, env] ← GeneratePG[DecList, env];

for DecList.one: AbstractProduction [ Declaration ]

let GeneratePG [tree, env] ← GeneratePG[Declaration, env];

for DecList.many: AbstractProduction [ DecList.head, DecList.tail ]

let GeneratePG [tree, env] ← GeneratePG[DecList.head, env];

-- we need concate here!

for Declaration.value: AbstractProduction [ IdentList, Access, Entry, ReadOnly, TypeExp, Initialization ]

let GeneratePG [tree, env] ← GeneratePG[Initialization, env];

for Declaration.type: AbstractProduction [ IdentList, Access.id, Access.type, TypeExp, Default ]

let GeneratePG [tree, env] ← MakeBogusPGN[];

for Declaration.opaquetype: AbstractProduction [ IdentList, Access, OptSize ]

let GeneratePG [tree, env] ← MakeBogusPGN[];

for Initialization.empty: AbstractProduction [ ]

let GeneratePG [tree, env] ← MakeBogusPGN[];

for Initialization.binding: AbstractProduction [ InitialValue ]

let GeneratePG [tree, env] ← GeneratePG[InitialValue, env];

for Initialization.assignment: AbstractProduction [ InitialValue ]

let GeneratePG [tree, env] ← GeneratePG[InitialValue, env];

for InitialValue.trash: AbstractProduction [ ]

let GeneratePG [tree, env] ← MakeBogusPGN[];

for InitialValue.code: AbstractProduction [ ]

let GeneratePG [tree, env] ← MakeBogusPGN[];

for InitialValue.exp: AbstractProduction [ Exp ]

let GeneratePG [tree, env] ← MakeSemiBogusPGN[evaluatedExp]

where evaluatedExp ← Evaluate [ Exp ];

for InitialValue.block: AbstractProduction [ Checked, Inline, Block ]

let GeneratePG [tree, env] ← MakeBogusPGN[];

for InitialValue.machinecode: AbstractProduction [ Checked, CodeList ]

let GeneratePG [tree, env] ← MakeBogusPGN[];

for Exp.sum: AbstractProduction [ Exp.left, AddOp, Exp.right ]

let Evaluate [tree] ← MakeIntegerEvExp [0];

for Exp.sum: AbstractProduction [ Exp.left, AddOp, Exp.right ]

let Evaluate [tree] ← MakeIntegerEvExp [0];

for Exp.unarysum: AbstractProduction [ AddOp, Exp ]

let Evaluate [tree] ← MakeIntegerEvExp [1];

for Exp.product: AbstractProduction [ Exp.left, MultOp, Exp.right ]

let Evaluate [tree] ← MakeIntegerEvExp [2];

for Exp.or: AbstractProduction [ Exp.left, Exp.right ]

let Evaluate [tree] ← MakeIntegerEvExp [3];

for Exp.and: AbstractProduction [ Exp.left, Exp.right ]

let Evaluate [tree] ← MakeIntegerEvExp [4];

for Exp.not: AbstractProduction [ Exp ]

let Evaluate [tree] ← MakeIntegerEvExp [5];

for Exp.relation: AbstractProduction [ Exp, Relation ]

let Evaluate [tree] ← MakeIntegerEvExp [6];

for Exp.ifthenelse: AbstractProduction [ Exp.cond, Exp.thenpart, Exp.elsepart ]

let Evaluate [tree] ← MakeIntegerEvExp [7];

for Exp.select: AbstractProduction [ SelectHead, SelectExpList, Exp.default ]

let Evaluate [tree] ← MakeIntegerEvExp [8];

for Exp.assign: AbstractProduction [ Exp.lhs, Exp.rhs ]

let Evaluate [tree] ← MakeIntegerEvExp [9];

for Exp.multiassign: AbstractProduction [ ExpList, Exp ]

let Evaluate [tree] ← MakeIntegerEvExp [10];

for Exp.id: AbstractProduction [ Id ]

let Evaluate [tree] ← MakeIntegerEvExp [11];

for Exp.num: AbstractProduction [ Num ]

let Evaluate [tree] ← Evaluate[Num];

for Exp.string: AbstractProduction [ String ]

let Evaluate [tree] ← MakeIntegerEvExp [13];

for Exp.flnum: AbstractProduction [ Flnum ]

let Evaluate [tree] ← MakeIntegerEvExp [14];

for Exp.char: AbstractProduction [ Char ]

let Evaluate [tree] ← MakeIntegerEvExp [15];

for Exp.atom: AbstractProduction [ Atom ]

let Evaluate [tree] ← MakeIntegerEvExp [16];

for Exp.narrow: AbstractProduction [ Exp, OptType, Catch ]

let Evaluate [tree] ← MakeIntegerEvExp [17];

for Exp.loophole: AbstractProduction [ Exp, OptType ]

let Evaluate [tree] ← MakeIntegerEvExp [18];

for Exp.apply: AbstractProduction [ Exp.rator, Exp.rand, Catch ]

let Evaluate [tree] ← MakeIntegerEvExp [19];

for Exp.qualifier: AbstractProduction [ Exp, Qualifier ]

let Evaluate [tree] ← MakeIntegerEvExp [20];

for Exp.explist: AbstractProduction [ ExpList ]

let Evaluate [tree] ← MakeIntegerEvExp [21];

for Exp.prefixop: AbstractProduction [ PrefixOp, OrderList ]

let Evaluate [tree] ← MakeIntegerEvExp [22];

for Exp.val: AbstractProduction [ OrderList ]

let Evaluate [tree] ← MakeIntegerEvExp [23];

for Exp.all: AbstractProduction [ OrderList ]

let Evaluate [tree] ← MakeIntegerEvExp [24];

for Exp.new: AbstractProduction [ New, TypeExp, Initialization, Catch ]

let Evaluate [tree] ← MakeIntegerEvExp [25];

for Exp.cons: AbstractProduction [ Cons, ExpList, Catch ]

let Evaluate [tree] ← MakeIntegerEvExp [26];

for Exp.listcons: AbstractProduction [ ListCons, ExpList ]

let Evaluate [tree] ← MakeIntegerEvExp [27];

for Exp.nil: AbstractProduction [ ]

let Evaluate [tree] ← MakeIntegerEvExp [28];

for Exp.typeop: AbstractProduction [ TypeOp, TypeExp ]

let Evaluate [tree] ← MakeIntegerEvExp [29];

for Exp.size: AbstractProduction [ TypeExp ]

let Evaluate [tree] ← MakeIntegerEvExp [30];

for Exp.size2: AbstractProduction [ TypeExp, Exp ]

let Evaluate [tree] ← MakeIntegerEvExp [31];

for Exp.bits: AbstractProduction [ TypeExp ]

let Evaluate [tree] ← MakeIntegerEvExp [32];

for Exp.bits2: AbstractProduction [ TypeExp, Exp ]

let Evaluate [tree] ← MakeIntegerEvExp [33];

for Exp.bytes: AbstractProduction [ TypeExp ]

let Evaluate [tree] ← MakeIntegerEvExp [34];

for Exp.bytes2: AbstractProduction [ TypeExp, Exp ]

let Evaluate [tree] ← MakeIntegerEvExp [35];

for Exp.units: AbstractProduction [ TypeExp ]

let Evaluate [tree] ← MakeIntegerEvExp [36];

for Exp.units2: AbstractProduction [ TypeExp, Exp ]

let Evaluate [tree] ← MakeIntegerEvExp [37];

for Exp.words: AbstractProduction [ TypeExp ]

let Evaluate [tree] ← MakeIntegerEvExp [38];

for Exp.words2: AbstractProduction [ TypeExp, Exp ]

let Evaluate [tree] ← MakeIntegerEvExp [39];

for Exp.istype: AbstractProduction [ Exp, TypeExp ]

let Evaluate [tree] ← MakeIntegerEvExp [40];

for Exp.address: AbstractProduction [ Exp ]

let Evaluate [tree] ← MakeIntegerEvExp [41];

for Exp.descriptor: AbstractProduction [ DescList ]

let Evaluate [tree] ← MakeIntegerEvExp [42];

for Exp.error: AbstractProduction [ ]

let Evaluate [tree] ← MakeIntegerEvExp [43];

for Exp.transfer: AbstractProduction [ TransferOp, Exp ]

let Evaluate [tree] ← MakeIntegerEvExp [44];

for Num.decimal: AbstractProduction [ Decimalnum ]

let Evaluate [tree] ← MakeIntegerEvExp[DecimalnumValue[Decimalnum]];

for Num.octal: AbstractProduction [ Octalnum ]

let Evaluate [tree] ← MakeIntegerEvExp[OctalnumValue[Octalnum]];

for Num.hex: AbstractProduction [ Hexnum ]

let Evaluate [tree] ← MakeIntegerEvExp[HexnumValue[Hexnum]];

End.