
<<SaffronPGMethods.ThreeC4>>
    <<Copyright Ó 1988 by Xerox Corporation.  All rights reserved.>>
    <<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.