[Indigo]<Casaba>7.0>ThreeC4Examples>Example.ThreeC4!1

Example.ThreeC4

Bill Jackson (bj) April 22, 1987 2:16:40 am PDT

ExampleParser: Control Module;

ExampleGeneric: Module = Begin

Generic Tokens

{ "+" "-" "*" "/" "(" ")" "#" "!" "." } : SimpleTokens;

number: GenericToken = "tokenDECIMAL";

End;

ExampleBase: Module = Begin

Cedar Types

INT: CedarType;

BOOLEAN: CedarType;

ROPE: CedarType From Rope;

Base Functions

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

Recursive Functions

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: AbstractType[ Evaluate ];

Expression.bin: AbstractProduction [ Expression.left, Op.op, Expression.right ];

Expression.number: AbstractProduction [ number ];

Expression.loc: AbstractProduction [ ];

Expression.signal: AbstractProduction [ ];

End;

ExampleDoit: Module = Begin

Expression

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.

eof...