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);
}
