int CMessageEditorDlg::find_event()
{
char *str;
int i, formula, node;
CComboBox *box;
for (i=0; i<Num_mission_events; i++) {
node = Mission_events[i].formula;
if (find_operator(CTEXT(node)) == OP_WHEN) {
node = CDR(node);
formula = CAR(node); // bool conditional
if (CDR(CDR(node)) == -1) { // only 1 action
node = CADR(node);
if ((find_operator(CTEXT(node)) == OP_SEND_MESSAGE) && !stricmp(CTEXT(CDR(CDR(CDR(node)))), m_message_name)) {
box = (CComboBox *) GetDlgItem(IDC_SENDER);
str = CTEXT(CDR(node));
m_sender = box->FindStringExact(-1, str);
if (m_sender == CB_ERR)
m_sender = 0;
box = (CComboBox *) GetDlgItem(IDC_PRIORITY);
str = CTEXT(CDR(CDR(node)));
m_priority = box->FindStringExact(-1, str);
if (m_priority == CB_ERR)
m_priority = 0;
return i;
}
}
}
}
m_sender = m_priority = 0;
return -1;
}
svalue_t evaluate_function(int start, int stop)
{
svariable_t *func = NULL;
int startpoint, endpoint;
// the arguments need to be built locally in case of
// function returns as function arguments eg
// print("here is a random number: ", rnd() );
int argc;
svalue_t argv[MAXARGS];
if (tokens[start].type != TO_function || tokens[stop].type != TO_oper || tokens[stop].v[0] != ')')
script_error("misplaced closing bracket\n");
// all the functions are stored in the global script
else if (!(func = global_script.variableforname(tokens[start].v)))
script_error("no such function: '%s'\n", tokens[start].v);
else if (func->type != svt_function)
script_error("'%s' not a function\n", tokens[start].v);
if (killscript) return nullvar; // one of the above errors occurred
// build the argument list
// use a C command-line style system rather than
// a system using a fixed length list
argc = 0;
endpoint = start + 2; // ignore the function name and first bracket
while (endpoint < stop)
{
startpoint = endpoint;
endpoint = find_operator(startpoint, stop-1, ",");
// check for -1: no more ','s
if (endpoint == -1)
endpoint = stop; // evaluate the last expression
if (endpoint-1 < startpoint)
break;
argv[argc] = evaluate_expression(startpoint, endpoint-1);
endpoint++; // skip the ','
argc++;
}
// store the arguments in the global arglist
t_argc = argc;
t_argv = argv;
if(killscript) return nullvar;
// now run the function
func->value.handler();
// return the returned value
return t_return;
}
void Dag::construct_dag(InsCtrl*& ins)
{
InsCtrl* new_ins=new InsCtrl(ins->sstab); //get the stack symbol table
last_oper=0;
std::vector<FBlock*> ins_fblk=ins->get_all_func_block();
for(int i=0;i<ins_fblk.size();i++)
{
FBlock* fblk=ins_fblk[i];
for(int j=0;j<fblk->all_blocks.size();j++)
{
BBlock* bblk=fblk->all_blocks[j];
if(!bblk->has_array()) //we currently do not consider arraies, migh
{
for(int k=0;k<bblk->all_ins.size();k++)
{
Quadcode* q=bblk->all_ins[k];
Quadcode* code=NULL;
Quadcode::Quad_type oper=q->get_quad_type();
symbol* src_arg1=NULL;
symbol* src_arg2=NULL;
symbol* obj_arg=NULL;
unsigned int index1;
unsigned int index2;
unsigned int index3;
switch(oper)
{
case Quadcode::ASSIGN:
src_arg1=q->get_src_arg()[0];
obj_arg=q->get_obj_arg();
if(!find_sym(src_arg1,symbol_nodeNum,index1)) //cannot find the src node in the dag tree
{
index1=dag_nodes.size();
dag_nodes.push_back(new DNode(src_arg1)); //src first leave node
update_node(src_arg1,index1); //update the src symbol index
}
update_node(obj_arg,index1); //update the obj arg, and the index num is the tree node index obj was assigned to
assignment[last_oper].push_back(std::pair<symbol*, unsigned int>(obj_arg,index1)); //assign information, the index begin with 0
break;
case Quadcode::ADD:
case Quadcode::SUB:
case Quadcode::MUL:
case Quadcode::DIV:
src_arg1=q->get_src_arg()[0];
src_arg2=q->get_src_arg()[1];
obj_arg=q->get_obj_arg();
if(!find_sym(src_arg1,symbol_nodeNum,index1)) //cannot find the src node in dag tree
{
index1=dag_nodes.size();
dag_nodes.push_back(new DNode(src_arg1));
update_node(src_arg1,index1);
}
if(!find_sym(src_arg2,symbol_nodeNum,index2))
{
index2=dag_nodes.size();
dag_nodes.push_back(new DNode(src_arg2));
update_node(src_arg2,index2);
}
if(!find_operator(oper,operators,dag_nodes,index1,index2,index3))
{
index3=dag_nodes.size();
dag_nodes.push_back(new DNode(oper,index1,index2));
operators[oper].insert(index3);
last_oper=dag_nodes.size();
}
update_node(obj_arg,index3);
assignment[last_oper].push_back(std::pair<symbol*,unsigned int>(obj_arg,index3));
break;
case Quadcode::INV:
src_arg1=q->get_src_arg()[0];
obj_arg=q->get_obj_arg();
if(!find_sym(src_arg1,symbol_nodeNum,index1))
{
index1=dag_nodes.size();
dag_nodes.push_back(new DNode(src_arg1));
update_node(src_arg1,index1);
}
if(!find_operator(oper,operators,dag_nodes,index1,index2))
{
index2=dag_nodes.size();
dag_nodes.push_back(new DNode(oper,index1));
operators[oper].insert(index2);
last_oper=dag_nodes.size();
}
update_node(obj_arg,index2);
assignment[last_oper].push_back(std::pair<symbol*,unsigned int>(obj_arg,index2));
break;
case Quadcode::CALL:
case Quadcode::SIND:
output_quadcode(*new_ins);
src_arg1=q->get_src_arg()[0];
obj_arg=q->get_obj_arg();
if(obj_arg==NULL)
code=Quadcode::new_Quad_code(oper,src_arg1);
else code=Quadcode::new_Quad_code(oper,obj_arg,src_arg1);
new_ins->new_instruction(code);
break;
case Quadcode::JMP:
case Quadcode::LABEL:
// case Quadcode::READ:
case Quadcode::WRITE:
case Quadcode::PUSH:
case Quadcode::SREF:
output_quadcode(*new_ins);
src_arg1=q->get_src_arg()[0];
code=Quadcode::new_Quad_code(oper,src_arg1);
new_ins->new_instruction(code);
break;
case Quadcode::FUNC:
case Quadcode::MAIN:
case Quadcode::ENDF:
case Quadcode::ENDM:
case Quadcode::PARAM:
case Quadcode::READ:
output_quadcode(*new_ins);
obj_arg=q->get_obj_arg();
code=Quadcode::new_Quad_code(oper,obj_arg);
new_ins->new_instruction(code);
break;
case Quadcode::JEQ:
case Quadcode::JGE:
case Quadcode::JGT:
case Quadcode::JLE:
case Quadcode::JLT:
case Quadcode::JNE:
output_quadcode(*new_ins);
src_arg1=q->get_src_arg()[0];
src_arg2=q->get_src_arg()[1];
obj_arg=q->get_src_arg()[2];
code=Quadcode::new_Quad_code(oper,obj_arg,src_arg1,src_arg2);
new_ins->new_instruction(code);
break;
case Quadcode::LINE:
output_quadcode(*new_ins);
code=Quadcode::new_Quad_code(oper);
new_ins->new_instruction(code);
break;
default:
assert(0);
}
// std::cout<<"y "<<*q;
q->disable();
}
output_quadcode(*new_ins);
}
else
{
for(int m=0;m<bblk->all_ins.size();m++)
{// std::cout<<"s "<<*bblk->all_ins[m];
new_ins->new_instruction(bblk->all_ins[m]);
}
output_quadcode(*new_ins);
}
}
output_quadcode(*new_ins);
}
delete ins;
new_ins->reorder_all_ins();
std::ofstream file("block_dag.txt",std::ios::out);
std::vector<FBlock*> blo=new_ins->get_all_func_block();
for(int i1=0;i1<blo.size();i1++)
{
file<<*blo[i1];
}
ins=new_ins;
}
svalue_t OPstructure(int start, int n, int stop)
{
svariable_t *func = NULL;
// the arguments need to be built locally in case of
// function returns as function arguments eg
// print("here is a random number: ", rnd() );
int argc;
svalue_t argv[MAXARGS];
// all the functions are stored in the global script
if( !(func = variableforname(&global_script, tokens[n+1])) )
script_error("no such function: '%s'\n",tokens[n+1]);
else if(func->type != svt_function)
script_error("'%s' not a function\n", tokens[n+1]);
if(killscript) return nullvar; // one of the above errors occurred
// build the argument list
// add the left part as first arg
argv[0] = evaluate_expression(start, n-1);
argc = 1; // start on second argv
if(stop != n+1) // can be a.b not a.b()
{
int startpoint, endpoint;
// ignore the function name and first bracket
endpoint = n + 3;
while(endpoint < stop)
{
startpoint = endpoint;
endpoint = find_operator(startpoint, stop-1, ",");
// check for -1: no more ','s
if(endpoint == -1)
{ // evaluate the last expression
endpoint = stop;
}
if(endpoint-1 < startpoint)
break;
argv[argc] = evaluate_expression(startpoint, endpoint-1);
endpoint++; // skip the ','
argc++;
}
}
// store the arguments in the global arglist
t_argc = argc;
t_argv = argv;
if(killscript) return nullvar;
// now run the function
func->value.handler();
// return the returned value
return t_return;
}
