コード例 #1
0
	Node* Parser::parseWhileStmt()
	{
		expect(Token::TYPE::WHILE);
		nextToken();
		auto _condition = parseBinaryExpr();
		auto _block = parseBlock();
		return make_node<WhileStmtNode>(_condition, _block);
	}
コード例 #2
0
	Node* Parser::parseAssignment()
	{
		expect(Token::TYPE::IDENTIFIER);

		string _id = *lookahead._literal;
		nextToken();
		expect(Token::TYPE::ASSIGN);
		nextToken();
		Node* _exp = parseBinaryExpr();
		return make_node<AssignmentNode>(_id, _exp);
	}
コード例 #3
0
ファイル: parser.cpp プロジェクト: wfwt/jszb
static Node *parseBinaryExpr(Parser *p, Node **lhs, int prec)
{
	enum Token op;
	Node *rhs;
	int prec2;
	
	op = p->tok;
	p->tok = lexerGetToken(p->lex, &p->tokval, &p->toklen);
	rhs = parseUnaryExpr(p);
	if (!rhs) {
		handleParserError(p, 1, "解析BinaryExpr出错");
		return 0;
	}
	
	prec2 = getPrec(p->tok);
	if (prec2 < 0) {
		Node *e = (Node *)binaryExprNew(*lhs, op, rhs);
		if (e) {
			return e;
		}
	} else if (prec2 <= prec) {
		Node *newlhs = (Node *)binaryExprNew(*lhs, op, rhs);
		if (newlhs) {
			*lhs = newlhs;
			return parseBinaryExpr(p, lhs, prec2);
		}
	} else {
		Node *newrhs = parseBinaryExpr(p, &rhs, prec2);
		if (newrhs) {
			rhs = newrhs;
			Node *e2 = (Node *)binaryExprNew(*lhs, op, rhs);
			if (e2) {
				return e2;
			}
		}
	}
	nodeFree(rhs);
	return 0;
}
コード例 #4
0
ファイル: parser.cpp プロジェクト: wfwt/jszb
static Node *parseExpr(Parser *p)
{
	Node *expr = 0;
	expr = parseUnaryExpr(p);
	if (expr) {
		int prec = getPrec(p->tok);
		if (prec > 0) {
			Node *e2 = parseBinaryExpr(p, &expr, prec);
			if (e2) {
#ifdef LOG_PARSE
				info("解析得到BinaryExpr\n");
#endif
				expr = e2;
			} else {
				nodeFree(expr);
				expr = 0;
			}
		}
	}
	return expr;
}
コード例 #5
0
	Node* Parser::parseUnaryExpr()
	{
		// UnaryExpr: ( + | - )? Int
		if (match(Token::TYPE::ADD))
		{
			nextToken();
			if (match(Token::TYPE::NUMBER))
			{
				double _data = lookahead._double;
				auto numberNode = make_node<NumberNode>(_data, lookahead.maybeInt);
				nextToken();
				return numberNode;
			}
			else if (match(Token::TYPE::IDENTIFIER))
			{
				string s = *lookahead._literal;
				nextToken();
				return make_node<IdentifierNode>(s);
			}
			else
			{
				ReportError("Expected number.");
				return nullptr;
			}
		}
		else if (match(Token::TYPE::SUB))
		{
			nextToken();
			if (match(Token::Token::NUMBER))
			{
				double _data = lookahead._double;
				auto _node = make_node<NumberNode>(_data, lookahead.maybeInt);
				nextToken();
				return _node;
			}
			else if (match(Token::TYPE::IDENTIFIER))
			{
				Token _t = nextToken();
				auto _node = make_node<IdentifierNode>(*_t._literal);
				return make_node<UnaryExprNode>(OperatorType::SUB, _node);
			}
			else
			{
				ReportError("Expected number or identifier");
				return nullptr;
			}
		}
		else if (match(Token::TYPE::NUMBER))
		{
			Token _t = nextToken();
			return make_node<NumberNode>(_t._double, _t.maybeInt);
		}
		else if (match(Token::TYPE::IDENTIFIER))
		{
			Token _t = nextToken();
			return make_node<IdentifierNode>(*_t._literal);
		}
		else if (match(Token::TYPE::OPEN_PAREN))
		{
			nextToken();
			auto _node = parseBinaryExpr();
			expect(Token::TYPE::CLOSE_PAREN);
			nextToken();
			return _node;
		}
		else
		{
			ReportError("Unexpected token, expected +, - or Integer.");
			return nullptr;
		}
	}
コード例 #6
0
	Node* Parser::parseExpression()
	{
		return parseBinaryExpr();
	}