Value Parse() { Value v = ParseFactor(); Gobble('LF'); Expect('EOF'); return v; }
Value Parse() { Value v = ParseFactor(); Gobble(T_LINEFEED); Expect(T_ENDOFFILE); return v; }
Expression *Parser::ParsePlusExpr() { // FactorExpr [ +/- FactorExpr ] * Expression* current = ParseFactor(); while (lexer_->GetToken()->type() == Token::PLUS || lexer_->GetToken()->type() == Token::MINUS) { Token* token = lexer_->GetToken(); lexer_->Advance(); Expression * right = ParseFactor(); current = new EApplication(token, new EApplication(token, new EVar(token, token->TokenStr()), current), right); } return current; }
ParsingResult Parser::ParseTerm(ArithmExpr& term, TokIterator& it) { term.SetLineNumber(current_line_); ParsingResult fact_res = ParseFactor(term, it); if(fact_res != CORRECT) { return fact_res; } // term.AddElem(PtrVisitable(new Factor(factor))); return ParseTermLoop(term, it) ? CORRECT : INCORRECT; }
//************************************** NodeExpression* Parser::ParseTerm() { NodeExpression* r = ParseFactor(); while(t.GetValue() == "*" || t.GetValue() == "/" || t.GetValue() == "div"|| t.GetValue() == "mod" || t.GetValue() == "and" || t.GetValue()== "xor") { Token _t = t; string op = t.GetValue(); t = sc.GetNextToken(); NodeExpression* rr = ParseFactor(); if (_t.GetValue() == "/") { if(!(r->GetType()->IsScalar() && rr->GetType()->IsScalar())) throw Error("type mismatch", _t); if(!r->GetType()->IsReal()) { r = new NodeIntToReal(r); r->SetType((SymType*)(table->find("real")->second)); } //r = new NodeUnaryOp(new Symbol("(Real)"), r); //r->SetType((SymType*)(table->find("real")->second)); if(!rr->GetType()->IsReal()) { rr = new NodeIntToReal(rr); rr->SetType((SymType*)(table->find("real")->second)); } //rr = new NodeUnaryOp(new Symbol("(Real)"), rr); } else if (t.GetValue() == "div"|| t.GetValue() == "mod" || t.GetValue() == "and" || t.GetValue()== "xor") { if (!r->GetType()->IsInt() || !rr->GetType()->IsInt()) throw Error("type mismatch", t); } else CheckTypes(r, rr, false); r = new NodeBinaryOp(new Symbol(op), r, rr); r->SetType(rr->GetType()); } return r; }
bool Parser::ParseTermLoop(ArithmExpr& term, TokIterator& it) { if(it->type_ != MUL_OP && it->type_ != DIV_OP) { return true; } term.AddOperation(it->value_); // Factor factor; ParsingResult fact_res = ParseFactor(term, ++it); if(fact_res != CORRECT) { return false; } // term.AddElem(PtrVisitable(new Factor(factor))); return ParseTermLoop(term, it); }
Expresion* Sintactico::ParseUnaryExpression() { tipo_token op = ParseUnaryOperator(); Expresion* expr = ParseFactor(); switch ( op ) { case op_suma: return new SumaUnaria(expr); case op_resta: return new RestaUnaria(expr); case kw_not: return new Negacion(expr); default: return 0; } }
Expresion* Sintactico::_ParseTerm(Expresion* her) { //Utilizamos Primeros( multiplicative-operator ) if ( proximo_token.GetTipo() == op_mul || proximo_token.GetTipo() == op_div || proximo_token.GetTipo() == op_divent || proximo_token.GetTipo() == op_mod || proximo_token.GetTipo() == op_and ) { tipo_token tipo_mul = ParseMultiplicativeOperator(); Expresion* expr = ParseFactor(); Expresion* sin; switch ( tipo_mul ) { case op_mul: sin = new Multiplicacion(her,expr); break; case op_div: sin = new Division(her,expr); break; case op_divent: sin = new Division(her,expr); break; case op_mod: sin = new Modulo(her,expr); break; case op_and: sin = new AndBinario(her,expr); break; default: break; } return _ParseTerm(sin); } return her; }
const char* RegExp::ParseTerm(StrPP& term) { StrPP factor; term = ""; if(reExpression == BOL) { term += reExpression[0]; reExpression++; } do { if(ParseFactor(factor) == "") return(NULL); term += factor; } while(IsFactor()); // parse all factors of this term return term; }
Value ParseFactor() { switch (lex.token) { case 'INT': { int i = atoi(lex.sattr.c_str()); lex.Next(); return Value(i); } case 'FLT': { double f = atof(lex.sattr.c_str()); lex.Next(); return Value((float)f); } case 'STR': { string s = lex.sattr; lex.Next(); auto str = g_vm->NewString(s); allocated.push_back(str); return Value(str); } case 'NIL': { lex.Next(); return Value(0, V_NIL); } case '-': { lex.Next(); Value v = ParseFactor(); switch (v.type) { case V_INT: v.ival *= -1; break; case V_FLOAT: v.fval *= -1; break; default: lex.Error("numeric value expected"); } return v; } case '[': { lex.Next(); Gobble('LF'); vector<Value> elems; if (lex.token == ']') lex.Next(); else { for (;;) { elems.push_back(ParseFactor()); bool haslf = lex.token == 'LF'; if (haslf) lex.Next(); if (lex.token == ']') break; if (!haslf) Expect(','); } lex.Next(); } int type = -1; if (lex.token == ':') { lex.Next(); string sname = lex.sattr; Expect('ID'); size_t reqargs = 0; int idx = g_vm->StructIdx(sname, reqargs); if (idx >= 0) // if unknown type, becomes regular vector { while (elems.size() < reqargs) { elems.push_back(Value(0, V_NIL)); } // pad with NIL if current type has more fields while (elems.size() > reqargs) { elems.back().DEC(); elems.pop_back(); } // drop elements if current type has less fields type = idx; } } auto vec = g_vm->NewVector(elems.size(), type); allocated.push_back(vec); for (auto &e : elems) vec->push(e.INC()); return Value(vec); } default: lex.Error("illegal start of expression: " + lex.TokStr()); return Value(); } }
NodeExpression* Parser::ParseFactor() { NodeExpression* r = NULL; if (t.GetValue() == "-" || t.GetValue() == "+" || t.GetValue() == "not") { string op = t.GetValue(); t = sc.GetNextToken(); NodeExpression* _r = ParseFactor(); r = new NodeUnaryOp(new Symbol(op), _r); r->SetType(_r->GetType()); } else { if (t.GetValue() != "(" && t.GetType() != identifier && t.GetType() != int_const_dec && t.GetType() != float_const) throw Error("Syntax error : unexpected \""+t.GetValue()+"\";", t); if(t.GetValue() == "(") { t = sc.GetNextToken(); r = ParseComparision(); t = RequireToken(")" , "\")\" expected"); } switch(t.GetType()){ case int_const_dec : case float_const: { SymVarConst* _const = new SymVarConst(t.GetValue(), t.GetValue(), NULL); if (t.GetType() == int_const_dec) _const->SetType((SymType*)mainTable->find("integer")->second); else _const->SetType((SymType*)mainTable->find("real")->second); t = sc.GetNextToken(); r = new NodeConst(_const); r->SetType(_const->GetType()); return r; break; } case identifier: { Token t1 = t; bool found = false; _Table::iterator it = TableStack.Find(t1.GetValue(), found); if (!found) throw Error("unknown identifier", t); t = sc.GetNextToken(); SymVar* name = (SymVar*)it->second; SymType* Type = name->GetType(); if (t.GetValue() == "(") { if (!it->second->IsFunc()) throw Error("unexpected identifier", t); if (((SymFunc*)it->second)->IsForward()) throw Error("undefined forward ("+it->second->GetName()+")", t); r = ParseSub((SymFunc*)it->second); } else if(name->GetType()->IsRec() || name->GetType()->IsArr()) { r = new NodeVar(name); r->SetType(Type); while(name->GetType()->IsRec() || name->GetType()->IsArr()) { SymVar* name2 = name; if (name->GetType()->IsRec()) r = ParseRec(r, name); if (name->GetType()->IsArr()) r = ParseArr(r,name); if (name2 == name) break; } } else { if (name->IsConst()) r = new NodeConst(it->second); else r = new NodeVar(it->second); r->SetType(Type); } break; } } } return r; }
ExprNode* Parser :: ParseExpr(int priority){ if (priority > 15) return ParseFactor(); ExprNode *left = ParseExpr(priority + 1); ExprNode *root = left; Token *op = scan.Get(); if(scan.isEnd() || isEq(op, _SEPARATION, "}") || isEq(op, _SEPARATION, ")") || isEq(op, _SEPARATION, "]") || isEq(op, _OPERATION, ":") || isEq(op, _SEPARATION, ";") || isEq(op, _SEPARATION, "{")){ //root->getType(); return root; } // if ( // isEq(op, _SEPARATION, ",")){ // scan.Next(); // // return root; // } errorIf(((op->Type != _OPERATION && op->Value != ",")) &&( op->Value !="(") &&(!isEq(op, _SEPARATION,"[")) , "Invalid expression. Operation expected",op); if(priorityTable[op->Value] < priority) return root; while(!scan.isEnd() && ((op->Type == _OPERATION && (priorityTable[op->Value] >= priority) && op->Value != "}") || op->Value =="(" || op->Value == "[")){ string oper = op->Value; if(oper == "("){ root = ParseFuncCall(root); } else if(oper == "["){ root = ParseArrIndex(root); break; } else if(oper == "--" ||oper == "++"){ root = new PostfixUnaryOpNode(op, root); scan.Next(); } else if(oper == "?"){ scan.Next(); ExprNode* l = ParseExpr(); if(scan.Get()->Value != ":") throw MyException("Invalid ternary operator", scan.Get()); scan.Next(); ExprNode* r = ParseExpr(); root = new TernaryOpNode(op, root, l, r); } else if(oper == "." || oper == "->") root = ParseMember(root); else { if(isEq(op, _SEPARATION, "]")) break; scan.Next(); root = new BinOpNode(op, root, ParseExpr(priority + 1)); } op = scan.Get(); } root->getType(); return root; }
Expresion* Sintactico::ParseTerm() { Expresion* expr = ParseFactor(); return _ParseTerm(expr); }