Value *newEnvValue(Env *parent) {
newEnvValueC++;
Value *res = allocValue();
res->type = ENV_VALUE_TYPE;
res->data = newEnv(parent ? parent->envValue : newNoneValue(), res);
res->mark = UNMARKED;
envPutLocal(res->data, getIntId("this"), res);
return res;
}
void CRunGui::createActions()
{
newEnvAct = new QAction(tr("&New Environment"), this);
newEnvAct->setShortcut(tr("Ctrl+N"));
newEnvAct->setStatusTip(tr("Create a new environment"));
connect(newEnvAct, SIGNAL(triggered()), this, SLOT(newEnv()));
openEnvAct = new QAction(tr("&Open Environment..."), this);
openEnvAct->setShortcut(tr("Ctrl+O"));
openEnvAct->setStatusTip(tr("Open an existing environment"));
connect(openEnvAct, SIGNAL(triggered()), this, SLOT(openEnv()));
saveEnvAct = new QAction(tr("&Save Environment"), this);
saveEnvAct->setShortcut(tr("Ctrl+S"));
saveEnvAct->setStatusTip(tr("Save the environment to disk"));
connect(saveEnvAct, SIGNAL(triggered()), this, SLOT(saveEnv()));
saveEnvAsAct = new QAction(tr("Save &Environment As..."), this);
saveEnvAsAct->setShortcut(tr("Ctrl+E"));
saveEnvAsAct->setStatusTip(tr("Save the environment to disk"));
connect(saveEnvAsAct, SIGNAL(triggered()), this, SLOT(saveEnvAs()));
exitAct = new QAction(tr("E&xit"), this);
exitAct->setShortcut(tr("Ctrl+Q"));
exitAct->setStatusTip(tr("Exit the application"));
connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));
saveAggrStatsAct = new QAction(tr("Save &Aggregated Statistics"), this);
saveAggrStatsAct->setShortcut(tr("Ctrl+A"));
saveAggrStatsAct->setStatusTip(tr("Saves various aggregated statistics into a text file."));
connect(saveAggrStatsAct, SIGNAL(triggered()), this, SLOT(saveAggrStats()));
saveTimeStatsAct = new QAction(tr("Save &Time Statistics"), this);
saveTimeStatsAct->setShortcut(tr("Ctrl+T"));
saveTimeStatsAct->setStatusTip(tr("Saves various time dependent statistics into a .csv file."));
connect(saveTimeStatsAct, SIGNAL(triggered()), this, SLOT(saveTimeStats()));
saveHistStatsAct = new QAction(tr("Save &Histogram Statistics"), this);
saveHistStatsAct->setShortcut(tr("Ctrl+H"));
saveHistStatsAct->setStatusTip(tr("Saves data for view in histogram graph."));
connect(saveHistStatsAct, SIGNAL(triggered()), this, SLOT(saveHistStats()));
aboutAct = new QAction(tr("&About"), this);
aboutAct->setStatusTip(tr("Show the application's About box"));
connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));
}
void Environment::SetEnv(const TCHAR* key, const TCHAR* value)
{
assert(key);
assert(value);
std::pair<size_t, size_t> keyPos = FindKey(m_env, key);
std::vector<TCHAR> newEnv(m_env.begin(), m_env.begin()+keyPos.first);
AppendEntry(newEnv, key, value);
newEnv.insert(newEnv.end(), m_env.begin()+keyPos.second, m_env.end());
m_env.swap(newEnv);
}
int checkPointExtRuleSet( Region *r ) {
ruleEngineConfig.extFuncDescIndex = newEnv( newHashTable2( 100, r ), ruleEngineConfig.extFuncDescIndex, NULL, r );
return ruleEngineConfig.extRuleSet->len;
}
vector<MamaInstruction> LetRecNode::codeV(const Environment &e, int sd) const {
ENTERED("codeV");
typedef MamaInstruction MI;
if (!_isProgram && _decls.empty() && _compiler.testFlag(Compiler::OptimizeUseless)) {
return _expr->codeV(e, sd);
}
/*
Slide 53:
codeV(letrec y_1 = e_1 ; ... ; y_n = e_n in expr) env sd =
alloc n
e_1->codeC(newEnv, sd + n)
rewrite n
...
e_n->codeC(newEnv, sd + n)
rewrite 1
expr->codeV(newEnv, sd + n)
slide n
where newEnv = env U { y_i -> (L, sd + i) | i = 1, ..., n }
*/
// Initialize the new environment
Environment newEnv(e);
set<RDecl*> *makeClosures = 0;
if (_compiler.testFlag(Compiler::OptimizeLetRecDecls)) {
for (unsigned i = 1; i <= _decls.size(); i++) {
newEnv.addLocal(_decls.at(i - 1)->alias, sd + i);
}
} else {
makeClosures = new set<RDecl*>();
for (unsigned i = 1; i <= _decls.size(); i++) {
newEnv.addLocal(_decls.at(i - 1)->alias, sd + i);
for (unsigned j = i + 1; j < _decls.size(); j++) {
if (_decls.at(i - 1)->expr->usesVariable(_decls.at(j)->alias)) {
makeClosures->insert(_decls.at(i - 1));
break;
}
}
}
}
vector<MI> r;
const int n = _decls.size();
int j = n;
if (n != 0 || !_compiler.testFlag(Compiler::OptimizeUseless)) {
r.push_back(MI(MI::ALLOC, n) << sd); // alloc n
}
if (makeClosures == 0 || makeClosures->size() == _decls.size()) {
for (VRNCI it = _decls.begin(); it != _decls.end(); it++, j--) {
r += (*it)->expr->codeC(newEnv, sd + n); // e_i->codeC(newEnv, sd + n)
r.push_back(MI(MI::REWRITE, j) << sd); // rewrite
}
if (makeClosures != 0) delete makeClosures;
} else {
for (VRNCI it = _decls.begin(); it != _decls.end(); it++, j--) {
if (makeClosures->find(*it) != makeClosures->end()) {
r += (*it)->expr->codeC(newEnv, sd + n); // e_i->codeC(newEnv, sd + n)
} else {
r += (*it)->expr->codeC(newEnv, sd + n); // e_i->codeV(newEnv, sd + n)
}
r.push_back(MI(MI::REWRITE, j) << sd); // rewrite
}
delete makeClosures;
}
r += _expr->codeV(newEnv, sd + n); // expr->codeV(newEnv, sd + n)
if (n != 0 || !_compiler.testFlag(Compiler::OptimizeUseless)) {
r.push_back(MI(MI::SLIDE, n)); // slide n
}
if (_isProgram) r.push_back(MI(MI::HALT)); // halt
return r /= "letrec_V";
}
Env *defaultEnv( Region *r ) {
Env *global = newEnv( newHashTable2( 10, r ), NULL, NULL, r );
Env *env = newEnv( newHashTable2( 10, r ), global, NULL, r );
return env;
}
/* call an action with actionName and string parameters */
Res *computeExpressionWithParams( const char *actionName, const char **params, int paramsCount, ruleExecInfo_t *rei, int reiSaveFlag, msParamArray_t *msParamArray, rError_t *errmsg, Region *r ) {
#ifdef DEBUG
char buf[ERR_MSG_LEN > 1024 ? ERR_MSG_LEN : 1024];
snprintf( buf, 1024, "computExpressionWithParams: %s\n", actionName );
writeToTmp( "entry.log", buf );
#endif
/* set clearDelayed to 0 so that nested calls to this function do not call clearDelay() */
int recclearDelayed = ruleEngineConfig.clearDelayed;
ruleEngineConfig.clearDelayed = 0;
if ( overflow( actionName, MAX_NAME_LEN ) ) {
addRErrorMsg( errmsg, RE_BUFFER_OVERFLOW, "error: potential buffer overflow" );
return newErrorRes( r, RE_BUFFER_OVERFLOW );
}
int k;
for ( k = 0; k < paramsCount; k++ ) {
if ( overflow( params[k], MAX_RULE_LEN ) ) {
addRErrorMsg( errmsg, RE_BUFFER_OVERFLOW, "error: potential buffer overflow" );
return newErrorRes( r, RE_BUFFER_OVERFLOW );
}
}
Node** paramNodes = ( Node ** )region_alloc( r, sizeof( Node * ) * paramsCount );
int i;
for ( i = 0; i < paramsCount; i++ ) {
Node *node;
/*Pointer *e = newPointer2(params[i]);
if(e == NULL) {
addRErrorMsg(errmsg, -1, "error: can not create Pointer.");
return newErrorRes(r, -1);
}
node = parseTermRuleGen(e, 1, errmsg, r);*/
node = newNode( TK_STRING, params[i], 0, r );
/*if(node==NULL) {
addRErrorMsg(errmsg, OUT_OF_MEMORY, "error: out of memory.");
return newErrorRes(r, OUT_OF_MEMORY);
} else if (getNodeType(node) == N_ERROR) {
return newErrorRes(r, RES_ERR_CODE(node));
}*/
paramNodes[i] = node;
}
Node *node = createFunctionNode( actionName, paramNodes, paramsCount, NULL, r );
Env *global = newEnv( newHashTable2( 10, r ), NULL, NULL, r );
Env *env = newEnv( newHashTable2( 10, r ), global, NULL, r );
if ( msParamArray != NULL ) {
convertMsParamArrayToEnv( msParamArray, global, r );
deleteFromHashTable(global->current, "ruleExecOut");
}
Res *res = computeNode( node, NULL, env, rei, reiSaveFlag, errmsg, r );
/* deleteEnv(env, 3); */
if ( recclearDelayed ) {
clearDelayed();
}
ruleEngineConfig.clearDelayed = recclearDelayed;
return res;
}
