Godep vendoring for external packages

vendor/github.com/mattn/anko/ast/doc.go

@@ -0,0 +1,2 @@
+// Package ast implements abstruct-syntax-tree for anko.
+package ast

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
+}

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
+}

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
+}

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
+}

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

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)
+}

vendor/github.com/mattn/anko/parser/parser.go.y

@@ -0,0 +1,705 @@
+%{
+package parser
+
+import (
+	"github.com/mattn/anko/ast"
+)
+
+%}
+
+%type<compstmt> compstmt
+%type<stmts> stmts
+%type<stmt> stmt
+%type<stmt_if> stmt_if
+%type<stmt_default> stmt_default
+%type<stmt_case> stmt_case
+%type<stmt_cases> stmt_cases
+%type<typ> typ
+%type<expr> expr
+%type<exprs> exprs
+%type<expr_many> expr_many
+%type<expr_lets> expr_lets
+%type<expr_pair> expr_pair
+%type<expr_pairs> expr_pairs
+%type<expr_idents> 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<tok> 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'
+	{
+	}
+	;
+
+%%

vendor/github.com/mattn/anko/vm/doc.go

@@ -0,0 +1,2 @@
+// Package vm implements virtual-machine for anko.
+package vm

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)
+}