Value *valueSub(Value *v1, Value *v2) {
if (v1->type != INT_VALUE_TYPE || v2->type != INT_VALUE_TYPE)
error("- operator only works for int");
return newIntValue((long)v1->data - (long)v2->data);
}
void AccumulateInherit (Environment globEnv) {
/* on entry:
The internal representations of all single accumulating computations
have been associated to the properties AccuLhs, AccuExecListe,
AccuDepList of the computation key.
The other Accu-properties are set.
The inheritance relation in the computation scopes are established.
The attribute types are determined.
on exit:
AccuInheritAtTreeSymbs collects for every TREE symbol the inherited
accumulated computations.
for every rule
the rule the accumulating rule computations are collected, and
for every symbol occurrence symocc
the accumulating computations are instantiated from the corresponding
TREE symbols.
*/
RuleProdList rules;
#ifdef ACCUTEST
printf("AccumulateInherit begin\n");
#endif
ex42 = newIntValue (42, ZeroCoord);
AccuInheritAtTreeSymbs (globEnv);
/* for each accu. attr. of each TREE symbol all computations inherited
from CLASS symbols are combined in the 3 accu properties of the TREE symbol
now
instantiate the computations from TREE symbols to symbol occurrences:
*/
/* step through all productions: */
rules = GrammarRules;
while (rules != NULLRuleProdList)
{ RuleProd rule = HeadRuleProdList (rules);
ProdSymbolList prod = rule->prod;
DefTableKey ruleKey = RuleKeyOfRuleProd (rule);
Binding rulecomp;
Environment ruleScope = GetLowerScope (ruleKey, NoEnv);
int symbolIndex = -1;
#ifdef ACCUTEST
printf ("RULE %s:\n",
StringTable (GetNameSym (ruleKey, 0)));
#endif
/* search the rule attributes for accumulating computations: */
rulecomp = DefinitionsOf(ruleScope);
while (rulecomp != NoBinding)
{ if (GetIsAccu (KeyOf (rulecomp), 0)) {
/* The computations for this attribute have been accumulated
in three properties; combine them into one assign: */
ResetCompRepr
(KeyOf (rulecomp), MakeAccuAssign (KeyOf (rulecomp)));
}
rulecomp = NextDefinition(rulecomp);
}
/* step through all nonterminal occurrences of this production: */
while (prod != NULLProdSymbolList) {
ProdSymbol sy = HeadProdSymbolList (prod);
DefTableKey symKey = sy->u.s.symbolkey;
if (sy->kind != IsProdLiteral && !GetIsTerm (symKey, 0)) {
Environment syCompScope = sy->u.s.scope;
Environment attrenv = GetAttrScope (symKey, NoEnv);
Binding attr = DefinitionsOf (attrenv);
symbolIndex++;
#ifdef ACCUTEST
printf (" symbol no. %d %s\n", symbolIndex,
StringTable (GetNameSym (symKey, 0)));
#endif
/* search all attributes of this symbol for accumulating ones: */
while (attr != NoBinding) {
if (GetHasAccuAsgn (KeyOf (attr), 0) &&
((symbolIndex > 0 &&
GetAttrClass (KeyOf (attr), NoClass) == INHClass) ||
(symbolIndex == 0 &&
GetAttrClass (KeyOf (attr), NoClass) == SYNTClass))) {
int attrId = IdnOf (attr);
/* symbol symKey has an accumulating attribute named attrId */
Binding symOccAttrComp = BindingInEnv (syCompScope, attrId);
Binding symAttrComp;
PExpr assign;
#ifdef ACCUTEST
printf (" attribute %s.%s\n",
StringTable (GetNameSym (symKey, 0)),
StringTable (GetNameSym (KeyOf (attr), 0)));
#endif
if (symOccAttrComp == NoBinding) {
/* no computation exists for this attr at all, create one: */
symOccAttrComp =
MakeAnAccuBinding (syCompScope, attr, ruleKey, ZeroCoord);
ResetCompRepr (KeyOf (symOccAttrComp),
newAssign (newAttrAccRule (sy, KeyOf (attr), 0, ZeroCoord),
ex42, ZeroCoord));
} else if (EnvOf (symOccAttrComp) != syCompScope) {
/* there are computations to be inherited */
/* there is no computation in the symbol occurrence,
we create one: */
symAttrComp = symOccAttrComp;
symOccAttrComp =
MakeAnAccuBinding (syCompScope, attr, ruleKey,
GetCoord (KeyOf (symAttrComp), ZeroCoord));
ResetInheritedFrom (KeyOf (symOccAttrComp), symAttrComp);
assign =
copyExpr (MakeAccuAssign (KeyOf (symAttrComp)));
instantiateExpr (assign, rule, sy);
ResetCompRepr (KeyOf (symOccAttrComp), assign);
ResetIsBottomUp (KeyOf(symOccAttrComp),
GetIsBottomUp (KeyOf(symAttrComp), 0));
} else {
symAttrComp = OverridesBinding (symOccAttrComp);
if (symAttrComp == NoBinding) {
/* there are no symbol computations,
combine the 3 properties in rule context:
*/
ResetCompRepr (KeyOf (symOccAttrComp),
MakeAccuAssign (KeyOf (symOccAttrComp)));
} else {
/* There are properties in symbol context (symAttrComp)
and 3 properties in the symbol occurrence (symOccAttrComp).
Instantiate the symbol computation:
*/
assign = copyExpr (MakeAccuAssign (KeyOf(symAttrComp)));
instantiateExpr (assign, rule, sy);
/* decompose assign onto symOccAttrComp: */
AccumulateExpr (KeyOf (symOccAttrComp), assign);
/* compose the 3 properties into an assign: */
assign = MakeAccuAssign (KeyOf (symOccAttrComp));
ResetCompRepr (KeyOf (symOccAttrComp), assign);
}
}
}/* an accumulating attribute of the symbol occurrence */
attr = NextDefinition (attr);
}/* the attributes of the symbol occurrence */
}/* is a non-terminal occurrence in the rule */
if (rule->islistof) break; /* lhs only */
prod = TailProdSymbolList (prod);
}/* all rule elements */
rules = TailRuleProdList (rules);
}/* all rules */
#ifdef ACCUTEST
printf("AccumulateInherit end\n");
#endif
}/* AccumulateInherit */
