ExampleParser: Control Module; ExampleGeneric: Module = Begin { "+" "-" "*" "/" "(" ")" "#" "!" "." } : SimpleTokens; number: GenericToken = "tokenDECIMAL"; End; ExampleBase: Module = Begin INT: CedarType; BOOLEAN: CedarType; ROPE: CedarType From Rope; Op: EnumeratedBaseType = { plus, minus, mult, div }; ValueOf: BaseFunction[ number.node ] Returns [ INT.value ]; EqualOp: BaseFunction[ Op.left, Op.right ] Returns [ BOOLEAN.yes ]; Add: BaseFunction[ INT.left, INT.right ] Returns [ INT.result ]; Subtract: BaseFunction[ INT.left, INT.right ] Returns [ INT.result ]; Multipy: BaseFunction[ INT.left, INT.right ] Returns [ INT.result ]; Divide: BaseFunction[ INT.left, INT.right ] Returns [ INT.result ]; Signal: BaseFunction Returns [ INT.result ]; Error: BaseFunction[ ROPE.message ] Returns [ INT.result ]; End; ExampleTree: Module = Begin Evaluate: TreeRecursiveFunction [ Tree ] Returns [ INT ]; End; ExampleCG: Module = Begin maingoal: NonTerminal Builds Expression; for maingoal _ sum "." Build sum; sum: NonTerminal Builds Expression; for sum.prod _ product Build product; for sum.plus _ sum "+" product Build Expression.bin[sum, Op.plus, product]; for sum.minus _ sum "-" product Build Expression.bin[sum, Op.minus, product]; product: NonTerminal Builds Expression; for product.prim _ primitive Build primitive; for product.mult _ product "*" primitive Build Expression.bin[product, Op.mult, primitive]; for product.div _ product "/" primitive Build Expression.bin[product, Op.div, primitive]; primitive: NonTerminal Builds Expression; for primitive.number _ number Build Expression.number[number]; for primitive.loc _ "#" Build Expression.loc[]; for primitive.signal _ "!" Build Expression.signal[]; for primitive.paren _ "(" sum ")" Build sum; End; ExampleAT: Module = Begin Expression: AbstractType [ Evaluate ]; End; ExampleAG: Module = Begin Expression.bin: AbstractProduction [ Expression.left, Op.op, Expression.right ]; Expression.number: AbstractProduction [ number ]; Expression.loc: AbstractProduction [ ]; Expression.signal: AbstractProduction [ ]; End; ExampleDoit: Module = Begin for Expression.bin: AbstractProduction [ Expression.left, Op.op, Expression.right ] let Evaluate[tree] _ if ( EqualOp[Op.op, Op.plus] ) then Add[Evaluate[Expression.left], Evaluate[Expression.right]] else if ( EqualOp[Op.op, Op.minus] ) then Subtract[Evaluate[Expression.left], Evaluate[Expression.right]] else if ( EqualOp[Op.op, Op.mult] ) then Multipy[Evaluate[Expression.left], Evaluate[Expression.right]] else if ( EqualOp[Op.op, Op.div] ) then Divide[Evaluate[Expression.left], Evaluate[Expression.right]] else Error["unknown binary operator"]; for Expression.number: AbstractProduction [ number ] let Evaluate[tree] _ ValueOf[number]; for Expression.loc: AbstractProduction [ ] let Evaluate[tree] _ SourcePosition[tree]; for Expression.signal: AbstractProduction [ ] let Evaluate[tree] _ Signal[]; End. úExample.ThreeC4 Copyright Ó 1987 by Xerox Corporation. All rights reserved. Bill Jackson (bj) April 22, 1987 2:16:40 am PDT Generic Tokens Cedar Types Base Functions Recursive Functions Expression: AbstractType[ Evaluate ]; Expression eof... Ê©˜code–%clearTabStops 20 sp flushLeft tabStop™K–%clearTabStops 20 sp flushLeft tabStop™˜BK–%clearTabStops 32 sp flushLeft tabStopš¡œ"˜&—————K–%clearTabStops 32 sp flushLeft tabStop˜—–%clearTabStops 32 sp flushLeft tabStopš¡œœ¡œ˜4K–%clearTabStops 32 sp flushLeft tabStopš¡œ"˜%K–%clearTabStops 32 sp flushLeft tabStop˜—–%clearTabStops 32 sp flushLeft tabStopš¡œœ¡œ˜*K–%clearTabStops 32 sp flushLeft tabStopš¡œ'˜*K–%clearTabStops 32 sp flushLeft tabStop˜—–%clearTabStops 32 sp flushLeft tabStopš¡œœ¡œ˜-K–%clearTabStops 32 sp flushLeft tabStopš¡œ˜K–%clearTabStops 32 sp flushLeft tabStop˜——K–%clearTabStops 20 sp flushLeft tabStop˜—J–%clearTabStops 20 sp flushLeft tabStop˜J–%clearTabStops 20 sp flushLeft tabStop™J–%clearTabStops 20 sp flushLeft tabStop˜—…—Š(-