diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json new file mode 100644 index 0000000..968e5f9 --- /dev/null +++ b/Godeps/Godeps.json @@ -0,0 +1,22 @@ +{ + "ImportPath": "github.com/leonelquinteros/gotext", + "GoVersion": "go1.6", + "GodepVersion": "v74", + "Packages": [ + "./..." + ], + "Deps": [ + { + "ImportPath": "github.com/mattn/anko/ast", + "Rev": "a8c68fa2983e7dd5d3472992b1fbe2f7c44261f0" + }, + { + "ImportPath": "github.com/mattn/anko/parser", + "Rev": "a8c68fa2983e7dd5d3472992b1fbe2f7c44261f0" + }, + { + "ImportPath": "github.com/mattn/anko/vm", + "Rev": "a8c68fa2983e7dd5d3472992b1fbe2f7c44261f0" + } + ] +} diff --git a/Godeps/Readme b/Godeps/Readme new file mode 100644 index 0000000..4cdaa53 --- /dev/null +++ b/Godeps/Readme @@ -0,0 +1,5 @@ +This directory tree is generated automatically by godep. + +Please do not edit. + +See https://github.com/tools/godep for more information. diff --git a/vendor/github.com/mattn/anko/ast/doc.go b/vendor/github.com/mattn/anko/ast/doc.go new file mode 100644 index 0000000..8781cfc --- /dev/null +++ b/vendor/github.com/mattn/anko/ast/doc.go @@ -0,0 +1,2 @@ +// Package ast implements abstruct-syntax-tree for anko. +package ast diff --git a/vendor/github.com/mattn/anko/ast/expr.go b/vendor/github.com/mattn/anko/ast/expr.go new file mode 100644 index 0000000..c43aac6 --- /dev/null +++ b/vendor/github.com/mattn/anko/ast/expr.go @@ -0,0 +1,201 @@ +package ast + +// Expr provides all of interfaces for expression. +type Expr interface { + Pos + expr() +} + +// ExprImpl provide commonly implementations for Expr. +type ExprImpl struct { + PosImpl // ExprImpl provide Pos() function. +} + +// expr provide restraint interface. +func (x *ExprImpl) expr() {} + +// NumberExpr provide Number expression. +type NumberExpr struct { + ExprImpl + Lit string +} + +// StringExpr provide String expression. +type StringExpr struct { + ExprImpl + Lit string +} + +// ArrayExpr provide Array expression. +type ArrayExpr struct { + ExprImpl + Exprs []Expr +} + +// PairExpr provide one of Map key/value pair. +type PairExpr struct { + ExprImpl + Key string + Value Expr +} + +// MapExpr provide Map expression. +type MapExpr struct { + ExprImpl + MapExpr map[string]Expr +} + +// IdentExpr provide identity expression. +type IdentExpr struct { + ExprImpl + Lit string +} + +// UnaryExpr provide unary minus expression. ex: -1, ^1, ~1. +type UnaryExpr struct { + ExprImpl + Operator string + Expr Expr +} + +// AddrExpr provide referencing address expression. +type AddrExpr struct { + ExprImpl + Expr Expr +} + +// DerefExpr provide dereferencing address expression. +type DerefExpr struct { + ExprImpl + Expr Expr +} + +// ParenExpr provide parent block expression. +type ParenExpr struct { + ExprImpl + SubExpr Expr +} + +// BinOpExpr provide binary operator expression. +type BinOpExpr struct { + ExprImpl + Lhs Expr + Operator string + Rhs Expr +} + +type TernaryOpExpr struct { + ExprImpl + Expr Expr + Lhs Expr + Rhs Expr +} + +// CallExpr provide calling expression. +type CallExpr struct { + ExprImpl + Func interface{} + Name string + SubExprs []Expr + VarArg bool + Go bool +} + +// AnonCallExpr provide anonymous calling expression. ex: func(){}(). +type AnonCallExpr struct { + ExprImpl + Expr Expr + SubExprs []Expr + VarArg bool + Go bool +} + +// MemberExpr provide expression to refer menber. +type MemberExpr struct { + ExprImpl + Expr Expr + Name string +} + +// ItemExpr provide expression to refer Map/Array item. +type ItemExpr struct { + ExprImpl + Value Expr + Index Expr +} + +// SliceExpr provide expression to refer slice of Array. +type SliceExpr struct { + ExprImpl + Value Expr + Begin Expr + End Expr +} + +// FuncExpr provide function expression. +type FuncExpr struct { + ExprImpl + Name string + Stmts []Stmt + Args []string + VarArg bool +} + +// LetExpr provide expression to let variable. +type LetExpr struct { + ExprImpl + Lhs Expr + Rhs Expr +} + +// LetsExpr provide multiple expression of let. +type LetsExpr struct { + ExprImpl + Lhss []Expr + Operator string + Rhss []Expr +} + +// AssocExpr provide expression to assoc operation. +type AssocExpr struct { + ExprImpl + Lhs Expr + Operator string + Rhs Expr +} + +// NewExpr provide expression to make new instance. +type NewExpr struct { + ExprImpl + Name string + SubExprs []Expr +} + +// ConstExpr provide expression for constant variable. +type ConstExpr struct { + ExprImpl + Value string +} + +type ChanExpr struct { + ExprImpl + Lhs Expr + Rhs Expr +} + +type Type struct { + Name string +} + +type MakeChanExpr struct { + ExprImpl + Type string + SizeExpr Expr +} + +type MakeArrayExpr struct { + ExprImpl + Type string + LenExpr Expr + CapExpr Expr +} diff --git a/vendor/github.com/mattn/anko/ast/pos.go b/vendor/github.com/mattn/anko/ast/pos.go new file mode 100644 index 0000000..5a0e470 --- /dev/null +++ b/vendor/github.com/mattn/anko/ast/pos.go @@ -0,0 +1,28 @@ +package ast + +// Position provides interface to store code locations. +type Position struct { + Line int + Column int +} + +// Pos interface provies two functions to get/set the position for expression or statement. +type Pos interface { + Position() Position + SetPosition(Position) +} + +// PosImpl provies commonly implementations for Pos. +type PosImpl struct { + pos Position +} + +// Position return the position of the expression or statement. +func (x *PosImpl) Position() Position { + return x.pos +} + +// SetPosition is a function to specify position of the expression or statement. +func (x *PosImpl) SetPosition(pos Position) { + x.pos = pos +} diff --git a/vendor/github.com/mattn/anko/ast/stmt.go b/vendor/github.com/mattn/anko/ast/stmt.go new file mode 100644 index 0000000..14bbdf7 --- /dev/null +++ b/vendor/github.com/mattn/anko/ast/stmt.go @@ -0,0 +1,127 @@ +package ast + +// Stmt provides all of interfaces for statement. +type Stmt interface { + Pos + stmt() +} + +// StmtImpl provide commonly implementations for Stmt.. +type StmtImpl struct { + PosImpl // StmtImpl provide Pos() function. +} + +// stmt provide restraint interface. +func (x *StmtImpl) stmt() {} + +// ExprStmt provide expression statement. +type ExprStmt struct { + StmtImpl + Expr Expr +} + +// IfStmt provide "if/else" statement. +type IfStmt struct { + StmtImpl + If Expr + Then []Stmt + ElseIf []Stmt // This is array of IfStmt + Else []Stmt +} + +// TryStmt provide "try/catch/finally" statement. +type TryStmt struct { + StmtImpl + Try []Stmt + Var string + Catch []Stmt + Finally []Stmt +} + +// ForStmt provide "for in" expression statement. +type ForStmt struct { + StmtImpl + Var string + Value Expr + Stmts []Stmt +} + +// CForStmt provide C-style "for (;;)" expression statement. +type CForStmt struct { + StmtImpl + Expr1 Expr + Expr2 Expr + Expr3 Expr + Stmts []Stmt +} + +// LoopStmt provide "for expr" expression statement. +type LoopStmt struct { + StmtImpl + Expr Expr + Stmts []Stmt +} + +// BreakStmt provide "break" expression statement. +type BreakStmt struct { + StmtImpl +} + +// ContinueStmt provide "continue" expression statement. +type ContinueStmt struct { + StmtImpl +} + +// ForStmt provide "return" expression statement. +type ReturnStmt struct { + StmtImpl + Exprs []Expr +} + +// ThrowStmt provide "throw" expression statement. +type ThrowStmt struct { + StmtImpl + Expr Expr +} + +// ModuleStmt provide "module" expression statement. +type ModuleStmt struct { + StmtImpl + Name string + Stmts []Stmt +} + +// VarStmt provide statement to let variables in current scope. +type VarStmt struct { + StmtImpl + Names []string + Exprs []Expr +} + +// SwitchStmt provide switch statement. +type SwitchStmt struct { + StmtImpl + Expr Expr + Cases []Stmt +} + +// CaseStmt provide switch/case statement. +type CaseStmt struct { + StmtImpl + Expr Expr + Stmts []Stmt +} + +// DefaultStmt provide switch/default statement. +type DefaultStmt struct { + StmtImpl + Stmts []Stmt +} + +// LetsStmt provide multiple statement of let. +type LetsStmt struct { + StmtImpl + Lhss []Expr + Operator string + Rhss []Expr +} diff --git a/vendor/github.com/mattn/anko/ast/token.go b/vendor/github.com/mattn/anko/ast/token.go new file mode 100644 index 0000000..6b47cd0 --- /dev/null +++ b/vendor/github.com/mattn/anko/ast/token.go @@ -0,0 +1,7 @@ +package ast + +type Token struct { + PosImpl // StmtImpl provide Pos() function. + Tok int + Lit string +} diff --git a/vendor/github.com/mattn/anko/parser/Makefile b/vendor/github.com/mattn/anko/parser/Makefile new file mode 100644 index 0000000..8b33e31 --- /dev/null +++ b/vendor/github.com/mattn/anko/parser/Makefile @@ -0,0 +1,4 @@ +all : parser.go + +parser.go : parser.go.y + go tool yacc -o $@ parser.go.y diff --git a/vendor/github.com/mattn/anko/parser/lexer.go b/vendor/github.com/mattn/anko/parser/lexer.go new file mode 100644 index 0000000..ea0fc49 --- /dev/null +++ b/vendor/github.com/mattn/anko/parser/lexer.go @@ -0,0 +1,530 @@ +// Package parser implements parser for anko. +package parser + +import ( + "errors" + "fmt" + + "github.com/mattn/anko/ast" +) + +const ( + EOF = -1 // End of file. + EOL = '\n' // End of line. +) + +// Error provides a convenient interface for handling runtime error. +// It can be Error inteface with type cast which can call Pos(). +type Error struct { + Message string + Pos ast.Position + Filename string + Fatal bool +} + +// Error returns the error message. +func (e *Error) Error() string { + return e.Message +} + +// Scanner stores informations for lexer. +type Scanner struct { + src []rune + offset int + lineHead int + line int +} + +// opName is correction of operation names. +var opName = map[string]int{ + "func": FUNC, + "return": RETURN, + "var": VAR, + "throw": THROW, + "if": IF, + "for": FOR, + "break": BREAK, + "continue": CONTINUE, + "in": IN, + "else": ELSE, + "new": NEW, + "true": TRUE, + "false": FALSE, + "nil": NIL, + "module": MODULE, + "try": TRY, + "catch": CATCH, + "finally": FINALLY, + "switch": SWITCH, + "case": CASE, + "default": DEFAULT, + "go": GO, + "chan": CHAN, + "make": MAKE, +} + +// Init resets code to scan. +func (s *Scanner) Init(src string) { + s.src = []rune(src) +} + +// Scan analyses token, and decide identify or literals. +func (s *Scanner) Scan() (tok int, lit string, pos ast.Position, err error) { +retry: + s.skipBlank() + pos = s.pos() + switch ch := s.peek(); { + case isLetter(ch): + lit, err = s.scanIdentifier() + if err != nil { + return + } + if name, ok := opName[lit]; ok { + tok = name + } else { + tok = IDENT + } + case isDigit(ch): + tok = NUMBER + lit, err = s.scanNumber() + if err != nil { + return + } + case ch == '"': + tok = STRING + lit, err = s.scanString('"') + if err != nil { + return + } + case ch == '\'': + tok = STRING + lit, err = s.scanString('\'') + if err != nil { + return + } + case ch == '`': + tok = STRING + lit, err = s.scanRawString() + if err != nil { + return + } + default: + switch ch { + case EOF: + tok = EOF + case '#': + for !isEOL(s.peek()) { + s.next() + } + goto retry + case '!': + s.next() + switch s.peek() { + case '=': + tok = NEQ + lit = "!=" + default: + s.back() + tok = int(ch) + lit = string(ch) + } + case '=': + s.next() + switch s.peek() { + case '=': + tok = EQEQ + lit = "==" + default: + s.back() + tok = int(ch) + lit = string(ch) + } + case '+': + s.next() + switch s.peek() { + case '+': + tok = PLUSPLUS + lit = "++" + case '=': + tok = PLUSEQ + lit = "+=" + default: + s.back() + tok = int(ch) + lit = string(ch) + } + case '-': + s.next() + switch s.peek() { + case '-': + tok = MINUSMINUS + lit = "--" + case '=': + tok = MINUSEQ + lit = "-=" + default: + s.back() + tok = int(ch) + lit = string(ch) + } + case '*': + s.next() + switch s.peek() { + case '*': + tok = POW + lit = "**" + case '=': + tok = MULEQ + lit = "*=" + default: + s.back() + tok = int(ch) + lit = string(ch) + } + case '/': + s.next() + switch s.peek() { + case '=': + tok = DIVEQ + lit = "/=" + default: + s.back() + tok = int(ch) + lit = string(ch) + } + case '>': + s.next() + switch s.peek() { + case '=': + tok = GE + lit = ">=" + case '>': + tok = SHIFTRIGHT + lit = ">>" + default: + s.back() + tok = int(ch) + lit = string(ch) + } + case '<': + s.next() + switch s.peek() { + case '-': + tok = OPCHAN + lit = "<-" + case '=': + tok = LE + lit = "<=" + case '<': + tok = SHIFTLEFT + lit = "<<" + default: + s.back() + tok = int(ch) + lit = string(ch) + } + case '|': + s.next() + switch s.peek() { + case '|': + tok = OROR + lit = "||" + case '=': + tok = OREQ + lit = "|=" + default: + s.back() + tok = int(ch) + lit = string(ch) + } + case '&': + s.next() + switch s.peek() { + case '&': + tok = ANDAND + lit = "&&" + case '=': + tok = ANDEQ + lit = "&=" + default: + s.back() + tok = int(ch) + lit = string(ch) + } + case '.': + s.next() + if s.peek() == '.' { + s.next() + if s.peek() == '.' { + tok = VARARG + } else { + err = fmt.Errorf(`syntax error "%s"`, "..") + return + } + } else { + s.back() + tok = int(ch) + lit = string(ch) + } + case '(', ')', ':', ';', '%', '?', '{', '}', ',', '[', ']', '^', '\n': + s.next() + if ch == '[' && s.peek() == ']' { + s.next() + if isLetter(s.peek()) { + s.back() + tok = ARRAYLIT + lit = "[]" + } else { + s.back() + s.back() + tok = int(ch) + lit = string(ch) + } + } else { + s.back() + tok = int(ch) + lit = string(ch) + } + default: + err = fmt.Errorf(`syntax error "%s"`, string(ch)) + return + } + s.next() + } + return +} + +// isLetter returns true if the rune is a letter for identity. +func isLetter(ch rune) bool { + return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' +} + +// isDigit returns true if the rune is a number. +func isDigit(ch rune) bool { + return '0' <= ch && ch <= '9' +} + +// isHex returns true if the rune is a hex digits. +func isHex(ch rune) bool { + return ('0' <= ch && ch <= '9') || ('a' <= ch && ch <= 'f') || ('A' <= ch && ch <= 'F') +} + +// isEOL returns true if the rune is at end-of-line or end-of-file. +func isEOL(ch rune) bool { + return ch == '\n' || ch == -1 +} + +// isBlank returns true if the rune is empty character.. +func isBlank(ch rune) bool { + return ch == ' ' || ch == '\t' || ch == '\r' +} + +// peek returns current rune in the code. +func (s *Scanner) peek() rune { + if s.reachEOF() { + return EOF + } + return s.src[s.offset] +} + +// next moves offset to next. +func (s *Scanner) next() { + if !s.reachEOF() { + if s.peek() == '\n' { + s.lineHead = s.offset + 1 + s.line++ + } + s.offset++ + } +} + +// current returns the current offset. +func (s *Scanner) current() int { + return s.offset +} + +// offset sets the offset value. +func (s *Scanner) set(o int) { + s.offset = o +} + +// back moves back offset once to top. +func (s *Scanner) back() { + s.offset-- +} + +// reachEOF returns true if offset is at end-of-file. +func (s *Scanner) reachEOF() bool { + return len(s.src) <= s.offset +} + +// pos returns the position of current. +func (s *Scanner) pos() ast.Position { + return ast.Position{Line: s.line + 1, Column: s.offset - s.lineHead + 1} +} + +// skipBlank moves position into non-black character. +func (s *Scanner) skipBlank() { + for isBlank(s.peek()) { + s.next() + } +} + +// scanIdentifier returns identifier begining at current position. +func (s *Scanner) scanIdentifier() (string, error) { + var ret []rune + for { + if !isLetter(s.peek()) && !isDigit(s.peek()) { + break + } + ret = append(ret, s.peek()) + s.next() + } + return string(ret), nil +} + +// scanNumber returns number begining at current position. +func (s *Scanner) scanNumber() (string, error) { + var ret []rune + ch := s.peek() + ret = append(ret, ch) + s.next() + if ch == '0' && s.peek() == 'x' { + ret = append(ret, s.peek()) + s.next() + for isHex(s.peek()) { + ret = append(ret, s.peek()) + s.next() + } + } else { + for isDigit(s.peek()) || s.peek() == '.' { + ret = append(ret, s.peek()) + s.next() + } + if s.peek() == 'e' { + ret = append(ret, s.peek()) + s.next() + if isDigit(s.peek()) || s.peek() == '+' || s.peek() == '-' { + ret = append(ret, s.peek()) + s.next() + for isDigit(s.peek()) || s.peek() == '.' { + ret = append(ret, s.peek()) + s.next() + } + } + for isDigit(s.peek()) || s.peek() == '.' { + ret = append(ret, s.peek()) + s.next() + } + } + if isLetter(s.peek()) { + return "", errors.New("identifier starts immediately after numeric literal") + } + } + return string(ret), nil +} + +// scanRawString returns raw-string starting at current position. +func (s *Scanner) scanRawString() (string, error) { + var ret []rune + for { + s.next() + if s.peek() == EOF { + return "", errors.New("unexpected EOF") + break + } + if s.peek() == '`' { + s.next() + break + } + ret = append(ret, s.peek()) + } + return string(ret), nil +} + +// scanString returns string starting at current position. +// This handles backslash escaping. +func (s *Scanner) scanString(l rune) (string, error) { + var ret []rune +eos: + for { + s.next() + switch s.peek() { + case EOL: + return "", errors.New("unexpected EOL") + case EOF: + return "", errors.New("unexpected EOF") + case l: + s.next() + break eos + case '\\': + s.next() + switch s.peek() { + case 'b': + ret = append(ret, '\b') + continue + case 'f': + ret = append(ret, '\f') + continue + case 'r': + ret = append(ret, '\r') + continue + case 'n': + ret = append(ret, '\n') + continue + case 't': + ret = append(ret, '\t') + continue + } + ret = append(ret, s.peek()) + continue + default: + ret = append(ret, s.peek()) + } + } + return string(ret), nil +} + +// Lexer provides inteface to parse codes. +type Lexer struct { + s *Scanner + lit string + pos ast.Position + e error + stmts []ast.Stmt +} + +// Lex scans the token and literals. +func (l *Lexer) Lex(lval *yySymType) int { + tok, lit, pos, err := l.s.Scan() + if err != nil { + l.e = &Error{Message: fmt.Sprintf("%s", err.Error()), Pos: pos, Fatal: true} + } + lval.tok = ast.Token{Tok: tok, Lit: lit} + lval.tok.SetPosition(pos) + l.lit = lit + l.pos = pos + return tok +} + +// Error sets parse error. +func (l *Lexer) Error(msg string) { + l.e = &Error{Message: msg, Pos: l.pos, Fatal: false} +} + +// Parser provides way to parse the code using Scanner. +func Parse(s *Scanner) ([]ast.Stmt, error) { + l := Lexer{s: s} + if yyParse(&l) != 0 { + return nil, l.e + } + return l.stmts, l.e +} + +// ParserSrc provides way to parse the code from source. +func ParseSrc(src string) ([]ast.Stmt, error) { + scanner := &Scanner{ + src: []rune(src), + } + return Parse(scanner) +} diff --git a/vendor/github.com/mattn/anko/parser/parser.go b/vendor/github.com/mattn/anko/parser/parser.go new file mode 100644 index 0000000..01f5adf --- /dev/null +++ b/vendor/github.com/mattn/anko/parser/parser.go @@ -0,0 +1,1997 @@ +//line parser.go.y:2 +package parser + +import __yyfmt__ "fmt" + +//line parser.go.y:2 +import ( + "github.com/mattn/anko/ast" +) + +//line parser.go.y:26 +type yySymType struct { + yys int + compstmt []ast.Stmt + stmt_if ast.Stmt + stmt_default ast.Stmt + stmt_case ast.Stmt + stmt_cases []ast.Stmt + stmts []ast.Stmt + stmt ast.Stmt + typ ast.Type + expr ast.Expr + exprs []ast.Expr + expr_many []ast.Expr + expr_lets ast.Expr + expr_pair ast.Expr + expr_pairs []ast.Expr + expr_idents []string + tok ast.Token + term ast.Token + terms ast.Token + opt_terms ast.Token +} + +const IDENT = 57346 +const NUMBER = 57347 +const STRING = 57348 +const ARRAY = 57349 +const VARARG = 57350 +const FUNC = 57351 +const RETURN = 57352 +const VAR = 57353 +const THROW = 57354 +const IF = 57355 +const ELSE = 57356 +const FOR = 57357 +const IN = 57358 +const EQEQ = 57359 +const NEQ = 57360 +const GE = 57361 +const LE = 57362 +const OROR = 57363 +const ANDAND = 57364 +const NEW = 57365 +const TRUE = 57366 +const FALSE = 57367 +const NIL = 57368 +const MODULE = 57369 +const TRY = 57370 +const CATCH = 57371 +const FINALLY = 57372 +const PLUSEQ = 57373 +const MINUSEQ = 57374 +const MULEQ = 57375 +const DIVEQ = 57376 +const ANDEQ = 57377 +const OREQ = 57378 +const BREAK = 57379 +const CONTINUE = 57380 +const PLUSPLUS = 57381 +const MINUSMINUS = 57382 +const POW = 57383 +const SHIFTLEFT = 57384 +const SHIFTRIGHT = 57385 +const SWITCH = 57386 +const CASE = 57387 +const DEFAULT = 57388 +const GO = 57389 +const CHAN = 57390 +const MAKE = 57391 +const OPCHAN = 57392 +const ARRAYLIT = 57393 +const UNARY = 57394 + +var yyToknames = [...]string{ + "$end", + "error", + "$unk", + "IDENT", + "NUMBER", + "STRING", + "ARRAY", + "VARARG", + "FUNC", + "RETURN", + "VAR", + "THROW", + "IF", + "ELSE", + "FOR", + "IN", + "EQEQ", + "NEQ", + "GE", + "LE", + "OROR", + "ANDAND", + "NEW", + "TRUE", + "FALSE", + "NIL", + "MODULE", + "TRY", + "CATCH", + "FINALLY", + "PLUSEQ", + "MINUSEQ", + "MULEQ", + "DIVEQ", + "ANDEQ", + "OREQ", + "BREAK", + "CONTINUE", + "PLUSPLUS", + "MINUSMINUS", + "POW", + "SHIFTLEFT", + "SHIFTRIGHT", + "SWITCH", + "CASE", + "DEFAULT", + "GO", + "CHAN", + "MAKE", + "OPCHAN", + "ARRAYLIT", + "'='", + "'?'", + "':'", + "','", + "'>'", + "'<'", + "'+'", + "'-'", + "'*'", + "'/'", + "'%'", + "UNARY", + "'{'", + "'}'", + "';'", + "'.'", + "'!'", + "'^'", + "'&'", + "'('", + "')'", + "'['", + "']'", + "'|'", + "'\\n'", +} +var yyStatenames = [...]string{} + +const yyEofCode = 1 +const yyErrCode = 2 +const yyInitialStackSize = 16 + +//line parser.go.y:705 + +//line yacctab:1 +var yyExca = [...]int{ + -1, 0, + 1, 3, + -2, 121, + -1, 1, + 1, -1, + -2, 0, + -1, 2, + 55, 48, + -2, 1, + -1, 10, + 55, 49, + -2, 24, + -1, 43, + 55, 48, + -2, 122, + -1, 85, + 65, 3, + -2, 121, + -1, 88, + 55, 49, + -2, 43, + -1, 90, + 65, 3, + -2, 121, + -1, 97, + 1, 57, + 8, 57, + 45, 57, + 46, 57, + 52, 57, + 54, 57, + 55, 57, + 64, 57, + 65, 57, + 66, 57, + 72, 57, + 74, 57, + 76, 57, + -2, 52, + -1, 99, + 1, 59, + 8, 59, + 45, 59, + 46, 59, + 52, 59, + 54, 59, + 55, 59, + 64, 59, + 65, 59, + 66, 59, + 72, 59, + 74, 59, + 76, 59, + -2, 52, + -1, 127, + 17, 0, + 18, 0, + -2, 85, + -1, 128, + 17, 0, + 18, 0, + -2, 86, + -1, 147, + 55, 49, + -2, 43, + -1, 149, + 65, 3, + -2, 121, + -1, 151, + 65, 3, + -2, 121, + -1, 153, + 65, 1, + -2, 36, + -1, 156, + 65, 3, + -2, 121, + -1, 178, + 65, 3, + -2, 121, + -1, 220, + 55, 50, + -2, 44, + -1, 221, + 1, 45, + 45, 45, + 46, 45, + 52, 45, + 55, 51, + 65, 45, + 66, 45, + 76, 45, + -2, 52, + -1, 228, + 1, 51, + 8, 51, + 45, 51, + 46, 51, + 55, 51, + 65, 51, + 66, 51, + 72, 51, + 74, 51, + 76, 51, + -2, 52, + -1, 230, + 65, 3, + -2, 121, + -1, 232, + 65, 3, + -2, 121, + -1, 245, + 65, 3, + -2, 121, + -1, 256, + 1, 106, + 8, 106, + 45, 106, + 46, 106, + 52, 106, + 54, 106, + 55, 106, + 64, 106, + 65, 106, + 66, 106, + 72, 106, + 74, 106, + 76, 106, + -2, 104, + -1, 258, + 1, 110, + 8, 110, + 45, 110, + 46, 110, + 52, 110, + 54, 110, + 55, 110, + 64, 110, + 65, 110, + 66, 110, + 72, 110, + 74, 110, + 76, 110, + -2, 108, + -1, 269, + 65, 3, + -2, 121, + -1, 274, + 65, 3, + -2, 121, + -1, 275, + 65, 3, + -2, 121, + -1, 280, + 1, 105, + 8, 105, + 45, 105, + 46, 105, + 52, 105, + 54, 105, + 55, 105, + 64, 105, + 65, 105, + 66, 105, + 72, 105, + 74, 105, + 76, 105, + -2, 103, + -1, 281, + 1, 109, + 8, 109, + 45, 109, + 46, 109, + 52, 109, + 54, 109, + 55, 109, + 64, 109, + 65, 109, + 66, 109, + 72, 109, + 74, 109, + 76, 109, + -2, 107, + -1, 287, + 65, 3, + -2, 121, + -1, 288, + 65, 3, + -2, 121, + -1, 291, + 45, 3, + 46, 3, + 65, 3, + -2, 121, + -1, 295, + 65, 3, + -2, 121, + -1, 302, + 45, 3, + 46, 3, + 65, 3, + -2, 121, + -1, 315, + 65, 3, + -2, 121, + -1, 316, + 65, 3, + -2, 121, +} + +const yyNprod = 127 +const yyPrivate = 57344 + +var yyTokenNames []string +var yyStates []string + +const yyLast = 2223 + +var yyAct = [...]int{ + + 81, 169, 237, 10, 217, 238, 45, 6, 92, 211, + 93, 2, 1, 250, 281, 42, 82, 7, 209, 88, + 6, 91, 280, 276, 94, 95, 96, 98, 100, 6, + 7, 11, 40, 154, 246, 173, 105, 93, 108, 7, + 110, 243, 112, 225, 10, 103, 104, 80, 116, 117, + 89, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 102, 172, 139, 140, 141, 142, 166, 144, 145, + 147, 257, 64, 65, 66, 67, 68, 69, 92, 109, + 93, 155, 55, 261, 161, 255, 148, 153, 152, 115, + 115, 78, 199, 158, 320, 259, 182, 262, 164, 143, + 260, 146, 319, 254, 312, 147, 247, 205, 49, 259, + 309, 74, 76, 177, 77, 160, 72, 180, 148, 170, + 239, 240, 268, 308, 305, 304, 167, 301, 101, 292, + 286, 285, 148, 263, 252, 258, 179, 234, 231, 148, + 236, 188, 316, 148, 10, 192, 193, 229, 147, 256, + 186, 196, 187, 315, 189, 190, 200, 150, 295, 194, + 183, 198, 288, 207, 275, 274, 245, 149, 220, 210, + 212, 219, 224, 90, 148, 111, 226, 227, 279, 195, + 114, 222, 269, 115, 271, 213, 175, 157, 79, 176, + 8, 241, 314, 244, 242, 214, 215, 216, 239, 240, + 5, 310, 235, 84, 253, 44, 248, 206, 151, 170, + 282, 249, 223, 251, 218, 208, 204, 203, 165, 118, + 106, 83, 46, 4, 267, 168, 87, 43, 197, 17, + 270, 3, 0, 265, 113, 266, 0, 0, 0, 0, + 227, 0, 0, 278, 44, 61, 63, 0, 273, 0, + 0, 0, 283, 284, 0, 0, 0, 64, 65, 66, + 67, 68, 69, 0, 0, 70, 71, 55, 56, 57, + 0, 0, 289, 291, 0, 0, 78, 293, 294, 0, + 0, 0, 60, 62, 50, 51, 52, 53, 54, 307, + 299, 300, 302, 49, 303, 0, 74, 76, 306, 77, + 0, 72, 0, 0, 0, 311, 58, 59, 61, 63, + 73, 75, 0, 0, 0, 0, 0, 0, 317, 318, + 64, 65, 66, 67, 68, 69, 0, 0, 70, 71, + 55, 56, 57, 0, 0, 0, 0, 0, 0, 78, + 0, 0, 48, 0, 298, 60, 62, 50, 51, 52, + 53, 54, 0, 0, 0, 0, 49, 0, 0, 74, + 76, 297, 77, 0, 72, 58, 59, 61, 63, 73, + 75, 0, 0, 0, 0, 0, 0, 0, 0, 64, + 65, 66, 67, 68, 69, 0, 0, 70, 71, 55, + 56, 57, 0, 0, 0, 0, 0, 0, 78, 0, + 0, 48, 202, 0, 60, 62, 50, 51, 52, 53, + 54, 0, 0, 0, 0, 49, 0, 0, 74, 76, + 0, 77, 201, 72, 58, 59, 61, 63, 73, 75, + 0, 0, 0, 0, 0, 0, 0, 0, 64, 65, + 66, 67, 68, 69, 0, 0, 70, 71, 55, 56, + 57, 0, 0, 0, 0, 0, 0, 78, 0, 0, + 48, 185, 0, 60, 62, 50, 51, 52, 53, 54, + 0, 0, 0, 0, 49, 0, 0, 74, 76, 0, + 77, 184, 72, 58, 59, 61, 63, 73, 75, 0, + 0, 0, 0, 0, 0, 0, 0, 64, 65, 66, + 67, 68, 69, 0, 0, 70, 71, 55, 56, 57, + 0, 0, 0, 0, 0, 0, 78, 0, 0, 48, + 0, 0, 60, 62, 50, 51, 52, 53, 54, 0, + 0, 0, 0, 49, 0, 0, 74, 76, 313, 77, + 0, 72, 58, 59, 61, 63, 73, 75, 0, 0, + 0, 0, 0, 0, 0, 0, 64, 65, 66, 67, + 68, 69, 0, 0, 70, 71, 55, 56, 57, 0, + 0, 0, 0, 0, 0, 78, 0, 0, 48, 0, + 0, 60, 62, 50, 51, 52, 53, 54, 0, 0, + 0, 0, 49, 0, 0, 74, 76, 296, 77, 0, + 72, 58, 59, 61, 63, 73, 75, 0, 0, 0, + 0, 0, 0, 0, 0, 64, 65, 66, 67, 68, + 69, 0, 0, 70, 71, 55, 56, 57, 0, 0, + 0, 0, 0, 0, 78, 0, 0, 48, 290, 0, + 60, 62, 50, 51, 52, 53, 54, 0, 0, 0, + 0, 49, 0, 0, 74, 76, 0, 77, 0, 72, + 58, 59, 61, 63, 73, 75, 0, 0, 0, 0, + 0, 0, 0, 0, 64, 65, 66, 67, 68, 69, + 0, 0, 70, 71, 55, 56, 57, 0, 0, 0, + 0, 0, 0, 78, 0, 0, 48, 0, 0, 60, + 62, 50, 51, 52, 53, 54, 0, 287, 0, 0, + 49, 0, 0, 74, 76, 0, 77, 0, 72, 58, + 59, 61, 63, 73, 75, 0, 0, 0, 0, 0, + 0, 0, 0, 64, 65, 66, 67, 68, 69, 0, + 0, 70, 71, 55, 56, 57, 0, 0, 0, 0, + 0, 0, 78, 0, 0, 48, 0, 0, 60, 62, + 50, 51, 52, 53, 54, 0, 0, 0, 0, 49, + 0, 0, 74, 76, 0, 77, 272, 72, 58, 59, + 61, 63, 73, 75, 0, 0, 0, 0, 0, 0, + 0, 0, 64, 65, 66, 67, 68, 69, 0, 0, + 70, 71, 55, 56, 57, 0, 0, 0, 0, 0, + 0, 78, 0, 0, 48, 0, 0, 60, 62, 50, + 51, 52, 53, 54, 0, 0, 0, 0, 49, 0, + 0, 74, 76, 0, 77, 264, 72, 58, 59, 61, + 63, 73, 75, 0, 0, 0, 0, 0, 0, 0, + 0, 64, 65, 66, 67, 68, 69, 0, 0, 70, + 71, 55, 56, 57, 0, 0, 0, 0, 0, 0, + 78, 0, 0, 48, 0, 0, 60, 62, 50, 51, + 52, 53, 54, 0, 0, 0, 233, 49, 0, 0, + 74, 76, 0, 77, 0, 72, 58, 59, 61, 63, + 73, 75, 0, 0, 0, 0, 0, 0, 0, 0, + 64, 65, 66, 67, 68, 69, 0, 0, 70, 71, + 55, 56, 57, 0, 0, 0, 0, 0, 0, 78, + 0, 0, 48, 0, 0, 60, 62, 50, 51, 52, + 53, 54, 0, 232, 0, 0, 49, 0, 0, 74, + 76, 0, 77, 0, 72, 58, 59, 61, 63, 73, + 75, 0, 0, 0, 0, 0, 0, 0, 0, 64, + 65, 66, 67, 68, 69, 0, 0, 70, 71, 55, + 56, 57, 0, 0, 0, 0, 0, 0, 78, 0, + 0, 48, 0, 0, 60, 62, 50, 51, 52, 53, + 54, 0, 230, 0, 0, 49, 0, 0, 74, 76, + 0, 77, 0, 72, 58, 59, 61, 63, 73, 75, + 0, 0, 0, 0, 0, 0, 0, 0, 64, 65, + 66, 67, 68, 69, 0, 0, 70, 71, 55, 56, + 57, 0, 0, 0, 0, 0, 0, 78, 0, 0, + 48, 181, 0, 60, 62, 50, 51, 52, 53, 54, + 0, 0, 0, 0, 49, 0, 0, 74, 76, 0, + 77, 0, 72, 58, 59, 61, 63, 73, 75, 0, + 0, 0, 0, 0, 0, 0, 0, 64, 65, 66, + 67, 68, 69, 0, 0, 70, 71, 55, 56, 57, + 0, 0, 0, 0, 0, 0, 78, 0, 0, 48, + 0, 0, 60, 62, 50, 51, 52, 53, 54, 0, + 178, 0, 0, 49, 0, 0, 74, 76, 0, 77, + 0, 72, 58, 59, 61, 63, 73, 75, 0, 0, + 0, 0, 0, 0, 0, 0, 64, 65, 66, 67, + 68, 69, 0, 0, 70, 71, 55, 56, 57, 0, + 0, 0, 0, 0, 0, 78, 0, 0, 48, 0, + 0, 60, 62, 50, 51, 52, 53, 54, 0, 0, + 0, 0, 49, 0, 0, 74, 76, 171, 77, 0, + 72, 58, 59, 61, 63, 73, 75, 0, 0, 0, + 0, 0, 0, 0, 0, 64, 65, 66, 67, 68, + 69, 0, 0, 70, 71, 55, 56, 57, 0, 0, + 0, 0, 0, 0, 78, 0, 0, 48, 0, 0, + 60, 62, 50, 51, 52, 53, 54, 0, 159, 0, + 0, 49, 0, 0, 74, 76, 0, 77, 0, 72, + 58, 59, 61, 63, 73, 75, 0, 0, 0, 0, + 0, 0, 0, 0, 64, 65, 66, 67, 68, 69, + 0, 0, 70, 71, 55, 56, 57, 0, 0, 0, + 0, 0, 0, 78, 0, 0, 48, 0, 0, 60, + 62, 50, 51, 52, 53, 54, 0, 156, 0, 0, + 49, 0, 0, 74, 76, 0, 77, 0, 72, 21, + 22, 28, 0, 0, 32, 14, 9, 15, 41, 0, + 18, 0, 0, 0, 0, 0, 0, 0, 36, 29, + 30, 31, 16, 19, 0, 0, 0, 0, 0, 0, + 0, 0, 12, 13, 0, 0, 0, 0, 0, 20, + 0, 0, 37, 0, 38, 39, 0, 0, 0, 0, + 0, 0, 0, 0, 23, 27, 0, 0, 0, 34, + 0, 6, 0, 24, 25, 26, 35, 0, 33, 0, + 0, 7, 58, 59, 61, 63, 73, 75, 0, 0, + 0, 0, 0, 0, 0, 0, 64, 65, 66, 67, + 68, 69, 0, 0, 70, 71, 55, 56, 57, 0, + 0, 0, 0, 0, 0, 78, 0, 47, 48, 0, + 0, 60, 62, 50, 51, 52, 53, 54, 0, 0, + 0, 0, 49, 0, 0, 74, 76, 0, 77, 0, + 72, 58, 59, 61, 63, 73, 75, 0, 0, 0, + 0, 0, 0, 0, 0, 64, 65, 66, 67, 68, + 69, 0, 0, 70, 71, 55, 56, 57, 0, 0, + 0, 0, 0, 0, 78, 0, 0, 48, 0, 0, + 60, 62, 50, 51, 52, 53, 54, 0, 0, 0, + 0, 49, 0, 0, 74, 76, 0, 77, 0, 72, + 58, 59, 61, 63, 73, 75, 0, 0, 0, 0, + 0, 0, 0, 0, 64, 65, 66, 67, 68, 69, + 0, 0, 70, 71, 55, 56, 57, 0, 0, 0, + 0, 0, 0, 78, 0, 0, 48, 0, 0, 60, + 62, 50, 51, 52, 53, 54, 0, 0, 0, 0, + 49, 0, 0, 74, 174, 0, 77, 0, 72, 58, + 59, 61, 63, 73, 75, 0, 0, 0, 0, 0, + 0, 0, 0, 64, 65, 66, 67, 68, 69, 0, + 0, 70, 71, 55, 56, 57, 0, 0, 0, 0, + 0, 0, 78, 0, 0, 48, 0, 0, 60, 62, + 50, 51, 52, 53, 54, 0, 0, 0, 0, 163, + 0, 0, 74, 76, 0, 77, 0, 72, 58, 59, + 61, 63, 73, 75, 0, 0, 0, 0, 0, 0, + 0, 0, 64, 65, 66, 67, 68, 69, 0, 0, + 70, 71, 55, 56, 57, 0, 0, 0, 0, 0, + 0, 78, 0, 0, 48, 0, 0, 60, 62, 50, + 51, 52, 53, 54, 58, 59, 61, 63, 162, 75, + 0, 74, 76, 0, 77, 0, 72, 0, 64, 65, + 66, 67, 68, 69, 0, 0, 70, 71, 55, 56, + 57, 0, 0, 0, 0, 0, 0, 78, 0, 0, + 0, 0, 0, 60, 62, 50, 51, 52, 53, 54, + 58, 59, 61, 63, 49, 0, 0, 74, 76, 0, + 77, 0, 72, 0, 64, 65, 66, 67, 68, 69, + 0, 0, 70, 71, 55, 56, 57, 0, 0, 0, + 0, 0, 0, 78, 0, 0, 0, 0, 0, 60, + 62, 50, 51, 52, 53, 54, 0, 0, 0, 0, + 49, 0, 0, 74, 76, 0, 77, 0, 72, 21, + 22, 191, 0, 0, 32, 14, 9, 15, 41, 0, + 18, 0, 0, 0, 0, 0, 0, 0, 36, 29, + 30, 31, 16, 19, 0, 0, 0, 0, 0, 0, + 0, 0, 12, 13, 0, 0, 0, 0, 0, 20, + 0, 0, 37, 0, 38, 39, 0, 0, 0, 0, + 0, 0, 0, 0, 23, 27, 0, 0, 0, 34, + 0, 0, 0, 24, 25, 26, 35, 0, 33, 21, + 22, 28, 0, 0, 32, 14, 9, 15, 41, 0, + 18, 0, 0, 0, 0, 0, 0, 0, 36, 29, + 30, 31, 16, 19, 0, 0, 0, 0, 0, 0, + 0, 0, 12, 13, 0, 0, 0, 0, 0, 20, + 0, 0, 37, 0, 38, 39, 0, 0, 64, 65, + 66, 67, 68, 69, 23, 27, 70, 71, 55, 34, + 0, 0, 0, 24, 25, 26, 35, 78, 33, 0, + 0, 0, 0, 0, 0, 50, 51, 52, 53, 54, + 228, 22, 28, 0, 49, 32, 0, 74, 76, 0, + 77, 0, 72, 0, 0, 0, 0, 0, 0, 36, + 29, 30, 31, 0, 0, 0, 0, 0, 21, 22, + 28, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 37, 0, 38, 39, 36, 29, 30, + 31, 0, 0, 0, 0, 23, 27, 228, 22, 28, + 34, 0, 32, 0, 24, 25, 26, 35, 0, 33, + 277, 37, 0, 38, 39, 0, 36, 29, 30, 31, + 0, 0, 0, 23, 27, 221, 22, 28, 34, 0, + 32, 0, 24, 25, 26, 35, 0, 33, 0, 0, + 37, 0, 38, 39, 36, 29, 30, 31, 0, 0, + 0, 0, 23, 27, 107, 22, 28, 34, 0, 32, + 0, 24, 25, 26, 35, 0, 33, 0, 37, 0, + 38, 39, 0, 36, 29, 30, 31, 0, 0, 0, + 23, 27, 99, 22, 28, 34, 0, 32, 0, 24, + 25, 26, 35, 0, 33, 0, 0, 37, 0, 38, + 39, 36, 29, 30, 31, 0, 0, 0, 0, 23, + 27, 97, 22, 28, 34, 0, 32, 0, 24, 25, + 26, 35, 0, 33, 0, 37, 0, 38, 39, 0, + 36, 29, 30, 31, 0, 0, 0, 23, 27, 86, + 22, 28, 34, 0, 32, 0, 24, 25, 26, 35, + 0, 33, 0, 0, 37, 0, 38, 39, 36, 29, + 30, 31, 0, 0, 0, 0, 23, 27, 0, 0, + 0, 34, 0, 0, 0, 24, 25, 26, 35, 0, + 33, 0, 37, 0, 38, 39, 0, 0, 64, 65, + 66, 67, 68, 69, 23, 27, 0, 0, 55, 85, + 0, 0, 0, 24, 25, 26, 35, 78, 33, 0, + 0, 0, 0, 0, 0, 0, 0, 52, 53, 54, + 0, 0, 0, 0, 49, 0, 0, 74, 76, 0, + 77, 0, 72, +} +var yyPact = [...]int{ + + -59, -1000, 1845, -59, -59, -1000, -1000, -1000, -1000, 228, + 1375, 146, -1000, -1000, 1954, 1954, 227, 199, 2125, 119, + 1954, -63, -1000, 1954, 1954, 1954, 2097, 2068, -1000, -1000, + -1000, -1000, 67, -59, -59, 1954, 226, 2040, 18, 1954, + 130, 1954, -1000, 1315, -1000, 138, -1000, 1954, 1954, 225, + 1954, 1954, 1954, 1954, 1954, 1954, 1954, 1954, 1954, 1954, + 1954, 1954, 1954, 1954, 1954, 1954, 1954, 1954, 1954, 1954, + -1000, -1000, 1954, 1954, 1954, 1954, 1954, 1954, 1954, 1954, + 129, 1434, 1434, 113, 154, -59, 17, 25, 1243, 145, + -59, 1184, 1954, 1954, 51, 51, 51, -63, 1611, -63, + 1552, 224, 6, 1954, 213, 1125, 1, -36, 1493, 148, + 1434, -59, 1066, -1000, 1954, -59, 1434, 1007, -1000, 2147, + 2147, 51, 51, 51, 1434, 1867, 1867, 236, 236, 1867, + 1867, 1867, 1867, 1434, 1434, 1434, 1434, 1434, 1434, 1434, + 1657, 1434, 1703, 98, 417, 1434, -1000, 1434, -59, -59, + 1954, -59, 100, 1775, 1954, 1954, -59, 1954, 96, -59, + 94, 358, 223, 222, 45, 209, 221, -37, -46, -1000, + 141, -1000, 1954, 1954, 1954, 220, 220, 2011, -59, -1000, + 218, 1954, -29, -1000, -1000, 1954, 1983, 92, 948, 83, + -1000, 141, 889, 830, 82, -1000, 183, 85, 163, -31, + -1000, -1000, 1954, -1000, -1000, 112, -38, 44, 208, -59, + -61, -59, 79, 1954, 41, 87, 73, 38, -1000, 52, + 1434, -63, 78, -1000, 1434, -1000, 771, 1434, -63, -1000, + -59, -1000, -59, 1954, -1000, 128, -1000, -1000, -1000, 1954, + 140, -1000, -1000, -1000, 712, -59, 111, 110, -49, 1926, + -1000, 123, -1000, 1434, -1000, -50, -1000, -58, -1000, 216, + -1000, 1954, 1954, -1000, -1000, 76, 75, 653, 108, -59, + 594, -59, -1000, 74, -59, -59, 104, -1000, -1000, -1000, + -1000, -1000, -1000, 535, 299, -1000, -1000, -59, -59, 72, + -59, -59, -1000, 70, 69, -59, -1000, -1000, 1954, 68, + 55, 181, -59, -1000, -1000, -1000, 49, 476, -1000, 172, + 99, -1000, -1000, -1000, 88, -59, -59, 47, 39, -1000, + -1000, +} +var yyPgo = [...]int{ + + 0, 12, 241, 200, 239, 5, 2, 238, 4, 0, + 32, 31, 236, 1, 235, 6, 11, 233, 210, +} +var yyR1 = [...]int{ + + 0, 1, 1, 2, 2, 2, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 4, 4, 4, 7, 7, + 7, 7, 7, 6, 5, 13, 14, 14, 14, 15, + 15, 15, 12, 11, 11, 11, 8, 8, 10, 10, + 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 16, 16, 17, 17, 18, 18, +} +var yyR2 = [...]int{ + + 0, 1, 2, 0, 2, 3, 4, 3, 3, 1, + 1, 2, 2, 5, 1, 4, 7, 9, 5, 13, + 12, 9, 8, 5, 1, 7, 5, 5, 0, 2, + 2, 2, 2, 5, 4, 3, 0, 1, 4, 0, + 1, 4, 3, 1, 4, 4, 1, 3, 0, 1, + 4, 4, 1, 1, 2, 2, 2, 2, 4, 2, + 4, 1, 1, 1, 1, 5, 3, 7, 8, 8, + 9, 5, 6, 5, 6, 3, 5, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 2, 2, 3, + 3, 3, 3, 5, 4, 6, 5, 5, 4, 6, + 5, 4, 4, 6, 6, 5, 7, 7, 9, 3, + 2, 0, 1, 1, 2, 1, 1, +} +var yyChk = [...]int{ + + -1000, -1, -16, -2, -17, -18, 66, 76, -3, 11, + -9, -11, 37, 38, 10, 12, 27, -4, 15, 28, + 44, 4, 5, 59, 68, 69, 70, 60, 6, 24, + 25, 26, 9, 73, 64, 71, 23, 47, 49, 50, + -10, 13, -16, -17, -18, -15, 4, 52, 53, 67, + 58, 59, 60, 61, 62, 41, 42, 43, 17, 18, + 56, 19, 57, 20, 31, 32, 33, 34, 35, 36, + 39, 40, 75, 21, 70, 22, 71, 73, 50, 52, + -10, -9, -9, 4, 14, 64, 4, -12, -9, -11, + 64, -9, 71, 73, -9, -9, -9, 4, -9, 4, + -9, 71, 4, -16, -16, -9, 4, 4, -9, 71, + -9, 55, -9, -3, 52, 55, -9, -9, 4, -9, + -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, + -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, + -9, -9, -9, -10, -9, -9, -11, -9, 55, 64, + 13, 64, -1, -16, 16, 66, 64, 52, -1, 64, + -10, -9, 67, 67, -15, 4, 71, -10, -14, -13, + 6, 72, 71, 71, 71, 48, 51, -16, 64, -11, + -16, 54, 8, 72, 74, 54, -16, -1, -9, -1, + 65, 6, -9, -9, -1, -11, 65, -7, -16, 8, + 72, 74, 54, 4, 4, 72, 8, -15, 4, 55, + -16, 55, -16, 54, -10, -10, -10, -8, 4, -8, + -9, 4, -1, 4, -9, 72, -9, -9, 4, 65, + 64, 65, 64, 66, 65, 29, 65, -6, -5, 45, + 46, -6, -5, 72, -9, 64, 72, 72, 8, -16, + 74, -16, 65, -9, 72, 8, 72, 8, 72, 67, + 72, 55, 55, 65, 74, -1, -1, -9, 4, 64, + -9, 54, 74, -1, 64, 64, 72, 74, -13, 65, + 72, 72, 4, -9, -9, 65, 65, 64, 64, -1, + 54, -16, 65, -1, -1, 64, 72, 72, 55, -1, + -1, 65, -16, -1, 65, 65, -1, -9, 65, 65, + 30, -1, 65, 72, 30, 64, 64, -1, -1, 65, + 65, +} +var yyDef = [...]int{ + + -2, -2, -2, 121, 122, 123, 125, 126, 4, 39, + -2, 0, 9, 10, 48, 0, 0, 14, 48, 0, + 0, 52, 53, 0, 0, 0, 0, 0, 61, 62, + 63, 64, 0, 121, 121, 0, 0, 0, 0, 0, + 0, 0, 2, -2, 124, 0, 40, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 97, 98, 0, 0, 0, 0, 48, 0, 0, 48, + 11, 49, 12, 0, 0, -2, 52, 0, -2, 0, + -2, 0, 48, 0, 54, 55, 56, -2, 0, -2, + 0, 39, 0, 48, 36, 0, 0, 52, 0, 0, + 120, 121, 0, 5, 48, 121, 7, 0, 66, 77, + 78, 79, 80, 81, 82, 83, 84, -2, -2, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 99, + 100, 101, 102, 0, 0, 119, 8, -2, 121, -2, + 0, -2, 0, -2, 0, 0, -2, 48, 0, 28, + 0, 0, 0, 0, 0, 40, 39, 121, 121, 37, + 0, 75, 48, 48, 48, 0, 0, 0, -2, 6, + 0, 0, 0, 108, 112, 0, 0, 0, 0, 0, + 15, 61, 0, 0, 0, 42, 0, 0, 0, 0, + 104, 111, 0, 58, 60, 0, 0, 0, 40, 121, + 0, 121, 0, 0, 0, 0, 0, 0, 46, 0, + -2, -2, 0, 41, 65, 107, 0, 50, -2, 13, + -2, 26, -2, 0, 18, 0, 23, 31, 32, 0, + 0, 29, 30, 103, 0, -2, 0, 0, 0, 0, + 71, 0, 73, 35, 76, 0, -2, 0, -2, 0, + 115, 0, 0, 27, 114, 0, 0, 0, 0, -2, + 0, 121, 113, 0, -2, -2, 0, 72, 38, 74, + -2, -2, 47, 0, 0, 25, 16, -2, -2, 0, + 121, -2, 67, 0, 0, -2, 116, 117, 0, 0, + 0, 22, -2, 34, 68, 69, 0, 0, 17, 21, + 0, 33, 70, 118, 0, -2, -2, 0, 0, 20, + 19, +} +var yyTok1 = [...]int{ + + 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 76, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 68, 3, 3, 3, 62, 70, 3, + 71, 72, 60, 58, 55, 59, 67, 61, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 54, 66, + 57, 52, 56, 53, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 73, 3, 74, 69, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 64, 75, 65, +} +var yyTok2 = [...]int{ + + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 63, +} +var yyTok3 = [...]int{ + 0, +} + +var yyErrorMessages = [...]struct { + state int + token int + msg string +}{} + +//line yaccpar:1 + +/* parser for yacc output */ + +var ( + yyDebug = 0 + yyErrorVerbose = false +) + +type yyLexer interface { + Lex(lval *yySymType) int + Error(s string) +} + +type yyParser interface { + Parse(yyLexer) int + Lookahead() int +} + +type yyParserImpl struct { + lval yySymType + stack [yyInitialStackSize]yySymType + char int +} + +func (p *yyParserImpl) Lookahead() int { + return p.char +} + +func yyNewParser() yyParser { + return &yyParserImpl{} +} + +const yyFlag = -1000 + +func yyTokname(c int) string { + if c >= 1 && c-1 < len(yyToknames) { + if yyToknames[c-1] != "" { + return yyToknames[c-1] + } + } + return __yyfmt__.Sprintf("tok-%v", c) +} + +func yyStatname(s int) string { + if s >= 0 && s < len(yyStatenames) { + if yyStatenames[s] != "" { + return yyStatenames[s] + } + } + return __yyfmt__.Sprintf("state-%v", s) +} + +func yyErrorMessage(state, lookAhead int) string { + const TOKSTART = 4 + + if !yyErrorVerbose { + return "syntax error" + } + + for _, e := range yyErrorMessages { + if e.state == state && e.token == lookAhead { + return "syntax error: " + e.msg + } + } + + res := "syntax error: unexpected " + yyTokname(lookAhead) + + // To match Bison, suggest at most four expected tokens. + expected := make([]int, 0, 4) + + // Look for shiftable tokens. + base := yyPact[state] + for tok := TOKSTART; tok-1 < len(yyToknames); tok++ { + if n := base + tok; n >= 0 && n < yyLast && yyChk[yyAct[n]] == tok { + if len(expected) == cap(expected) { + return res + } + expected = append(expected, tok) + } + } + + if yyDef[state] == -2 { + i := 0 + for yyExca[i] != -1 || yyExca[i+1] != state { + i += 2 + } + + // Look for tokens that we accept or reduce. + for i += 2; yyExca[i] >= 0; i += 2 { + tok := yyExca[i] + if tok < TOKSTART || yyExca[i+1] == 0 { + continue + } + if len(expected) == cap(expected) { + return res + } + expected = append(expected, tok) + } + + // If the default action is to accept or reduce, give up. + if yyExca[i+1] != 0 { + return res + } + } + + for i, tok := range expected { + if i == 0 { + res += ", expecting " + } else { + res += " or " + } + res += yyTokname(tok) + } + return res +} + +func yylex1(lex yyLexer, lval *yySymType) (char, token int) { + token = 0 + char = lex.Lex(lval) + if char <= 0 { + token = yyTok1[0] + goto out + } + if char < len(yyTok1) { + token = yyTok1[char] + goto out + } + if char >= yyPrivate { + if char < yyPrivate+len(yyTok2) { + token = yyTok2[char-yyPrivate] + goto out + } + } + for i := 0; i < len(yyTok3); i += 2 { + token = yyTok3[i+0] + if token == char { + token = yyTok3[i+1] + goto out + } + } + +out: + if token == 0 { + token = yyTok2[1] /* unknown char */ + } + if yyDebug >= 3 { + __yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char)) + } + return char, token +} + +func yyParse(yylex yyLexer) int { + return yyNewParser().Parse(yylex) +} + +func (yyrcvr *yyParserImpl) Parse(yylex yyLexer) int { + var yyn int + var yyVAL yySymType + var yyDollar []yySymType + _ = yyDollar // silence set and not used + yyS := yyrcvr.stack[:] + + Nerrs := 0 /* number of errors */ + Errflag := 0 /* error recovery flag */ + yystate := 0 + yyrcvr.char = -1 + yytoken := -1 // yyrcvr.char translated into internal numbering + defer func() { + // Make sure we report no lookahead when not parsing. + yystate = -1 + yyrcvr.char = -1 + yytoken = -1 + }() + yyp := -1 + goto yystack + +ret0: + return 0 + +ret1: + return 1 + +yystack: + /* put a state and value onto the stack */ + if yyDebug >= 4 { + __yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate)) + } + + yyp++ + if yyp >= len(yyS) { + nyys := make([]yySymType, len(yyS)*2) + copy(nyys, yyS) + yyS = nyys + } + yyS[yyp] = yyVAL + yyS[yyp].yys = yystate + +yynewstate: + yyn = yyPact[yystate] + if yyn <= yyFlag { + goto yydefault /* simple state */ + } + if yyrcvr.char < 0 { + yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval) + } + yyn += yytoken + if yyn < 0 || yyn >= yyLast { + goto yydefault + } + yyn = yyAct[yyn] + if yyChk[yyn] == yytoken { /* valid shift */ + yyrcvr.char = -1 + yytoken = -1 + yyVAL = yyrcvr.lval + yystate = yyn + if Errflag > 0 { + Errflag-- + } + goto yystack + } + +yydefault: + /* default state action */ + yyn = yyDef[yystate] + if yyn == -2 { + if yyrcvr.char < 0 { + yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval) + } + + /* look through exception table */ + xi := 0 + for { + if yyExca[xi+0] == -1 && yyExca[xi+1] == yystate { + break + } + xi += 2 + } + for xi += 2; ; xi += 2 { + yyn = yyExca[xi+0] + if yyn < 0 || yyn == yytoken { + break + } + } + yyn = yyExca[xi+1] + if yyn < 0 { + goto ret0 + } + } + if yyn == 0 { + /* error ... attempt to resume parsing */ + switch Errflag { + case 0: /* brand new error */ + yylex.Error(yyErrorMessage(yystate, yytoken)) + Nerrs++ + if yyDebug >= 1 { + __yyfmt__.Printf("%s", yyStatname(yystate)) + __yyfmt__.Printf(" saw %s\n", yyTokname(yytoken)) + } + fallthrough + + case 1, 2: /* incompletely recovered error ... try again */ + Errflag = 3 + + /* find a state where "error" is a legal shift action */ + for yyp >= 0 { + yyn = yyPact[yyS[yyp].yys] + yyErrCode + if yyn >= 0 && yyn < yyLast { + yystate = yyAct[yyn] /* simulate a shift of "error" */ + if yyChk[yystate] == yyErrCode { + goto yystack + } + } + + /* the current p has no shift on "error", pop stack */ + if yyDebug >= 2 { + __yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys) + } + yyp-- + } + /* there is no state on the stack with an error shift ... abort */ + goto ret1 + + case 3: /* no shift yet; clobber input char */ + if yyDebug >= 2 { + __yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken)) + } + if yytoken == yyEofCode { + goto ret1 + } + yyrcvr.char = -1 + yytoken = -1 + goto yynewstate /* try again in the same state */ + } + } + + /* reduction by production yyn */ + if yyDebug >= 2 { + __yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate)) + } + + yynt := yyn + yypt := yyp + _ = yypt // guard against "declared and not used" + + yyp -= yyR2[yyn] + // yyp is now the index of $0. Perform the default action. Iff the + // reduced production is ε, $1 is possibly out of range. + if yyp+1 >= len(yyS) { + nyys := make([]yySymType, len(yyS)*2) + copy(nyys, yyS) + yyS = nyys + } + yyVAL = yyS[yyp+1] + + /* consult goto table to find next state */ + yyn = yyR1[yyn] + yyg := yyPgo[yyn] + yyj := yyg + yyS[yyp].yys + 1 + + if yyj >= yyLast { + yystate = yyAct[yyg] + } else { + yystate = yyAct[yyj] + if yyChk[yystate] != -yyn { + yystate = yyAct[yyg] + } + } + // dummy call; replaced with literal code + switch yynt { + + case 1: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:65 + { + yyVAL.compstmt = nil + } + case 2: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:69 + { + yyVAL.compstmt = yyDollar[1].stmts + } + case 3: + yyDollar = yyS[yypt-0 : yypt+1] + //line parser.go.y:74 + { + yyVAL.stmts = nil + if l, ok := yylex.(*Lexer); ok { + l.stmts = yyVAL.stmts + } + } + case 4: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:81 + { + yyVAL.stmts = []ast.Stmt{yyDollar[2].stmt} + if l, ok := yylex.(*Lexer); ok { + l.stmts = yyVAL.stmts + } + } + case 5: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:88 + { + if yyDollar[3].stmt != nil { + yyVAL.stmts = append(yyDollar[1].stmts, yyDollar[3].stmt) + if l, ok := yylex.(*Lexer); ok { + l.stmts = yyVAL.stmts + } + } + } + case 6: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:99 + { + yyVAL.stmt = &ast.VarStmt{Names: yyDollar[2].expr_idents, Exprs: yyDollar[4].expr_many} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 7: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:104 + { + yyVAL.stmt = &ast.LetsStmt{Lhss: []ast.Expr{yyDollar[1].expr}, Operator: "=", Rhss: []ast.Expr{yyDollar[3].expr}} + } + case 8: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:108 + { + yyVAL.stmt = &ast.LetsStmt{Lhss: yyDollar[1].expr_many, Operator: "=", Rhss: yyDollar[3].expr_many} + } + case 9: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:112 + { + yyVAL.stmt = &ast.BreakStmt{} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 10: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:117 + { + yyVAL.stmt = &ast.ContinueStmt{} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 11: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:122 + { + yyVAL.stmt = &ast.ReturnStmt{Exprs: yyDollar[2].exprs} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 12: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:127 + { + yyVAL.stmt = &ast.ThrowStmt{Expr: yyDollar[2].expr} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 13: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:132 + { + yyVAL.stmt = &ast.ModuleStmt{Name: yyDollar[2].tok.Lit, Stmts: yyDollar[4].compstmt} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 14: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:137 + { + yyVAL.stmt = yyDollar[1].stmt_if + yyVAL.stmt.SetPosition(yyDollar[1].stmt_if.Position()) + } + case 15: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:142 + { + yyVAL.stmt = &ast.LoopStmt{Stmts: yyDollar[3].compstmt} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 16: + yyDollar = yyS[yypt-7 : yypt+1] + //line parser.go.y:147 + { + yyVAL.stmt = &ast.ForStmt{Var: yyDollar[2].tok.Lit, Value: yyDollar[4].expr, Stmts: yyDollar[6].compstmt} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 17: + yyDollar = yyS[yypt-9 : yypt+1] + //line parser.go.y:152 + { + yyVAL.stmt = &ast.CForStmt{Expr1: yyDollar[2].expr_lets, Expr2: yyDollar[4].expr, Expr3: yyDollar[6].expr, Stmts: yyDollar[8].compstmt} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 18: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:157 + { + yyVAL.stmt = &ast.LoopStmt{Expr: yyDollar[2].expr, Stmts: yyDollar[4].compstmt} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 19: + yyDollar = yyS[yypt-13 : yypt+1] + //line parser.go.y:162 + { + yyVAL.stmt = &ast.TryStmt{Try: yyDollar[3].compstmt, Var: yyDollar[6].tok.Lit, Catch: yyDollar[8].compstmt, Finally: yyDollar[12].compstmt} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 20: + yyDollar = yyS[yypt-12 : yypt+1] + //line parser.go.y:167 + { + yyVAL.stmt = &ast.TryStmt{Try: yyDollar[3].compstmt, Catch: yyDollar[7].compstmt, Finally: yyDollar[11].compstmt} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 21: + yyDollar = yyS[yypt-9 : yypt+1] + //line parser.go.y:172 + { + yyVAL.stmt = &ast.TryStmt{Try: yyDollar[3].compstmt, Var: yyDollar[6].tok.Lit, Catch: yyDollar[8].compstmt} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 22: + yyDollar = yyS[yypt-8 : yypt+1] + //line parser.go.y:177 + { + yyVAL.stmt = &ast.TryStmt{Try: yyDollar[3].compstmt, Catch: yyDollar[7].compstmt} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 23: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:182 + { + yyVAL.stmt = &ast.SwitchStmt{Expr: yyDollar[2].expr, Cases: yyDollar[4].stmt_cases} + yyVAL.stmt.SetPosition(yyDollar[1].tok.Position()) + } + case 24: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:187 + { + yyVAL.stmt = &ast.ExprStmt{Expr: yyDollar[1].expr} + yyVAL.stmt.SetPosition(yyDollar[1].expr.Position()) + } + case 25: + yyDollar = yyS[yypt-7 : yypt+1] + //line parser.go.y:195 + { + yyDollar[1].stmt_if.(*ast.IfStmt).ElseIf = append(yyDollar[1].stmt_if.(*ast.IfStmt).ElseIf, &ast.IfStmt{If: yyDollar[4].expr, Then: yyDollar[6].compstmt}) + yyVAL.stmt_if.SetPosition(yyDollar[1].stmt_if.Position()) + } + case 26: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:200 + { + if yyVAL.stmt_if.(*ast.IfStmt).Else != nil { + yylex.Error("multiple else statement") + } else { + yyVAL.stmt_if.(*ast.IfStmt).Else = append(yyVAL.stmt_if.(*ast.IfStmt).Else, yyDollar[4].compstmt...) + } + yyVAL.stmt_if.SetPosition(yyDollar[1].stmt_if.Position()) + } + case 27: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:209 + { + yyVAL.stmt_if = &ast.IfStmt{If: yyDollar[2].expr, Then: yyDollar[4].compstmt, Else: nil} + yyVAL.stmt_if.SetPosition(yyDollar[1].tok.Position()) + } + case 28: + yyDollar = yyS[yypt-0 : yypt+1] + //line parser.go.y:215 + { + yyVAL.stmt_cases = []ast.Stmt{} + } + case 29: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:219 + { + yyVAL.stmt_cases = []ast.Stmt{yyDollar[2].stmt_case} + } + case 30: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:223 + { + yyVAL.stmt_cases = []ast.Stmt{yyDollar[2].stmt_default} + } + case 31: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:227 + { + yyVAL.stmt_cases = append(yyDollar[1].stmt_cases, yyDollar[2].stmt_case) + } + case 32: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:231 + { + for _, stmt := range yyDollar[1].stmt_cases { + if _, ok := stmt.(*ast.DefaultStmt); ok { + yylex.Error("multiple default statement") + } + } + yyVAL.stmt_cases = append(yyDollar[1].stmt_cases, yyDollar[2].stmt_default) + } + case 33: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:242 + { + yyVAL.stmt_case = &ast.CaseStmt{Expr: yyDollar[2].expr, Stmts: yyDollar[5].compstmt} + } + case 34: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:248 + { + yyVAL.stmt_default = &ast.DefaultStmt{Stmts: yyDollar[4].compstmt} + } + case 35: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:254 + { + yyVAL.expr_pair = &ast.PairExpr{Key: yyDollar[1].tok.Lit, Value: yyDollar[3].expr} + } + case 36: + yyDollar = yyS[yypt-0 : yypt+1] + //line parser.go.y:259 + { + yyVAL.expr_pairs = []ast.Expr{} + } + case 37: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:263 + { + yyVAL.expr_pairs = []ast.Expr{yyDollar[1].expr_pair} + } + case 38: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:267 + { + yyVAL.expr_pairs = append(yyDollar[1].expr_pairs, yyDollar[4].expr_pair) + } + case 39: + yyDollar = yyS[yypt-0 : yypt+1] + //line parser.go.y:272 + { + yyVAL.expr_idents = []string{} + } + case 40: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:276 + { + yyVAL.expr_idents = []string{yyDollar[1].tok.Lit} + } + case 41: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:280 + { + yyVAL.expr_idents = append(yyDollar[1].expr_idents, yyDollar[4].tok.Lit) + } + case 42: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:285 + { + yyVAL.expr_lets = &ast.LetsExpr{Lhss: yyDollar[1].expr_many, Operator: "=", Rhss: yyDollar[3].expr_many} + } + case 43: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:291 + { + yyVAL.expr_many = []ast.Expr{yyDollar[1].expr} + } + case 44: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:295 + { + yyVAL.expr_many = append(yyDollar[1].exprs, yyDollar[4].expr) + } + case 45: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:299 + { + yyVAL.expr_many = append(yyDollar[1].exprs, &ast.IdentExpr{Lit: yyDollar[4].tok.Lit}) + } + case 46: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:304 + { + yyVAL.typ = ast.Type{Name: yyDollar[1].tok.Lit} + } + case 47: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:308 + { + yyVAL.typ = ast.Type{Name: yyDollar[1].typ.Name + "." + yyDollar[3].tok.Lit} + } + case 48: + yyDollar = yyS[yypt-0 : yypt+1] + //line parser.go.y:313 + { + yyVAL.exprs = nil + } + case 49: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:317 + { + yyVAL.exprs = []ast.Expr{yyDollar[1].expr} + } + case 50: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:321 + { + yyVAL.exprs = append(yyDollar[1].exprs, yyDollar[4].expr) + } + case 51: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:325 + { + yyVAL.exprs = append(yyDollar[1].exprs, &ast.IdentExpr{Lit: yyDollar[4].tok.Lit}) + } + case 52: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:331 + { + yyVAL.expr = &ast.IdentExpr{Lit: yyDollar[1].tok.Lit} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 53: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:336 + { + yyVAL.expr = &ast.NumberExpr{Lit: yyDollar[1].tok.Lit} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 54: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:341 + { + yyVAL.expr = &ast.UnaryExpr{Operator: "-", Expr: yyDollar[2].expr} + yyVAL.expr.SetPosition(yyDollar[2].expr.Position()) + } + case 55: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:346 + { + yyVAL.expr = &ast.UnaryExpr{Operator: "!", Expr: yyDollar[2].expr} + yyVAL.expr.SetPosition(yyDollar[2].expr.Position()) + } + case 56: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:351 + { + yyVAL.expr = &ast.UnaryExpr{Operator: "^", Expr: yyDollar[2].expr} + yyVAL.expr.SetPosition(yyDollar[2].expr.Position()) + } + case 57: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:356 + { + yyVAL.expr = &ast.AddrExpr{Expr: &ast.IdentExpr{Lit: yyDollar[2].tok.Lit}} + yyVAL.expr.SetPosition(yyDollar[2].tok.Position()) + } + case 58: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:361 + { + yyVAL.expr = &ast.AddrExpr{Expr: &ast.MemberExpr{Expr: yyDollar[2].expr, Name: yyDollar[4].tok.Lit}} + yyVAL.expr.SetPosition(yyDollar[2].expr.Position()) + } + case 59: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:366 + { + yyVAL.expr = &ast.DerefExpr{Expr: &ast.IdentExpr{Lit: yyDollar[2].tok.Lit}} + yyVAL.expr.SetPosition(yyDollar[2].tok.Position()) + } + case 60: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:371 + { + yyVAL.expr = &ast.DerefExpr{Expr: &ast.MemberExpr{Expr: yyDollar[2].expr, Name: yyDollar[4].tok.Lit}} + yyVAL.expr.SetPosition(yyDollar[2].expr.Position()) + } + case 61: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:376 + { + yyVAL.expr = &ast.StringExpr{Lit: yyDollar[1].tok.Lit} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 62: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:381 + { + yyVAL.expr = &ast.ConstExpr{Value: yyDollar[1].tok.Lit} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 63: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:386 + { + yyVAL.expr = &ast.ConstExpr{Value: yyDollar[1].tok.Lit} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 64: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:391 + { + yyVAL.expr = &ast.ConstExpr{Value: yyDollar[1].tok.Lit} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 65: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:396 + { + yyVAL.expr = &ast.TernaryOpExpr{Expr: yyDollar[1].expr, Lhs: yyDollar[3].expr, Rhs: yyDollar[5].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 66: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:401 + { + yyVAL.expr = &ast.MemberExpr{Expr: yyDollar[1].expr, Name: yyDollar[3].tok.Lit} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 67: + yyDollar = yyS[yypt-7 : yypt+1] + //line parser.go.y:406 + { + yyVAL.expr = &ast.FuncExpr{Args: yyDollar[3].expr_idents, Stmts: yyDollar[6].compstmt} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 68: + yyDollar = yyS[yypt-8 : yypt+1] + //line parser.go.y:411 + { + yyVAL.expr = &ast.FuncExpr{Args: []string{yyDollar[3].tok.Lit}, Stmts: yyDollar[7].compstmt, VarArg: true} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 69: + yyDollar = yyS[yypt-8 : yypt+1] + //line parser.go.y:416 + { + yyVAL.expr = &ast.FuncExpr{Name: yyDollar[2].tok.Lit, Args: yyDollar[4].expr_idents, Stmts: yyDollar[7].compstmt} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 70: + yyDollar = yyS[yypt-9 : yypt+1] + //line parser.go.y:421 + { + yyVAL.expr = &ast.FuncExpr{Name: yyDollar[2].tok.Lit, Args: []string{yyDollar[4].tok.Lit}, Stmts: yyDollar[8].compstmt, VarArg: true} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 71: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:426 + { + yyVAL.expr = &ast.ArrayExpr{Exprs: yyDollar[3].exprs} + if l, ok := yylex.(*Lexer); ok { + yyVAL.expr.SetPosition(l.pos) + } + } + case 72: + yyDollar = yyS[yypt-6 : yypt+1] + //line parser.go.y:431 + { + yyVAL.expr = &ast.ArrayExpr{Exprs: yyDollar[3].exprs} + if l, ok := yylex.(*Lexer); ok { + yyVAL.expr.SetPosition(l.pos) + } + } + case 73: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:436 + { + mapExpr := make(map[string]ast.Expr) + for _, v := range yyDollar[3].expr_pairs { + mapExpr[v.(*ast.PairExpr).Key] = v.(*ast.PairExpr).Value + } + yyVAL.expr = &ast.MapExpr{MapExpr: mapExpr} + if l, ok := yylex.(*Lexer); ok { + yyVAL.expr.SetPosition(l.pos) + } + } + case 74: + yyDollar = yyS[yypt-6 : yypt+1] + //line parser.go.y:445 + { + mapExpr := make(map[string]ast.Expr) + for _, v := range yyDollar[3].expr_pairs { + mapExpr[v.(*ast.PairExpr).Key] = v.(*ast.PairExpr).Value + } + yyVAL.expr = &ast.MapExpr{MapExpr: mapExpr} + if l, ok := yylex.(*Lexer); ok { + yyVAL.expr.SetPosition(l.pos) + } + } + case 75: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:454 + { + yyVAL.expr = &ast.ParenExpr{SubExpr: yyDollar[2].expr} + if l, ok := yylex.(*Lexer); ok { + yyVAL.expr.SetPosition(l.pos) + } + } + case 76: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:459 + { + yyVAL.expr = &ast.NewExpr{Name: yyDollar[2].tok.Lit, SubExprs: yyDollar[4].exprs} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 77: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:464 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "+", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 78: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:469 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "-", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 79: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:474 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "*", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 80: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:479 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "/", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 81: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:484 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "%", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 82: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:489 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "**", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 83: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:494 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "<<", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 84: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:499 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: ">>", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 85: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:504 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "==", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 86: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:509 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "!=", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 87: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:514 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: ">", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 88: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:519 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: ">=", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 89: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:524 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "<", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 90: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:529 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "<=", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 91: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:534 + { + yyVAL.expr = &ast.AssocExpr{Lhs: yyDollar[1].expr, Operator: "+=", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 92: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:539 + { + yyVAL.expr = &ast.AssocExpr{Lhs: yyDollar[1].expr, Operator: "-=", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 93: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:544 + { + yyVAL.expr = &ast.AssocExpr{Lhs: yyDollar[1].expr, Operator: "*=", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 94: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:549 + { + yyVAL.expr = &ast.AssocExpr{Lhs: yyDollar[1].expr, Operator: "/=", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 95: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:554 + { + yyVAL.expr = &ast.AssocExpr{Lhs: yyDollar[1].expr, Operator: "&=", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 96: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:559 + { + yyVAL.expr = &ast.AssocExpr{Lhs: yyDollar[1].expr, Operator: "|=", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 97: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:564 + { + yyVAL.expr = &ast.AssocExpr{Lhs: yyDollar[1].expr, Operator: "++"} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 98: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:569 + { + yyVAL.expr = &ast.AssocExpr{Lhs: yyDollar[1].expr, Operator: "--"} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 99: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:574 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "|", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 100: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:579 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "||", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 101: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:584 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "&", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 102: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:589 + { + yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "&&", Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 103: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:594 + { + yyVAL.expr = &ast.CallExpr{Name: yyDollar[1].tok.Lit, SubExprs: yyDollar[3].exprs, VarArg: true} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 104: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:599 + { + yyVAL.expr = &ast.CallExpr{Name: yyDollar[1].tok.Lit, SubExprs: yyDollar[3].exprs} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 105: + yyDollar = yyS[yypt-6 : yypt+1] + //line parser.go.y:604 + { + yyVAL.expr = &ast.CallExpr{Name: yyDollar[2].tok.Lit, SubExprs: yyDollar[4].exprs, VarArg: true, Go: true} + yyVAL.expr.SetPosition(yyDollar[2].tok.Position()) + } + case 106: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:609 + { + yyVAL.expr = &ast.CallExpr{Name: yyDollar[2].tok.Lit, SubExprs: yyDollar[4].exprs, Go: true} + yyVAL.expr.SetPosition(yyDollar[2].tok.Position()) + } + case 107: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:614 + { + yyVAL.expr = &ast.AnonCallExpr{Expr: yyDollar[1].expr, SubExprs: yyDollar[3].exprs, VarArg: true} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 108: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:619 + { + yyVAL.expr = &ast.AnonCallExpr{Expr: yyDollar[1].expr, SubExprs: yyDollar[3].exprs} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 109: + yyDollar = yyS[yypt-6 : yypt+1] + //line parser.go.y:624 + { + yyVAL.expr = &ast.AnonCallExpr{Expr: yyDollar[2].expr, SubExprs: yyDollar[4].exprs, VarArg: true, Go: true} + yyVAL.expr.SetPosition(yyDollar[2].expr.Position()) + } + case 110: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:629 + { + yyVAL.expr = &ast.AnonCallExpr{Expr: yyDollar[2].expr, SubExprs: yyDollar[4].exprs, Go: true} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 111: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:634 + { + yyVAL.expr = &ast.ItemExpr{Value: &ast.IdentExpr{Lit: yyDollar[1].tok.Lit}, Index: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 112: + yyDollar = yyS[yypt-4 : yypt+1] + //line parser.go.y:639 + { + yyVAL.expr = &ast.ItemExpr{Value: yyDollar[1].expr, Index: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 113: + yyDollar = yyS[yypt-6 : yypt+1] + //line parser.go.y:644 + { + yyVAL.expr = &ast.SliceExpr{Value: &ast.IdentExpr{Lit: yyDollar[1].tok.Lit}, Begin: yyDollar[3].expr, End: yyDollar[5].expr} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 114: + yyDollar = yyS[yypt-6 : yypt+1] + //line parser.go.y:649 + { + yyVAL.expr = &ast.SliceExpr{Value: yyDollar[1].expr, Begin: yyDollar[3].expr, End: yyDollar[5].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 115: + yyDollar = yyS[yypt-5 : yypt+1] + //line parser.go.y:654 + { + yyVAL.expr = &ast.MakeChanExpr{Type: yyDollar[4].typ.Name, SizeExpr: nil} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 116: + yyDollar = yyS[yypt-7 : yypt+1] + //line parser.go.y:659 + { + yyVAL.expr = &ast.MakeChanExpr{Type: yyDollar[4].typ.Name, SizeExpr: yyDollar[6].expr} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 117: + yyDollar = yyS[yypt-7 : yypt+1] + //line parser.go.y:664 + { + yyVAL.expr = &ast.MakeArrayExpr{Type: yyDollar[4].typ.Name, LenExpr: yyDollar[6].expr} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 118: + yyDollar = yyS[yypt-9 : yypt+1] + //line parser.go.y:669 + { + yyVAL.expr = &ast.MakeArrayExpr{Type: yyDollar[4].typ.Name, LenExpr: yyDollar[6].expr, CapExpr: yyDollar[8].expr} + yyVAL.expr.SetPosition(yyDollar[1].tok.Position()) + } + case 119: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.go.y:674 + { + yyVAL.expr = &ast.ChanExpr{Lhs: yyDollar[1].expr, Rhs: yyDollar[3].expr} + yyVAL.expr.SetPosition(yyDollar[1].expr.Position()) + } + case 120: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:679 + { + yyVAL.expr = &ast.ChanExpr{Rhs: yyDollar[2].expr} + yyVAL.expr.SetPosition(yyDollar[2].expr.Position()) + } + case 123: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:690 + { + } + case 124: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.go.y:693 + { + } + case 125: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:698 + { + } + case 126: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.go.y:701 + { + } + } + goto yystack /* stack new state and value */ +} diff --git a/vendor/github.com/mattn/anko/parser/parser.go.y b/vendor/github.com/mattn/anko/parser/parser.go.y new file mode 100644 index 0000000..9ebe8ae --- /dev/null +++ b/vendor/github.com/mattn/anko/parser/parser.go.y @@ -0,0 +1,705 @@ +%{ +package parser + +import ( + "github.com/mattn/anko/ast" +) + +%} + +%type compstmt +%type stmts +%type stmt +%type stmt_if +%type stmt_default +%type stmt_case +%type stmt_cases +%type typ +%type expr +%type exprs +%type expr_many +%type expr_lets +%type expr_pair +%type expr_pairs +%type expr_idents + +%union{ + compstmt []ast.Stmt + stmt_if ast.Stmt + stmt_default ast.Stmt + stmt_case ast.Stmt + stmt_cases []ast.Stmt + stmts []ast.Stmt + stmt ast.Stmt + typ ast.Type + expr ast.Expr + exprs []ast.Expr + expr_many []ast.Expr + expr_lets ast.Expr + expr_pair ast.Expr + expr_pairs []ast.Expr + expr_idents []string + tok ast.Token + term ast.Token + terms ast.Token + opt_terms ast.Token +} + +%token IDENT NUMBER STRING ARRAY VARARG FUNC RETURN VAR THROW IF ELSE FOR IN EQEQ NEQ GE LE OROR ANDAND NEW TRUE FALSE NIL MODULE TRY CATCH FINALLY PLUSEQ MINUSEQ MULEQ DIVEQ ANDEQ OREQ BREAK CONTINUE PLUSPLUS MINUSMINUS POW SHIFTLEFT SHIFTRIGHT SWITCH CASE DEFAULT GO CHAN MAKE OPCHAN ARRAYLIT + +%right '=' +%right '?' ':' +%left OROR +%left ANDAND +%left IDENT +%nonassoc EQEQ NEQ ',' +%left '>' GE '<' LE SHIFTLEFT SHIFTRIGHT + +%left '+' '-' PLUSPLUS MINUSMINUS +%left '*' '/' '%' +%right UNARY + +%% + +compstmt : opt_terms + { + $$ = nil + } + | stmts opt_terms + { + $$ = $1 + } + +stmts : + { + $$ = nil + if l, ok := yylex.(*Lexer); ok { + l.stmts = $$ + } + } + | opt_terms stmt + { + $$ = []ast.Stmt{$2} + if l, ok := yylex.(*Lexer); ok { + l.stmts = $$ + } + } + | stmts terms stmt + { + if $3 != nil { + $$ = append($1, $3) + if l, ok := yylex.(*Lexer); ok { + l.stmts = $$ + } + } + } + +stmt : + VAR expr_idents '=' expr_many + { + $$ = &ast.VarStmt{Names: $2, Exprs: $4} + $$.SetPosition($1.Position()) + } + | expr '=' expr + { + $$ = &ast.LetsStmt{Lhss: []ast.Expr{$1}, Operator: "=", Rhss: []ast.Expr{$3}} + } + | expr_many '=' expr_many + { + $$ = &ast.LetsStmt{Lhss: $1, Operator: "=", Rhss: $3} + } + | BREAK + { + $$ = &ast.BreakStmt{} + $$.SetPosition($1.Position()) + } + | CONTINUE + { + $$ = &ast.ContinueStmt{} + $$.SetPosition($1.Position()) + } + | RETURN exprs + { + $$ = &ast.ReturnStmt{Exprs: $2} + $$.SetPosition($1.Position()) + } + | THROW expr + { + $$ = &ast.ThrowStmt{Expr: $2} + $$.SetPosition($1.Position()) + } + | MODULE IDENT '{' compstmt '}' + { + $$ = &ast.ModuleStmt{Name: $2.Lit, Stmts: $4} + $$.SetPosition($1.Position()) + } + | stmt_if + { + $$ = $1 + $$.SetPosition($1.Position()) + } + | FOR '{' compstmt '}' + { + $$ = &ast.LoopStmt{Stmts: $3} + $$.SetPosition($1.Position()) + } + | FOR IDENT IN expr '{' compstmt '}' + { + $$ = &ast.ForStmt{Var: $2.Lit, Value: $4, Stmts: $6} + $$.SetPosition($1.Position()) + } + | FOR expr_lets ';' expr ';' expr '{' compstmt '}' + { + $$ = &ast.CForStmt{Expr1: $2, Expr2: $4, Expr3: $6, Stmts: $8} + $$.SetPosition($1.Position()) + } + | FOR expr '{' compstmt '}' + { + $$ = &ast.LoopStmt{Expr: $2, Stmts: $4} + $$.SetPosition($1.Position()) + } + | TRY '{' compstmt '}' CATCH IDENT '{' compstmt '}' FINALLY '{' compstmt '}' + { + $$ = &ast.TryStmt{Try: $3, Var: $6.Lit, Catch: $8, Finally: $12} + $$.SetPosition($1.Position()) + } + | TRY '{' compstmt '}' CATCH '{' compstmt '}' FINALLY '{' compstmt '}' + { + $$ = &ast.TryStmt{Try: $3, Catch: $7, Finally: $11} + $$.SetPosition($1.Position()) + } + | TRY '{' compstmt '}' CATCH IDENT '{' compstmt '}' + { + $$ = &ast.TryStmt{Try: $3, Var: $6.Lit, Catch: $8} + $$.SetPosition($1.Position()) + } + | TRY '{' compstmt '}' CATCH '{' compstmt '}' + { + $$ = &ast.TryStmt{Try: $3, Catch: $7} + $$.SetPosition($1.Position()) + } + | SWITCH expr '{' stmt_cases '}' + { + $$ = &ast.SwitchStmt{Expr: $2, Cases: $4} + $$.SetPosition($1.Position()) + } + | expr + { + $$ = &ast.ExprStmt{Expr: $1} + $$.SetPosition($1.Position()) + } + + +stmt_if : + stmt_if ELSE IF expr '{' compstmt '}' + { + $1.(*ast.IfStmt).ElseIf = append($1.(*ast.IfStmt).ElseIf, &ast.IfStmt{If: $4, Then: $6}) + $$.SetPosition($1.Position()) + } + | stmt_if ELSE '{' compstmt '}' + { + if $$.(*ast.IfStmt).Else != nil { + yylex.Error("multiple else statement") + } else { + $$.(*ast.IfStmt).Else = append($$.(*ast.IfStmt).Else, $4...) + } + $$.SetPosition($1.Position()) + } + | IF expr '{' compstmt '}' + { + $$ = &ast.IfStmt{If: $2, Then: $4, Else: nil} + $$.SetPosition($1.Position()) + } + +stmt_cases : + { + $$ = []ast.Stmt{} + } + | opt_terms stmt_case + { + $$ = []ast.Stmt{$2} + } + | opt_terms stmt_default + { + $$ = []ast.Stmt{$2} + } + | stmt_cases stmt_case + { + $$ = append($1, $2) + } + | stmt_cases stmt_default + { + for _, stmt := range $1 { + if _, ok := stmt.(*ast.DefaultStmt); ok { + yylex.Error("multiple default statement") + } + } + $$ = append($1, $2) + } + +stmt_case : + CASE expr ':' opt_terms compstmt + { + $$ = &ast.CaseStmt{Expr: $2, Stmts: $5} + } + +stmt_default : + DEFAULT ':' opt_terms compstmt + { + $$ = &ast.DefaultStmt{Stmts: $4} + } + +expr_pair : + STRING ':' expr + { + $$ = &ast.PairExpr{Key: $1.Lit, Value: $3} + } + +expr_pairs : + { + $$ = []ast.Expr{} + } + | expr_pair + { + $$ = []ast.Expr{$1} + } + | expr_pairs ',' opt_terms expr_pair + { + $$ = append($1, $4) + } + +expr_idents : + { + $$ = []string{} + } + | IDENT + { + $$ = []string{$1.Lit} + } + | expr_idents ',' opt_terms IDENT + { + $$ = append($1, $4.Lit) + } + +expr_lets : expr_many '=' expr_many + { + $$ = &ast.LetsExpr{Lhss: $1, Operator: "=", Rhss: $3} + } + +expr_many : + expr + { + $$ = []ast.Expr{$1} + } + | exprs ',' opt_terms expr + { + $$ = append($1, $4) + } + | exprs ',' opt_terms IDENT + { + $$ = append($1, &ast.IdentExpr{Lit: $4.Lit}) + } + +typ : IDENT + { + $$ = ast.Type{Name: $1.Lit} + } + | typ '.' IDENT + { + $$ = ast.Type{Name: $1.Name + "." + $3.Lit} + } + +exprs : + { + $$ = nil + } + | expr + { + $$ = []ast.Expr{$1} + } + | exprs ',' opt_terms expr + { + $$ = append($1, $4) + } + | exprs ',' opt_terms IDENT + { + $$ = append($1, &ast.IdentExpr{Lit: $4.Lit}) + } + +expr : + IDENT + { + $$ = &ast.IdentExpr{Lit: $1.Lit} + $$.SetPosition($1.Position()) + } + | NUMBER + { + $$ = &ast.NumberExpr{Lit: $1.Lit} + $$.SetPosition($1.Position()) + } + | '-' expr %prec UNARY + { + $$ = &ast.UnaryExpr{Operator: "-", Expr: $2} + $$.SetPosition($2.Position()) + } + | '!' expr %prec UNARY + { + $$ = &ast.UnaryExpr{Operator: "!", Expr: $2} + $$.SetPosition($2.Position()) + } + | '^' expr %prec UNARY + { + $$ = &ast.UnaryExpr{Operator: "^", Expr: $2} + $$.SetPosition($2.Position()) + } + | '&' IDENT %prec UNARY + { + $$ = &ast.AddrExpr{Expr: &ast.IdentExpr{Lit: $2.Lit}} + $$.SetPosition($2.Position()) + } + | '&' expr '.' IDENT %prec UNARY + { + $$ = &ast.AddrExpr{Expr: &ast.MemberExpr{Expr: $2, Name: $4.Lit}} + $$.SetPosition($2.Position()) + } + | '*' IDENT %prec UNARY + { + $$ = &ast.DerefExpr{Expr: &ast.IdentExpr{Lit: $2.Lit}} + $$.SetPosition($2.Position()) + } + | '*' expr '.' IDENT %prec UNARY + { + $$ = &ast.DerefExpr{Expr: &ast.MemberExpr{Expr: $2, Name: $4.Lit}} + $$.SetPosition($2.Position()) + } + | STRING + { + $$ = &ast.StringExpr{Lit: $1.Lit} + $$.SetPosition($1.Position()) + } + | TRUE + { + $$ = &ast.ConstExpr{Value: $1.Lit} + $$.SetPosition($1.Position()) + } + | FALSE + { + $$ = &ast.ConstExpr{Value: $1.Lit} + $$.SetPosition($1.Position()) + } + | NIL + { + $$ = &ast.ConstExpr{Value: $1.Lit} + $$.SetPosition($1.Position()) + } + | expr '?' expr ':' expr + { + $$ = &ast.TernaryOpExpr{Expr: $1, Lhs: $3, Rhs: $5} + $$.SetPosition($1.Position()) + } + | expr '.' IDENT + { + $$ = &ast.MemberExpr{Expr: $1, Name: $3.Lit} + $$.SetPosition($1.Position()) + } + | FUNC '(' expr_idents ')' '{' compstmt '}' + { + $$ = &ast.FuncExpr{Args: $3, Stmts: $6} + $$.SetPosition($1.Position()) + } + | FUNC '(' IDENT VARARG ')' '{' compstmt '}' + { + $$ = &ast.FuncExpr{Args: []string{$3.Lit}, Stmts: $7, VarArg: true} + $$.SetPosition($1.Position()) + } + | FUNC IDENT '(' expr_idents ')' '{' compstmt '}' + { + $$ = &ast.FuncExpr{Name: $2.Lit, Args: $4, Stmts: $7} + $$.SetPosition($1.Position()) + } + | FUNC IDENT '(' IDENT VARARG ')' '{' compstmt '}' + { + $$ = &ast.FuncExpr{Name: $2.Lit, Args: []string{$4.Lit}, Stmts: $8, VarArg: true} + $$.SetPosition($1.Position()) + } + | '[' opt_terms exprs opt_terms ']' + { + $$ = &ast.ArrayExpr{Exprs: $3} + if l, ok := yylex.(*Lexer); ok { $$.SetPosition(l.pos) } + } + | '[' opt_terms exprs ',' opt_terms ']' + { + $$ = &ast.ArrayExpr{Exprs: $3} + if l, ok := yylex.(*Lexer); ok { $$.SetPosition(l.pos) } + } + | '{' opt_terms expr_pairs opt_terms '}' + { + mapExpr := make(map[string]ast.Expr) + for _, v := range $3 { + mapExpr[v.(*ast.PairExpr).Key] = v.(*ast.PairExpr).Value + } + $$ = &ast.MapExpr{MapExpr: mapExpr} + if l, ok := yylex.(*Lexer); ok { $$.SetPosition(l.pos) } + } + | '{' opt_terms expr_pairs ',' opt_terms '}' + { + mapExpr := make(map[string]ast.Expr) + for _, v := range $3 { + mapExpr[v.(*ast.PairExpr).Key] = v.(*ast.PairExpr).Value + } + $$ = &ast.MapExpr{MapExpr: mapExpr} + if l, ok := yylex.(*Lexer); ok { $$.SetPosition(l.pos) } + } + | '(' expr ')' + { + $$ = &ast.ParenExpr{SubExpr: $2} + if l, ok := yylex.(*Lexer); ok { $$.SetPosition(l.pos) } + } + | NEW IDENT '(' exprs ')' + { + $$ = &ast.NewExpr{Name: $2.Lit, SubExprs: $4} + $$.SetPosition($1.Position()) + } + | expr '+' expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "+", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr '-' expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "-", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr '*' expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "*", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr '/' expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "/", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr '%' expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "%", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr POW expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "**", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr SHIFTLEFT expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "<<", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr SHIFTRIGHT expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: ">>", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr EQEQ expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "==", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr NEQ expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "!=", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr '>' expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: ">", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr GE expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: ">=", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr '<' expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "<", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr LE expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "<=", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr PLUSEQ expr + { + $$ = &ast.AssocExpr{Lhs: $1, Operator: "+=", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr MINUSEQ expr + { + $$ = &ast.AssocExpr{Lhs: $1, Operator: "-=", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr MULEQ expr + { + $$ = &ast.AssocExpr{Lhs: $1, Operator: "*=", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr DIVEQ expr + { + $$ = &ast.AssocExpr{Lhs: $1, Operator: "/=", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr ANDEQ expr + { + $$ = &ast.AssocExpr{Lhs: $1, Operator: "&=", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr OREQ expr + { + $$ = &ast.AssocExpr{Lhs: $1, Operator: "|=", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr PLUSPLUS + { + $$ = &ast.AssocExpr{Lhs: $1, Operator: "++"} + $$.SetPosition($1.Position()) + } + | expr MINUSMINUS + { + $$ = &ast.AssocExpr{Lhs: $1, Operator: "--"} + $$.SetPosition($1.Position()) + } + | expr '|' expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "|", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr OROR expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "||", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr '&' expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "&", Rhs: $3} + $$.SetPosition($1.Position()) + } + | expr ANDAND expr + { + $$ = &ast.BinOpExpr{Lhs: $1, Operator: "&&", Rhs: $3} + $$.SetPosition($1.Position()) + } + | IDENT '(' exprs VARARG ')' + { + $$ = &ast.CallExpr{Name: $1.Lit, SubExprs: $3, VarArg: true} + $$.SetPosition($1.Position()) + } + | IDENT '(' exprs ')' + { + $$ = &ast.CallExpr{Name: $1.Lit, SubExprs: $3} + $$.SetPosition($1.Position()) + } + | GO IDENT '(' exprs VARARG ')' + { + $$ = &ast.CallExpr{Name: $2.Lit, SubExprs: $4, VarArg: true, Go: true} + $$.SetPosition($2.Position()) + } + | GO IDENT '(' exprs ')' + { + $$ = &ast.CallExpr{Name: $2.Lit, SubExprs: $4, Go: true} + $$.SetPosition($2.Position()) + } + | expr '(' exprs VARARG ')' + { + $$ = &ast.AnonCallExpr{Expr: $1, SubExprs: $3, VarArg: true} + $$.SetPosition($1.Position()) + } + | expr '(' exprs ')' + { + $$ = &ast.AnonCallExpr{Expr: $1, SubExprs: $3} + $$.SetPosition($1.Position()) + } + | GO expr '(' exprs VARARG ')' + { + $$ = &ast.AnonCallExpr{Expr: $2, SubExprs: $4, VarArg: true, Go: true} + $$.SetPosition($2.Position()) + } + | GO expr '(' exprs ')' + { + $$ = &ast.AnonCallExpr{Expr: $2, SubExprs: $4, Go: true} + $$.SetPosition($1.Position()) + } + | IDENT '[' expr ']' + { + $$ = &ast.ItemExpr{Value: &ast.IdentExpr{Lit: $1.Lit}, Index: $3} + $$.SetPosition($1.Position()) + } + | expr '[' expr ']' + { + $$ = &ast.ItemExpr{Value: $1, Index: $3} + $$.SetPosition($1.Position()) + } + | IDENT '[' expr ':' expr ']' + { + $$ = &ast.SliceExpr{Value: &ast.IdentExpr{Lit: $1.Lit}, Begin: $3, End: $5} + $$.SetPosition($1.Position()) + } + | expr '[' expr ':' expr ']' + { + $$ = &ast.SliceExpr{Value: $1, Begin: $3, End: $5} + $$.SetPosition($1.Position()) + } + | MAKE '(' CHAN typ ')' + { + $$ = &ast.MakeChanExpr{Type: $4.Name, SizeExpr: nil} + $$.SetPosition($1.Position()) + } + | MAKE '(' CHAN typ ',' expr ')' + { + $$ = &ast.MakeChanExpr{Type: $4.Name, SizeExpr: $6} + $$.SetPosition($1.Position()) + } + | MAKE '(' ARRAYLIT typ ',' expr ')' + { + $$ = &ast.MakeArrayExpr{Type: $4.Name, LenExpr: $6} + $$.SetPosition($1.Position()) + } + | MAKE '(' ARRAYLIT typ ',' expr ',' expr ')' + { + $$ = &ast.MakeArrayExpr{Type: $4.Name, LenExpr: $6, CapExpr: $8} + $$.SetPosition($1.Position()) + } + | expr OPCHAN expr + { + $$ = &ast.ChanExpr{Lhs: $1, Rhs: $3} + $$.SetPosition($1.Position()) + } + | OPCHAN expr + { + $$ = &ast.ChanExpr{Rhs: $2} + $$.SetPosition($2.Position()) + } + +opt_terms : /* none */ + | terms + ; + + +terms : term + { + } + | terms term + { + } + ; + +term : ';' + { + } + | '\n' + { + } + ; + +%% diff --git a/vendor/github.com/mattn/anko/vm/doc.go b/vendor/github.com/mattn/anko/vm/doc.go new file mode 100644 index 0000000..6bbb194 --- /dev/null +++ b/vendor/github.com/mattn/anko/vm/doc.go @@ -0,0 +1,2 @@ +// Package vm implements virtual-machine for anko. +package vm diff --git a/vendor/github.com/mattn/anko/vm/env.go b/vendor/github.com/mattn/anko/vm/env.go new file mode 100644 index 0000000..0e431e2 --- /dev/null +++ b/vendor/github.com/mattn/anko/vm/env.go @@ -0,0 +1,258 @@ +package vm + +import ( + "fmt" + "reflect" + "strings" + "sync" + + "github.com/mattn/anko/parser" +) + +// Env provides interface to run VM. This mean function scope and blocked-scope. +// If stack goes to blocked-scope, it will make new Env. +type Env struct { + name string + env map[string]reflect.Value + typ map[string]reflect.Type + parent *Env + interrupt *bool + sync.RWMutex +} + +// NewEnv creates new global scope. +func NewEnv() *Env { + b := false + + return &Env{ + env: make(map[string]reflect.Value), + typ: make(map[string]reflect.Type), + parent: nil, + interrupt: &b, + } +} + +// NewEnv creates new child scope. +func (e *Env) NewEnv() *Env { + return &Env{ + env: make(map[string]reflect.Value), + typ: make(map[string]reflect.Type), + parent: e, + name: e.name, + interrupt: e.interrupt, + } +} + +func NewPackage(n string) *Env { + b := false + + return &Env{ + env: make(map[string]reflect.Value), + typ: make(map[string]reflect.Type), + parent: nil, + name: n, + interrupt: &b, + } +} + +func (e *Env) NewPackage(n string) *Env { + return &Env{ + env: make(map[string]reflect.Value), + typ: make(map[string]reflect.Type), + parent: e, + name: n, + interrupt: e.interrupt, + } +} + +// Destroy deletes current scope. +func (e *Env) Destroy() { + e.Lock() + defer e.Unlock() + + if e.parent == nil { + return + } + for k, v := range e.parent.env { + if v.IsValid() && v.Interface() == e { + delete(e.parent.env, k) + } + } + e.parent = nil + e.env = nil +} + +// NewModule creates new module scope as global. +func (e *Env) NewModule(n string) *Env { + m := &Env{ + env: make(map[string]reflect.Value), + parent: e, + name: n, + } + e.Define(n, m) + return m +} + +// SetName sets a name of the scope. This means that the scope is module. +func (e *Env) SetName(n string) { + e.Lock() + e.name = n + e.Unlock() +} + +// GetName returns module name. +func (e *Env) GetName() string { + e.RLock() + defer e.RUnlock() + + return e.name +} + +// Addr returns pointer value which specified symbol. It goes to upper scope until +// found or returns error. +func (e *Env) Addr(k string) (reflect.Value, error) { + e.RLock() + defer e.RUnlock() + + if v, ok := e.env[k]; ok { + return v.Addr(), nil + } + if e.parent == nil { + return NilValue, fmt.Errorf("Undefined symbol '%s'", k) + } + return e.parent.Addr(k) +} + +// Type returns type which specified symbol. It goes to upper scope until +// found or returns error. +func (e *Env) Type(k string) (reflect.Type, error) { + e.RLock() + defer e.RUnlock() + + if v, ok := e.typ[k]; ok { + return v, nil + } + if e.parent == nil { + return NilType, fmt.Errorf("Undefined type '%s'", k) + } + return e.parent.Type(k) +} + +// Get returns value which specified symbol. It goes to upper scope until +// found or returns error. +func (e *Env) Get(k string) (reflect.Value, error) { + e.RLock() + defer e.RUnlock() + + if v, ok := e.env[k]; ok { + return v, nil + } + if e.parent == nil { + return NilValue, fmt.Errorf("Undefined symbol '%s'", k) + } + return e.parent.Get(k) +} + +// Set modifies value which specified as symbol. It goes to upper scope until +// found or returns error. +func (e *Env) Set(k string, v interface{}) error { + e.Lock() + defer e.Unlock() + + if _, ok := e.env[k]; ok { + val, ok := v.(reflect.Value) + if !ok { + val = reflect.ValueOf(v) + } + e.env[k] = val + return nil + } + if e.parent == nil { + return fmt.Errorf("Unknown symbol '%s'", k) + } + return e.parent.Set(k, v) +} + +// DefineGlobal defines symbol in global scope. +func (e *Env) DefineGlobal(k string, v interface{}) error { + if e.parent == nil { + return e.Define(k, v) + } + return e.parent.DefineGlobal(k, v) +} + +// DefineType defines type which specifis symbol in global scope. +func (e *Env) DefineType(k string, t interface{}) error { + if strings.Contains(k, ".") { + return fmt.Errorf("Unknown symbol '%s'", k) + } + global := e + keys := []string{k} + + e.RLock() + for global.parent != nil { + if global.name != "" { + keys = append(keys, global.name) + } + global = global.parent + } + e.RUnlock() + + for i, j := 0, len(keys)-1; i < j; i, j = i+1, j-1 { + keys[i], keys[j] = keys[j], keys[i] + } + + typ, ok := t.(reflect.Type) + if !ok { + typ = reflect.TypeOf(t) + } + + global.Lock() + global.typ[strings.Join(keys, ".")] = typ + global.Unlock() + + return nil +} + +// Define defines symbol in current scope. +func (e *Env) Define(k string, v interface{}) error { + if strings.Contains(k, ".") { + return fmt.Errorf("Unknown symbol '%s'", k) + } + val, ok := v.(reflect.Value) + if !ok { + val = reflect.ValueOf(v) + } + + e.Lock() + e.env[k] = val + e.Unlock() + + return nil +} + +// String return the name of current scope. +func (e *Env) String() string { + e.RLock() + defer e.RUnlock() + + return e.name +} + +// Dump show symbol values in the scope. +func (e *Env) Dump() { + e.RLock() + for k, v := range e.env { + fmt.Printf("%v = %#v\n", k, v) + } + e.RUnlock() +} + +// Execute parses and runs source in current scope. +func (e *Env) Execute(src string) (reflect.Value, error) { + stmts, err := parser.ParseSrc(src) + if err != nil { + return NilValue, err + } + return Run(stmts, e) +} diff --git a/vendor/github.com/mattn/anko/vm/vm.go b/vendor/github.com/mattn/anko/vm/vm.go new file mode 100644 index 0000000..7e85d5b --- /dev/null +++ b/vendor/github.com/mattn/anko/vm/vm.go @@ -0,0 +1,1504 @@ +package vm + +import ( + "errors" + "fmt" + "math" + "os" + "reflect" + "strconv" + "strings" + + "github.com/mattn/anko/ast" + "github.com/mattn/anko/parser" +) + +var ( + NilValue = reflect.ValueOf((*interface{})(nil)) + NilType = reflect.TypeOf((*interface{})(nil)) + TrueValue = reflect.ValueOf(true) + FalseValue = reflect.ValueOf(false) +) + +// Error provides a convenient interface for handling runtime error. +// It can be Error interface with type cast which can call Pos(). +type Error struct { + Message string + Pos ast.Position +} + +var ( + BreakError = errors.New("Unexpected break statement") + ContinueError = errors.New("Unexpected continue statement") + ReturnError = errors.New("Unexpected return statement") + InterruptError = errors.New("Execution interrupted") +) + +// NewStringError makes error interface with message. +func NewStringError(pos ast.Pos, err string) error { + if pos == nil { + return &Error{Message: err, Pos: ast.Position{1, 1}} + } + return &Error{Message: err, Pos: pos.Position()} +} + +// NewErrorf makes error interface with message. +func NewErrorf(pos ast.Pos, format string, args ...interface{}) error { + return &Error{Message: fmt.Sprintf(format, args...), Pos: pos.Position()} +} + +// NewError makes error interface with message. +// This doesn't overwrite last error. +func NewError(pos ast.Pos, err error) error { + if err == nil { + return nil + } + if err == BreakError || err == ContinueError || err == ReturnError { + return err + } + if pe, ok := err.(*parser.Error); ok { + return pe + } + if ee, ok := err.(*Error); ok { + return ee + } + return &Error{Message: err.Error(), Pos: pos.Position()} +} + +// Error returns the error message. +func (e *Error) Error() string { + return e.Message +} + +// Func is function interface to reflect functions internaly. +type Func func(args ...reflect.Value) (reflect.Value, error) + +func (f Func) String() string { + return fmt.Sprintf("[Func: %p]", f) +} + +func ToFunc(f Func) reflect.Value { + return reflect.ValueOf(f) +} + +// Run executes statements in the specified environment. +func Run(stmts []ast.Stmt, env *Env) (reflect.Value, error) { + rv := NilValue + var err error + for _, stmt := range stmts { + if _, ok := stmt.(*ast.BreakStmt); ok { + return NilValue, BreakError + } + if _, ok := stmt.(*ast.ContinueStmt); ok { + return NilValue, ContinueError + } + rv, err = RunSingleStmt(stmt, env) + if err != nil { + return rv, err + } + if _, ok := stmt.(*ast.ReturnStmt); ok { + return reflect.ValueOf(rv), ReturnError + } + } + return rv, nil +} + +// Interrupts the execution of any running statements in the specified environment. +// +// Note that the execution is not instantly aborted: after a call to Interrupt, +// the current running statement will finish, but the next statement will not run, +// and instead will return a NilValue and an InterruptError. +func Interrupt(env *Env) { + env.Lock() + *(env.interrupt) = true + env.Unlock() +} + +// RunSingleStmt executes one statement in the specified environment. +func RunSingleStmt(stmt ast.Stmt, env *Env) (reflect.Value, error) { + env.Lock() + if *(env.interrupt) { + *(env.interrupt) = false + env.Unlock() + + return NilValue, InterruptError + } + env.Unlock() + + switch stmt := stmt.(type) { + case *ast.ExprStmt: + rv, err := invokeExpr(stmt.Expr, env) + if err != nil { + return rv, NewError(stmt, err) + } + return rv, nil + case *ast.VarStmt: + rv := NilValue + var err error + rvs := []reflect.Value{} + for _, expr := range stmt.Exprs { + rv, err = invokeExpr(expr, env) + if err != nil { + return rv, NewError(expr, err) + } + rvs = append(rvs, rv) + } + result := []interface{}{} + for i, name := range stmt.Names { + if i < len(rvs) { + env.Define(name, rvs[i]) + result = append(result, rvs[i].Interface()) + } + } + return reflect.ValueOf(result), nil + case *ast.LetsStmt: + rv := NilValue + var err error + vs := []interface{}{} + for _, rhs := range stmt.Rhss { + rv, err = invokeExpr(rhs, env) + if err != nil { + return rv, NewError(rhs, err) + } + if rv == NilValue { + vs = append(vs, nil) + } else if rv.IsValid() && rv.CanInterface() { + vs = append(vs, rv.Interface()) + } else { + vs = append(vs, nil) + } + } + rvs := reflect.ValueOf(vs) + if len(stmt.Lhss) > 1 && rvs.Len() == 1 { + item := rvs.Index(0) + if item.Kind() == reflect.Interface { + item = item.Elem() + } + if item.Kind() == reflect.Slice { + rvs = item + } + } + for i, lhs := range stmt.Lhss { + if i >= rvs.Len() { + break + } + v := rvs.Index(i) + if v.Kind() == reflect.Interface { + v = v.Elem() + } + _, err = invokeLetExpr(lhs, v, env) + if err != nil { + return rvs, NewError(lhs, err) + } + } + if rvs.Len() == 1 { + return rvs.Index(0), nil + } + return rvs, nil + case *ast.IfStmt: + // If + rv, err := invokeExpr(stmt.If, env) + if err != nil { + return rv, NewError(stmt, err) + } + if toBool(rv) { + // Then + newenv := env.NewEnv() + defer newenv.Destroy() + rv, err = Run(stmt.Then, newenv) + if err != nil { + return rv, NewError(stmt, err) + } + return rv, nil + } + done := false + if len(stmt.ElseIf) > 0 { + for _, stmt := range stmt.ElseIf { + stmt_if := stmt.(*ast.IfStmt) + // ElseIf + rv, err = invokeExpr(stmt_if.If, env) + if err != nil { + return rv, NewError(stmt, err) + } + if !toBool(rv) { + continue + } + // ElseIf Then + done = true + rv, err = Run(stmt_if.Then, env) + if err != nil { + return rv, NewError(stmt, err) + } + break + } + } + if !done && len(stmt.Else) > 0 { + // Else + newenv := env.NewEnv() + defer newenv.Destroy() + rv, err = Run(stmt.Else, newenv) + if err != nil { + return rv, NewError(stmt, err) + } + } + return rv, nil + case *ast.TryStmt: + newenv := env.NewEnv() + defer newenv.Destroy() + _, err := Run(stmt.Try, newenv) + if err != nil { + // Catch + cenv := env.NewEnv() + defer cenv.Destroy() + if stmt.Var != "" { + cenv.Define(stmt.Var, reflect.ValueOf(err)) + } + _, e1 := Run(stmt.Catch, cenv) + if e1 != nil { + err = NewError(stmt.Catch[0], e1) + } else { + err = nil + } + } + if len(stmt.Finally) > 0 { + // Finally + fenv := env.NewEnv() + defer fenv.Destroy() + _, e2 := Run(stmt.Finally, newenv) + if e2 != nil { + err = NewError(stmt.Finally[0], e2) + } + } + return NilValue, NewError(stmt, err) + case *ast.LoopStmt: + newenv := env.NewEnv() + defer newenv.Destroy() + for { + if stmt.Expr != nil { + ev, ee := invokeExpr(stmt.Expr, newenv) + if ee != nil { + return ev, ee + } + if !toBool(ev) { + break + } + } + + rv, err := Run(stmt.Stmts, newenv) + if err != nil { + if err == BreakError { + err = nil + break + } + if err == ContinueError { + err = nil + continue + } + if err == ReturnError { + return rv, err + } + return rv, NewError(stmt, err) + } + } + return NilValue, nil + case *ast.ForStmt: + val, ee := invokeExpr(stmt.Value, env) + if ee != nil { + return val, ee + } + if val.Kind() == reflect.Interface { + val = val.Elem() + } + if val.Kind() != reflect.Array && val.Kind() != reflect.Slice { + return NilValue, NewStringError(stmt, "Invalid operation for non-array value") + } + newenv := env.NewEnv() + defer newenv.Destroy() + + for i := 0; i < val.Len(); i++ { + iv := val.Index(i) + if val.Index(i).Kind() == reflect.Interface || val.Index(i).Kind() == reflect.Ptr { + iv = iv.Elem() + } + newenv.Define(stmt.Var, iv) + rv, err := Run(stmt.Stmts, newenv) + if err != nil { + if err == BreakError { + err = nil + break + } + if err == ContinueError { + err = nil + continue + } + if err == ReturnError { + return rv, err + } + return rv, NewError(stmt, err) + } + } + return NilValue, nil + case *ast.CForStmt: + newenv := env.NewEnv() + defer newenv.Destroy() + _, err := invokeExpr(stmt.Expr1, newenv) + if err != nil { + return NilValue, err + } + for { + fb, err := invokeExpr(stmt.Expr2, newenv) + if err != nil { + return NilValue, err + } + if !toBool(fb) { + break + } + + rv, err := Run(stmt.Stmts, newenv) + if err != nil { + if err == BreakError { + err = nil + break + } + if err == ContinueError { + err = nil + continue + } + if err == ReturnError { + return rv, err + } + return rv, NewError(stmt, err) + } + _, err = invokeExpr(stmt.Expr3, newenv) + if err != nil { + return NilValue, err + } + } + return NilValue, nil + case *ast.ReturnStmt: + rvs := []interface{}{} + switch len(stmt.Exprs) { + case 0: + return NilValue, nil + case 1: + rv, err := invokeExpr(stmt.Exprs[0], env) + if err != nil { + return rv, NewError(stmt, err) + } + return rv, nil + } + for _, expr := range stmt.Exprs { + rv, err := invokeExpr(expr, env) + if err != nil { + return rv, NewError(stmt, err) + } + if isNil(rv) { + rvs = append(rvs, nil) + } else if rv.IsValid() { + rvs = append(rvs, rv.Interface()) + } else { + rvs = append(rvs, nil) + } + } + return reflect.ValueOf(rvs), nil + case *ast.ThrowStmt: + rv, err := invokeExpr(stmt.Expr, env) + if err != nil { + return rv, NewError(stmt, err) + } + if !rv.IsValid() { + return NilValue, NewError(stmt, err) + } + return rv, NewStringError(stmt, fmt.Sprint(rv.Interface())) + case *ast.ModuleStmt: + newenv := env.NewEnv() + newenv.SetName(stmt.Name) + rv, err := Run(stmt.Stmts, newenv) + if err != nil { + return rv, NewError(stmt, err) + } + env.DefineGlobal(stmt.Name, reflect.ValueOf(newenv)) + return rv, nil + case *ast.SwitchStmt: + rv, err := invokeExpr(stmt.Expr, env) + if err != nil { + return rv, NewError(stmt, err) + } + done := false + var default_stmt *ast.DefaultStmt + for _, ss := range stmt.Cases { + if ssd, ok := ss.(*ast.DefaultStmt); ok { + default_stmt = ssd + continue + } + case_stmt := ss.(*ast.CaseStmt) + cv, err := invokeExpr(case_stmt.Expr, env) + if err != nil { + return rv, NewError(stmt, err) + } + if !equal(rv, cv) { + continue + } + rv, err = Run(case_stmt.Stmts, env) + if err != nil { + return rv, NewError(stmt, err) + } + done = true + break + } + if !done && default_stmt != nil { + rv, err = Run(default_stmt.Stmts, env) + if err != nil { + return rv, NewError(stmt, err) + } + } + return rv, nil + default: + return NilValue, NewStringError(stmt, "unknown statement") + } +} + +// toString converts all reflect.Value-s into string. +func toString(v reflect.Value) string { + if v.Kind() == reflect.Interface { + v = v.Elem() + } + if v.Kind() == reflect.String { + return v.String() + } + if !v.IsValid() { + return "nil" + } + return fmt.Sprint(v.Interface()) +} + +// toBool converts all reflect.Value-s into bool. +func toBool(v reflect.Value) bool { + if v.Kind() == reflect.Interface { + v = v.Elem() + } + + switch v.Kind() { + case reflect.Float32, reflect.Float64: + return v.Float() != 0.0 + case reflect.Int, reflect.Int32, reflect.Int64: + return v.Int() != 0 + case reflect.Bool: + return v.Bool() + case reflect.String: + if v.String() == "true" { + return true + } + if toInt64(v) != 0 { + return true + } + } + return false +} + +// toFloat64 converts all reflect.Value-s into float64. +func toFloat64(v reflect.Value) float64 { + if v.Kind() == reflect.Interface { + v = v.Elem() + } + switch v.Kind() { + case reflect.Float32, reflect.Float64: + return v.Float() + case reflect.Int, reflect.Int32, reflect.Int64: + return float64(v.Int()) + } + return 0.0 +} + +func isNil(v reflect.Value) bool { + if !v.IsValid() || v.Kind().String() == "unsafe.Pointer" { + return true + } + if (v.Kind() == reflect.Interface || v.Kind() == reflect.Ptr) && v.IsNil() { + return true + } + return false +} + +func isNum(v reflect.Value) bool { + switch v.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Float32, reflect.Float64: + return true + } + return false +} + +// equal returns true when lhsV and rhsV is same value. +func equal(lhsV, rhsV reflect.Value) bool { + lhsIsNil, rhsIsNil := isNil(lhsV), isNil(rhsV) + if lhsIsNil && rhsIsNil { + return true + } + if (!lhsIsNil && rhsIsNil) || (lhsIsNil && !rhsIsNil) { + return false + } + if lhsV.Kind() == reflect.Interface || lhsV.Kind() == reflect.Ptr { + lhsV = lhsV.Elem() + } + if rhsV.Kind() == reflect.Interface || rhsV.Kind() == reflect.Ptr { + rhsV = rhsV.Elem() + } + if !lhsV.IsValid() || !rhsV.IsValid() { + return true + } + if isNum(lhsV) && isNum(rhsV) { + if rhsV.Type().ConvertibleTo(lhsV.Type()) { + rhsV = rhsV.Convert(lhsV.Type()) + } + } + if lhsV.CanInterface() && rhsV.CanInterface() { + return reflect.DeepEqual(lhsV.Interface(), rhsV.Interface()) + } + return reflect.DeepEqual(lhsV, rhsV) +} + +// toInt64 converts all reflect.Value-s into int64. +func toInt64(v reflect.Value) int64 { + if v.Kind() == reflect.Interface { + v = v.Elem() + } + switch v.Kind() { + case reflect.Float32, reflect.Float64: + return int64(v.Float()) + case reflect.Int, reflect.Int32, reflect.Int64: + return v.Int() + case reflect.String: + s := v.String() + var i int64 + var err error + if strings.HasPrefix(s, "0x") { + i, err = strconv.ParseInt(s, 16, 64) + } else { + i, err = strconv.ParseInt(s, 10, 64) + } + if err == nil { + return int64(i) + } + } + return 0 +} + +func invokeLetExpr(expr ast.Expr, rv reflect.Value, env *Env) (reflect.Value, error) { + switch lhs := expr.(type) { + case *ast.IdentExpr: + if env.Set(lhs.Lit, rv) != nil { + if strings.Contains(lhs.Lit, ".") { + return NilValue, NewErrorf(expr, "Undefined symbol '%s'", lhs.Lit) + } + env.Define(lhs.Lit, rv) + } + return rv, nil + case *ast.MemberExpr: + v, err := invokeExpr(lhs.Expr, env) + if err != nil { + return v, NewError(expr, err) + } + + if v.Kind() == reflect.Interface { + v = v.Elem() + } + if v.Kind() == reflect.Slice { + v = v.Index(0) + } + + if !v.IsValid() { + return NilValue, NewStringError(expr, "Cannot assignable") + } + + if v.Kind() == reflect.Ptr { + v = v.Elem() + } + if v.Kind() == reflect.Struct { + v = v.FieldByName(lhs.Name) + if !v.CanSet() { + return NilValue, NewStringError(expr, "Cannot assignable") + } + v.Set(rv) + } else if v.Kind() == reflect.Map { + v.SetMapIndex(reflect.ValueOf(lhs.Name), rv) + } else { + if !v.CanSet() { + return NilValue, NewStringError(expr, "Cannot assignable") + } + v.Set(rv) + } + return v, nil + case *ast.ItemExpr: + v, err := invokeExpr(lhs.Value, env) + if err != nil { + return v, NewError(expr, err) + } + i, err := invokeExpr(lhs.Index, env) + if err != nil { + return i, NewError(expr, err) + } + if v.Kind() == reflect.Interface { + v = v.Elem() + } + if v.Kind() == reflect.Array || v.Kind() == reflect.Slice { + if i.Kind() != reflect.Int && i.Kind() != reflect.Int64 { + return NilValue, NewStringError(expr, "Array index should be int") + } + ii := int(i.Int()) + if ii < 0 || ii >= v.Len() { + return NilValue, NewStringError(expr, "Cannot assignable") + } + vv := v.Index(ii) + if !vv.CanSet() { + return NilValue, NewStringError(expr, "Cannot assignable") + } + vv.Set(rv) + return rv, nil + } + if v.Kind() == reflect.Map { + if i.Kind() != reflect.String { + return NilValue, NewStringError(expr, "Map key should be string") + } + v.SetMapIndex(i, rv) + return rv, nil + } + return v, NewStringError(expr, "Invalid operation") + case *ast.SliceExpr: + v, err := invokeExpr(lhs.Value, env) + if err != nil { + return v, NewError(expr, err) + } + rb, err := invokeExpr(lhs.Begin, env) + if err != nil { + return rb, NewError(expr, err) + } + re, err := invokeExpr(lhs.End, env) + if err != nil { + return re, NewError(expr, err) + } + if v.Kind() == reflect.Interface { + v = v.Elem() + } + if v.Kind() == reflect.Array || v.Kind() == reflect.Slice { + if rb.Kind() != reflect.Int && rb.Kind() != reflect.Int64 { + return NilValue, NewStringError(expr, "Array index should be int") + } + if re.Kind() != reflect.Int && re.Kind() != reflect.Int64 { + return NilValue, NewStringError(expr, "Array index should be int") + } + ii := int(rb.Int()) + if ii < 0 || ii >= v.Len() { + return NilValue, NewStringError(expr, "Cannot assignable") + } + ij := int(re.Int()) + if ij < 0 || ij >= v.Len() { + return NilValue, NewStringError(expr, "Cannot assignable") + } + vv := v.Slice(ii, ij) + if !vv.CanSet() { + return NilValue, NewStringError(expr, "Cannot assignable") + } + vv.Set(rv) + return rv, nil + } + return v, NewStringError(expr, "Invalid operation") + } + return NilValue, NewStringError(expr, "Invalid operation") +} + +// invokeExpr evaluates one expression. +func invokeExpr(expr ast.Expr, env *Env) (reflect.Value, error) { + switch e := expr.(type) { + case *ast.NumberExpr: + if strings.Contains(e.Lit, ".") || strings.Contains(e.Lit, "e") { + v, err := strconv.ParseFloat(e.Lit, 64) + if err != nil { + return NilValue, NewError(expr, err) + } + return reflect.ValueOf(float64(v)), nil + } + var i int64 + var err error + if strings.HasPrefix(e.Lit, "0x") { + i, err = strconv.ParseInt(e.Lit[2:], 16, 64) + } else { + i, err = strconv.ParseInt(e.Lit, 10, 64) + } + if err != nil { + return NilValue, NewError(expr, err) + } + return reflect.ValueOf(i), nil + case *ast.IdentExpr: + return env.Get(e.Lit) + case *ast.StringExpr: + return reflect.ValueOf(e.Lit), nil + case *ast.ArrayExpr: + a := make([]interface{}, len(e.Exprs)) + for i, expr := range e.Exprs { + arg, err := invokeExpr(expr, env) + if err != nil { + return arg, NewError(expr, err) + } + a[i] = arg.Interface() + } + return reflect.ValueOf(a), nil + case *ast.MapExpr: + m := make(map[string]interface{}) + for k, expr := range e.MapExpr { + v, err := invokeExpr(expr, env) + if err != nil { + return v, NewError(expr, err) + } + m[k] = v.Interface() + } + return reflect.ValueOf(m), nil + case *ast.DerefExpr: + v := NilValue + var err error + switch ee := e.Expr.(type) { + case *ast.IdentExpr: + v, err = env.Get(ee.Lit) + if err != nil { + return v, err + } + case *ast.MemberExpr: + v, err := invokeExpr(ee.Expr, env) + if err != nil { + return v, NewError(expr, err) + } + if v.Kind() == reflect.Interface { + v = v.Elem() + } + if v.Kind() == reflect.Slice { + v = v.Index(0) + } + if v.IsValid() && v.CanInterface() { + if vme, ok := v.Interface().(*Env); ok { + m, err := vme.Get(ee.Name) + if !m.IsValid() || err != nil { + return NilValue, NewStringError(expr, fmt.Sprintf("Invalid operation '%s'", ee.Name)) + } + return m, nil + } + } + + m := v.MethodByName(ee.Name) + if !m.IsValid() { + if v.Kind() == reflect.Ptr { + v = v.Elem() + } + if v.Kind() == reflect.Struct { + m = v.FieldByName(ee.Name) + if !m.IsValid() { + return NilValue, NewStringError(expr, fmt.Sprintf("Invalid operation '%s'", ee.Name)) + } + } else if v.Kind() == reflect.Map { + m = v.MapIndex(reflect.ValueOf(ee.Name)) + if !m.IsValid() { + return NilValue, NewStringError(expr, fmt.Sprintf("Invalid operation '%s'", ee.Name)) + } + } else { + return NilValue, NewStringError(expr, fmt.Sprintf("Invalid operation '%s'", ee.Name)) + } + v = m + } else { + v = m + } + default: + return NilValue, NewStringError(expr, "Invalid operation for the value") + } + if v.Kind() != reflect.Ptr { + return NilValue, NewStringError(expr, "Cannot deference for the value") + } + return v.Addr(), nil + case *ast.AddrExpr: + v := NilValue + var err error + switch ee := e.Expr.(type) { + case *ast.IdentExpr: + v, err = env.Get(ee.Lit) + if err != nil { + return v, err + } + case *ast.MemberExpr: + v, err := invokeExpr(ee.Expr, env) + if err != nil { + return v, NewError(expr, err) + } + if v.Kind() == reflect.Interface { + v = v.Elem() + } + if v.Kind() == reflect.Slice { + v = v.Index(0) + } + if v.IsValid() && v.CanInterface() { + if vme, ok := v.Interface().(*Env); ok { + m, err := vme.Get(ee.Name) + if !m.IsValid() || err != nil { + return NilValue, NewStringError(expr, fmt.Sprintf("Invalid operation '%s'", ee.Name)) + } + return m, nil + } + } + + m := v.MethodByName(ee.Name) + if !m.IsValid() { + if v.Kind() == reflect.Ptr { + v = v.Elem() + } + if v.Kind() == reflect.Struct { + m = v.FieldByName(ee.Name) + if !m.IsValid() { + return NilValue, NewStringError(expr, fmt.Sprintf("Invalid operation '%s'", ee.Name)) + } + } else if v.Kind() == reflect.Map { + m = v.MapIndex(reflect.ValueOf(ee.Name)) + if !m.IsValid() { + return NilValue, NewStringError(expr, fmt.Sprintf("Invalid operation '%s'", ee.Name)) + } + } else { + return NilValue, NewStringError(expr, fmt.Sprintf("Invalid operation '%s'", ee.Name)) + } + v = m + } else { + v = m + } + default: + return NilValue, NewStringError(expr, "Invalid operation for the value") + } + if !v.CanAddr() { + i := v.Interface() + return reflect.ValueOf(&i), nil + } + return v.Addr(), nil + case *ast.UnaryExpr: + v, err := invokeExpr(e.Expr, env) + if err != nil { + return v, NewError(expr, err) + } + switch e.Operator { + case "-": + if v.Kind() == reflect.Float64 { + return reflect.ValueOf(-v.Float()), nil + } + return reflect.ValueOf(-v.Int()), nil + case "^": + return reflect.ValueOf(^toInt64(v)), nil + case "!": + return reflect.ValueOf(!toBool(v)), nil + default: + return NilValue, NewStringError(e, "Unknown operator ''") + } + case *ast.ParenExpr: + v, err := invokeExpr(e.SubExpr, env) + if err != nil { + return v, NewError(expr, err) + } + return v, nil + case *ast.FuncExpr: + f := reflect.ValueOf(func(expr *ast.FuncExpr, env *Env) Func { + return func(args ...reflect.Value) (reflect.Value, error) { + if !expr.VarArg { + if len(args) != len(expr.Args) { + return NilValue, NewStringError(expr, "Arguments Number of mismatch") + } + } + newenv := env.NewEnv() + if expr.VarArg { + newenv.Define(expr.Args[0], reflect.ValueOf(args)) + } else { + for i, arg := range expr.Args { + newenv.Define(arg, args[i]) + } + } + rr, err := Run(expr.Stmts, newenv) + if err == ReturnError { + err = nil + rr = rr.Interface().(reflect.Value) + } + return rr, err + } + }(e, env)) + env.Define(e.Name, f) + return f, nil + case *ast.MemberExpr: + v, err := invokeExpr(e.Expr, env) + if err != nil { + return v, NewError(expr, err) + } + if v.Kind() == reflect.Interface { + v = v.Elem() + } + if v.Kind() == reflect.Slice { + v = v.Index(0) + } + if v.IsValid() && v.CanInterface() { + if vme, ok := v.Interface().(*Env); ok { + m, err := vme.Get(e.Name) + if !m.IsValid() || err != nil { + return NilValue, NewStringError(expr, fmt.Sprintf("Invalid operation '%s'", e.Name)) + } + return m, nil + } + } + + m := v.MethodByName(e.Name) + if !m.IsValid() { + if v.Kind() == reflect.Ptr { + v = v.Elem() + } + if v.Kind() == reflect.Struct { + m = v.FieldByName(e.Name) + if !m.IsValid() { + return NilValue, NewStringError(expr, fmt.Sprintf("Invalid operation '%s'", e.Name)) + } + } else if v.Kind() == reflect.Map { + m = v.MapIndex(reflect.ValueOf(e.Name)) + if !m.IsValid() { + return NilValue, NewStringError(expr, fmt.Sprintf("Invalid operation '%s'", e.Name)) + } + } else { + return NilValue, NewStringError(expr, fmt.Sprintf("Invalid operation '%s'", e.Name)) + } + } + return m, nil + case *ast.ItemExpr: + v, err := invokeExpr(e.Value, env) + if err != nil { + return v, NewError(expr, err) + } + i, err := invokeExpr(e.Index, env) + if err != nil { + return i, NewError(expr, err) + } + if v.Kind() == reflect.Interface { + v = v.Elem() + } + if v.Kind() == reflect.Array || v.Kind() == reflect.Slice { + if i.Kind() != reflect.Int && i.Kind() != reflect.Int64 { + return NilValue, NewStringError(expr, "Array index should be int") + } + ii := int(i.Int()) + if ii < 0 || ii >= v.Len() { + return NilValue, nil + } + return v.Index(ii), nil + } + if v.Kind() == reflect.Map { + if i.Kind() != reflect.String { + return NilValue, NewStringError(expr, "Map key should be string") + } + return v.MapIndex(i), nil + } + if v.Kind() == reflect.String { + rs := []rune(v.Interface().(string)) + ii := int(i.Int()) + if ii < 0 || ii >= len(rs) { + return NilValue, nil + } + return reflect.ValueOf(rs[ii]), nil + } + return v, NewStringError(expr, "Invalid operation") + case *ast.SliceExpr: + v, err := invokeExpr(e.Value, env) + if err != nil { + return v, NewError(expr, err) + } + rb, err := invokeExpr(e.Begin, env) + if err != nil { + return rb, NewError(expr, err) + } + re, err := invokeExpr(e.End, env) + if err != nil { + return re, NewError(expr, err) + } + if v.Kind() == reflect.Interface { + v = v.Elem() + } + if v.Kind() == reflect.Array || v.Kind() == reflect.Slice { + if rb.Kind() != reflect.Int && rb.Kind() != reflect.Int64 { + return NilValue, NewStringError(expr, "Array index should be int") + } + if re.Kind() != reflect.Int && re.Kind() != reflect.Int64 { + return NilValue, NewStringError(expr, "Array index should be int") + } + ii := int(rb.Int()) + if ii < 0 || ii > v.Len() { + return NilValue, nil + } + ij := int(re.Int()) + if ij < 0 || ij > v.Len() { + return v, nil + } + return v.Slice(ii, ij), nil + } + if v.Kind() == reflect.String { + if rb.Kind() != reflect.Int && rb.Kind() != reflect.Int64 { + return NilValue, NewStringError(expr, "Array index should be int") + } + if re.Kind() != reflect.Int && re.Kind() != reflect.Int64 { + return NilValue, NewStringError(expr, "Array index should be int") + } + r := []rune(v.String()) + ii := int(rb.Int()) + if ii < 0 || ii >= len(r) { + return NilValue, nil + } + ij := int(re.Int()) + if ij < 0 || ij >= len(r) { + return NilValue, nil + } + return reflect.ValueOf(string(r[ii:ij])), nil + } + return v, NewStringError(expr, "Invalid operation") + case *ast.AssocExpr: + switch e.Operator { + case "++": + if alhs, ok := e.Lhs.(*ast.IdentExpr); ok { + v, err := env.Get(alhs.Lit) + if err != nil { + return v, err + } + if v.Kind() == reflect.Float64 { + v = reflect.ValueOf(toFloat64(v) + 1.0) + } else { + v = reflect.ValueOf(toInt64(v) + 1) + } + if env.Set(alhs.Lit, v) != nil { + env.Define(alhs.Lit, v) + } + return v, nil + } + case "--": + if alhs, ok := e.Lhs.(*ast.IdentExpr); ok { + v, err := env.Get(alhs.Lit) + if err != nil { + return v, err + } + if v.Kind() == reflect.Float64 { + v = reflect.ValueOf(toFloat64(v) - 1.0) + } else { + v = reflect.ValueOf(toInt64(v) - 1) + } + if env.Set(alhs.Lit, v) != nil { + env.Define(alhs.Lit, v) + } + return v, nil + } + } + + v, err := invokeExpr(&ast.BinOpExpr{Lhs: e.Lhs, Operator: e.Operator[0:1], Rhs: e.Rhs}, env) + if err != nil { + return v, err + } + + if v.Kind() == reflect.Interface { + v = v.Elem() + } + return invokeLetExpr(e.Lhs, v, env) + case *ast.LetExpr: + rv, err := invokeExpr(e.Rhs, env) + if err != nil { + return rv, NewError(e, err) + } + if rv.Kind() == reflect.Interface { + rv = rv.Elem() + } + return invokeLetExpr(e.Lhs, rv, env) + case *ast.LetsExpr: + rv := NilValue + var err error + vs := []interface{}{} + for _, rhs := range e.Rhss { + rv, err = invokeExpr(rhs, env) + if err != nil { + return rv, NewError(rhs, err) + } + if rv == NilValue { + vs = append(vs, nil) + } else if rv.IsValid() && rv.CanInterface() { + vs = append(vs, rv.Interface()) + } else { + vs = append(vs, nil) + } + } + rvs := reflect.ValueOf(vs) + if len(e.Lhss) > 1 && rvs.Len() == 1 { + item := rvs.Index(0) + if item.Kind() == reflect.Interface { + item = item.Elem() + } + if item.Kind() == reflect.Slice { + rvs = item + } + } + for i, lhs := range e.Lhss { + if i >= rvs.Len() { + break + } + v := rvs.Index(i) + if v.Kind() == reflect.Interface { + v = v.Elem() + } + _, err = invokeLetExpr(lhs, v, env) + if err != nil { + return rvs, NewError(lhs, err) + } + } + if rvs.Len() == 1 { + return rvs.Index(0), nil + } + return rvs, nil + //case *ast.NewExpr: + // println("NEW") + // return NilValue, nil + case *ast.BinOpExpr: + lhsV := NilValue + rhsV := NilValue + var err error + + lhsV, err = invokeExpr(e.Lhs, env) + if err != nil { + return lhsV, NewError(expr, err) + } + if lhsV.Kind() == reflect.Interface { + lhsV = lhsV.Elem() + } + if e.Rhs != nil { + rhsV, err = invokeExpr(e.Rhs, env) + if err != nil { + return rhsV, NewError(expr, err) + } + if rhsV.Kind() == reflect.Interface { + rhsV = rhsV.Elem() + } + } + switch e.Operator { + case "+": + if lhsV.Kind() == reflect.String || rhsV.Kind() == reflect.String { + return reflect.ValueOf(toString(lhsV) + toString(rhsV)), nil + } + if (lhsV.Kind() == reflect.Array || lhsV.Kind() == reflect.Slice) && (rhsV.Kind() != reflect.Array && rhsV.Kind() != reflect.Slice) { + return reflect.Append(lhsV, rhsV), nil + } + if (lhsV.Kind() == reflect.Array || lhsV.Kind() == reflect.Slice) && (rhsV.Kind() == reflect.Array || rhsV.Kind() == reflect.Slice) { + return reflect.AppendSlice(lhsV, rhsV), nil + } + if lhsV.Kind() == reflect.Float64 || rhsV.Kind() == reflect.Float64 { + return reflect.ValueOf(toFloat64(lhsV) + toFloat64(rhsV)), nil + } + return reflect.ValueOf(toInt64(lhsV) + toInt64(rhsV)), nil + case "-": + if lhsV.Kind() == reflect.Float64 || rhsV.Kind() == reflect.Float64 { + return reflect.ValueOf(toFloat64(lhsV) - toFloat64(rhsV)), nil + } + return reflect.ValueOf(toInt64(lhsV) - toInt64(rhsV)), nil + case "*": + if lhsV.Kind() == reflect.String && (rhsV.Kind() == reflect.Int || rhsV.Kind() == reflect.Int32 || rhsV.Kind() == reflect.Int64) { + return reflect.ValueOf(strings.Repeat(toString(lhsV), int(toInt64(rhsV)))), nil + } + if lhsV.Kind() == reflect.Float64 || rhsV.Kind() == reflect.Float64 { + return reflect.ValueOf(toFloat64(lhsV) * toFloat64(rhsV)), nil + } + return reflect.ValueOf(toInt64(lhsV) * toInt64(rhsV)), nil + case "/": + return reflect.ValueOf(toFloat64(lhsV) / toFloat64(rhsV)), nil + case "%": + return reflect.ValueOf(toInt64(lhsV) % toInt64(rhsV)), nil + case "==": + return reflect.ValueOf(equal(lhsV, rhsV)), nil + case "!=": + return reflect.ValueOf(equal(lhsV, rhsV) == false), nil + case ">": + return reflect.ValueOf(toFloat64(lhsV) > toFloat64(rhsV)), nil + case ">=": + return reflect.ValueOf(toFloat64(lhsV) >= toFloat64(rhsV)), nil + case "<": + return reflect.ValueOf(toFloat64(lhsV) < toFloat64(rhsV)), nil + case "<=": + return reflect.ValueOf(toFloat64(lhsV) <= toFloat64(rhsV)), nil + case "|": + return reflect.ValueOf(toInt64(lhsV) | toInt64(rhsV)), nil + case "||": + if toBool(lhsV) { + return lhsV, nil + } + return rhsV, nil + case "&": + return reflect.ValueOf(toInt64(lhsV) & toInt64(rhsV)), nil + case "&&": + if toBool(lhsV) { + return rhsV, nil + } + return lhsV, nil + case "**": + if lhsV.Kind() == reflect.Float64 { + return reflect.ValueOf(math.Pow(toFloat64(lhsV), toFloat64(rhsV))), nil + } + return reflect.ValueOf(int64(math.Pow(toFloat64(lhsV), toFloat64(rhsV)))), nil + case ">>": + return reflect.ValueOf(toInt64(lhsV) >> uint64(toInt64(rhsV))), nil + case "<<": + return reflect.ValueOf(toInt64(lhsV) << uint64(toInt64(rhsV))), nil + default: + return NilValue, NewStringError(expr, "Unknown operator") + } + case *ast.ConstExpr: + switch e.Value { + case "true": + return reflect.ValueOf(true), nil + case "false": + return reflect.ValueOf(false), nil + } + return reflect.ValueOf(nil), nil + case *ast.AnonCallExpr: + f, err := invokeExpr(e.Expr, env) + if err != nil { + return f, NewError(expr, err) + } + if f.Kind() == reflect.Interface { + f = f.Elem() + } + if f.Kind() != reflect.Func { + return f, NewStringError(expr, "Unknown function") + } + return invokeExpr(&ast.CallExpr{Func: f, SubExprs: e.SubExprs, VarArg: e.VarArg, Go: e.Go}, env) + case *ast.CallExpr: + f := NilValue + + if e.Func != nil { + f = e.Func.(reflect.Value) + } else { + var err error + ff, err := env.Get(e.Name) + if err != nil { + return f, err + } + f = ff + } + _, isReflect := f.Interface().(Func) + + args := []reflect.Value{} + l := len(e.SubExprs) + for i, expr := range e.SubExprs { + arg, err := invokeExpr(expr, env) + if err != nil { + return arg, NewError(expr, err) + } + + if i < f.Type().NumIn() { + if !f.Type().IsVariadic() { + it := f.Type().In(i) + if arg.Kind().String() == "unsafe.Pointer" { + arg = reflect.New(it).Elem() + } + if arg.Kind() != it.Kind() && arg.IsValid() && arg.Type().ConvertibleTo(it) { + arg = arg.Convert(it) + } else if arg.Kind() == reflect.Func { + if _, isFunc := arg.Interface().(Func); isFunc { + rfunc := arg + arg = reflect.MakeFunc(it, func(args []reflect.Value) []reflect.Value { + for i := range args { + args[i] = reflect.ValueOf(args[i]) + } + if e.Go { + go func() { + rfunc.Call(args) + }() + return []reflect.Value{} + } + return rfunc.Call(args)[:it.NumOut()] + }) + } + } else if !arg.IsValid() { + arg = reflect.Zero(it) + } + } + } + if !arg.IsValid() { + arg = NilValue + } + + if !isReflect { + if e.VarArg && i == l-1 { + for j := 0; j < arg.Len(); j++ { + args = append(args, arg.Index(j).Elem()) + } + } else { + args = append(args, arg) + } + } else { + if arg.Kind() == reflect.Interface { + arg = arg.Elem() + } + if e.VarArg && i == l-1 { + for j := 0; j < arg.Len(); j++ { + args = append(args, reflect.ValueOf(arg.Index(j).Elem())) + } + } else { + args = append(args, reflect.ValueOf(arg)) + } + } + } + ret := NilValue + var err error + fnc := func() { + defer func() { + if os.Getenv("ANKO_DEBUG") == "" { + if ex := recover(); ex != nil { + if e, ok := ex.(error); ok { + err = e + } else { + err = errors.New(fmt.Sprint(ex)) + } + } + } + }() + if f.Kind() == reflect.Interface { + f = f.Elem() + } + rets := f.Call(args) + if isReflect { + ev := rets[1].Interface() + if ev != nil { + err = ev.(error) + } + ret = rets[0].Interface().(reflect.Value) + } else { + for i, expr := range e.SubExprs { + if ae, ok := expr.(*ast.AddrExpr); ok { + if id, ok := ae.Expr.(*ast.IdentExpr); ok { + invokeLetExpr(id, args[i].Elem().Elem(), env) + } + } + } + if f.Type().NumOut() == 1 { + ret = rets[0] + } else { + var result []interface{} + for _, r := range rets { + result = append(result, r.Interface()) + } + ret = reflect.ValueOf(result) + } + } + } + if e.Go { + go fnc() + return NilValue, nil + } + fnc() + if err != nil { + return ret, NewError(expr, err) + } + return ret, nil + case *ast.TernaryOpExpr: + rv, err := invokeExpr(e.Expr, env) + if err != nil { + return rv, NewError(expr, err) + } + if toBool(rv) { + lhsV, err := invokeExpr(e.Lhs, env) + if err != nil { + return lhsV, NewError(expr, err) + } + return lhsV, nil + } + rhsV, err := invokeExpr(e.Rhs, env) + if err != nil { + return rhsV, NewError(expr, err) + } + return rhsV, nil + case *ast.MakeChanExpr: + typ, err := env.Type(e.Type) + if err != nil { + return NilValue, err + } + var size int + if e.SizeExpr != nil { + rv, err := invokeExpr(e.SizeExpr, env) + if err != nil { + return NilValue, err + } + size = int(toInt64(rv)) + } + return func() (reflect.Value, error) { + defer func() { + if os.Getenv("ANKO_DEBUG") == "" { + if ex := recover(); ex != nil { + if e, ok := ex.(error); ok { + err = e + } else { + err = errors.New(fmt.Sprint(ex)) + } + } + } + }() + return reflect.MakeChan(reflect.ChanOf(reflect.BothDir, typ), size), nil + }() + case *ast.MakeArrayExpr: + typ, err := env.Type(e.Type) + if err != nil { + return NilValue, err + } + var alen int + if e.LenExpr != nil { + rv, err := invokeExpr(e.LenExpr, env) + if err != nil { + return NilValue, err + } + alen = int(toInt64(rv)) + } + var acap int + if e.CapExpr != nil { + rv, err := invokeExpr(e.CapExpr, env) + if err != nil { + return NilValue, err + } + acap = int(toInt64(rv)) + } else { + acap = alen + } + return func() (reflect.Value, error) { + defer func() { + if os.Getenv("ANKO_DEBUG") == "" { + if ex := recover(); ex != nil { + if e, ok := ex.(error); ok { + err = e + } else { + err = errors.New(fmt.Sprint(ex)) + } + } + } + }() + return reflect.MakeSlice(reflect.SliceOf(typ), alen, acap), nil + }() + case *ast.ChanExpr: + rhs, err := invokeExpr(e.Rhs, env) + if err != nil { + return NilValue, NewError(expr, err) + } + + if e.Lhs == nil { + if rhs.Kind() == reflect.Chan { + rv, _ := rhs.Recv() + return rv, nil + } + } else { + lhs, err := invokeExpr(e.Lhs, env) + if err != nil { + return NilValue, NewError(expr, err) + } + if lhs.Kind() == reflect.Chan { + lhs.Send(rhs) + return NilValue, nil + } else if rhs.Kind() == reflect.Chan { + rv, _ := rhs.Recv() + return invokeLetExpr(e.Lhs, rv, env) + } + } + return NilValue, NewStringError(expr, "Invalid operation for chan") + default: + return NilValue, NewStringError(expr, "Unknown expression") + } +}