/******************************************************************************
* OkApply(): OK or Apply button clicked.
******************************************************************************/
void Dir::okApply () {
m_searchAll = m_sui->searchAllDirsCheckBox->isChecked();
QFile file(CONFIG_FILE);
if (!file.open(QIODevice::ReadWrite)) {
boxError(QString(QObject::tr("Could not open configuration file '%1'."))
.arg(CONFIG_FILE));
return;
}
listWidget2List(m_sui->excludeListWidget, &m_right);
listWidget2List(m_sui->includeListWidget, &m_left);
positionAfterLine(file, "[Directories]");
list2File(file, m_left, "INCLUDE=");
list2File(file, m_right, "EXCLUDE=");
int b = 0;
b+=file.write("SEARCHALL=");
b+=file.write(m_searchAll ? "1" : "0");
for (int i = 0; i < 80 - b - 1; ++i)
file.write(" ");
file.write("\n");
file.close();
}
/**
* Apply a function to a list of arguments.
* Apply a function F to a list of arguments (a,b,c,...).
* F can be either a closure over an abstraction, or a
* pattern matcher. If it is not the case then we have :
* F(a,b,c,...) ==> (a,b,c,...):F
*
* @param fun the function to apply
* @param larg the list of arguments
* @return the resulting expression in normal form
*/
static Tree applyList (Tree fun, Tree larg)
{
Tree abstr;
Tree globalDefEnv;
Tree visited;
Tree localValEnv;
Tree envList;
Tree originalRules;
Tree revParamList;
Tree id;
Tree body;
Automaton* automat;
int state;
prim2 p2;
//cerr << "applyList (" << *fun << ", " << *larg << ")" << endl;
if (isNil(larg)) return fun;
if (isBoxError(fun) || isBoxError(larg)) {
return boxError();
}
if (isBoxPatternMatcher(fun, automat, state, envList, originalRules, revParamList)) {
Tree result;
int state2;
vector<Tree> envVect;
list2vec(envList, envVect);
//cerr << "applyList/apply_pattern_matcher(" << automat << "," << state << "," << *hd(larg) << ")" << endl;
state2 = apply_pattern_matcher(automat, state, hd(larg), result, envVect);
//cerr << "state2 = " << state2 << "; result = " << *result << endl;
if (state2 >= 0 && isNil(result)) {
// we need to continue the pattern matching
return applyList(
boxPatternMatcher(automat, state2, vec2list(envVect), originalRules, cons(hd(larg),revParamList)),
tl(larg) );
} else if (state2 < 0) {
stringstream error;
error << "ERROR : pattern matching failed, no rule of " << boxpp(boxCase(originalRules))
<< " matches argument list " << boxpp(reverse(cons(hd(larg), revParamList))) << endl;
throw faustexception(error.str());
} else {
// Pattern Matching was succesful
// the result is a closure that we need to evaluate.
if (isClosure(result, body, globalDefEnv, visited, localValEnv)) {
// why ??? return simplifyPattern(eval(body, nil, localValEnv));
//return eval(body, nil, localValEnv);
return applyList(eval(body, gGlobal->nil, localValEnv), tl(larg));
} else {
cerr << "wrong result from pattern matching (not a closure) : " << boxpp(result) << endl;
return boxError();
}
}
}
if (!isClosure(fun, abstr, globalDefEnv, visited, localValEnv)) {
// principle : f(a,b,c,...) ==> (a,b,c,...):f
int ins, outs;
// check arity of function
Tree efun = a2sb(fun);
//cerr << "TRACEPOINT 1 : " << boxpp(efun) << endl;
if (!getBoxType(efun, &ins, &outs)) { // on laisse comme ca pour le moment
// we can't determine the input arity of the expression
// hope for the best
return boxSeq(larg2par(larg), fun);
}
// check arity of arg list
if (!boxlistOutputs(larg, &outs)) {
// we don't know yet the output arity of larg. Therefore we can't
// do any arity checking nor add _ to reach the required number of arguments
// cerr << "warning : can't infere the type of : " << boxpp(larg) << endl;
return boxSeq(larg2par(larg), fun);
}
if (outs > ins) {
stringstream error;
error << "too much arguments : " << outs << ", instead of : " << ins << endl;
error << "when applying : " << boxpp(fun) << endl
<< "to : " << boxpp(larg) << endl;
throw faustexception(error.str());
}
if ((outs == 1)
&& (( isBoxPrim2(fun, &p2) && (p2 != sigPrefix))
|| (getUserData(fun) && ((xtended*)getUserData(fun))->isSpecialInfix()))) {
// special case : /(3) ==> _,3 : /
Tree larg2 = concat(nwires(ins-outs), larg);
return boxSeq(larg2par(larg2), fun);
} else {
Tree larg2 = concat(larg, nwires(ins-outs));
return boxSeq(larg2par(larg2), fun);
}
}
if (isBoxEnvironment(abstr)) {
evalerrorbox(yyfilename, -1, "an environment can't be used as a function", fun);
}
if (!isBoxAbstr(abstr, id, body)) {
evalerror(yyfilename, -1, "(internal) not an abstraction inside closure", fun);
}
// try to synthetise a name from the function name and the argument name
{
Tree arg = eval(hd(larg), visited, localValEnv);
Tree narg; if ( isBoxNumeric(arg,narg) ) { arg = narg; }
Tree f = eval(body, visited, pushValueDef(id, arg, localValEnv));
Tree fname;
if (getDefNameProperty(fun, fname)) {
stringstream s; s << tree2str(fname); if (!gGlobal->gSimpleNames) s << "(" << boxpp(arg) << ")";
setDefNameProperty(f, s.str());
}
return applyList(f, tl(larg));
}
}
