expr_parser.go

func (p *Parser) parseExpression() ast.Expr {
	expr := p.parseAndExpr()
	for p.tok == tokens.OR {
		op := p.tok
		p.scan()
		expr = &ast.BinaryExpr{
			Left:     expr,
			Operator: op,
			Right:    p.parseAndExpr(),
		}
	}
	return expr
}

func (p *Parser) parseAndExpr() ast.Expr {
	expr := p.parseNotExpr()
	for p.tok == tokens.AND {
		op := p.tok
		p.scan()
		expr = &ast.BinaryExpr{
			Left:     expr,
			Operator: op,
			Right:    p.parseNotExpr(),
		}
	}
	return expr
}

func (p *Parser) parseNotExpr() (expr ast.Expr) {
	if p.tok == tokens.NOT {
		p.scan()
		expr = &ast.NotExpr{
			Expr: p.parseRelExpr(),
		}
	} else {
		expr = p.parseRelExpr()
	}
	return expr
}

func (p *Parser) parseRelExpr() ast.Expr {
	expr := p.parseAddExpr()
	for p.tok == tokens.EQL ||
		p.tok == tokens.NEQ ||
		p.tok == tokens.LSS ||
		p.tok == tokens.GTR ||
		p.tok == tokens.LEQ ||
		p.tok == tokens.GEQ {
		op := p.tok
		p.scan()
		expr = &ast.BinaryExpr{
			Left:     expr,
			Operator: op,
			Right:    p.parseAddExpr(),
		}
	}
	return expr
}

func (p *Parser) parseAddExpr() ast.Expr {
	expr := p.parseMulExpr()
	for p.tok == tokens.ADD ||
		p.tok == tokens.SUB {
		op := p.tok
		p.scan()
		expr = &ast.BinaryExpr{
			Left:     expr,
			Operator: op,
			Right:    p.parseMulExpr(),
		}
	}
	return expr
}

func (p *Parser) parseMulExpr() ast.Expr {
	expr := p.parseUnaryExpr()
	for p.tok == tokens.MUL ||
		p.tok == tokens.DIV ||
		p.tok == tokens.MOD {
		op := p.tok
		p.scan()
		expr = &ast.BinaryExpr{
			Left:     expr,
			Operator: op,
			Right:    p.parseUnaryExpr(),
		}
	}
	return expr
}

func (p *Parser) parseUnaryExpr() ast.Expr {
	switch op := p.tok; op {
	case tokens.ADD, tokens.SUB:
		p.scan()
		return &ast.UnaryExpr{
			Operator: op,
			Operand:  p.parseOperand(),
		}
	case tokens.EOF:
		return nil
	default:
		return p.parseOperand()
	}
}