예제 #1
0
파일: main.c 프로젝트: KovaxG/aut-eng-2014
/* reads the math expresion (in values) and its size*/
void readExpression(char **values, int *size)
{
    fprintf(stdout, "[INFO] [READ]\tIntroduce the mathematical expression separated by space in\n");
    fprintf(stdout, "\t\tpostfix form with operands in [a-zA-Z], operations in '+-*/'\n");
    fprintf(stdout, "\t\tand use '#' for unary operations:\n");
    fprintf(stdout, "[INFO] [READ]\t");
    char *buffer = (char*) calloc(1024, sizeof(char));
    fgets(buffer, 1024, stdin);

    *size = 0;
    while (*(buffer+*size) != '\n')
    {
        (*size)++;
    }
    *size = (*size+1)/2;

    char *result = (char*) calloc((*size+1), sizeof(char));
    for (int i=0; i<*size; i++)
    {
        *(result+i) = *(buffer+i*2);
    }

    free(buffer);
    if (checkExpression(result))
    {
        *values = result;
    }
    else
    {
        exitError("[READ]\tThe read expression contains invalid characters.\n");
    }
}
예제 #2
0
int main(int argc, char **argv){
	std::string evalexp(argv[1]);
	
	// Check input expression for unhandling symbols
	if(!checkExpression(evalexp)) return -1;

	// Clear expression from spaces
	for(uint i=0 ; i < evalexp.length(); i++){
		if(evalexp[i] == ' '){
			evalexp.erase(evalexp.begin() + i);
			if(i > 0) i--;
		}
	}
	std::cout << "Evaluating expression is: \"" << evalexp << "\"" << std::endl;

	std::cout << "Result is: " << evalExpression<int>(evalexp) << std::endl;
	return 0;
}
예제 #3
0
HRESULT STDMETHODCALLTYPE
    CAAFEssenceFileContainer::CreateEssenceStream (const aafCharacter * pName,
		aafMobID_constptr pMobID,
        IAAFEssenceStream ** ppEssenceStream)
{
  HRESULT hr = S_OK;
  CAAFEssenceFileStream *pEssenceFileStream = NULL;


  // Validate return argument.
  if (NULL == ppEssenceStream)
    return E_INVALIDARG;

  try
  {
    // First see if the stream has already been opened.
    checkResult(CheckExistingStreams(pName, openNew));


    // Create file stream object.
    pEssenceFileStream = CAAFEssenceFileStream::CreateFileStream(this);
 	  checkExpression(NULL != pEssenceFileStream, E_OUTOFMEMORY);
    
    // Temporarily reuse code for obsolete CAAFEssenceFileScream
    checkResult(pEssenceFileStream->Create(pName, pMobID));
    
    // Return the interface to the stream to the caller.
    checkResult(pEssenceFileStream->QueryInterface(IID_IAAFEssenceStream, (void **)ppEssenceStream));
  }
  catch (HRESULT& rResult)
  {
    hr = rResult;
  }

  //
  // If an error occurs the following release will delete the object.
  if (pEssenceFileStream)
    pEssenceFileStream->Release();

  return hr;
}
void Check_PriorDeclaration_Base::checkBaseExpression(const AST_BaseExpression::shared_ptr &stm)
{
    switch (stm->baseExpressionType()) {

    case AST_BaseExpressionType::betStatements:
    {
        const AST_BaseStatement::shared_ptr& local
                = boost::dynamic_pointer_cast<AST_BaseStatement>(stm);
        checkStatement(local);
        break;
    }
    case AST_BaseExpressionType::betIdentifier:
    {
        const AST_Identifier::shared_ptr& local
                = boost::dynamic_pointer_cast<AST_Identifier>(stm);
        checkIdentifier(local);
        break;
    }
    case AST_BaseExpressionType::betExpression:
    {
        const AST_Expression::shared_ptr& local
                = boost::dynamic_pointer_cast<AST_Expression>(stm);
        checkExpression(local);
        break;
    }
    case AST_BaseExpressionType::betBoolExpression:
    {
        const AST_Boolean_Expression::shared_ptr& local
                = boost::dynamic_pointer_cast<AST_Boolean_Expression>(stm);
        checkBoolExpression(local);
        break;
    }
    case AST_BaseExpressionType::betBoolValue:
    {
        const AST_Boolean::shared_ptr& local
                = boost::dynamic_pointer_cast<AST_Boolean>(stm);
        checkBoolValue(local);
        break;
    }
    case AST_BaseExpressionType::betDoubleValue:
    {
        const AST_Double::shared_ptr& local
                = boost::dynamic_pointer_cast<AST_Double>(stm);
        checkDoubleValue(local);
        break;
    }
    case AST_BaseExpressionType::betIntegerValue:
    {
        const AST_Integer::shared_ptr& local
                = boost::dynamic_pointer_cast<AST_Integer>(stm);
        checkIntegerValue(local);
        break;
    }
    case AST_BaseExpressionType::betStringValue:
    {
        const AST_String::shared_ptr& local
                = boost::dynamic_pointer_cast<AST_String>(stm);
        checkStringValue(local);
        break;
    }
    default:
        break;
    }
}
bool Mission::doTest(missionNode *node,int mode){
  if(mode==SCRIPT_PARSE){
    string teststr=node->attr_value("test");
    if(teststr.empty()){
      fatalError(node,mode,"you have to give test an argument what to test");
      assert(0);
    }

    if(teststr=="gt"){
      node->script.tester=TEST_GT;
    }
    else if(teststr=="lt"){
      node->script.tester=TEST_LT;
    }
    else if(teststr=="eq"){
      node->script.tester=TEST_EQ;
    }
    else if(teststr=="ne"){
      node->script.tester=TEST_NE;
    }
    else if(teststr=="ge"){
      node->script.tester=TEST_GE;
    }
    else if(teststr=="le"){
      node->script.tester=TEST_LE;
    }
#if 0
    else if(teststr=="between"){
      node->script.tester=TEST_BETWEEN;
    }
#endif
    else {
      fatalError(node,mode,"unknown test argument for test");
      assert(0);
    }

    vector<easyDomNode *>::const_iterator siter;
#if 0
    int i=0;
    for(siter= node->subnodes.begin() ; siter!=node->subnodes.end() && i<2; siter++){
      missionNode *snode=(missionNode *)*siter;
      (node->script.test_arg)[i]=snode;
    }
    if(i<2){
      fatalError(node,mode,"a test-expr needs exact two subnodes");
      assert(0);
    }
#endif

    int len=node->subnodes.size();
    if(len!=2){
      fatalError(node,mode,"a test-expr needs exact two subnodes");
      assert(0);
    }
    
    node->script.test_arg[0]=(missionNode *)node->subnodes[0];
    node->script.test_arg[1]=(missionNode *)node->subnodes[1];

  } // end of parse

    varInst * arg1_vi=checkExpression(node->script.test_arg[0],mode);
    varInst * arg2_vi=checkExpression(node->script.test_arg[1],mode);
    bool res=false;

      if(arg1_vi->type!=arg2_vi->type){
	fatalError(node,mode,"test is getting not the same types");
	assert(0);
      }
      
    if(mode==SCRIPT_RUN){
      if(arg1_vi->type==VAR_FLOAT){
	double arg1=arg1_vi->float_val;
	double arg2=arg2_vi->float_val;

	switch(node->script.tester){
	case TEST_GT:
	  res=(arg1>arg2);
	  break;
	case TEST_LT:
	  res=(arg1<arg2);
	  break;
	case TEST_EQ:
	  res=(arg1==arg2);
	  break;
	case TEST_NE:
	  res=(arg1!=arg2);
	  break;
	case TEST_GE:
	  res=(arg1>=arg2);
	  break;
	case TEST_LE:
	  res=(arg1<=arg2);
	  break;
	default:
	  fatalError(node,mode,"no valid tester");
	  assert(0);
	}
    }
    else if(arg1_vi->type==VAR_INT){
	int arg1=arg1_vi->int_val;
	int arg2=arg2_vi->int_val;

	switch(node->script.tester){
	case TEST_GT:
	  res=(arg1>arg2);
	  break;
	case TEST_LT:
	  res=(arg1<arg2);
	  break;
	case TEST_EQ:
	  res=(arg1==arg2);
	  break;
	case TEST_NE:
	  res=(arg1!=arg2);
	  break;
	case TEST_GE:
	  res=(arg1>=arg2);
	  break;
	case TEST_LE:
	  res=(arg1<=arg2);
	  break;
	default:
	  fatalError(node,mode,"no valid tester");
	  assert(0);
	}
    }
      else{
	fatalError(node,mode,"no such type allowed for test");
	assert(0);
      }
    }// SCRIPT_RUN

    deleteVarInst(arg1_vi);
    deleteVarInst(arg2_vi);

    return res;

}
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;
}
예제 #7
0
void TextModelLavaan::checkExpression(const QList<Token> &tokens, int &i, TextModelLavaan::BlockStatus *status)
{
	const Token &token = tokens[i];

	if (token.type == Variable)
	{
		i++;
		return;
	}
	else if (token.type == Number)
	{
		i++;
		return;
	}
	else if (token.type == FunctionOpen)
	{
		i++;

		if (i >= tokens.size())
		{
			status->setError("Missing closing bracket", token.pos, token.text.length());
			return;
		}

		Token next = tokens[i];

		if (next.type == FunctionClose)
		{
			status->setError("Missing function arguments", token.pos, token.text.length());
			return;
		}
		else if (next.type == FunctionOpen)
		{
			checkExpression(tokens, i, status);

			if (status->isError())
				return;
		}
		else if (next.type == Number)
		{
			i++;

			for (;;) {

				if (i >= tokens.length())
					break;

				next = tokens[i];
				if (next.type != Comma)
					break;

				i++;
				if (i >= tokens.length())
					break;

				next = tokens[i];
				if (next.type != Number)
				{
					status->setError("Expected a number", next.pos, next.text.length());
					return;
				}

				i++;
			}

		}
		else
		{
			status->setError("Expected a number (or vector)", next.pos, next.text.length());
		}


		if (i >= tokens.length())
		{
			status->setError("Missing closing bracket", token.pos, token.text.length());
			return;
		}

		next = tokens[i];

		if (next.type != FunctionClose)
		{
			status->setError("Expecting a closing bracket", next.pos, next.text.length());
			return;
		}

		i++;
	}
	else
	{
		status->setError("Expected an expression", token.pos, token.text.length());
		return;
	}



}
예제 #8
0
QList<Token> TextModelLavaan::parse(QTextBlock &block)
{
	BlockStatus *status = blockStatus(block);
	status->clearError();

	QList<Token> tokens = tokenise(block);

	if (status->isError())
	{
		qDebug() << "error : " << status->message << "\n";
		return tokens;
	}

	if (tokens.length() == 0 || tokens.at(0).type == Comment)
		return tokens;

	Token &first = tokens[0];

	if (first.type != Variable)
	{
		status->setError("Expected a variable", first.pos, first.text.length());
		return tokens;
	}
	else if (tokens.length() == 1)
	{
		status->setError("Expected an operator", first.pos + first.text.length(), -1);
		return tokens;
	}

	if (tokens.length() >= 2)
	{
		Token &second = tokens[1];

		if (second.type == Comment)
		{
			status->setError("Expected an operator", first.pos + first.text.length(), -1);
			return tokens;
		}
		else if (second.type == Operator)
		{
			if (second.text != "~~" &&
				 second.text != "~" &&
				 second.text != "=~" &&
				 second.text != "==" &&
				 second.text != ">" &&
				 second.text != "<" &&
				 second.text != ":=")
			{
				status->setError("Unrecognised operator", second.pos, second.text.length());
				return tokens;
			}
			else if (tokens.length() == 2)
			{
				status->setError("Expected an expression", second.pos + second.text.length(), -1);
				return tokens;
			}
		}
		else
		{
			status->setError("Expected an operator", second.pos, second.text.length());
			return tokens;
		}
	}

	int i = 2;

	checkExpression(tokens, i, status);
	if (status->isError())
		return tokens;

	while (i < tokens.length())
	{
		Token token = tokens.at(i);

		if (token.type == Comment)
			break;

		if (token.type != Plus)
		{
			status->setError("Expected a plus", token.pos, token.text.length());
			return tokens;
		}

		i++;

		if (i >= tokens.length())
		{
			status->setError("Expected an expression", token.pos + token.text.length(), -1);
			return tokens;
		}

		checkExpression(tokens, i, status);
		if (status->isError())
			return tokens;
	}


	return tokens;
}
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
}