コード例 #1
0
ファイル: ast.cpp プロジェクト: Dymanik/LenguajesII
		void printTree(std::ostream& os, int depth =0){
			os<<string(depth,' ')<<"NArray:values{"<<endl;
            for(int i=0; i<values.size(); i++){
				values[i]->printTree(os,depth+1);
            }
			os<<string(depth,' ')<<"}"<<endl;
		}
コード例 #2
0
ファイル: ast.cpp プロジェクト: Dymanik/LenguajesII
		void printTree(std::ostream& os, int depth =0){
			os<<string(depth,' ')<<"NFunctionCall: id="<< id.name<<endl;
			os<<string(depth+1,' ')<<"arguments= {"<<endl;
			for(int i=0;i<arguments.size();i++){
				arguments[i]->printTree(os,depth+2);   
			}
			os<<string(depth+1,' ')<<"}"<<endl;
		}
コード例 #3
0
ファイル: ast.cpp プロジェクト: Dymanik/LenguajesII
        NArray(std::string& s){
#ifdef DEBUG
            cout << "string param "<< s.size()<<endl;
            cout << "string param "<< s<<endl;
#endif
            for(int i=0; i<s.size();i++){
                values.push_back(new NChar(s[i]));
            }
#ifdef DEBUG
            cout << "constrc string "<< values.size()<<endl;
#endif
        }
コード例 #4
0
ファイル: ast.cpp プロジェクト: Dymanik/LenguajesII
		TType* typeChk(Symtable& t,TType* expected = NULL){
            bool err=false;
#ifdef DEBUG
            cout << "values size " << values.size() << endl;
#endif

            TType* elem = values[0]->typeChk(t);

            for(int i=1; i<values.size(); i++){
                if(elem != values[i]->typeChk(t))
                    err=true;
            }

            if(err){
                fprintf(stderr, "Array elements are not the same type.\n");
                return NULL;
            }else{
#ifdef DEBUG
                cout << "cons array type " << elem->name << endl;
#endif
                return new TArray(*elem,values.size());
            }
        
        }
コード例 #5
0
ファイル: ast.cpp プロジェクト: Dymanik/LenguajesII
		TType* typeChk(Symtable& t,TType* expected = NULL){
            TType* tip;
		    std::vector<TType*> args;
			for(int i=0;i<arguments.size();i++){
                tip = arguments[i]->typeChk(t);
				if(tip == NULL){
                    cerr << "Type of argument " << i << " doesn't exist" << endl;
                }else{
                    args.push_back(tip); 
                }
			}

            if(t.lookupFunc(id.name,args) == NULL){
                cerr << "Function "<<id.name<<" was not declared"<< endl;
			    return NULL;
            }else{
                #ifdef DEBUG
                cerr << "Function call type "<<(t.lookupFunc(id.name,args)->type)->name<< endl;
                #endif
                return t.lookupFunc(id.name,args)->type;
            }
		}
コード例 #6
0
CommandResult ExpressionInterpreter::interpretCommand(string userInput)
{
    CommandResult result = CommandSuccess;
    string text;
    stringstream ss;
    ss << userInput;

    ExpressionList currentState;
    currentState.push_back(mpRoot);
    ExpressionList nextState;

    while (result == CommandSuccess && !ss.eof())
    {
        ss >> text;
        transform(text.begin(), text.end(), text.begin(), ::tolower);

        ExpressionList::const_iterator iter = currentState.begin();
        ExpressionList::const_iterator end = currentState.end();
        for (; iter != end; ++iter)
        {
            Expression* expr = *iter;
            ExpressionList exprNextList = expr->getNextExpressionClosure(text);
            nextState.splice(nextState.end(), exprNextList);
        }

        if (nextState.size() > 0)
        {
            currentState = nextState;
            nextState.clear();
        }
        else
        {
            mErrorText = "'" + text + "' not recognized.";
            result = CommandInvalid;
        }
    }

    //remove impossible expressions in the final state before checking for ambiguity
    nextState.clear();
    ExpressionList::const_iterator iter = currentState.begin();
    ExpressionList::const_iterator end = currentState.end();
    for (; iter != end; ++iter)
    {
        Expression* expr = *iter;
        if (expr->isExecutable())
        {
            nextState.push_back(expr);
        }
        else
        {
            ExpressionList children = expr->getNextExpressions();

            bool flag = false;

            ExpressionList::const_iterator iter = children.begin();
            ExpressionList::const_iterator end = children.end();
            for (; iter != end; ++iter)
            {
                if ((*iter)->getName()[0] == '[')
                {
                    flag = true;
                }
            }

            if (flag || children.size() == 0)
            {
                nextState.push_back(expr);
            }
        }
    }

    currentState = nextState;

    if (currentState.size() != 1)
    {
        mErrorText = "'" + text + "' ambiguous or incomplete.";
        result = CommandInvalid;
    }

    //run command if executable and non-ambiguous
    if (result == CommandSuccess)
    {
        Expression* expr = *(currentState.begin());

        ExpressionList executables = expr->getClosureExecutables(false);
        if (executables.size() == 1)
        {
            ilmErrorTypes initResult = ilm_init();
            if (ILM_SUCCESS != initResult)
            {
                mErrorText = ILM_ERROR_STRING(initResult);
                result = CommandExecutionFailed;
            }
            else
            {
                Expression* exec = executables.front();
                exec->execute();
                ilm_commitChanges();
                ilm_destroy();
            }
        }
        else if (executables.size() == 0)
        {
            mErrorText = "command is incomplete.";
            result = CommandIncomplete;
        }
        else
        {
            mErrorText = "command is ambiguous.";
            result = CommandIncomplete;
        }
    }

    return result;
}