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