/**
* Search the environment for the definition of a symbol
* ID and evaluate it. Detects recursive definitions using
* a set of visited IDxENV. Associates the symbol as a definition name
* property of the definition.
* @param id the symbol ID t-o search
* @param visited set of visited symbols (used for recursive definition detection)
* @param lenv the environment where to search
* @return the evaluated definition of ID
*/
static Tree evalIdDef(Tree id, Tree visited, Tree lenv)
{
Tree def = NULL;
Tree name = NULL;
// search the environment env for a definition of symbol id
while (!isNil(lenv) && !getProperty(lenv, id, def)) {
lenv = lenv->branch(0);
}
// check that the definition exists
if (isNil(lenv)) {
evalerror(getDefFileProp(id), getDefLineProp(id), "undefined symbol", id);
}
//cerr << "Id definition is " << *def << endl;
// check that it is not a recursive definition
Tree p = cons(id,lenv);
// set the definition name property
assert(def);
if (!getDefNameProperty(def, name)) {
// if the definition has no name use the identifier
stringstream s; s << boxpp(id);
//XXXXXX setDefNameProperty(def, s.str());
}
// return the evaluated definition
return eval(def, addElement(p,visited), gGlobal->nil);
}
/**
* Add a definition (as a property) to the current top level layer. Check
* and warn for multiple definitions.
* @param id the symbol id to be defined
* @param def the definition to be binded to the symbol id
* @param lenv the environment where to add this new definition
*/
static void addLayerDef(Tree id, Tree def, Tree lenv)
{
// check for multiple definitions of a symbol in the same layer
Tree olddef;
if(getProperty(lenv, id, olddef))
{
if(def == olddef)
{
evalwarning(getDefFileProp(id), getDefLineProp(id), "equivalent re-definitions of", id);
}
else
{
fprintf(stderr, "%s:%d: ERROR: redefinition of symbols are not allowed : ", getDefFileProp(id), getDefLineProp(id));
print(id, stderr);
fprintf(stderr, " is already defined in file \"%s\" line %d \n", getDefFileProp(id), getDefLineProp(id));
gErrorCount++;
}
}
setProperty(lenv, id, def);
}
static Tree realeval (Tree exp, Tree visited, Tree localValEnv)
{
//Tree def;
Tree fun;
Tree arg;
Tree var, num, body, ldef;
Tree label;
Tree cur, lo, hi, step;
Tree e1, e2, exp2, notused, visited2, lenv2;
Tree rules;
Tree id;
//cerr << "EVAL " << *exp << " (visited : " << *visited << ")" << endl;
//cerr << "REALEVAL of " << *exp << endl;
xtended* xt = (xtended*) getUserData(exp);
// constants
//-----------
if ( xt ||
isBoxInt(exp) || isBoxReal(exp) ||
isBoxWire(exp) || isBoxCut(exp) ||
isBoxPrim0(exp) || isBoxPrim1(exp) ||
isBoxPrim2(exp) || isBoxPrim3(exp) ||
isBoxPrim4(exp) || isBoxPrim5(exp) ||
isBoxFFun(exp) || isBoxFConst(exp) || isBoxFVar(exp) ||
isBoxWaveform(exp)) {
return exp;
// block-diagram constructors
//---------------------------
} else if (isBoxSeq(exp, e1, e2)) {
return boxSeq(eval(e1, visited, localValEnv), eval(e2, visited, localValEnv));
} else if (isBoxPar(exp, e1, e2)) {
return boxPar(eval(e1, visited, localValEnv), eval(e2, visited, localValEnv));
} else if (isBoxRec(exp, e1, e2)) {
return boxRec(eval(e1, visited, localValEnv), eval(e2, visited, localValEnv));
} else if (isBoxSplit(exp, e1, e2)) {
return boxSplit(eval(e1, visited, localValEnv), eval(e2, visited, localValEnv));
} else if (isBoxMerge(exp, e1, e2)) {
return boxMerge(eval(e1, visited, localValEnv), eval(e2, visited, localValEnv));
// Modules
//--------
} else if (isBoxAccess(exp, body, var)) {
Tree val = eval(body, visited, localValEnv);
if (isClosure(val, exp2, notused, visited2, lenv2)) {
// it is a closure, we have an environment to access
return eval(closure(var,notused,visited2,lenv2), visited, localValEnv);
} else {
evalerror(getDefFileProp(exp), getDefLineProp(exp), "no environment to access", exp);
}
//////////////////////en chantier////////////////////////////
} else if (isBoxModifLocalDef(exp, body, ldef)) {
Tree val = eval(body, visited, localValEnv);
if (isClosure(val, exp2, notused, visited2, lenv2)) {
// we rebuild the closure using a copy of the original environment
// modified with some new definitions
Tree lenv3 = copyEnvReplaceDefs(lenv2, ldef, visited2, localValEnv);
return eval(closure(exp2,notused,visited2,lenv3), visited, localValEnv);
} else {
evalerror(getDefFileProp(exp), getDefLineProp(exp), "not a closure", val);
evalerror(getDefFileProp(exp), getDefLineProp(exp), "no environment to access", exp);
}
///////////////////////////////////////////////////////////////////
} else if (isBoxComponent(exp, label)) {
string fname = tree2str(label);
Tree eqlst = gGlobal->gReader.expandlist(gGlobal->gReader.getlist(fname));
Tree res = closure(boxIdent("process"), gGlobal->nil, gGlobal->nil, pushMultiClosureDefs(eqlst, gGlobal->nil, gGlobal->nil));
setDefNameProperty(res, label);
//cerr << "component is " << boxpp(res) << endl;
return res;
} else if (isBoxLibrary(exp, label)) {
string fname = tree2str(label);
Tree eqlst = gGlobal->gReader.expandlist(gGlobal->gReader.getlist(fname));
Tree res = closure(boxEnvironment(), gGlobal->nil, gGlobal->nil, pushMultiClosureDefs(eqlst, gGlobal->nil, gGlobal->nil));
setDefNameProperty(res, label);
//cerr << "component is " << boxpp(res) << endl;
return res;
// user interface elements
//------------------------
} else if (isBoxButton(exp, label)) {
const char* l1 = tree2str(label);
const char* l2 = evalLabel(l1, visited, localValEnv);
//cout << "button label : " << l1 << " become " << l2 << endl;
return ((l1 == l2) ? exp : boxButton(tree(l2)));
} else if (isBoxCheckbox(exp, label)) {
const char* l1 = tree2str(label);
const char* l2 = evalLabel(l1, visited, localValEnv);
//cout << "check box label : " << l1 << " become " << l2 << endl;
return ((l1 == l2) ? exp : boxCheckbox(tree(l2)));
} else if (isBoxVSlider(exp, label, cur, lo, hi, step)) {
const char* l1 = tree2str(label);
const char* l2 = evalLabel(l1, visited, localValEnv);
return ( boxVSlider(tree(l2),
tree(eval2double(cur, visited, localValEnv)),
tree(eval2double(lo, visited, localValEnv)),
tree(eval2double(hi, visited, localValEnv)),
tree(eval2double(step, visited, localValEnv))));
} else if (isBoxHSlider(exp, label, cur, lo, hi, step)) {
const char* l1 = tree2str(label);
const char* l2 = evalLabel(l1, visited, localValEnv);
return ( boxHSlider(tree(l2),
tree(eval2double(cur, visited, localValEnv)),
tree(eval2double(lo, visited, localValEnv)),
tree(eval2double(hi, visited, localValEnv)),
tree(eval2double(step, visited, localValEnv))));
} else if (isBoxNumEntry(exp, label, cur, lo, hi, step)) {
const char* l1 = tree2str(label);
const char* l2 = evalLabel(l1, visited, localValEnv);
return (boxNumEntry(tree(l2),
tree(eval2double(cur, visited, localValEnv)),
tree(eval2double(lo, visited, localValEnv)),
tree(eval2double(hi, visited, localValEnv)),
tree(eval2double(step, visited, localValEnv))));
} else if (isBoxVGroup(exp, label, arg)) {
const char* l1 = tree2str(label);
const char* l2 = evalLabel(l1, visited, localValEnv);
return boxVGroup(tree(l2), eval(arg, visited, localValEnv) );
} else if (isBoxHGroup(exp, label, arg)) {
const char* l1 = tree2str(label);
const char* l2 = evalLabel(l1, visited, localValEnv);
return boxHGroup(tree(l2), eval(arg, visited, localValEnv) );
} else if (isBoxTGroup(exp, label, arg)) {
const char* l1 = tree2str(label);
const char* l2 = evalLabel(l1, visited, localValEnv);
return boxTGroup(tree(l2), eval(arg, visited, localValEnv) );
} else if (isBoxHBargraph(exp, label, lo, hi)) {
const char* l1 = tree2str(label);
const char* l2 = evalLabel(l1, visited, localValEnv);
return boxHBargraph(tree(l2),
tree(eval2double(lo, visited, localValEnv)),
tree(eval2double(hi, visited, localValEnv)));
} else if (isBoxVBargraph(exp, label, lo, hi)) {
const char* l1 = tree2str(label);
const char* l2 = evalLabel(l1, visited, localValEnv);
return boxVBargraph(tree(l2),
tree(eval2double(lo, visited, localValEnv)),
tree(eval2double(hi, visited, localValEnv)));
// lambda calculus
//----------------
} else if (isBoxIdent(exp)) {
return evalIdDef(exp, visited, localValEnv);
} else if (isBoxWithLocalDef(exp, body, ldef)) {
return eval(body, visited, pushMultiClosureDefs(ldef, visited, localValEnv));
} else if (isBoxAppl(exp, fun, arg)) {
return applyList( eval(fun, visited, localValEnv),
revEvalList(arg, visited, localValEnv) );
} else if (isBoxAbstr(exp)) {
// it is an abstraction : return a closure
return closure(exp, gGlobal->nil, visited, localValEnv);
} else if (isBoxEnvironment(exp)) {
// environment : return also a closure
return closure(exp, gGlobal->nil, visited, localValEnv);
} else if (isClosure(exp, exp2, notused, visited2, lenv2)) {
if (isBoxAbstr(exp2)) {
// a 'real' closure
return closure(exp2, gGlobal->nil, setUnion(visited,visited2), lenv2);
} else if (isBoxEnvironment(exp2)) {
// a 'real' closure
return closure(exp2, gGlobal->nil, setUnion(visited,visited2), lenv2);
} else {
// it was a suspended evaluation
return eval(exp2, setUnion(visited,visited2), lenv2);
}
// Algorithmic constructions
//--------------------------
} else if (isBoxIPar(exp, var, num, body)) {
int n = eval2int(num, visited, localValEnv);
return iteratePar(var, n, body, visited, localValEnv);
} else if (isBoxISeq(exp, var, num, body)) {
int n = eval2int(num, visited, localValEnv);
return iterateSeq(var, n, body, visited, localValEnv);
} else if (isBoxISum(exp, var, num, body)) {
int n = eval2int(num, visited, localValEnv);
return iterateSum(var, n, body, visited, localValEnv);
} else if (isBoxIProd(exp, var, num, body)) {
int n = eval2int(num, visited, localValEnv);
return iterateProd(var, n, body, visited, localValEnv);
// static
} else if (isBoxInputs(exp, body)) {
int ins, outs;
Tree b = a2sb(eval(body, visited, localValEnv));
if (getBoxType (b, &ins, &outs)) {
return boxInt(ins);
} else {
stringstream error;
error << "ERROR : can't evaluate ' : " << *exp << endl;
throw faustexception(error.str());
}
} else if (isBoxOutputs(exp, body)) {
int ins, outs;
Tree b = a2sb(eval(body, visited, localValEnv));
if (getBoxType (b, &ins, &outs)) {
return boxInt(outs);
} else {
stringstream error;
error << "ERROR : can't evaluate ' : " << *exp << endl;
throw faustexception(error.str());
}
} else if (isBoxSlot(exp)) {
return exp;
} else if (isBoxSymbolic(exp)) {
return exp;
// Pattern matching extension
//---------------------------
} else if (isBoxCase(exp, rules)) {
return evalCase(rules, localValEnv);
} else if (isBoxPatternVar(exp, id)) {
return exp;
//return evalIdDef(id, visited, localValEnv);
} else if (isBoxPatternMatcher(exp)) {
return exp;
} else {
stringstream error;
error << "ERROR : EVAL doesn't intercept : " << *exp << endl;
throw faustexception(error.str());
}
return NULL;
}