goyacc/parser.go.y

   1 %{
   2 package main
   3 import (
   4         "text/scanner"
   5         "strconv"
   6         "strings"
   7         "fmt"
   8 )
   9 type Expression interface{}
  10 type ParenExpr struct {
  11         SubExpr Expression
  12 }
  13 type Token struct {
  14         token   int
  15         literal string
  16 }
  17 type NumExpr struct {
  18         literal string
  19 }
  20 type BinOpExpr struct {
  21         left     NumExpr
  22         operator string
  23         right    NumExpr
  24 }
  25 type AssocExpr struct {
  26         left     Expression
  27         operator string
  28         right    Expression
  29 }
  30 type UnaryExpr struct {
  31         operator string
  32         right    Expression
  33 }
  34 %}
  35 %union{
  36         token Token
  37         expr  Expression
  38 }
  39 %type<expr> program
  40 %type<expr> expr
  41 %token<token> NUMBER NOT AND OR IS
  42 %left IS
  43 %left '<' GE '>' LE
  44 %left AND
  45 %left OR
  46 %right NOT
  47 %%
  48 program
  49         : expr
  50         {
  51                 $$ = $1
  52                 yylex.(*Lexer).result = $$
  53         }
  54 expr
  55         : NUMBER
  56         {
  57                 $$ = NumExpr{literal: $1.literal}
  58         }
  59         | NOT expr
  60         {
  61                 $$ = UnaryExpr{operator: "!", right: $2}
  62         }
  63         | expr AND expr
  64         {
  65                 $$ = AssocExpr{left: $1, operator: "&&", right: $3}
  66         }
  67         | '(' expr ')'
  68         {
  69                 $$ = ParenExpr{SubExpr: $2}
  70         }
  71         | expr OR expr
  72         {
  73                 $$ = AssocExpr{left: $1, operator: "||", right: $3}
  74         }
  75         | NUMBER '<' NUMBER
  76         {
  77                 $$ = BinOpExpr{left: NumExpr{literal: $1.literal}, operator: "<", right: NumExpr{literal: $3.literal}}
  78         }
  79         | NUMBER '>' NUMBER
  80         {
  81                 $$ = BinOpExpr{left: NumExpr{literal: $1.literal}, operator: ">", right: NumExpr{literal: $3.literal}}
  82         }
  83         | NUMBER IS NUMBER
  84         {
  85                 $$ = BinOpExpr{left: NumExpr{literal: $1.literal}, operator: "=", right: NumExpr{literal: $3.literal}}
  86         }
  87         | NUMBER GE NUMBER
  88         {
  89                 $$ = BinOpExpr{left: NumExpr{literal: $1.literal}, operator: ">=", right: NumExpr{literal: $3.literal}}
  90         }
  91         | NUMBER LE NUMBER
  92         {
  93                 $$ = BinOpExpr{left: NumExpr{literal: $1.literal}, operator: "<=", right: NumExpr{literal: $3.literal}}
  94         }
  95 %%
  96 type Lexer struct {
  97         scanner.Scanner
  98         Vars map[string]interface{}
  99         result Expression
 100 }
 101 func (l *Lexer) Lex(lval *yySymType) int {
 102         token := l.Scan()
 103         lit := l.TokenText()
 104         tok := int(token)
 105         switch tok {
 106         case scanner.Int:
 107                 tok = NUMBER
 108         default:
 109                 switch lit {
 110                 case "IS":
 111                         tok = IS
 112                 case "NOT":
 113                         tok = NOT
 114                 case "AND":
 115                         tok = AND
 116                 case "OR":
 117                         tok = OR
 118                 case "<=":
 119                         tok = LE
 120                 case ">=":
 121                         tok = GE
 122                 default:
 123                         if v, ok := l.Vars[lit]; ok {
 124                                 switch v.(type) {
 125                                 case int:
 126                                         tok = NUMBER
 127                                         lit = strconv.Itoa(v.(int))
 128                                 }
 129                         }
 130                 }
 131         }
 132         lval.token = Token{token: tok, literal: lit}
 133         return tok
 134 }
 135 func (l *Lexer) Error(e string) {
 136         panic(e)
 137 }
 138 func EvalN(e Expression) int {
 139         switch t := e.(type) {
 140         case NumExpr:
 141                 num, _ := strconv.Atoi(t.literal)
 142                 return num
 143         }
 144         return 0
 145 }
 146 func Eval(e Expression) bool {
 147         switch t := e.(type) {
 148         case ParenExpr:
 149                 fmt.Println("Sub")
 150                 return Eval(t.SubExpr)
 151         case UnaryExpr:
 152                 fmt.Println(t.operator)
 153                 right := Eval(t.right)
 154                 switch t.operator {
 155                 case "!":
 156                         return ! right
 157                 }
 158         case AssocExpr:
 159                 fmt.Println("Assoc")
 160                 left := Eval(t.left)
 161                 right := Eval(t.right)
 162                 switch t.operator {
 163                 case "||":
 164                         return left || right
 165                 case "&&":
 166                         return left && right
 167                 }
 168         case BinOpExpr:
 169                 fmt.Println("BinOp")
 170                 left := EvalN(t.left)
 171                 right := EvalN(t.right)
 172                 switch t.operator {
 173                 case ">":
 174                         return left > right
 175                 case "<":
 176                         return left < right
 177                 case "=":
 178                         return left == right
 179                 }
 180         default:
 181                 fmt.Printf("unsuported expr[%+v]", t)
 182         }
 183         return false
 184 }
 185 func Parse(exp string, vars map[string]interface{}) bool {
 186         l := new(Lexer)
 187         l.Vars = vars
 188         l.Init(strings.NewReader(exp))
 189         yyParse(l)
 190         return Eval(l.result)
 191 }
 192
 193 func main() {
 194         vars := map[string]interface{}{
 195                 "A": 1,
 196                 "B": 1,
 197         }
 198         f := Parse("NOT (A IS B)", vars)
 199         fmt.Printf("%t\n", f) // false
 200
 201         t := Parse("A IS B", vars)
 202         fmt.Printf("%t\n", t) // true
 203 }