unsigned int Mission::createClassInstance( string modulename ) { missionNode *module_node = runtime.modules[modulename]; if (module_node == NULL) { fatalError( NULL, SCRIPT_RUN, "module "+modulename+" not found" ); assert( 0 ); } module_node->script.classinst_counter++; char buf[200]; sprintf( buf, "class counter for module %s : %d\n", modulename.c_str(), module_node->script.classinst_counter ); debug( 1, NULL, 0, buf ); varInstMap *cvmap = new varInstMap(); module_node->script.classvars.push_back( cvmap ); varInstMap *cvmap0 = module_node->script.classvars[0]; vsUMap< string, varInst* >::const_iterator iter; for (iter = cvmap0->begin(); iter != cvmap0->end(); iter++) { varInst *vi0 = (*iter).second; string vi0_name = (*iter).first; varInst *vi = newVarInst( VI_CLASSVAR ); vi->type = vi0->type; assignVariable( vi, vi0 ); (*cvmap)[vi0_name] = vi; } return module_node->script.classinst_counter; }
/******************************************************* * assign TRUE or FALSE for ALL literals * @param I the interpretation */ void generateRandomComplete(Interpretation I) { for(int i = 1;i<=I.size;i++) { int value; int v= rand()%2; if(v==0) value=FALSE; else value=TRUE; assignVariable(I,i,value); } }
void Mission::doArguments( missionNode *node, int mode, varInstMap *varmap ) { int nr_arguments = 0; if (mode == SCRIPT_PARSE) { if (parsemode == PARSE_DECL) { vector< easyDomNode* >::const_iterator siter; for (siter = node->subnodes.begin(); siter != node->subnodes.end(); siter++) { missionNode *snode = (missionNode*) *siter; if (snode->tag == DTAG_DEFVAR) { doDefVar( snode, mode ); nr_arguments++; } else { fatalError( node, mode, "only defvars allowed below argument node" ); assert( 0 ); } } node->script.nr_arguments = nr_arguments; } } nr_arguments = node->script.nr_arguments; if (mode == SCRIPT_RUN) { if (varmap) { int nr_called = varmap->size(); if (nr_arguments != nr_called) { fatalError( node, mode, "wrong number of args in doScript " ); assert( 0 ); } for (int i = 0; i < nr_arguments; i++) { missionNode *defnode = (missionNode*) node->subnodes[i]; doDefVar( defnode, mode ); varInst *vi = doVariable( defnode, mode ); varInst *call_vi = (*varmap)[defnode->script.name]; if (call_vi == NULL) { fatalError( node, mode, "argument var "+node->script.name+" no found in varmap" ); assert( 0 ); } assignVariable( vi, call_vi ); } } else //no varmap == 0 args if (nr_arguments != 0) { fatalError( node, mode, "doScript expected to be called with arguments" ); assert( 0 ); } } if (mode == SCRIPT_PARSE) { if (parsemode == PARSE_DECL) { missionNode *exec_scope = scope_stack.back(); exec_scope->script.nr_arguments = nr_arguments; node->script.nr_arguments = nr_arguments; } } }
void Mission::doReturn( missionNode *node, int mode ) { trace( node, mode ); if (mode == SCRIPT_PARSE) { missionNode *script = current_script; node->script.exec_node = script; } int len = node->subnodes.size(); varInst *vi = newVarInst( VI_LOCAL ); missionNode *script = node->script.exec_node; if (script->script.vartype == VAR_VOID) { if (len != 0) { fatalError( node, mode, "script returning void, but return statement with node" ); assert( 0 ); } } else { //return something non-void if (len != 1) { fatalError( node, mode, "return statement needs only one subnode" ); assert( 0 ); } missionNode *expr = (missionNode*) node->subnodes[0]; if (script->script.vartype == VAR_BOOL) { bool res = checkBoolExpr( expr, mode ); vi->bool_val = res; } else if (script->script.vartype == VAR_FLOAT) { double res = checkFloatExpr( expr, mode ); vi->float_val = res; } else if (script->script.vartype == VAR_INT) { int res = checkIntExpr( expr, mode ); vi->int_val = res; } else if (script->script.vartype == VAR_OBJECT) { varInst *vi2 = checkObjectExpr( expr, mode ); vi->type = VAR_OBJECT; assignVariable( vi, vi2 ); } else { fatalError( node, mode, "unkown variable type" ); assert( 0 ); } } if (mode == SCRIPT_RUN) { contextStack *cstack = runtime.cur_thread->exec_stack.back(); vi->type = script->script.vartype; cstack->return_value = vi; } }
int main(){ Formula f; Interpretation I; int clauses=rand()%20; int var=rand()%30; createFormula(&f, clauses, var); generateFullRandomFormula(&f,clauses,var); createAndInitializeInterpretation(&I, f.nbVariables); for (int i = 0; i < f.nbVariables; ++i) { assignVariable(I,i,rand()%2); } int randomValue= rand()%(f.nbClauses); printf("\nstatus of a random clause %d: %d",randomValue,statusClause(f.clauses[randomValue],I)); randomValue= rand()%(f.nbClauses); printf("\nsatifcation of a random clause %d : %d",randomValue,isSatisfiedClause(f.clauses[randomValue],I)); randomValue= rand()%(f.nbClauses); printf("\nfalsefcation of a random clause %d : %d",randomValue,isFalsifiedClause(f.clauses[randomValue],I)); randomValue= rand()%(f.nbClauses); printf("\nUndetermination of a random clause %d : %d",randomValue,isUndefClause(f.clauses[randomValue],I)); randomValue= rand()%(f.nbClauses); printf("\nUnit of a random clause %d : %d",randomValue,isUnit(f.clauses[randomValue],I)); printf("\nThe status of the fourmla is %d",statusFormula(f,I)); printf("\nSatification of the fourmla is %d",isSatisfiedFormula(f,I)); printf("\nFalefication of the fourmla is %d",isFalsifiedFormula(f,I)); printf("\nUndetermination of the fourmla is %d",isUndefFormula(f,I)); displayFormula(f,I); }
varInst* Mission::doExec( missionNode *node, int mode ) { trace( node, mode ); if (mode == SCRIPT_PARSE) { string name = node->attr_value( "name" ); if ( name.empty() ) { fatalError( node, mode, "you have to give name to exec" ); assert( 0 ); } node->script.name = name; string use_modstr = node->attr_value( "module" ); missionNode *module = NULL; missionNode *script = NULL; if ( !use_modstr.empty() ) { module = runtime.modules[use_modstr]; } else { module = current_module; } if (module == NULL) { fatalError( node, mode, "module "+use_modstr+" not found" ); assert( 0 ); } script = module->script.scripts[name]; if (script == NULL) { fatalError( node, mode, "script "+name+" not found in module "+use_modstr ); assert( 0 ); } node->script.exec_node = script; node->script.vartype = script->script.vartype; node->script.module_node = module; } missionNode *arg_node = node->script.exec_node->script.argument_node; int nr_arguments; if (arg_node == NULL) nr_arguments = 0; else nr_arguments = arg_node->script.nr_arguments; int nr_exec_args = node->subnodes.size(); if (nr_arguments != nr_exec_args) { char buffer[200]; sprintf( buffer, "wrong nr of arguments in doExec=%d doScript=%d", nr_exec_args, nr_arguments ); fatalError( node, mode, buffer ); assert( 0 ); } varInstMap *varmap = NULL; if (nr_arguments > 0) { varmap = new varInstMap; for (int i = 0; i < nr_arguments; i++) { missionNode *defnode = (missionNode*) arg_node->subnodes[i]; missionNode *callnode = (missionNode*) node->subnodes[i]; varInst *vi = newVarInst( VI_LOCAL ); vi->type = defnode->script.vartype; if (defnode->script.vartype == VAR_FLOAT) { debug( 4, node, mode, "doExec checking floatExpr" ); double res = checkFloatExpr( callnode, mode ); vi->float_val = res; } else if (defnode->script.vartype == VAR_INT) { debug( 4, node, mode, "doExec checking intExpr" ); int res = checkIntExpr( callnode, mode ); vi->int_val = res; } else if (defnode->script.vartype == VAR_BOOL) { debug( 4, node, mode, "doExec checking boolExpr" ); bool ok = checkBoolExpr( callnode, mode ); vi->bool_val = ok; } else if (defnode->script.vartype == VAR_OBJECT) { debug( 3, node, mode, "doExec checking objectExpr" ); varInst *ovi = checkObjectExpr( callnode, mode ); vi->type = VAR_OBJECT; if (mode == SCRIPT_RUN) assignVariable( vi, ovi ); deleteVarInst( ovi ); } else { fatalError( node, mode, "unsupported vartype in doExec" ); assert( 0 ); } (*varmap)[defnode->script.name] = vi; } } if (mode == SCRIPT_RUN) { //SCRIPT_RUN debug( 4, node, mode, "executing "+node->script.name ); missionNode *module = node->script.module_node; missionNode *old_module = runtime.cur_thread->module_stack.back(); unsigned int classid = 0; if (old_module == module) classid = runtime.cur_thread->classid_stack.back(); runtime.cur_thread->module_stack.push_back( module ); runtime.cur_thread->classid_stack.push_back( classid ); varInst *vi = doScript( node->script.exec_node, mode, varmap ); runtime.cur_thread->module_stack.pop_back(); runtime.cur_thread->classid_stack.pop_back(); if (varmap) { deleteVarMap( varmap ); delete varmap; } return vi; } //SCRIPT_PARSE varInst *vi = newVarInst( VI_TEMP ); vi->type = node->script.exec_node->script.vartype; return vi; }
varInst* Mission::doScript( missionNode *node, int mode, varInstMap *varmap ) { trace( node, mode ); if (mode == SCRIPT_PARSE) { current_script = node; if (parsemode == PARSE_DECL) { node->script.name = node->attr_value( "name" ); if ( node->script.name.empty() ) fatalError( node, mode, "you have to give a script name" ); current_module->script.scripts[node->script.name] = node; debug( 5, node, mode, "added to module "+current_module->script.name+" : script ="+node->script.name ); node->script.nr_arguments = 0; string retvalue = node->attr_value( "type" ); if (retvalue.empty() || retvalue == "void") node->script.vartype = VAR_VOID; else node->script.vartype = vartypeFromString( retvalue ); } scope_stack.push_back( node ); } debug( 5, node, mode, "executing script name="+node->script.name ); if (mode == SCRIPT_RUN) { addContextStack( node ); addContext( node ); } vector< easyDomNode* >::const_iterator siter; if (mode == SCRIPT_PARSE && parsemode == PARSE_DECL) { node->script.nr_arguments = 0; node->script.argument_node = NULL; } for (siter = node->subnodes.begin(); siter != node->subnodes.end() && !have_return( mode ); siter++) { missionNode *snode = (missionNode*) *siter; if (snode->tag == DTAG_ARGUMENTS) { doArguments( snode, mode, varmap ); if (mode == SCRIPT_PARSE && parsemode == PARSE_DECL) node->script.argument_node = snode; char buffer[200]; sprintf( buffer, "nr of arguments=%d", node->script.nr_arguments ); debug( 3, node, mode, buffer ); } else { if (mode == SCRIPT_PARSE && parsemode == PARSE_DECL) { //do nothing, break here } else { checkStatement( snode, mode ); } } } if (mode == SCRIPT_RUN) { removeContext(); contextStack *cstack = runtime.cur_thread->exec_stack.back(); varInst *vi = cstack->return_value; if (vi != NULL) { if (node->script.vartype != vi->type) { fatalError( node, mode, "doScript: return type not set correctly" ); assert( 0 ); } } else if (node->script.vartype != VAR_VOID) { fatalError( node, mode, "no return set from doScript" ); assert( 0 ); } varInst *viret = NULL; if (vi) { viret = newVarInst( VI_TEMP ); viret->type = vi->type; assignVariable( viret, vi ); } removeContextStack(); return viret; } else { scope_stack.pop_back(); return NULL; } }
varInst * Mission::doMath(missionNode *node,int mode){ // if(mode==SCRIPT_PARSE){ string mathname=node->attr_value("math"); int len=node->subnodes.size(); if(len<2){ fatalError(node,mode,"math needs at least 2 arguments"); assert(0); } varInst *res_vi=newVarInst(VI_TEMP); varInst* res1_vi=checkExpression((missionNode *)node->subnodes[0],mode); if(res1_vi->type!=VAR_INT && res1_vi->type!=VAR_FLOAT && res1_vi->type!=VAR_ANY){ printf("res1_vi=%d\n",res1_vi->type); fatalError(node,mode,"only int or float expr allowed for math"); assert(0); } res_vi->type=res1_vi->type; assignVariable(res_vi,res1_vi); if(res_vi->type==VAR_ANY){ res_vi->type=VAR_FLOAT; } deleteVarInst(res1_vi); // char buffer[200]; //sprintf(buffer,"fmath: 1st expr returns %f",res); //debug(4,node,mode,buffer); for(int i=1;i<len;i++){ varInst * res2_vi=checkExpression((missionNode *)node->subnodes[i],mode); var_type res2_type=res2_vi->type; if(res2_type==VAR_INT && res_vi->type==VAR_FLOAT){ res2_type=VAR_FLOAT; if(mode==SCRIPT_RUN){ float res2=(float)res2_vi->int_val; float res=floatMath(mathname,res_vi->float_val,res2); res_vi->float_val=res; } } else if(res2_type==VAR_FLOAT && res_vi->type==VAR_INT){ res_vi->type=VAR_FLOAT; if(mode==SCRIPT_RUN){ res_vi->float_val=(float)res_vi->int_val; float res2=res2_vi->float_val; float res=floatMath(mathname,res_vi->float_val,res2); res_vi->float_val=res; } } else{ if(res_vi->type!=res2_type){ fatalError(node,mode,"can't do math on such types"); assert(0); } if(mode==SCRIPT_RUN){ if(res_vi->type==VAR_INT){ int res=intMath(mathname,res_vi->int_val,res2_vi->int_val); res_vi->int_val=res; } else if(res_vi->type==VAR_FLOAT){ float res=floatMath(mathname,res_vi->float_val,res2_vi->float_val); res_vi->float_val=res; } else{ if(res_vi->type!=res2_type){ fatalError(node,mode,"can't do math on such types"); assert(0); } } } // of SCRIPT_RUN } // else deleteVarInst(res2_vi); } // for arguments return res_vi; }
varInst *Mission::call_omap(missionNode *node,int mode){ //varInst *viret=new varInst; varInst *viret=NULL; if(mode==SCRIPT_PARSE){ string cmd=node->attr_value("name"); node->script.method_id=module_omap_map[cmd]; } callback_module_omap_type method_id=(callback_module_omap_type) node->script.method_id; if(method_id==CMT_OMAP_new){ viret=call_omap_new(node,mode); return viret; } else{ varInst *ovi=getObjectArg(node,mode); omap_t *my_object=getOMapObject(node,mode,ovi); if(method_id==CMT_OMAP_delete){ if(mode==SCRIPT_RUN){ omap_t::iterator iter; for(iter=my_object->begin();iter!=my_object->end();iter++){ string varname=(*iter).first ; varInst *vi=(*iter).second; deleteVarInst(vi,true); } my_object->clear(); delete my_object; } viret=newVarInst(VI_TEMP); viret->type=VAR_VOID; } else if(method_id==CMT_OMAP_set){ missionNode *snode=getArgument(node,mode,2); //varInst *vi=doVariable(snode,mode); // should be getObjExpr varInst *var_vi=checkExpression(snode,mode); // should be getObjExpr string name=getStringArgument(node,mode,1); debug(3,node,mode,"omap set"); if(mode==SCRIPT_RUN){ varInst *push_vi=newVarInst(VI_IN_OBJECT); push_vi->type=var_vi->type; assignVariable(push_vi,var_vi); (*my_object)[name]=push_vi; //printf("setting [%s] type %d\n",name.c_str(),push_vi->type); } deleteVarInst(var_vi); viret=newVarInst(VI_TEMP); viret->type=VAR_VOID; //return viret; } else if(method_id==CMT_OMAP_get){ debug(3,node,mode,"omap.get"); string name=getStringArgument(node,mode,1); viret=newVarInst(VI_TEMP); viret->type=VAR_ANY; if(mode==SCRIPT_RUN){ varInst *back_vi=(*my_object)[name]; assignVariable(viret,back_vi); // printf("viret type=%d back_vi type=%d\n",viret->type,back_vi->type); if(back_vi->type>10){ assert(0); } deleteVarInst(back_vi); // this won't delete it } } else if(method_id==CMT_OMAP_toxml){ if(node->subnodes.size()!=1){ fatalError(node,mode,"olist.toxml needs no arguments"); assert(0); } debug(3,node,mode,"omap.toxml"); if(mode==SCRIPT_RUN){ //call_olist_toxml(node,mode,ovi); } viret =newVarInst(VI_TEMP); viret->type=VAR_VOID; } else if(method_id==CMT_OMAP_size){ if(node->subnodes.size()!=1){ fatalError(node,mode,"olist.size needs one arguments"); assert(0); } debug(3,node,mode,"omap.size"); viret=newVarInst(VI_TEMP); if(mode==SCRIPT_RUN){ int len=my_object->size(); viret->int_val=len; } viret->type=VAR_INT; //return viret; } else{ fatalError(node,mode,"unknown command "+node->script.name+" for callback omap"); assert(0); } deleteVarInst(ovi); return viret; } // else (objects) return NULL; // never reach }