/* */ #include "preproc.hpp" #include "parseerror.hpp" #include "../ast/ast.hpp" #include "common.hpp" #include using AST::ExprNode; AST::ExprNode Parse_ExprBlockNode(TokenStream& lex); AST::ExprNode Parse_Expr0(TokenStream& lex); AST::ExprNode Parse_ExprBlocks(TokenStream& lex); AST::ExprNode Parse_Expr1(TokenStream& lex); AST::Expr Parse_Expr(TokenStream& lex, bool const_only) { return AST::Expr(Parse_Expr0(lex)); } AST::Expr Parse_ExprBlock(TokenStream& lex) { return AST::Expr(Parse_ExprBlockNode(lex)); } ExprNode Parse_ExprBlockNode(TokenStream& lex) { ::std::vector nodes; Token tok; bool trailing_value = false; GET_CHECK_TOK(tok, lex, TOK_BRACE_OPEN); while( (tok = lex.getToken()).type() != TOK_BRACE_CLOSE ) { // 1. Handle 'let' // 2. Handle new blocks // 3. Handle a sequence of expressions broken by ';' switch(tok.type()) { case TOK_BRACE_OPEN: lex.putback(tok); nodes.push_back(Parse_ExprBlockNode(lex)); trailing_value = true; break; case TOK_RWORD_LET: //ret.append(); throw ParseError::Todo("block let"); GET_CHECK_TOK(tok, lex, TOK_SEMICOLON); trailing_value = false; break; case TOK_RWORD_LOOP: throw ParseError::Todo("loop"); break; case TOK_RWORD_FOR: throw ParseError::Todo("for"); break; case TOK_RWORD_WHILE: throw ParseError::Todo("while"); break; default: lex.putback(tok); nodes.push_back(Parse_Expr0(lex)); tok = lex.getToken(); if(tok.type() != TOK_SEMICOLON) { if(tok.type() != TOK_BRACE_CLOSE) throw ParseError::Unexpected(tok, Token(TOK_SEMICOLON)); else lex.putback(tok); trailing_value = true; } else{ trailing_value = false; } break; } } if( trailing_value == false ) { nodes.push_back(ExprNode()); } return AST::ExprNode(ExprNode::TagBlock(), nodes); } // 0: Assign AST::ExprNode Parse_Expr0(TokenStream& lex) { AST::ExprNode rv = Parse_ExprBlocks(lex); Token tok = lex.getToken(); if( tok.type() == TOK_EQUAL ) { ExprNode val = Parse_Expr1(lex); rv = ExprNode(ExprNode::TagAssign(), rv, val); } else { lex.putback(tok); } return rv; } // 0.5: Blocks AST::ExprNode Parse_ExprBlocks(TokenStream& lex) { Token tok = lex.getToken(); switch( tok.type() ) { case TOK_RWORD_MATCH: throw ParseError::Todo("match"); break; case TOK_RWORD_IF: throw ParseError::Todo("if"); break; default: lex.putback(tok); return Parse_Expr1(lex); } } #define LEFTASSOC(cur, next, cases) \ AST::ExprNode next(TokenStream& lex); \ AST::ExprNode cur(TokenStream& lex) \ { \ ::std::cout << ">>" << #cur << ::std::endl; \ AST::ExprNode rv = next(lex); \ while(true) \ { \ Token tok; \ switch((tok = lex.getToken()).type()) \ { \ cases \ default: \ ::std::cout << "<<" << #cur << ::std::endl; \ lex.putback(tok); \ return rv; \ } \ } \ } // 1: Bool OR LEFTASSOC(Parse_Expr1, Parse_Expr2, case TOK_DOUBLE_PIPE: throw ParseError::Todo("expr - boolean OR"); ) // 2: Bool AND LEFTASSOC(Parse_Expr2, Parse_Expr3, case TOK_DOUBLE_AMP: throw ParseError::Todo("expr - boolean AND"); ) // 3: (In)Equality LEFTASSOC(Parse_Expr3, Parse_Expr4, case TOK_DOUBLE_EQUAL: throw ParseError::Todo("expr - equal"); case TOK_EXLAM_EQUAL: throw ParseError::Todo("expr - not equal"); ) // 4: Comparisons LEFTASSOC(Parse_Expr4, Parse_Expr5, case TOK_LT: throw ParseError::Todo("expr - less than"); case TOK_GT: throw ParseError::Todo("expr - greater than"); case TOK_LTE: throw ParseError::Todo("expr - less than or equal"); case TOK_GTE: throw ParseError::Todo("expr - greater than or equal"); ) // 5: Bit OR LEFTASSOC(Parse_Expr5, Parse_Expr6, case TOK_PIPE: throw ParseError::Todo("expr - bitwise OR"); ) // 6: Bit XOR LEFTASSOC(Parse_Expr6, Parse_Expr7, case TOK_CARET: throw ParseError::Todo("expr - bitwise XOR"); ) // 7: Bit AND LEFTASSOC(Parse_Expr7, Parse_Expr8, case TOK_AMP: throw ParseError::Todo("expr - bitwise AND"); ) // 8: Bit Shifts LEFTASSOC(Parse_Expr8, Parse_Expr9, case TOK_DOUBLE_LT: throw ParseError::Todo("expr - shift left"); case TOK_DOUBLE_GT: throw ParseError::Todo("expr - shift right"); ) // 9: Add / Subtract LEFTASSOC(Parse_Expr9, Parse_Expr10, case TOK_PLUS: throw ParseError::Todo("expr - add"); case TOK_DASH: throw ParseError::Todo("expr - sub"); ) // 10: Cast LEFTASSOC(Parse_Expr10, Parse_Expr11, case TOK_RWORD_AS: throw ParseError::Todo("expr - cast"); ) // 11: Times / Divide / Modulo LEFTASSOC(Parse_Expr11, Parse_Expr12, case TOK_STAR: throw ParseError::Todo("expr - multiply"); case TOK_SLASH: throw ParseError::Todo("expr - divide"); case TOK_PERCENT: throw ParseError::Todo("expr - modulo"); ) // 12: Unaries AST::ExprNode Parse_ExprVal(TokenStream& lex); AST::ExprNode Parse_Expr12(TokenStream& lex) { Token tok; switch((tok = lex.getToken()).type()) { case TOK_DASH: throw ParseError::Todo("expr - negate"); case TOK_EXLAM: throw ParseError::Todo("expr - logical negate"); case TOK_STAR: throw ParseError::Todo("expr - dereference"); case TOK_RWORD_BOX: throw ParseError::Todo("expr - box"); case TOK_AMP: throw ParseError::Todo("expr - borrow"); default: lex.putback(tok); return Parse_ExprVal(lex); } } AST::ExprNode Parse_ExprVal(TokenStream& lex) { Token tok; AST::Path path; switch((tok = lex.getToken()).type()) { case TOK_IDENT: // Get path lex.putback(tok); path = Parse_Path(lex, false, true); if(0) case TOK_DOUBLE_COLON: path = Parse_Path(lex, true, true); switch( (tok = lex.getToken()).type() ) { case TOK_BRACE_OPEN: // Structure literal throw ParseError::Todo("Structure literal"); break; case TOK_PAREN_OPEN: // Function call throw ParseError::Todo("Function call"); break; default: // Value lex.putback(tok); throw ParseError::Todo("Variable/Constant"); } case TOK_INTEGER: return ExprNode(ExprNode::TagInteger(), tok.intval(), tok.datatype()); case TOK_FLOAT: throw ParseError::Todo("Float"); default: throw ParseError::Unexpected(tok); } }