Include [ SaffronBaseDecls, SaffronTreeDecls, SaffronAG, SaffronProgramGraphDecls ];

SaffronValueCompile1: Module = Begin

for Exp.sum:	AbstractProduction [ Exp.left, AddOp, Exp.right ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ 
CastIntegerValue[
if IsPlus[AddOp] 
then Add[RetrieveIntegerValue[lhs], RetrieveIntegerValue[rhs]] 
else Sub[RetrieveIntegerValue[lhs], RetrieveIntegerValue[rhs]],
GetIntrinsicIntegerTypes[cs]]
where lhs _ DemandNumber[uncheckedLhs]
where rhs _ DemandNumber[uncheckedRhs]
where uncheckedRhs _ EvaluateExpression[Exp.right, lc, fl, cs, targetType]
where uncheckedLhs _ EvaluateExpression[Exp.left, lc, fl, cs, targetType]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree2>
where result _
if And[And[Static[lhs], Static[rhs]], And[ConformsToInteger[lhsType], ConformsToInteger[rhsType]]]
then CastIntegerValue[
if IsPlus[AddOp] 
then Add[RetrieveIntegerValue[lhs], RetrieveIntegerValue[rhs]] 
else Sub[RetrieveIntegerValue[lhs], RetrieveIntegerValue[rhs]],
GetIntrinsicIntegerTypes[cs]]
else (MakeRuntimeValue[code, targetType] -- is targetType correct here?
where code _ ConcatProgramFragments[ConcatProgramFragments[pushLHS, pushRHS], op]
where pushLHS _ Code[lhs]
where pushRHS _ Code[rhs]
where op _ if IsPlus[AddOp] 
then MakePGAdd[]
else MakePGSubtract[]
)
where lhsType _ Type[lhs]
where rhsType _ Type[rhs]
where lhs _ DemandNumber[uncheckedLhs]
where rhs _ DemandNumber[uncheckedRhs]
where <uncheckedRhs, contextTree2> _ 
CompileExpression[Exp.right, contextTree1, cs, targetType]
where <uncheckedLhs, contextTree1> _ 
CompileExpression[Exp.left, contextTree, cs, targetType]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Arithmetic expression used as l-value"]
;

for Exp.unarysum:	AbstractProduction [ AddOp, Exp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ 
CastIntegerValue[
if IsPlus[AddOp] 
then RetrieveIntegerValue[rhs]
else Neg[RetrieveIntegerValue[rhs]],
GetIntrinsicIntegerTypes[cs]]
where rhs _ DemandNumber[uncheckedRhs]
where uncheckedRhs _ EvaluateExpression[Exp, lc, fl, cs, targetType]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _
if And[Static[rhs], ConformsToInteger[rhsType]]
then CastIntegerValue[
if IsPlus[AddOp] 
then RetrieveIntegerValue[rhs]
else Neg[RetrieveIntegerValue[rhs]],
GetIntrinsicIntegerTypes[cs]]
else (MakeRuntimeValue[code, targetType] -- is targetType correct here?
where code _ 
if IsPlus[AddOp]
then ConcatProgramFragments[pushRHS, MakePGNoOp[]]
else ConcatProgramFragments[pushRHS, MakePGNegate[]]
where pushRHS _ Code[rhs]
)
where rhsType _ Type[rhs]
where rhs _ DemandNumber[uncheckedRhs]
where <uncheckedRhs, contextTree1> _ 
CompileExpression[Exp, contextTree, cs, targetType]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Arithmetic expression used as l-value"]
;

for Exp.product:	AbstractProduction [ Exp.left, MultOp, Exp.right ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ 
CastIntegerValue[
if IsTimes[MultOp] 
then Mul[RetrieveIntegerValue[lhs], RetrieveIntegerValue[rhs]] 
else if IsDivide[MultOp]
then Div[RetrieveIntegerValue[lhs], RetrieveIntegerValue[rhs]]
else Mod[RetrieveIntegerValue[lhs], RetrieveIntegerValue[rhs]],
GetIntrinsicIntegerTypes[cs]]
where lhs _ DemandNumber[uncheckedLhs]
where rhs _ DemandNumber[uncheckedRhs]
where uncheckedRhs _ EvaluateExpression[Exp.right, lc, fl, cs, targetType]
where uncheckedLhs _ EvaluateExpression[Exp.left, lc, fl, cs, targetType]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree2>
where result _
if And[And[Static[lhs], Static[rhs]], And[ConformsToInteger[lhsType], ConformsToInteger[rhsType]]]
then CastIntegerValue[
if IsTimes[MultOp] 
then Mul[RetrieveIntegerValue[lhs], RetrieveIntegerValue[rhs]] 
else if IsDivide[MultOp]
then Div[RetrieveIntegerValue[lhs], RetrieveIntegerValue[rhs]]
else Mod[RetrieveIntegerValue[lhs], RetrieveIntegerValue[rhs]],
GetIntrinsicIntegerTypes[cs]]
else (MakeRuntimeValue[code, targetType] -- is targetType correct here?
where code _ ConcatProgramFragments[ConcatProgramFragments[pushLHS, pushRHS], op]
where pushLHS _ Code[lhs]
where pushRHS _ Code[rhs]
where op _ 
if IsTimes[MultOp] 
then MakePGMultiply[] 
else if IsDivide[MultOp]
then MakePGDivide[]
else MakePGMod[]
)
where lhsType _ Type[lhs]
where rhsType _ Type[rhs]
where lhs _ DemandNumber[uncheckedLhs]
where rhs _ DemandNumber[uncheckedRhs]
where <uncheckedRhs, contextTree2> _ 
CompileExpression[Exp.right, contextTree1, cs, targetType]
where <uncheckedLhs, contextTree1> _ 
CompileExpression[Exp.left, contextTree, cs, targetType]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Arithmetic expression used as l-value"]
;

for Exp.or:	AbstractProduction [ Exp.left, Exp.right ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ 
MakeStaticBoolean[Or[BooleanValue[lhs], BooleanValue[rhs]], boolean]
where rhs _ EvaluateAndTypeCheckExpression[Exp.right, lc, fl, cs, boolean]
where lhs _ EvaluateAndTypeCheckExpression[Exp.left, lc, fl, cs, boolean]
where boolean _ GetIntrinsicBooleanType[cs]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree2>
where result _
if And[Static[lhs], Static[rhs]] 
then MakeStaticBoolean[Or[BooleanValue[lhs], BooleanValue[rhs]], boolean]
else (MakeRuntimeValue[code, boolean]
where code _ ConcatProgramFragments[ConcatProgramFragments[pushLHS, pushRHS], op]
where pushLHS _ Code[lhs]
where pushRHS _ Code[rhs]
where op _ MakePGOr[]
)
where <rhs, contextTree2> _ 
CompileAndTypeCheckExpression[Exp.right, contextTree1, cs, boolean]
where <lhs, contextTree1> _ 
CompileAndTypeCheckExpression[Exp.left, contextTree, cs, boolean]
where boolean _ GetIntrinsicBooleanType[cs]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["OR expression used as l-value"]
;

for Exp.and:	AbstractProduction [ Exp.left, Exp.right ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ 
MakeStaticBoolean[And[BooleanValue[lhs], BooleanValue[rhs]], boolean]
where rhs _ EvaluateAndTypeCheckExpression[Exp.right, lc, fl, cs, boolean]
where lhs _ EvaluateAndTypeCheckExpression[Exp.left, lc, fl, cs, boolean]
where boolean _ GetIntrinsicBooleanType[cs]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree2>
where result _
if And[Static[lhs], Static[rhs]] 
then MakeStaticBoolean[And[BooleanValue[lhs], BooleanValue[rhs]], boolean]
else (MakeRuntimeValue[code, boolean]
where code _ ConcatProgramFragments[ConcatProgramFragments[pushLHS, pushRHS], op]
where pushLHS _ Code[lhs]
where pushRHS _ Code[rhs]
where op _ MakePGAnd[]
)
where <rhs, contextTree2> _ 
CompileAndTypeCheckExpression[Exp.right, contextTree1, cs, boolean]
where <lhs, contextTree1> _ 
CompileAndTypeCheckExpression[Exp.left, contextTree, cs, boolean]
where boolean _ GetIntrinsicBooleanType[cs]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["AND expression used as l-value"]
;

for Exp.not:	AbstractProduction [ Exp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ 
MakeStaticBoolean[Not[BooleanValue[rhs]], boolean]
where rhs _ EvaluateAndTypeCheckExpression[Exp, lc, fl, cs, boolean]
where boolean _ GetIntrinsicBooleanType[cs]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _
if Static[rhs] 
then MakeStaticBoolean[Not[BooleanValue[rhs]], boolean]
else (MakeRuntimeValue[code, boolean]
where code _ ConcatProgramFragments[Code[rhs], MakePGNot[]]
)
where <rhs, contextTree1> _ 
CompileAndTypeCheckExpression[Exp, contextTree, cs, boolean]
where boolean _ GetIntrinsicBooleanType[cs]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["NOT expression used as l-value"]
;

for Exp.relation:	AbstractProduction [ Exp, Relation ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["relation"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["relation"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Relation used as l-value"]
;

for Exp.ifthenelse:	AbstractProduction [ Exp.cond, Exp.thenpart, Exp.elsepart ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ 
if BooleanValue[EvaluateAndTypeCheckExpression[Exp.cond, lc, fl, cs, boolean]]
then EvaluateAndTypeCheckExpression[Exp.thenpart, lc, fl, cs, targetType]
else EvaluateAndTypeCheckExpression[Exp.elsepart, lc, fl, cs, targetType]
where boolean _ GetIntrinsicBooleanType[cs]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree4>
where <result, contextTree4> _ 
if Static[condition]
then if BooleanValue[condition]
then CompileAndTypeCheckExpression[Exp.thenpart, contextTree1, cs, targetType]
else CompileAndTypeCheckExpression[Exp.elsepart, contextTree1, cs, targetType]
else (<MakeRuntimeValue[code, targetType], contextTree3> -- is targetType correct here?
where code _ MakePGTest[Code[condition], Code[thenPart], Code[elsePart]]
where <elsePart, contextTree3> _ CompileAndTypeCheckExpression[Exp.elsepart, contextTree2, cs, targetType]
where <thenPart, contextTree2> _ CompileAndTypeCheckExpression[Exp.thenpart, contextTree1, cs, targetType]
)
where <condition, contextTree1> _ CompileAndTypeCheckExpression[Exp.cond, contextTree, cs, booleanType]
where booleanType _ GetIntrinsicBooleanType[cs]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["IF expression used as l-value"]
;

for Exp.select:	AbstractProduction [ SelectHead, SelectExpList, Exp.default ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["select"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["select"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["SELECT expression used as l-value"]
;

for Exp.assign:	AbstractProduction [ Exp.lhs, Exp.rhs ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeTrash[targetType]
where err _ Error["Exp.assign should never be evaluated!"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeRuntimeValue[code, tgn]
where code _ ConcatProgramFragments[Code[rhsValue], storeTOS]
where storeTOS _ if PFDIsLocal[lvalue]
then MakePGStoreLocal[lvalue]
else MakePGStoreIndirect[lvalue]
where <rhsValue, contextTree1> _ 
CompileAndTypeCheckExpression[Exp.rhs, contextTree, cs, tgn]
where <lvalue, tgn> _ CompileLValue[Exp.lhs, contextTree, cs]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Assignment expression used as l-value"]
;

for Exp.multiassign:	AbstractProduction [ ExpList, Exp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeTrash[targetType]
where err _ Error["Exp.multiassign should never be evaluated!"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["multiassign"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Multiple assignment expression used as l-value"]
;

for Exp.id:	AbstractProduction [ Id ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ result
where result _ if Static[value]
then value
else (MakeDummy[""]
where err _ Error["blat"])
where <access, tgn, initialization, value> _ DemandConstantField[field2]
where field2 _ if FieldExists[field1]
then field1
else LookupNameInContextRib[Id, ParentRib[lc]]
where field1 _ LookupNameInFieldList[fl, Id]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where contextTree1 _ FakeDamageContextTree[contextTree]
where result _ CompileLValueIntoRValue[expAsLValue, contextTree]
where <expAsLValue, tgn> _ CompileLValue[tree, contextTree, cs]
let CompileLValue[tree, contextTree, cs] _ GetPathToName[contextTree, Id]
;

for Exp.num:	AbstractProduction [ Num ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ result
where result _ CastIntegerValue[integerValue, GetIntrinsicIntegerTypes[cs]]
where integerValue _ IntegerValueFromLiteral[Num]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>  
where result _ CastIntegerValue[integerValue, GetIntrinsicIntegerTypes[cs]]
where integerValue _ IntegerValueFromLiteral[Num]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Number literal used as l-value"]
;

for Exp.string:	AbstractProduction [ String ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["string"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["string"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["String literal used as l-value"]
;

for Exp.flnum:	AbstractProduction [ Flnum ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["flnum"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["flnum"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["REAL literal used as l-value"]
;

for Exp.char:	AbstractProduction [ Char ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["char"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["char"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Character literal used as l-value"]
;

for Exp.atom:	AbstractProduction [ Atom ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["atom"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["atom"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Character literal used as l-value"]
;

for Exp.narrow:	AbstractProduction [ Exp, OptType, Catch ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["narrow"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["narrow"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["NARROW expression used as l-value"]
;

for Exp.loophole:	AbstractProduction [ Exp, OptType ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["loophole"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["loophole"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["LOOPHOLE expression used as l-value"]
;

for Exp.apply:	AbstractProduction [ Exp.rator, Exp.rand, Catch ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["apply"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["apply"]
where contextTree1 _ FakeDamageContextTree[contextTree] 
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Apply expression used as l-value"]
;

for Exp.qualifier:	AbstractProduction [ Exp, Qualifier ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["qualifier"]
let CompileExpression[tree, contextTree, cs, targetType] _ 
CompileQualifiedExpression[Qualifier, value, contextTree1, cs, targetType]
where <value, contextTree1> _ CompileAndTypeCheckExpression[Exp, contextTree, cs, top]
where top _ GetTop[cs]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Qualifier l-value not implemented yet!!!!!!!!!"]
;

for Exp.explist:	AbstractProduction [ ExpList ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["explist"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["explist"]
where contextTree1 _ FakeDamageContextTree[contextTree] 
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["ExpList l-value not implemented yet!!!!!!!!!"]
;

for Exp.prefixop:	AbstractProduction [ PrefixOp, OrderList ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["prefixop"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["prefixop"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["PrefixOp expression used as l-value"]
;

for Exp.val:	AbstractProduction [ OrderList ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["val"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["val"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Val expression used as l-value"]
;
 
for Exp.all:	AbstractProduction [ OrderList ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["all"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["all"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["ALL expression used as l-value"]
; 

for Exp.new:	AbstractProduction [ New, TypeExp, Initialization, Catch ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeTrash[targetType]
where err _ Error["Should not be evaluating Exp.new!"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["new"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["NEW expression used as l-value"]
; 
 
for Exp.cons:	AbstractProduction [ Cons, ExpList, Catch ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeTrash[targetType]
where err _ Error["Should not be evaluating Exp.cons!"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["cons"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["CONS expression used as l-value"]
; 

for Exp.listcons:	AbstractProduction [ ListCons, ExpList ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeTrash[targetType]
where err _ Error["Should not be evaluating Exp.listcons!"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["listcons"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["ListCons expression used as l-value"]
; 

for Exp.nil:	AbstractProduction [  ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["nil"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1> 
where result _ MakeDummy["nil"]
where contextTree1 _ FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["NIL expression used as l-value"]
; 

End;

SaffronValueCompile2: Module = Begin

for Exp.typeop:	AbstractProduction [ TypeOp, TypeExp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ 
if TypeOpIsCode[TypeOp] then ( MakeDummy[""]
where err _ Error["EvaluateExpression not implemented for code Exp.typeop"]
)
else if TypeOpIsFirst[TypeOp] 
then EvaluateFirstOfTypeExpression[TypeExp, lc, fl, cs, targetType]
else if TypeOpIsLast[TypeOp] 
then EvaluateLastOfTypeExpression[TypeExp, lc, fl, cs, targetType]
else if TypeOpIsNil[TypeOp] then ( MakeDummy[""]
where err _ Error["EvaluateExpression not implemented for nil Exp.typeop"]
)
else ( MakeDummy[""]
where err _ Error["in EvaluateExpression for Exp.typeop"]
)
let CompileExpression[tree, contextTree, cs, targetType] _ 
if TypeOpIsCode[TypeOp] then ( <dummy, contextTree1>
where dummy _ MakeDummy[""]
where contextTree1 _ FakeDamageContextTree[contextTree]
where err _ Error["CompileExpression not implemented for code Exp.typeop"]
)
else if TypeOpIsFirst[TypeOp] then ( <first, contextTree1>
where contextTree1 _ FakeDamageContextTree[contextTree]
where first _ CompileFirstOfTypeExpression[TypeExp, contextTree, cs, targetType]
)
else if TypeOpIsLast[TypeOp] then ( <last, contextTree1> 
where contextTree1 _ FakeDamageContextTree[contextTree]
where last _ CompileLastOfTypeExpression[TypeExp, contextTree, cs, targetType]
)
else if TypeOpIsNil[TypeOp] then ( <dummy, contextTree1>
where dummy _ MakeDummy[""]
where contextTree1 _FakeDamageContextTree[contextTree]
where err _ Error["CompileExpression not implemented for nil Exp.typeop"]
)
else ( <dummy, contextTree1>
where dummy _ MakeDummy[""]
where contextTree1 _ FakeDamageContextTree[contextTree]
where err _ Error["in CompileExpression for Exp.typeop"]
)
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["TypeOp expression used as l-value"]
;

for Exp.size:	AbstractProduction [ TypeExp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["size"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["size"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["SIZE expression used as l-value"]
;

for Exp.size2:	AbstractProduction [ TypeExp, Exp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["size2"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["size2"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["SIZE2 expression used as l-value"]
;

for Exp.bits:	AbstractProduction [ TypeExp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["bits"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["bits"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["BITS expression used as l-value"]
;

for Exp.bits2:	AbstractProduction [ TypeExp, Exp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["bits2"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["bits2"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["BITS2 expression used as l-value"]
;

for Exp.bytes:	AbstractProduction [ TypeExp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["bytes"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["bytes"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["BYTES expression used as l-value"]
;

for Exp.bytes2:	AbstractProduction [ TypeExp, Exp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["bytes2"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["bytes2"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["BYTES2 expression used as l-value"]
;

for Exp.units:	AbstractProduction [ TypeExp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["units"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["units"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["UNITS expression used as l-value"]
;
 
for Exp.units2:	AbstractProduction [ TypeExp, Exp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["units2"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["units2"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["UNITS2 expression used as l-value"]
;
 
for Exp.words:	AbstractProduction [ TypeExp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["words"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["words"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["WORDS expression used as l-value"]
;
 
for Exp.words2:	AbstractProduction [ TypeExp, Exp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["words2"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["words2"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["WORDS2 expression used as l-value"]
;

for Exp.istype:	AbstractProduction [ Exp, TypeExp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["istype"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["istype"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["ISTYPE expression used as l-value"]
;

for Exp.address:	AbstractProduction [ Exp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["address"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["address"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["@ expression used as l-value"]
;

for Exp.descriptor:	AbstractProduction [ DescList ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["descriptor"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["descriptor"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Descriptor used as l-value"]
;

for Exp.error:	AbstractProduction [  ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["error"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["error"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["ERROR used as l-value"]
;
 
for Exp.transfer:	AbstractProduction [ TransferOp, Exp ]
let EvaluateExpression[tree, lc, fl, cs, targetType] _ MakeDummy["transfer"]
let CompileExpression[tree, contextTree, cs, targetType] _ <result, contextTree1>
where result _ MakeDummy["transfer"]
where contextTree1 _FakeDamageContextTree[contextTree]
let CompileLValue[tree, contextTree, cs] _ <pfd, tgn>
where pfd _ EmptyPFD[]
where tgn _ GetIntrinsicBooleanType[cs] -- any type will do...
where err _ Error["Transfer expression used as l-value"]
;

for Num.decimal:	AbstractProduction [Decimalnum]
let IntegerValueFromLiteral[tree] _ ParseIntegerLiteral[digits, 10]
where digits _ RopeFromDecimalnum[Decimalnum];
for Num.octal:	AbstractProduction [Octalnum]
let IntegerValueFromLiteral[tree] _ ParseIntegerLiteral[digits, 8]
where digits _ RopeFromOctalnum[Octalnum];
for Num.hex:	AbstractProduction [Hexnum]
let IntegerValueFromLiteral[tree] _ ParseIntegerLiteral[digits, 16]
where digits _ RopeFromHexnum[Hexnum];

for AddOp.plus:	AbstractProduction []
let IsPlus[tree] _ True[]
let IsMinus[tree] _ False[];
for AddOp.minus:	AbstractProduction []
let IsPlus[tree] _ False[]
let IsMinus[tree] _ True[];

for MultOp.times:	AbstractProduction []
let IsTimes[tree] _ True[]
let IsDivide[tree] _ False[]
let IsMod[tree] _ False[];
for MultOp.divide:	AbstractProduction []
let IsTimes[tree] _ False[]
let IsDivide[tree] _ True[]
let IsMod[tree] _ False[];
for MultOp.mod:	AbstractProduction []
let IsTimes[tree] _ False[]
let IsDivide[tree] _ False[]
let IsMod[tree] _ True[];

for Relop.eq:	AbstractProduction []
let GetRelationOp[tree] _ RelationOp.eq;
for Relop.ne:	AbstractProduction []
let GetRelationOp[tree] _ RelationOp.ne;
for Relop.lt:	AbstractProduction []
let GetRelationOp[tree] _ RelationOp.lt;
for Relop.le:	AbstractProduction []
let GetRelationOp[tree] _ RelationOp.le;
for Relop.gt:	AbstractProduction []
let GetRelationOp[tree] _ RelationOp.gt;
for Relop.ge:	AbstractProduction []
let GetRelationOp[tree] _ RelationOp.ge;

for Initialization.empty:	AbstractProduction []
let InitializationIsEmpty[tree] _ True[]
let InitializationIsBinding[tree] _ False[]
let InitializationIsAssignment[tree] _ False[]
;

for Initialization.binding:	AbstractProduction [InitialValue]
let InitializationIsEmpty[tree] _ False[]
let InitializationIsBinding[tree] _ True[]
let InitializationIsAssignment[tree] _ False[]
;

for Initialization.assignment:	AbstractProduction [InitialValue]
let InitializationIsEmpty[tree] _ False[]
let InitializationIsBinding[tree] _ False[]
let InitializationIsAssignment[tree] _ True[]
;



for TypeOp.code: AbstractProduction []
let TypeOpIsCode[tree] _ True[]
let TypeOpIsFirst[tree] _ False[]
let TypeOpIsLast[tree] _ False[]
let TypeOpIsNil[tree] _ False[];

for TypeOp.first: AbstractProduction []
let TypeOpIsCode[tree] _ False[]
let TypeOpIsFirst[tree] _ True[]
let TypeOpIsLast[tree] _ False[]
let TypeOpIsNil[tree] _ False[];

for TypeOp.last: AbstractProduction []
let TypeOpIsCode[tree] _ False[]
let TypeOpIsFirst[tree] _ False[]
let TypeOpIsLast[tree] _ True[]
let TypeOpIsNil[tree] _ False[];

for TypeOp.nil: AbstractProduction []
let TypeOpIsCode[tree] _ False[]
let TypeOpIsFirst[tree] _ False[]
let TypeOpIsLast[tree] _ False[]
let TypeOpIsNil[tree] _ True[];


for Qualifier.prefixop: AbstractProduction [PrefixOp]
let CompileQualifiedExpression[tree, expValue, contextTree, cs, targetType] _ <
MakeDummy["Qualifier.prefixop"],
FakeDamageContextTree[contextTree]
>
;

for Qualifier.typeop: AbstractProduction [TypeOp]
let CompileQualifiedExpression[tree, expValue, contextTree, cs, targetType] _ <
MakeDummy["Qualifier.prefixop"],
FakeDamageContextTree[contextTree]
>
;

for Qualifier.size: AbstractProduction []
let CompileQualifiedExpression[tree, expValue, contextTree, cs, targetType] _ <
MakeDummy["Qualifier.prefixop"],
FakeDamageContextTree[contextTree]
>
;

for Qualifier.bits: AbstractProduction []
let CompileQualifiedExpression[tree, expValue, contextTree, cs, targetType] _ <
MakeDummy["Qualifier.prefixop"],
FakeDamageContextTree[contextTree]
>
;

for Qualifier.bytes: AbstractProduction []
let CompileQualifiedExpression[tree, expValue, contextTree, cs, targetType] _ <
MakeDummy["Qualifier.prefixop"],
FakeDamageContextTree[contextTree]
>
;

for Qualifier.units: AbstractProduction []
let CompileQualifiedExpression[tree, expValue, contextTree, cs, targetType] _ <
MakeDummy["Qualifier.prefixop"],
FakeDamageContextTree[contextTree]
>
;

for Qualifier.words: AbstractProduction []
let CompileQualifiedExpression[tree, expValue, contextTree, cs, targetType] _ <
MakeDummy["Qualifier.prefixop"],
FakeDamageContextTree[contextTree]
>
;

for Qualifier.apply: AbstractProduction [ExpList, Catch]
let CompileQualifiedExpression[tree, expValue, contextTree, cs, targetType] _ <
MakeDummy["Qualifier.apply"],
FakeDamageContextTree[contextTree]
>
;

for Qualifier.select: AbstractProduction [Id]
let CompileQualifiedExpression[tree, expValue, contextTree, cs, targetType] _ <
MakeDummy["Qualifier.prefixop"],
FakeDamageContextTree[contextTree]
>
;

for Qualifier.indirect: AbstractProduction []
let CompileQualifiedExpression[tree, expValue, contextTree, cs, targetType] _ <
MakeDummy["Qualifier.prefixop"],
FakeDamageContextTree[contextTree]
>
;

End;

SaffronTypeCompile: Module = Begin

for TypeExp.record:	AbstractProduction [ MachineDependent, Monitored, RecList ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of RECORD not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on RECORD types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on RECORD types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of RECORD not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on RECORD types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on RECORD types."]
;

for TypeExp.union:	AbstractProduction [ Tag, VariantList ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of UNION not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on UNION types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on UNION types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of UNION not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on UNION types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on UNION types."]
;

for TypeExp.sequence:	AbstractProduction [ Packed, Tag, TypeExp ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of SEQUENCE not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on SEQUENCE types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on SEQUENCE types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of SEQUENCE not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on SEQUENCE types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on SEQUENCE types."]
;

for TypeExp.enum:	AbstractProduction [ MachineDependent, ElementList ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of Enumerated not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST of Enumerated not implemented yet."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST of Enumerated not implemented yet."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of Enumerated not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST of Enumerated not implemented yet."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST of Enumerated not implemented yet."]
;

for TypeExp.ref:	AbstractProduction [ ReadOnly, TypeExp ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of REF not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on REF types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on REF types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of REF not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on REF types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on REF types."]
;

for TypeExp.refany:	AbstractProduction [ ReadOnly ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of REF ANY not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on REF ANY types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on REF ANY types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of REF ANY not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on REF ANY types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on REF ANY types."]
;

for TypeExp.refunspecified:	AbstractProduction [ ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of REF UNSPECIFIED not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on REF UNSPECIFIED types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on REF UNSPECIFIED types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of REF UNSPECIFIED not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on REF UNSPECIFIED types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on REF UNSPECIFIED types."]
;

for TypeExp.typeid:	AbstractProduction [ TypeId ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ 
EvaluateSizeOfTypeExpression[TypeId, lc, fl, cs, targetType]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ 
EvaluateFirstOfTypeExpression[TypeId, lc, fl, cs, targetType]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ 
EvaluateLastOfTypeExpression[TypeId, lc, fl, cs, targetType]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _
CompileSizeOfTypeExpression[TypeId, contextTree, cs, targetType]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ 
CompileFirstOfTypeExpression[TypeId, contextTree, cs, targetType]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ 
CompileLastOfTypeExpression[TypeId, contextTree, cs, targetType]
;

for TypeExp.subrange:	AbstractProduction [ Subrange ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ 
EvaluateSizeOfTypeExpression[Subrange, lc, fl, cs, targetType]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ 
EvaluateFirstOfTypeExpression[Subrange, lc, fl, cs, targetType]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ 
EvaluateLastOfTypeExpression[Subrange, lc, fl, cs, targetType]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _
CompileSizeOfTypeExpression[Subrange, contextTree, cs, targetType]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ 
CompileFirstOfTypeExpression[Subrange, contextTree, cs, targetType]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ 
CompileLastOfTypeExpression[Subrange, contextTree, cs, targetType]
;

for TypeExp.pointer:	AbstractProduction [ Ordered, Base, PointerType ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of POINTER not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on POINTER types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on POINTER types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of POINTER not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on POINTER types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on POINTER types."]
;

for TypeExp.var:	AbstractProduction [ TypeExp ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of VAR not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on VAR types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on VAR types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of VAR not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on VAR types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on VAR types."]
;

for TypeExp.list:	AbstractProduction [ ReadOnly, TypeExp ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of LIST not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on LIST types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on LIST types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of LIST not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on LIST types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on LIST types."]
;

for TypeExp.array:	AbstractProduction [ Packed, OptType, TypeExp ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of ARRAY not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on ARRAY types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on ARRAY types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of ARRAY not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on ARRAY types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on ARRAY types."]
;

for TypeExp.descriptor:	AbstractProduction [ ReadOnly, TypeExp ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of DESCRIPTOR not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on DESCRIPTOR types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on DESCRIPTOR types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of DESCRIPTOR not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on DESCRIPTOR types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on DESCRIPTOR types."]
;

for TypeExp.transfer:	AbstractProduction [ Safe, TransferMode, Arguments ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of Transfer type not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on Transfer types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on Transfer types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of Transfer type not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on Transfer types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on Transfer types."]
;

for TypeExp.relative:	AbstractProduction [ TypeId, TypeExp ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of RELATIVE not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on RELATIVE types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on RELATIVE types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of RELATIVE not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on RELATIVE types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on RELATIVE types."]
;

for TypeExp.zone:	AbstractProduction [ Uncounted ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of ZONE not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on ZONE types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on ZONE types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of ZONE not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on ZONE types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on ZONE types."]
;

for TypeExp.long:	AbstractProduction [ TypeExp ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of LONG not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST of LONG not implemented yet."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST of LONG not implemented yet."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of LONG not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST of LONG not implemented yet."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST of LONG not implemented yet."]
;

for TypeExp.frame:	AbstractProduction [ Id ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of FRAME not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on FRAME types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on FRAME types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of FRAME not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on FRAME types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on FRAME types."]
;

for TypeExp.painted:	AbstractProduction [ TypeId, TypeExp ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of PAINTED not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on PAINTED types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on PAINTED types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of PAINTED not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on PAINTED types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on PAINTED types."]
;

for TypeExp.typeapply:	AbstractProduction [ TypeApply ]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of TypeApply not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on TypeApply types."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on TypeApply types."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of TypeApply not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST is not a valid operation on TypeApply types."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST is not a valid operation on TypeApply types."]
;


for Subrange.named: AbstractProduction [TypeId, Interval]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of Named subrange not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST of Named subrange not implemented yet."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST of Named subrange not implemented yet."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of Named subrange not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST of Named subrange not implemented yet."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST of Named subrange not implemented yet."]
;
for Subrange.unnamed: AbstractProduction [Interval]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _
EvaluateSizeOfTypeExpression[Interval, lc, fl, cs, targetType]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _
EvaluateFirstOfTypeExpression[Interval, lc, fl, cs, targetType]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _
EvaluateLastOfTypeExpression[Interval, lc, fl, cs, targetType]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _
CompileSizeOfTypeExpression[Interval, contextTree, cs, targetType]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _
CompileFirstOfTypeExpression[Interval, contextTree, cs, targetType]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _
CompileLastOfTypeExpression[Interval, contextTree, cs, targetType]
;
for Interval.cc: AbstractProduction [Bounds]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of interval not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _
First[targetType]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _
Last[targetType]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of interval not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ 
First[targetType]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _  
Last[targetType]
;

for Interval.co: AbstractProduction [Bounds]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of interval not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _
First[targetType]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _
Pred[Last[targetType]]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of interval not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ 
First[targetType]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _  
Pred[Last[targetType]]
;

for Interval.oc: AbstractProduction [Bounds]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of interval not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _
Succ[First[targetType]]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _
Last[targetType]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of interval not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ 
Succ[First[targetType]]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _  
Last[targetType]
;

for Interval.oo: AbstractProduction [Bounds]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of interval not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _
Succ[First[targetType]]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _
Pred[Last[targetType]]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of interval not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ 
Succ[First[targetType]]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _  
Pred[Last[targetType]]
;

for TypeId.id: AbstractProduction [Id]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of id not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ First[tgn]
where <access, tgn> _ DemandTypeDeclarationField[field2]
where field2 _ if FieldExists[field1]
then field1
else LookupNameInContextRib[Id, ParentRib[lc]]
where field1 _ LookupNameInFieldList[fl, Id]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ Last[tgn]
where <access, tgn> _ DemandTypeDeclarationField[field2]
where field2 _ if FieldExists[field1]
then field1
else LookupNameInContextRib[Id, ParentRib[lc]]
where field1 _ LookupNameInFieldList[fl, Id]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of id not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ First[tgn]
where <access, tgn> _ DemandTypeDeclarationField[field]
where field _ LookupNameInContextRib[Id, Rib[contextTree]]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ Last[tgn]
where <access, tgn> _ DemandTypeDeclarationField[field]
where field _ LookupNameInContextRib[Id, Rib[contextTree]]
;

for TypeId.qualifier: AbstractProduction [TypeId, Id]
let EvaluateSizeOfTypeExpression[tree, lc, fl, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of TypeId.qualifier not implemented yet."]
let EvaluateFirstOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST of TypeId.qualifier not implemented yet."]
let EvaluateLastOfTypeExpression[tree, lc, fl, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST of TypeId.qualifier not implemented yet."]
let CompileSizeOfTypeExpression[tree, contextTree, cs, targetType] _ DummyBigINT[]
where err _ Error["SIZE of TypeId.qualifier not implemented yet."]
let CompileFirstOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["FIRST of TypeId.qualifier not implemented yet."]
let CompileLastOfTypeExpression[tree, contextTree, cs, targetType] _ MakeDummy[""]
where err _ Error["LAST of TypeId.qualifier not implemented yet."]
;



End.


xSaffronExpressionCompileMethods.ThreeC4
Copyright Σ 1988 by Xerox Corporation.  All rights reserved.
James Rauen, June 22, 1988 10:37:34 am PDT
Last edited by: James Rauen August 23, 1988 1:51:42 pm PDT

Methods for evaluating and compiling expressions.
the polymorphic operators must provide their own type checking; all others call CompileAndTypeCheckExpression.

we're not going to try simulating REAL arithmetic just now.
the targetTypes in the calls should be fixed...
the targetTypes in the calls should be fixed...
we're not going to try simulating REAL arithmetic just now.
the targetTypes in the calls should be fixed...
do we need to do a type check here?
let Compile[tree, contextTree, cs] _ <contextTree1, trash>
where trash _ 
let GetInitialValue[tree, tgn, contextTree, cs] _ 
<MakeDefaultMeValue[],FakeDamageContextTree[contextTree]>;
let GetInitialValue[tree, tgn, contextTree, cs] _ GetInitialValue[InitialValue, tgn, contextTree, cs];
let GetInitialValue[tree, tgn, contextTree, cs] _ GetInitialValue[InitialValue, tgn, contextTree, cs];
for InitialValue.trash:	AbstractProduction []
let GetInitialValue[tree, tgn, contextTree, cs] _ 
<MakeTrash[tgn],FakeDamageContextTree[contextTree]>;

for InitialValue.code:	AbstractProduction []
let GetInitialValue[tree, tgn, contextTree, cs] _ 
<MakeDummy["InitialValue.code"], FakeDamageContextTree[contextTree]>;

for InitialValue.exp:	AbstractProduction [Exp]
let GetInitialValue[tree, tgn, contextTree, cs] _ 
<MakeUnparsedValue[Exp], FakeDamageContextTree[contextTree]>;

for InitialValue.exp:	AbstractProduction [Exp]
let GetInitialValue[tree, tgn, contextTree, cs] _ 
CompileAndTypeCheckExpression[Exp, contextTree, cs, tgn];
is this correct (passing tgn)?

for InitialValue.block:	AbstractProduction [Checked, Inline, Block]
let GetInitialValue[tree, tgn, contextTree, cs] _ 
<MakeDummy["InitialValue.block"], FakeDamageContextTree[contextTree]>;

for InitialValue.machinecode:	AbstractProduction [Checked, CodeList]
let GetInitialValue[tree, tgn, contextTree, cs] _ 
<MakeDummy["InitialValue.machinecode"], FakeDamageContextTree[contextTree]>;

let CompileQualifiedExpression[tree, expValue, contextTree, cs, targetType] _ 
if IsTransferTGN[expType]
then (<value, contextTree1>
where value _ MakeDummy["Qualifier.prefixop"]
where contextTree1 _ FakeDamageContextTree[contextTree]
)
else if IsArrayTGN[expType]
then (<value, contextTree1>
where value _ MakeDummy["Qualifier.prefixop"]
where contextTree1 _ FakeDamageContextTree[contextTree]
)
else (<value, contextTree1>
where value _ MakeDummy["Qualifier.prefixop"]
where contextTree1 _ FakeDamageContextTree[contextTree]
)
where expType _ Type[expValue]


Κ2D˜™'Icode™<K™*K™:K™—Ilead1™1L˜KšΠizœM˜TK˜šΟnœœ˜$K˜Jš
œn™nJ™
codetabšΟb
Πbnœœ˜>šœ4˜7š
œ˜šœ˜Mš
œ
Οtœ‘œ‘œ
‘
œ
˜?Mšœ
‘œ‘œ‘œ˜?—Mš
œ˜—Mšœ
‘œ˜&Mšœ
‘œ˜&MšœE˜JMšœD˜I—šœN˜Qšœ	˜Mšœ`˜bšœ"Οkœ™;šœ˜šœ˜Mš
œ
‘œ‘œ‘œ
‘
œ
˜?Mšœ
‘œ‘œ‘œ˜?—Mš
œ˜—šœ
‘œ
‘ΠctΟc
£˜GMšœ‘D˜QMšœ˜Mšœ˜šœœ˜Mšœ˜Mšœ˜—M˜
———Mšœ˜Mšœ˜Mšœ
‘œ˜&Mšœ
‘œ˜&šœ ˜%Mš
œ:˜:—šœ ˜%Mš
œ8˜8—Mšœœ™/—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ5˜:—M˜
M˜—šŸ
 œœ˜3šœ4˜7š
œ˜šœ˜Mšœ‘˜Mšœ
‘˜$—Mš
œ˜—Mšœ
‘œ˜&Mšœ?˜D—šœN˜Qšœ	˜šœ-˜/šœ˜šœ˜Mšœ‘˜Mšœ
‘˜$—Mš
œ˜—šœ
‘œ
‘£€
£˜Gšœ˜
šœ˜Mšœ
‘œ˜2Mšœ
‘œ˜4——Mšœ˜M˜
———Mšœ˜Mšœ
‘œ˜&šœ ˜%Mš
œ3˜3—Mšœœ™/—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ5˜:—M˜
M˜—šŸ
 œœ ˜Cšœ4˜7š
œ˜šœ˜Mš
œ
‘œ‘œ‘œ
‘
œ
˜?šœ
œ˜Mš	œ
‘œ‘œ‘œ
‘
˜>Mšœ‘œ‘œ
‘˜?——Mš
œ˜—Mšœ
‘œ˜&Mšœ
‘œ˜&MšœE˜JMšœD˜I—šœN˜Qšœ	˜šœ`˜bšœ˜šœ˜Mš
œ
‘œ‘œ‘œ
‘
œ
˜?šœ
œ˜Mš	œ
‘œ‘œ‘œ
‘
˜>Mšœ‘œ‘œ
‘˜?——Mš
œ˜—šœ
‘œ
‘£€
£˜GMšœ‘D˜QMšœ˜Mšœ˜šœ˜šœ˜Mšœ˜—šœ
œ˜Mšœ˜—Mšœ˜—M˜
—Mšœ"’œ™;——Mšœ˜Mšœ˜Mšœ
‘œ˜&Mšœ
‘œ˜&šœ ˜%Mš
œ:˜:—šœ ˜%Mš
œ8˜8—Mšœœ™/—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ5˜:—M˜
M˜—šŸ
 œœ˜6šœ4˜7Mšœ‘*œ‘
˜DMšœE˜JMšœD˜IMšœ&˜+—šœN˜Qšœ	˜šœ˜!Mšœ‘*œ‘
˜Išœ
‘œ‘
˜%Mšœ‘D˜QMšœ˜Mšœ˜Mšœ˜M˜
———šœ˜Mš
œC˜C—šœ˜Mš
œA˜A—Mšœ&˜+—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ-˜2—˜
M˜——šŸ
 œœ˜7šœ4˜7Mšœ‘+œ‘
˜EMšœE˜JMšœD˜IMšœ&˜+—šœN˜Qšœ	˜šœ˜!Mšœ‘+œ‘
˜Jšœ
‘œ‘
˜%Mšœ‘D˜QMšœ˜Mšœ˜Mšœ˜M˜
———šœ˜Mš
œC˜C—šœ˜Mš
œA˜A—Mšœ&˜+—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ.˜3—˜
M˜——šŸ
 œœ˜'šœ4˜7Mšœ‘œ‘
˜2Mšœ?˜DMšœ&˜+—šœN˜Qšœ	˜šœ
˜Mšœ‘œ‘
˜7šœ
‘œ‘
˜%Mšœ‘œ	‘˜;M˜
———šœ˜Mš
œ<˜<—Mšœ&˜+—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ.˜3—˜
M˜——šŸ
 œœ˜6MšœI˜LšœN˜QMšœ˜$Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ(˜-—˜
M˜——šŸ
 œœ)˜Ošœ4˜7šœL˜NMšœE˜IMšœE˜I—Mšœ&˜+—šœN˜Qšœ˜šœ˜šœ
œ˜MšœJ˜NMšœJ˜N—šœ
‘œ
‘£€
£˜WMšœC˜HMšœe˜jMšœe˜jM˜
———Mšœb˜gMšœ*˜/—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ-˜2—˜
M˜——šŸ
 
œœ+˜MMšœG˜JšœN˜QMšœ˜"Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ1˜6—˜
M˜——šŸ
 
œœ˜7šœI˜LMšœ5˜:—šœN˜QMšœ%˜*Mšœ8˜=šœœ˜&Mšœ˜Mšœ˜ —šœ˜!Mš
œ<˜<—Mšœ8˜=—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ5˜:—˜
M˜——šŸ
 œœ˜8šœI˜LMšœ:˜?—šœN˜QMšœ"˜'Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ>˜C—˜
M˜——šŸ
 œœ˜%šœ:˜=šœ
œ˜Mšœ˜
šœ˜Mšœ˜——M™#MšœC˜Hšœ
œ˜%Mšœ˜Mšœ*˜.—Mšœ'˜,—šœN˜QMšœ2˜7Mšœ;˜@Mšœ:˜?—MšœF˜I˜
M˜——šŸ
 œœ˜'šœ:˜=MšœF˜KMšœ
‘œ˜1—šœP˜SMšœ‘œ<˜KMšœ
‘œ˜1Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ.˜3—˜
M˜——šŸ
 
œœ˜-MšœG˜JšœN˜QMšœ˜"Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ.˜3—˜
M˜——šŸ
 	œœ
˜+MšœF˜IšœN˜QMšœ˜!Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ,˜1—˜
M˜——šŸ
 œœ	˜)MšœE˜HšœN˜QMšœ˜ Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ1˜6—˜
M˜——šŸ
 œœ	˜)MšœE˜HšœN˜QMšœ˜ Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ1˜6—˜
M˜——šŸ
 
œœ˜:MšœG˜JšœN˜QMšœ˜"Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ1˜6—˜
M˜——šŸ
 œœ˜5MšœI˜LšœN˜QMšœ˜$Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ3˜8—˜
M˜——šŸ
 	œœ˜@MšœF˜IšœN˜QMšœ˜!Mšœ3˜8—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ0˜5—˜
M˜——šŸ
 
œœ˜8MšœJ˜Mšœ8˜;Mš
œJ˜JMš
œV˜VM˜—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ>˜C—˜
M˜——šŸ
 œœ˜/MšœH˜KšœN˜QMšœ˜#Mšœ3˜8—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ<˜A—˜
M˜——šŸ
 œœ˜<MšœI˜LšœN˜QMšœ˜$Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ3˜8—˜
M˜——šŸ
 œœ˜-MšœD˜GšœN˜QMšœ˜Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ.˜3—˜
Mš
œ
˜
——šŸ
 œœ˜-MšœD˜GšœN˜QMšœ˜Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ.˜3—š
œ˜M˜——šŸ
 œœ(˜GšœI˜LMšœ1˜6—šœN˜QMšœ˜Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ.˜3—š
œ˜Mš
œ
˜
——šŸ
 œœ˜9šœI˜LMšœ2˜7—šœN˜QMšœ˜ Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ/˜4—š
œ˜M˜——šŸ
 œœ˜:šœI˜LMšœ6˜;—šœN˜QMšœ˜$Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ3˜8—š
œ˜M˜——šŸ
 œœ˜$MšœD˜GšœO˜RMšœ˜Mšœ2˜7—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ.˜3—š
œ˜M˜——Mšœ
˜M˜—˜$M˜šŸ
 
œœ˜6šœ4˜7šœœ˜,MšœF˜KM˜
—šœ
œ˜Mšœ?˜C—šœ
œ˜Mšœ>˜B—šœ
œœ˜0MšœE˜JM˜
—šœ˜Mšœ4˜9Mš
œ
˜
——šœ8˜;šœœ˜4Mšœ˜Mšœ2˜7MšœE˜JMš
œ
˜
—šœ
œœ˜:Mšœ2˜7MšœK˜PM˜
—šœ
œœ˜9Mšœ2˜7MšœI˜NM˜
—šœ
œœ˜8Mšœ˜Mšœ1˜6MšœD˜IMš
œ
˜
—šœ˜Mšœ˜Mšœ2˜7Mšœ3˜8Mš
œ
˜
——šœ2˜5Mšœ˜Mšœ#€˜>Mšœ1˜6—Mš
œ
˜
M˜—šŸ
 œœ˜,MšœE˜HšœN˜QMšœ˜ Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ/˜4—š
œ
˜
M˜——šŸ
 	œœ˜2MšœF˜IšœN˜QMšœ˜!Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ0˜5—Mš
œ
˜
M˜—šŸ
 œœ˜,MšœE˜HšœN˜QMšœ˜ Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ/˜4—Mš
œ
˜
M˜—šŸ
 	œœ˜2MšœF˜IšœN˜QMšœ˜!Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ0˜5—š
œ
˜
M˜——šŸ
 	œœ˜-MšœF˜IšœN˜QMšœ˜!Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ0˜5—š
œ
˜
M˜——šŸ
 
œœ˜3MšœG˜JšœN˜QMšœ˜"Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ1˜6—š
œ
˜
M˜——šŸ
 	œœ˜-MšœF˜IšœN˜QMšœ˜!Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ0˜5—š
œ
˜
Mš
œ
˜
——šŸ
 
œœ˜3MšœG˜JšœN˜QMšœ˜"Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ1˜6—š
œ
˜
Mš
œ
˜
——šŸ
 	œœ˜-MšœF˜IšœN˜QMšœ˜!Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ0˜5—š
œ
˜
Mš
œ
˜
——šŸ
 
œœ˜3MšœG˜JšœN˜QMšœ˜"Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ1˜6—š
œ
˜
M˜——šŸ
 
œœ˜3MšœG˜JšœN˜QMšœ˜"Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ1˜6—š
œ
˜
M˜——šŸ
 œœ˜+MšœH˜KšœN˜QMšœ˜#Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ,˜1—š
œ
˜
M˜——šŸ
 œœ
˜3MšœK˜NšœN˜QMšœ!˜&Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ*˜/—š
œ
˜
M˜——šŸ
 	œœ˜&MšœF˜IšœN˜QMšœ˜!Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ%˜*—š
œ
˜
Mš
œ
˜
——šŸ
 œœ˜8MšœI˜LšœN˜QMšœ˜$Mšœ1˜6—šœ2˜5Mšœ˜Mšœ#€˜>Mšœ3˜8—Mš
œ
˜
—K˜šŸœœ
˜0šœ@˜CMšœ
‘(˜.——šŸ
œœ˜,šœ?˜BMšœ
‘œ‘
œ‘˜*——šŸœœ‘œ
˜(šœ@˜CMšœ
‘ ˜&——K˜šŸœœ˜%Mšœ˜Mšœ˜—šŸœœ˜&Mšœ˜Mšœ˜M˜—šŸ
 œœ˜'Mšœ˜Mšœ˜Mšœ˜—šŸœœ˜(Mšœ˜Mšœ˜Mšœ˜—šŸœœ˜%Mšœ˜Mšœ˜Mšœ˜M˜—šŸ	œœ˜#Mšœ%˜(—šŸ	œœ˜#Mšœ%˜(—šŸ	œœ˜#Mšœ%˜(—šŸ	œœ˜#Mšœ%˜(—šŸ	œœ˜#Mšœ%˜(—šŸ	œœ˜#Mšœ%˜(M˜—šŸœœ˜/Mšœ%˜(Mšœ(˜+Mšœ+˜.™:M™—šœ/™2Mš
œ:™:—M˜
M˜—šŸœœ˜=Mšœ&˜)Mšœ'˜*Mšœ+˜.Mšœc™fM˜
M˜—šŸœœ˜@Mšœ&˜)Mšœ(˜+Mšœ*˜-Mšœc™fM˜
M˜—šŸœœ™-šœ/™2Mš
œ4™4—M™—šŸœœ™,šœ/™2Mš
œE™E—M™—šŸœœ™.šœ/™2Mš
œ=™=—M™—šŸœœ™.šœ/™2Mš
œ9™9M™—M™—šŸœœ™Cšœ/™2Mš
œF™F—M™—šŸœœ™Dšœ/™2Mš
œL™L—M™—˜M˜—šœ
žœœ˜&Mšœ˜Mšœ˜!Mšœ˜ Mšœ˜ M˜—šœ
žŸœœ˜'Mšœ˜ Mšœ˜ Mšœ˜ Mšœ˜ M˜—šœ
žŸœœ˜&Mšœ˜ Mšœ˜!Mšœ˜Mšœ˜ M˜—šœ
žŸœœ˜%Mšœ˜ Mšœ˜!Mšœ˜ Mšœ˜M˜—M˜šœ
žœœ˜5šœL˜OMš
œ ˜ M˜"M˜
—˜
M˜——šœ
ž
Ÿœœ	˜1šœL˜OMš
œ ˜ M˜"M˜
—M˜
M˜—šœ
ž
Ÿœœ˜)šœL˜OMš
œ ˜ M˜"M˜
—M˜
M˜—šœ
ž
Ÿœœ˜)šœL˜OMš
œ ˜ M˜"M˜
—M˜
M˜—šœ
ž
Ÿœœ˜*šœL˜OMš
œ ˜ M˜"M˜
—M˜
M˜—šœ
ž
Ÿœœ˜*šœL˜OMš
œ ˜ M˜"M˜
—M˜
M˜—šœ
ž
Ÿœœ˜*šœL˜OMš
œ ˜ M˜"M˜
—M˜
M˜—šœ
ž
 œœ˜8šœL˜OMš
œ˜M˜"M˜
—šœK™Nšœ™šœ™Mšœ(™-Mšœ2™7Mš
œ
™
——šœ
œ™šœ™Mšœ(™-Mšœ2™7Mš
œ
™
——šœ™Mšœ(™-Mšœ2™7Mš
œ
™
—Mšœ™—M˜
M˜—šœ
ž
Ÿœœ˜-šœL˜OMš
œ ˜ M˜"M˜
—M˜
M˜—šœ
ž
Ÿœœ˜-šœL˜OMš
œ ˜ M˜"M˜
—M˜
M˜—Mšœ
˜M˜—šžœœ˜"M˜šœ
žœœ)˜OšœK˜NMšœ3˜8—šœL˜OMšœ?˜D—šœK˜NMšœ>˜C—šœO˜RMšœ3˜8—šœP˜SMšœ?˜D—šœO˜RMšœ>˜C—M˜
M˜—šœ
ž
œœ˜:šœK˜NMšœ2˜7—šœL˜OMšœ>˜C—šœK˜NMšœ=˜B—šœO˜RMšœ2˜7—šœP˜SMšœ>˜C—šœO˜RMšœ=˜B—M˜
M˜—šœ
žœœ˜AšœK˜NMšœ5˜:—šœL˜OMšœA˜F—šœK˜NMšœ@˜E—šœO˜RMšœ5˜:—šœP˜SMšœA˜F—šœO˜RMšœ@˜E—M˜
M˜—šœ
žœœ"˜FšœK˜NMšœ7˜<—šœL˜OMšœ8˜=—šœK˜NMšœ7˜<—šœO˜RMšœ7˜<—šœP˜SMšœ8˜=—šœO˜RMšœ7˜<—M˜
M˜—šœ
žœœ˜9šœK˜NMšœ0˜5—šœL˜OMšœ<˜A—šœK˜NMšœ;˜@—šœO˜RMšœ0˜5—šœP˜SMšœ<˜A—šœO˜RMšœ;˜@—M˜
M˜—šœ
žœœ
˜3šœK˜NMšœ4˜9—šœL˜OMšœ@˜E—šœK˜NMšœ?˜D—šœO˜RMšœ4˜9—šœP˜SMšœ@˜E—šœO˜RMšœ?˜D—M˜
M˜—šœ
žœœ˜2šœK˜NMšœ<˜A—šœL˜OMšœH˜M—šœK˜NMšœG˜L—šœO˜RMšœ<˜A—šœP˜SMšœH˜M—šœO˜RMšœG˜L—M˜
M˜—šœ
žœœ˜1šœ>˜AMš
œ<˜<—šœ?˜BMš
œ=˜=—šœ>˜AMš
œ<˜<—šœA˜DMš
œ@˜@—šœC˜FMš
œA˜A—šœB˜EMš
œ@˜@—M˜
M˜—šœ
žœœ
˜5šœ>˜AMš
œ>˜>—šœ?˜BMš
œ?˜?—šœ>˜AMš
œ>˜>—šœA˜DMš
œB˜B—šœC˜FMš
œC˜C—šœB˜EMš
œB˜B—M˜
M˜—šœ
žœœ˜FšœK˜NMšœ4˜9—šœL˜OMšœ@˜E—šœK˜NMšœ?˜D—šœO˜RMšœ4˜9—šœP˜SMšœ@˜E—šœO˜RMšœ?˜D—M˜
M˜—šœ
žœœ˜/šœK˜NMšœ0˜5—šœL˜OMšœ<˜A—šœK˜NMšœ;˜@—šœO˜RMšœ0˜5—šœP˜SMšœ<˜A—šœO˜RMšœ;˜@—M˜
M˜—šœ
žœœ˜:šœK˜NMšœ1˜6—šœL˜OMšœ=˜B—šœK˜NMšœ<˜A—šœO˜RMšœ1˜6—šœP˜SMšœ=˜B—šœO˜RMšœ<˜A—M˜
M˜—šœ
ž
œœ˜BšœK˜NMšœ2˜7—šœL˜OMšœ>˜C—šœK˜NMšœ=˜B—šœO˜RMšœ2˜7—šœP˜SMšœ>˜C—šœO˜RMšœ=˜B—M˜
M˜—šœ
žœœ˜@šœK˜NMšœ7˜<—šœL˜OMšœC˜H—šœK˜NMšœB˜G—šœO˜RMšœ7˜<—šœP˜SMšœC˜H—šœO˜RMšœB˜G—M˜
M˜—šœ
žœœ"˜JšœK˜NMšœ:˜?—šœL˜OMšœA˜F—šœK˜NMšœ@˜E—šœO˜RMšœ:˜?—šœP˜SMšœA˜F—šœO˜RMšœ@˜E—M˜
M˜—šœ
žœœ˜<šœK˜NMšœ5˜:—šœL˜OMšœA˜F—šœK˜NMšœ@˜E—šœO˜RMšœ5˜:—šœP˜SMšœA˜F—šœO˜RMšœ@˜E—M˜
M˜—šœ
žœœ˜2šœK˜NMšœ1˜6—šœL˜OMšœ=˜B—šœK˜NMšœ<˜A—šœO˜RMšœ1˜6—šœP˜SMšœ=˜B—šœO˜RMšœ<˜A—M˜
M˜—šœ
žœœ˜0šœK˜NMšœ1˜6—šœL˜OMšœ2˜7—šœK˜NMšœ1˜6—šœO˜RMšœ1˜6—šœP˜SMšœ2˜7—šœO˜RMšœ1˜6—M˜
M˜—šœ
ž
œœ˜,šœK˜NMšœ2˜7—šœL˜OMšœ>˜C—šœK˜NMšœ=˜B—šœO˜RMšœ2˜7—šœP˜SMšœ>˜C—šœO˜RMšœ=˜B—M˜
M˜—šœ
žœœ˜;šœK˜NMšœ4˜9—šœL˜OMšœ@˜E—šœK˜NMšœ?˜D—šœO˜RMšœ4˜9—šœP˜SMšœ@˜E—šœO˜RMšœ?˜D—M˜
M˜—šœ
žœœ˜7šœK˜NMšœ6˜;—šœL˜OMšœB˜G—šœK˜NMšœA˜F—šœO˜RMšœ6˜;—šœP˜SMšœB˜G—šœO˜RMšœA˜F—M˜
M˜—M˜šœ
žœœ˜9šœK˜NMšœ;˜@—šœL˜OMšœ<˜A—šœK˜NMšœ;˜@—šœO˜RMšœ;˜@—šœP˜SMšœ<˜A—šœO˜RMšœ;˜@—M˜
M™—šœ
žœœ˜3šœ=˜@Mš
œ>˜>—šœ>˜AMš
œ?˜?—šœ=˜@Mš
œ>˜>—šœA˜DMš
œB˜B—šœB˜EMš
œC˜C—šœA˜DMš
œB˜B—M˜
M™—šœ
žœœ	˜,šœK˜NMšœ5˜:—šœ>˜AMš
œ˜—šœ=˜@Mš
œ˜—šœO˜RMšœ5˜:—šœC˜FMš
œ˜—šœC˜FMš
œ˜—M˜
M˜—šœ
žœœ	˜,šœK˜NMšœ5˜:—šœ>˜AMš
œ˜—šœ=˜@Mš
œ˜—šœO˜RMšœ5˜:—šœC˜FMš
œ˜—šœC˜FMš
œ˜—M˜
M˜—šœ
žœœ	˜,šœK˜NMšœ5˜:—šœ>˜AMš
œ˜—šœ=˜@Mš
œ˜—šœO˜RMšœ5˜:—šœC˜FMš
œ˜—šœC˜FMš
œ˜—M˜
M˜—šœ
žœœ	˜,šœK˜NMšœ5˜:—šœ>˜AMš
œ˜—šœ=˜@Mš
œ˜—šœO˜RMšœ5˜:—šœC˜FMš
œ˜—šœC˜FMš
œ˜—M˜
M˜—šœ
ž	œœ˜&šœK˜NMšœ/˜4—šœI˜LMšœ3˜8šœ
œ˜%Mšœ˜Mšœ*˜.—Mšœ'˜,—šœG˜JMšœ3˜8šœ
œ˜%Mšœ˜Mšœ*˜.—Mšœ'˜,—šœO˜RMšœ/˜4—šœM˜PMšœ2˜7Mšœ5˜:—šœK˜NMšœ2˜7Mšœ5˜:—M˜
M˜—šœ
žœœ
˜5šœK˜NMšœ=˜B—šœL˜OMšœ>˜C—šœK˜NMšœ=˜B—šœO˜RMšœ=˜B—šœP˜SMšœ>˜C—šœO˜RMšœ=˜B—M˜
M˜M˜—M˜Mšœ
˜K˜——…—σ:/φ