//------------------------------------------------------------------------------------------------------ PolynomialItem* parseTerm(const QString& a_Eqn, int& a_Pos, PolynomialItem* a_Parent) { qInfo() << "Parsing term"; PolynomialItem* termItem = new PolynomialItem(a_Parent); termItem->setExprType(QString("Term")); termItem->setZ(0); termItem->setBorderColor(QColor("green")); // the first item has default operation * PolynomialItem* factorItem(parseFactor(a_Eqn, a_Pos, termItem)); factorItem->setOp('*'); while(a_Pos < a_Eqn.size() && a_Eqn[a_Pos] != QChar::Null) { QChar op(a_Eqn[a_Pos]); qInfo() << "parseTerm::Operator " << op.toLatin1(); if(op != '*' && op != '/') { return termItem; } ++a_Pos; factorItem = parseFactor(a_Eqn, a_Pos, termItem); factorItem->setOp(op); } return termItem; }
Token* RegxParser::parseTerm(const bool matchingRParen) { parserState state = fState; if (state == REGX_T_OR || state == REGX_T_EOF || (state == REGX_T_RPAREN && matchingRParen)) { return fTokenFactory->createToken(Token::T_EMPTY); } else { Token* tok = parseFactor(); Token* concatTok = 0; while ((state = fState) != REGX_T_OR && state != REGX_T_EOF && (state != REGX_T_RPAREN || !matchingRParen)) { if (concatTok == 0) { concatTok = fTokenFactory->createUnion(true); concatTok->addChild(tok, fTokenFactory); tok = concatTok; } concatTok->addChild(parseFactor(), fTokenFactory); } return tok; } }
Expr* Parser::parseFactor() { if ( check( INTEGER_T ) ) { Token num = match( INTEGER_T ); Num* node = new Num( stoi( num.lexeme ), num.line, num.column ); return node; } else if ( check( IDENT_T ) ) { Token ID = match( IDENT_T ); Id* node = new Id( ID.lexeme, ID.line, ID.column ); return node; } else if ( check( TRUE_T ) ) { Token trueToken = match( TRUE_T ); True* node = new True( trueToken.line, trueToken.column ); return node; } else if ( check( FALSE_T ) ) { Token falseToken = match( FALSE_T ); False* node = new False( falseToken.line, falseToken.column ); return node; } else if ( check( SUBTRACT_ST ) ) { Token unOp = match( SUBTRACT_ST ); Expr* factor = parseFactor(); UnOp* node = new UnOp( Neg, factor, unOp.line, unOp.column ); return node; } else if ( check( NOT_ST ) ) { Token unOp = match( NOT_ST ); Expr* factor = parseFactor(); UnOp* node = new UnOp( Not, factor, unOp.line, unOp.column ); return node; } else { Token leftParen = match( LEFTPARENTH_T ); Expr* node = parseExpr(); match( RIGHTPARENTH_T ); return node; } }
NodePtr parseTerm() { auto ret = std::make_shared<ConcatenateNode>(); ret->addSibling(parseFactor()); auto p = reader.peek(); while (p != '\0' && p != '|' && p != ')') { ret->addSibling(parseFactor()); p = reader.peek(); } return ret; }
/*! * term ::= ( factor )+ */ Node* Parser::parseTerm() { std::vector<Node*> v; v.push_back(parseFactor()); while ((token_ == Lexer::Token::identifier && peek_token_ != Lexer::Token::coloncolonequal && peek_token_ != Lexer::Token::minusgreater) || token_ == Lexer::Token::text || token_ == Lexer::Token::l_paren) { v.push_back(parseFactor()); } return new AndNode(v); }
static PSmmAstNode parseExpression(PSmmParser parser) { PSmmAstNode left = parseFactor(parser); if (left != &errorNode && left->kind != nkSmmParamDefinition) { left = parseBinOp(parser, left, 0); } return left; }
SymbolTableEntry* Parser::parseTermPrime(SymbolTableEntry* prevEntry){ if(isNext(tc_MULOP)){ OpType t = m_currentToken->getOpType(); match(tc_MULOP); SymbolTableEntry* factor = parseFactor(); SymbolTableEntry* temp = newTemp(); if(t == op_MULT){ m_code->generate(cd_MULT, prevEntry, factor, temp); } else if(t == op_DIVIDE){ m_code->generate(cd_DIVIDE, prevEntry, factor, temp); } else if(t == op_DIV){ m_code->generate(cd_DIV, prevEntry, factor, temp); } else if(t == op_MOD){ m_code->generate(cd_MOD, prevEntry, factor, temp); } else{ m_code->generate(cd_AND, prevEntry, factor, temp); } prevEntry = parseTermPrime(temp); } return prevEntry; }
Expr* Parser::parseTerm() { Expr* factor = parseFactor(); Expr* node = parseTermRest( factor, factor->line, factor->column ); return node; }
// Product -> Factor ((*|/|%) Factor)* Expression::Node *Expression::parseProduct() { //printf("parsing product\n"); Node *result = parseFactor(); for (;;) { if (consume("*")) { result = new Times(result, parseFactor()); } else if (consume("/")) { result = new Divide(result, parseFactor()); } else if (consume("%")) { result = new Mod(result, parseFactor()); } else { //printf("done parsing product\n"); return result; } } }
FactorPtr Parser::parseFactor() { FactorPtr factor(new Factor); if (m_curToken.tokenType() == TokenType::Number) { factor->number = parseNumber(); if (m_errorCode > ErrorCodes::NoError) { panic(factorFollow, factorFollowSize); return FactorPtr(); } return factor; } else if (m_curToken.tokenType() == TokenType::LParen) { match(TokenType::LParen); ExpressionPtr expr = parseExpression(); if (m_errorCode > ErrorCodes::NoError) { panic(factorFollow, factorFollowSize); return FactorPtr(); } if (!match(TokenType::RParen)) { reportError(ErrorCodes::ExpectedRParen); panic(factorFollow, factorFollowSize); return FactorPtr(); } factor->expression = expr; return factor; } else if (m_curToken.tokenType() == TokenType::Not) { match(TokenType::Not); factor->negatedFactor = parseFactor(); if (m_errorCode > ErrorCodes::NoError) { panic(factorFollow, factorFollowSize); return FactorPtr(); } return factor; } IdentifierPtr identifier = parseIdentifier(); if (m_errorCode > ErrorCodes::NoError) { panic(factorFollow, factorFollowSize); return FactorPtr(); } parseFactor_p(identifier); if (m_errorCode > ErrorCodes::NoError) { panic(factorFollow, factorFollowSize); return FactorPtr(); } factor->id = identifier; return factor; }
static PSmmAstNode parseBinOp(PSmmParser parser, PSmmAstNode left, int prec) { while (true) { int precedence = binOpPrecs[parser->curToken->kind & 0x7f]; if (!precedence || precedence < prec) { return left; } PSmmToken opToken = parser->curToken; getNextToken(parser); PSmmAstNode right = parseFactor(parser); if (right == &errorNode) return &errorNode; int nextPrecedence = binOpPrecs[parser->curToken->kind & 0x7f]; if (nextPrecedence && nextPrecedence > precedence) { right = parseBinOp(parser, right, precedence + 1); if (right == &errorNode) return &errorNode; } PSmmAstNode res = smmNewAstNode(nkSmmError, parser->a); res->left = left; res->right = right; res->token = opToken; res->isBinOp = true; switch (res->token->kind) { case tkSmmIntDiv: res->kind = nkSmmSDiv; break; // Second pass might change this to unsigned version case tkSmmIntMod: res->kind = nkSmmSRem; break; case '*': res->kind = nkSmmMul; break; case '/': res->kind = nkSmmFDiv; break; case '%': res->kind = nkSmmFRem; break; case '+': res->kind = nkSmmAdd; break; case '-': res->kind = nkSmmSub; break; case '>': res->kind = nkSmmGt; break; case '<': res->kind = nkSmmLt; break; case tkSmmEq: res->kind = nkSmmEq; break; case tkSmmNotEq: res->kind = nkSmmNotEq; break; case tkSmmGtEq: res->kind = nkSmmGtEq; break; case tkSmmLtEq: res->kind = nkSmmLtEq; break; case tkSmmAndOp: res->kind = nkSmmAndOp; break; case tkSmmXorOp: res->kind = nkSmmXorOp; break; case tkSmmOrOp: res->kind = nkSmmOrOp; break; default: assert(false && "Got unexpected token for binary operation"); break; } switch (res->token->kind) { case tkSmmAndOp: case tkSmmXorOp: case tkSmmOrOp: case tkSmmEq: case tkSmmNotEq: case tkSmmGtEq: case tkSmmLtEq: case '>': case '<': res->type = &builtInTypes[tiSmmBool]; break; } left = res; } }
Dimension UnitSystem::parse(const std::string& dimension) const { const size_t divCount = std::count( dimension.begin() , dimension.end() , '/' ); if( divCount > 1 ) throw std::invalid_argument("Dimension string can only have one division sign '/'"); const bool haveDivisor = divCount == 1; if( !haveDivisor ) return parseFactor( dimension ); std::vector<std::string> parts; boost::split(parts , dimension , boost::is_any_of("/")); Dimension dividend = parseFactor( parts[0] ); Dimension divisor = parseFactor( parts[1] ); if (dividend.getSIOffset() != 0.0 || divisor.getSIOffset() != 0.0) throw std::invalid_argument("Composite dimensions cannot currently require a conversion offset"); return Dimension::newComposite( dimension, dividend.getSIScaling() / divisor.getSIScaling() ); }
Expr* Parser::parseTermRest( Expr* e, int lin, int col ) { if ( check( ASTERISK_ST ) || check( DIV_ST ) || check( MOD_ST ) || check( AND_ST ) ) { Op2 mulOp = parseMulOp(); Expr* factor = parseFactor(); BinOp* binOp = new BinOp( e, mulOp, factor, lin, col ); Expr* node = parseTermRest( binOp, binOp->line, binOp->column ); return node; } else return e; }
TermPtr Parser::parseTerm() { TermPtr term(new Term); term->lhs = parseFactor(); if (m_errorCode > ErrorCodes::NoError) { panic(termFollow, termFollowSize); return TermPtr(); } // concat this to the term parseTerm_r(term); return term; }
// Unary → '!' Unary | Factor bool AnimExpression::parseUnary(const QString& str, QString::const_iterator& iter) { auto token = consumeToken(str, iter); if (token.type == Token::Not) { if (!parseUnary(str, iter)) { unconsumeToken(token); return false; } _opCodes.push_back(OpCode {OpCode::Not}); return true; } unconsumeToken(token); return parseFactor(str, iter); }
shared_ptr<Expression> Parser::parseTerm() { auto rootExp = parseFactor(); it++; while (it->tag == MUL || it->tag == DIV ) { auto opExp = make_shared<Expression>(); opExp->value = *it; opExp->addNode(rootExp); it++; opExp->addNode(parseTerm()); rootExp = opExp; it++; } if (!(it->tag == MUL || it->tag == DIV)) { it--; } return rootExp; }
SymbolTableEntry* Parser::parseFactor(){ SymbolTableEntry* factor = NULL; SymbolTableEntry* result = m_symbolTable->lookup(CodeFalse); if(isNext(tc_ID)){ factor = m_currentToken->getSymTabEntry(); match(tc_ID); result = parseFactorPrime(factor); } else if(isNext(tc_LPAREN)){ match(tc_LPAREN); result = parseExpression(); match(tc_RPAREN); if(m_parserError){ TokenCode synch[] = {tc_RPAREN, tc_END, tc_ADDOP, tc_MULOP, tc_RELOP, tc_THEN, tc_DO, tc_COMMA, tc_RBRACKET, tc_SEMICOL, tc_ELSE, tc_NONE}; recover(synch); // if(isNext(tc_RPAREN)){ // match(tc_RPAREN); // } } } else if(isNext(tc_NOT)){ match(tc_NOT); factor = parseFactor(); result = newTemp(); m_code->generate(cd_NOT, factor, NULL, result); } else{ result = m_currentToken->getSymTabEntry(); match(tc_NUMBER); if(m_parserError){ TokenCode synch[] = {tc_RPAREN, tc_END, tc_ADDOP, tc_MULOP, tc_RELOP, tc_THEN, tc_DO, tc_COMMA, tc_RBRACKET, tc_SEMICOL, tc_ELSE, tc_NONE}; recover(synch); // if(isNext(tc_NUMBER)){ // match(tc_NUMBER); // } } } return result; }
SymbolTableEntry* Parser::parseTerm(){ SymbolTableEntry* result = parseFactor(); result = parseTermPrime(result); return result; }