type binaryChunk struct {
	header
	sizeUpvalues byte
	mainFunc     *Prototype
}

type header struct {
	signature       [4]byte // magic number 0x1B4C7561, for identifying chunk file
	version         byte    // for version x.y.z, it is x*16+y
	format          byte    // default value is 0
	luacData        [6]byte // for verifying file, "\x19\x93\r\n\x1a\n"
	cintSize        byte
	sizetSize       byte
	instructionSize byte
	luaIntegerSize  byte
	luaNumberSize   byte
	luacInt         int64   // stores 0x5678, used to determine Big-endian or Little-endian
	luacNum         float32 // stores 370.5, used to determine number format(usually IEEE 754)
}

type Prototype struct {
	Source          string   // where source comes form, only not empty in main function
	LineDefined     uint32   // where this prototype starts in source file(line index), main function always starts with 0
	LastLineDefined uint32   // where this prototype ends in source file(line index)
	NumParams       byte     // useless if IsVararg is 1(true)
	IsVararg        byte     // whether this prototype accepts parametres of variable numbers, 0 for false and 1 for true
	MaxStackSize    byte     // how many virtual registers this function needs at least, stack is used to virtualize register
	Code            []uint32 // list of instructions
	Constants       []interface{}
	Upvalues        []Upvalue
	Protos          []*Prototype // list of sub-functions
	LineInfo        []uint32     // list of line indexes, mapped to Code(the instruction list)
	LocVars         []LocVar     // list of local variables
	UpvalueNames    []string     // mapped to Upvalues
}

type reader struct {
	data []byte
}

// param parentSource indicates where the source of the chunk file comes from
// chunk file only save this information for main function,
// thus it requires to be passed to every subfunctions
// read sub-functions recursively
func (r *reader) readProtos(parentSource string) []*Prototype {
	protos := make([]*Prototype, r.readUint32())
	for i := range protos {
		protos[i] = r.readProto(parentSource)
	}

	return protos
}

func (r *reader) readLocVars() []LocVar {
	locVars := make([]LocVar, r.readUint32())
	for i := range locVars {
		locVars[i] = LocVar{
			VarName: r.readString(),
			StartPC: r.readUint32(),
			EndPC:   r.readUint32(),
		}
	}

	return locVars
}

// ... more functions

type LuaState interface {
    /* basic stack manipulation */
    GetTop() int
    AbsIndex(idx int) int
    CheckStack(n int) bool
    Pop(n int)
    Copy(fromIdx, toIdx int)
    PushValue(idx int)
    Insert(idx int)
    // ...

    /* access functions (stack -> Go) */
    TypeName(tp LuaType) string
    Type(idx int) LuaType
    IsNone(idx int) bool
    IsNil(idx int) bool
    IsNoneOrNil(idx int) bool
    IsBoolean(idx int) bool
    IsInteger(idx int) bool
    IsNumber(idx int) bool
    IsString(idx int) bool
    ToBoolean(idx int) bool
    ToInteger(idx int) int64
    ToNumber(idx int) float64
    ToString(idx int) string
    // ...

    /* push functions (Go -> stack) */
    PushNil()
    PushBoolean(b bool)
    PushInteger(n int64)
    PushNumber(n float64)
    PushString(s string)
}

type luaState struct {
	stack    *luaStack
}

func New() *luaState {
	// ...
}

// ... more functions

type luaStack struct {
	slots []luaValue
	top   int // index of the top of the lua stack, notice that index starts with 1

	pc      int

	state *luaState
}

func (l *luaStack) push(val luaValue) {
	// ...
}

func (l *luaStack) pop() luaValue {
	// ...
}

// Get value from the stack by relevant index,
// returns the registry if idx is fake index of registry
// returns nil if the index is invalid.
func (l *luaStack) get(idx int) luaValue {
	// ...
}

func (l *luaStack) set(idx int, val luaValue) {
	// ...
}

type LuaVM interface {
    LuaState
    PC() int          // 返回当前PC（仅测试用）
    AddPC(n int)      // 修改PC（用于实现跳转指令）
    Fetch() uint32    // 取出当前指令；将PC指向下一条指令
    GetConst(idx int) // 将指定常量推入栈顶
}

type luaState struct {
    stack *luaStack
    // 下面是新添加的字段
    proto *binchunk.Prototype
    pc    int
}

func (self *luaState) PC() int {
    return self.pc
}

func (self *luaState) AddPC(n int) {
    self.pc += n
}

func (self *luaState) Fetch() uint32 {
    i := self.proto.Code[self.pc]
    self.pc++
    return i
}

func (self *luaState) GetConst(idx int) {
    c := self.proto.Constants[idx]
    self.stack.push(c)
}

func move(i Instruction, vm LuaVM) {
    a, b, _ := i.ABC()
    a += 1;    b += 1
    vm.Copy(b, a)
}

func jmp(i Instruction, vm LuaVM) {
    a, sBx := i.AsBx()
    vm.AddPC(sBx)
    if a != 0 {
        panic("todo!")
    }
}

type opcode struct {
    // ... 
    action func(i Instruction, vm api.LuaVM)
}

var opcodes = []opcode{
    /*     T  A    B       C     mode   name       action */
    opcode{0, 1, OpArgR, OpArgN, IABC, "MOVE    ", move    },
    opcode{0, 1, OpArgK, OpArgN, IABx, "LOADK   ", loadK   },
    opcode{0, 1, OpArgN, OpArgN, IABx, "LOADKX  ", loadKx  },
    opcode{0, 1, OpArgU, OpArgU, IABC, "LOADBOOL", loadBool},
    opcode{0, 1, OpArgU, OpArgN, IABC, "LOADNIL ", loadNil },
    // ... 
}


type Instruction uint32

func (self Instruction) Execute(vm api.LuaVM) {
    action := opcodes[self.Opcode()].action
    if action != nil {
        action(self, vm)
    } else {
        panic(self.OpName())
    }
}

type luaStack struct {
	slots []luaValue
	top   int // index of the top of the lua stack, notice that index starts with 1

	prev    *luaStack // use linked list to achieve function call-back stack
	varargs []luaValue
	pc      int

	state *luaState
}

type luaState struct {
    stack    *luaStack
    proto    *binchunk.Prototype
    pc       int
}

func New() *luaState {
	// ...
}

// Add a head node to the linked list.
func (l *luaState) pushLuaStack(stack *luaStack) {
	stack.prev = l.stack
	l.stack = stack
}

// Delete the head node of the linked list.
func (l *luaState) popLuaStack() {
	stack := l.stack
	l.stack = stack.prev
	stack.prev = nil
}

// ... more functions

type Lexer struct {
    chunk     string // 源代码
    chunkName string // 源文件名
    line      int    // 当前行号
}

func (self *Lexer) NextToken() (line, kind int, token string) {
    self.skipWhiteSpaces()
    if len(self.chunk) == 0 {
        return self.line, TOKEN_EOF, "EOF"
    }

    switch self.chunk[0] {
    case ';': self.next(1); return self.line, TOKEN_SEP_SEMI, ""
    case ',': self.next(1); return self.line, TOKEN_SEP_COMMA, ""
    // ... 
    case '=':
        if self.test("==") {
            self.next(2); return self.line, TOKEN_OP_EQ, "=="
        } else {
            self.next(1); return self.line, TOKEN_OP_ASSIGN, "="
        }
    case '<':
        if self.test("<<") {
            self.next(2); return self.line, TOKEN_OP_SHL, "<<"
        } else if self.test("<=") {
            self.next(2); return self.line, TOKEN_OP_LE, "<="
        } else {
            self.next(1); return self.line, TOKEN_OP_LT, "<"
        }
}

type Exp interface{}

type NilExp /*   */ struct{ Line int }
type TrueExp /*  */ struct{ Line int }
type FalseExp /* */ struct{ Line int }

type IntegerExp struct {
	Line int
	Val  int64
}

type StringExp struct {
	Line int
	Str  string
}

// exp1 op exp2
type BinopExp struct {
	Line int // line of operator
	Op   int // operator
	Exp1 Exp
	Exp2 Exp
}

// EBNF:
// functiondef::=function funcbody
// funcbody::= '(' [parlist] ')' block end
// parlist::= namelist [',' '...'] | '...'
// namelist::= Name {',' Name}
type FuncDefExp struct {
	Line     int
	LastLine int
	ParList  []string
	IsVararg bool
	Block    *Block
}

// EBNF:
// functioncall::=prefixexp [':' Name] args
// args::= '(' [explist] ')' | tableconstructor | LiteralString
type FuncCallExp struct {
	Line      int // line of `(`
	LastLine  int // line of `)`
	PrefixExp Exp
	NameExp   *StringExp
	Args      []Exp
}

// ... more expr


type Stat interface{}

type BreakStat /**/ struct{ Line int }     // break
type DoStat /*   */ struct{ Block *Block } // do block end

type FuncCallStat = FuncCallExp // function call, both statement and expression

// EBNF: while exp do block end
type WhileStat struct {
	Exp   Exp
	Block *Block
}

// simplified EBNF: if exp then block {elseif exp then block} end
type IfStat struct {
	// index 0 contains if-then, others contain elseif-then
	Exps   []Exp
	Blocks []*Block
}

// EBNF:
// for namelist in explist do block end
// namelist::= Name {',' Name}
// explist::= exp {',' exp}
type ForInStat struct {
	LineOfDo int
	NameList []string
	ExpList  []Exp
	Block    *Block
}

// ... more stat

func parseStat(lexer *Lexer) Stat {
	switch lexer.LookAhead() {
	case TOKEN_SEP_SEMI:
		return parseEmptyStat(lexer)
	case TOKEN_KW_BREAK:
		return parseBreakStat(lexer)
	case TOKEN_SEP_LABEL:
		return parseLabelStat(lexer)
	case TOKEN_KW_GOTO:
		return parseGotoStat(lexer)
	case TOKEN_KW_DO:
		return parseDoStat(lexer)
	case TOKEN_KW_WHILE:
		return parseWhileStat(lexer)
	case TOKEN_KW_REPEAT:
		return parseRepeatStat(lexer)
	case TOKEN_KW_IF:
		return parseIfStat(lexer)
	case TOKEN_KW_FOR:
		return parseForStat(lexer)
	case TOKEN_KW_FUNCTION:
		return parseFuncDefStat(lexer)
	case TOKEN_KW_LOCAL:
		return parseLocalAssignOrFuncDefStat(lexer)
	default:
		return parseAssignOrFuncCallStat(lexer)
	}
}

func parseBlock(lexer *Lexer) *Block {
	return &Block{
		Stats:    parseStats(lexer),
		RetExps:  parseRetExps(lexer),
		LastLine: lexer.Line(),
	}
}

func parseStats(lexer *Lexer) []Stat {
	stats := make([]Stat, 0, 8)
	for !_isReturnOrBlockEnd(lexer.LookAhead()) {
		stat := parseStat(lexer)
		if _, ok := stat.(*EmptyStat); !ok {
			stats = append(stats, stat)
		}
	}

	return stats
}

// ... more parser methods

func parseExp(lexer *Lexer) Exp {
	return parseExp12(lexer)
}

// x or y
func parseExp12(lexer *Lexer) Exp {
	exp := parseExp11(lexer)
	for lexer.LookAhead() == TOKEN_OP_OR {
		line, op, _ := lexer.NextToken()
		lor := &BinopExp{line, op, exp, parseExp11(lexer)}
		exp = optimizeLogicalOr(lor)
	}
	return exp
}

// x and y
func parseExp11(lexer *Lexer) Exp {
	exp := parseExp10(lexer)
	for lexer.LookAhead() == TOKEN_OP_AND {
		line, op, _ := lexer.NextToken()
		land := &BinopExp{line, op, exp, parseExp10(lexer)}
		exp = optimizeLogicalAnd(land)
	}
	return exp
}

// ... more expr parser methods

type funcInfo struct {
	insts []uint32 // corresponded instructions in binary chunk

	constants map[interface{}]int // key is the constant's value and val is it's index in the constant list
	usedRegs  int
	maxRegs   int

	scopeLv  int
	locVars  []*locVarInfo          // all declared local variables in order
	locNames map[string]*locVarInfo // current valid relationship between variable's name and the actual variable

	breaks [][]int // maintain addresses of `break` jmp

	parent   *funcInfo
	upvalues map[string]upvalInfo

	subFuncs  []*funcInfo
	numParams int
	isVararg  bool
}

func toProto(fi *funcInfo) *Prototype {
	proto := &Prototype{
		NumParams:    byte(fi.numParams),
		MaxStackSize: byte(fi.maxRegs),
		Code:         fi.insts,
		Constants:    getConstants(fi),
		Upvalues:     getUpvalues(fi),
		Protos:       toProtos(fi.subFuncs),
		LineInfo:     []uint32{},
		LocVars:      []LocVar{},
		UpvalueNames: []string{},
	}

	if fi.isVararg {
		proto.IsVararg = 1
	}

	return proto
}

// ...

func (self *funcInfo) allocReg() int {
	self.usedRegs++
	if self.usedRegs >= 255 {
		panic("function or expression needs too many registers")
	}
	if self.usedRegs > self.maxRegs {
		self.maxRegs = self.usedRegs
	}
	return self.usedRegs - 1
}

func (self *funcInfo) freeReg() {
	if self.usedRegs <= 0 {
		panic("usedRegs <= 0 !")
	}
	self.usedRegs--
}

// ... more register methods

func (f *funcInfo) addLocVar(name string) int {
	newVar := &locVarInfo{
		name:    name,
		prev:    f.locNames[name],
		scopeLv: f.scopeLv,
		slot:    f.allocReg(),
	}

	f.locVars = append(f.locVars, newVar)
	f.locNames[name] = newVar

	return newVar.slot
}

// ... more local variable methods

// r[a] = r[b]
func (self *funcInfo) emitMove(a, b int) {
	self.emitABC(OP_MOVE, a, b, 0)
}

// ... more instruction methods

func cgStat(fi *funcInfo, node Stat) {
	switch stat := node.(type) {
	case *FuncCallStat:
		cgFuncCallStat(fi, stat)
	case *BreakStat:
		cgBreakStat(fi, stat)
	case *DoStat:
		cgDoStat(fi, stat)
	case *WhileStat:
		cgWhileStat(fi, stat)
	case *RepeatStat:
		cgRepeatStat(fi, stat)
	case *IfStat:
		cgIfStat(fi, stat)
	case *ForNumStat:
		cgForNumStat(fi, stat)
	case *ForInStat:
		cgForInStat(fi, stat)
	case *AssignStat:
		cgAssignStat(fi, stat)
	case *LocalVarDeclStat:
		cgLocalVarDeclStat(fi, stat)
	case *LocalFuncDefStat:
		cgLocalFuncDefStat(fi, stat)
	case *LabelStat, *GotoStat:
		panic("label and goto statements are not supported!")
	}
}

func cgWhileStat(fi *funcInfo, node *WhileStat) {
	pcBeforeExp := fi.pc()
	r := fi.allocRegs()
	cgExp(fi, node.Exp, r, 1)
	fi.freeReg()
	fi.emitTest(r, 0)
	pcJmpToEnd := fi.emitJmp(0, 0)
	fi.enterScope(true)
	cgBlock(fi, node.Block)
	fi.closeOpenUpvals()
	fi.emitJmp(0, pcBeforeExp-fi.pc()-1)
	fi.exitScope()
	fi.fixSbx(pcJmpToEnd, fi.pc()-pcJmpToEnd)
}

// ...