Implement closures and LOAD_CLOSURE, LOAD_DEREF, MAKE_CLOSURE opcodes

ncw · ncw · commit 08eff15a1e2a · 2013-12-02T21:18:20.000Z
diff --git a/builtin/builtin.go b/builtin/builtin.go
@@ -278,7 +278,7 @@ func builtin___build_class__(self py.Object, args py.Tuple, kwargs py.StringDict
 	// fmt.Printf("Calling %v with %p and %p\n", fn.Name, fn.Globals, ns)
 	// fmt.Printf("Code = %#v\n", fn.Code)
 	locals := fn.LocalsForCall(py.Tuple{ns})
-	cell, err := vm.Run(fn.Globals, locals, fn.Code) // FIXME PyFunction_GET_CLOSURE(fn))
+	cell, err := vm.Run(fn.Globals, locals, fn.Code, fn.Closure)
 
 	// fmt.Printf("result = %#v err = %s\n", cell, err)
 	// fmt.Printf("locals = %#v\n", locals)
diff --git a/main.go b/main.go
@@ -62,7 +62,7 @@ func main() {
 	}
 	code := obj.(*py.Code)
 	module := py.NewModule("__main__", "", nil, nil)
-	res, err := vm.Run(module.Globals, module.Globals, code)
+	res, err := vm.Run(module.Globals, module.Globals, code, nil)
 	if err != nil {
 		log.Fatal(err)
 	}
diff --git a/py/frame.go b/py/frame.go
@@ -17,12 +17,13 @@ type Frame struct {
 	Globals  StringDict // global symbol table
 	Locals   StringDict // local symbol table
 	Stack    []Object   // Valuestack
+	Closure  Tuple      // Tuple of Cells that this function is closed over
 	// Next free slot in f_valuestack.  Frame creation sets to f_valuestack.
 	// Frame evaluation usually NULLs it, but a frame that yields sets it
 	// to the current stack top.
 	// Stacktop *Object
-	Yielded bool   // set if the function yielded, cleared otherwise
-	Trace   Object // Trace function
+	Yielded bool // set if the function yielded, cleared otherwise
+	// Trace   Object // Trace function
 
 	// In a generator, we need to be able to swap between the exception
 	// state inside the generator and the exception state of the calling
@@ -31,11 +32,11 @@ type Frame struct {
 	// These three fields exist exactly for that, and are unused for
 	// non-generator frames. See the save_exc_state and swap_exc_state
 	// functions in ceval.c for details of their use.
-	Exc_type      Object
-	Exc_value     *Object
-	Exc_traceback *Object
+	// Exc_type      Object
+	// Exc_value     *Object
+	// Exc_traceback *Object
 	// Borrowed reference to a generator, or NULL
-	Gen Object
+	// Gen Object
 
 	// FIXME Tstate *PyThreadState
 	Lasti int32 // Last instruction if called
@@ -44,12 +45,12 @@ type Frame struct {
 	// active (i.e. when f_trace is set).  At other times we use
 	// PyCode_Addr2Line to calculate the line from the current
 	// bytecode index.
-	Lineno     int        // Current line number
-	Iblock     int        // index in f_blockstack
-	Executing  byte       // whether the frame is still executing
+	// Lineno     int        // Current line number
+	// Iblock     int        // index in f_blockstack
+	// Executing  byte       // whether the frame is still executing
 	Blockstack []TryBlock // for try and loop blocks
 	Block      *TryBlock  // pointer to current block or nil
-	Localsplus []Object   // locals+stack, dynamically sized
+	// Localsplus []Object   // locals+stack, dynamically sized
 }
 
 var FrameType = NewType("frame", "Represents a stack frame")
@@ -60,11 +61,12 @@ func (o *Frame) Type() *Type {
 }
 
 // Make a new frame for a code object
-func NewFrame(globals, locals StringDict, code *Code) *Frame {
+func NewFrame(globals, locals StringDict, code *Code, closure Tuple) *Frame {
 	return &Frame{
 		Globals:  globals,
 		Locals:   locals,
 		Code:     code,
+		Closure:  closure,
 		Builtins: Builtins.Globals,
 		Stack:    make([]Object, 0, code.Stacksize),
 	}
diff --git a/py/function.go b/py/function.go
@@ -123,7 +123,7 @@ func (f *Function) M__call__(args Tuple, kwargs StringDict) Object {
 	} else {
 		locals = f.LocalsForCall(args)
 	}
-	result, err := Run(f.Globals, locals, f.Code)
+	result, err := Run(f.Globals, locals, f.Code, f.Closure)
 	if err != nil {
 		// Propagate the error
 		panic(err)
diff --git a/py/py.go b/py/py.go
@@ -10,7 +10,7 @@ type Object interface {
 var (
 	Ellipsis Object
 	// See vm/eval.go - set to avoid circular import
-	Run      func(globals, locals StringDict, code *Code) (res Object, err error)
+	Run      func(globals, locals StringDict, code *Code, closure Tuple) (res Object, err error)
 	RunFrame func(frame *Frame) (res Object, err error)
 )
 
diff --git a/vm/eval.go b/vm/eval.go
@@ -1005,21 +1005,45 @@ func do_DELETE_FAST(vm *Vm, var_num int32) {
 	}
 }
 
+// Name of slot for LOAD_CLOSURE / LOAD_DEREF / etc
+//
+// Returns name of variable and bool, true for free var, false for
+// cell var
+func _var_name(vm *Vm, i int32) (string, bool) {
+	cellvars := vm.frame.Code.Cellvars
+	if int(i) < len(cellvars) {
+		return cellvars[i], false
+	}
+	return vm.frame.Code.Freevars[int(i)-len(cellvars)], true
+}
+
 // Pushes a reference to the cell contained in slot i of the cell and
 // free variable storage. The name of the variable is co_cellvars[i]
 // if i is less than the length of co_cellvars. Otherwise it is
 // co_freevars[i - len(co_cellvars)].
 func do_LOAD_CLOSURE(vm *Vm, i int32) {
 	defer vm.CheckException()
-	vm.NotImplemented("LOAD_CLOSURE", i)
+	varname, _ := _var_name(vm, i)
+	// FIXME this is making a new cell each time rather than
+	// returning a reference to an old one
+	vm.PUSH(py.NewCell(vm.frame.Locals[varname]))
 }
 
 // Loads the cell contained in slot i of the cell and free variable
 // storage. Pushes a reference to the object the cell contains on the
 // stack.
 func do_LOAD_DEREF(vm *Vm, i int32) {
 	defer vm.CheckException()
-	vm.NotImplemented("LOAD_DEREF", i)
+	res := vm.frame.Closure[i].(*py.Cell).Get()
+	if res == nil {
+		varname, free := _var_name(vm, i)
+		if free {
+			vm.SetException(py.ExceptionNewf(py.UnboundLocalError, unboundFreeErrorMsg, varname))
+		} else {
+			vm.SetException(py.ExceptionNewf(py.UnboundLocalError, unboundLocalErrorMsg, varname))
+		}
+	}
+	vm.PUSH(res)
 }
 
 // Much like LOAD_DEREF but first checks the locals dictionary before
@@ -1111,24 +1135,18 @@ func do_CALL_FUNCTION(vm *Vm, argc int32) {
 	vm.Call(fn, args, kwargs)
 }
 
-// Pushes a new function object on the stack. TOS is the code
-// associated with the function. The function object is defined to
-// have argc default parameters, which are found below TOS.
-//
-// FIXME these docs are slightly wrong.
-func do_MAKE_FUNCTION(vm *Vm, argc int32) {
-	defer vm.CheckException()
+// Implementation for MAKE_FUNCTION and MAKE_CLOSURE
+func _make_function(vm *Vm, argc int32, opcode byte) {
 	posdefaults := argc & 0xff
 	kwdefaults := (argc >> 8) & 0xff
 	num_annotations := (argc >> 16) & 0x7fff
 	qualname := vm.POP()
 	code := vm.POP()
 	function := py.NewFunction(code.(*py.Code), vm.frame.Globals, string(qualname.(py.String)))
 
-	// FIXME share code with MAKE_CLOSURE
-	// if opcode == MAKE_CLOSURE {
-	// 	function.Closure = vm.POP();
-	// }
+	if opcode == MAKE_CLOSURE {
+		function.Closure = vm.POP().(py.Tuple)
+	}
 
 	if num_annotations > 0 {
 		names := vm.POP().(py.Tuple) // names of args with annotations
@@ -1167,15 +1185,24 @@ func do_MAKE_FUNCTION(vm *Vm, argc int32) {
 	vm.PUSH(function)
 }
 
+// Pushes a new function object on the stack. TOS is the code
+// associated with the function. The function object is defined to
+// have argc default parameters, which are found below TOS.
+//
+// FIXME these docs are slightly wrong.
+func do_MAKE_FUNCTION(vm *Vm, argc int32) {
+	defer vm.CheckException()
+	_make_function(vm, argc, MAKE_FUNCTION)
+}
+
 // Creates a new function object, sets its func_closure slot, and
 // pushes it on the stack. TOS is the code associated with the
 // function, TOS1 the tuple containing cells for the closure’s free
 // variables. The function also has argc default parameters, which are
 // found below the cells.
 func do_MAKE_CLOSURE(vm *Vm, argc int32) {
 	defer vm.CheckException()
-	vm.NotImplemented("MAKE_CLOSURE", argc)
-	// see MAKE_FUNCTION
+	_make_function(vm, argc, MAKE_CLOSURE)
 }
 
 // Pushes a slice object on the stack. argc must be 2 or 3. If it is
@@ -1278,6 +1305,8 @@ func (vm *Vm) UnwindExceptHandler(frame *py.Frame, block *py.TryBlock) {
 // FIXME figure out how we are going to signal exceptions!
 //
 // Returns an Object and an error.  The error will be a py.ExceptionInfo
+//
+// This is the equivalent of PyEval_EvalFrame
 func RunFrame(frame *py.Frame) (res py.Object, err error) {
 	vm := NewVm(frame)
 	// defer func() {
@@ -1412,8 +1441,10 @@ func RunFrame(frame *py.Frame) (res py.Object, err error) {
 // Any parameters are expected to have been decoded into locals
 //
 // Returns an Object and an error.  The error will be a py.ExceptionInfo
-func Run(globals, locals py.StringDict, code *py.Code) (res py.Object, err error) {
-	frame := py.NewFrame(globals, locals, code)
+//
+// This is the equivalent of PyEval_EvalCode with closure support
+func Run(globals, locals py.StringDict, code *py.Code, closure py.Tuple) (res py.Object, err error) {
+	frame := py.NewFrame(globals, locals, code, closure)
 
 	// If this is a generator then make a generator object from
 	// the frame and return that instead

Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ func main() {`
`62`	`62`	`}`
`63`	`63`	`code := obj.(*py.Code)`
`64`	`64`	`module := py.NewModule("__main__", "", nil, nil)`
`65`		`- res, err := vm.Run(module.Globals, module.Globals, code)`
	`65`	`+ res, err := vm.Run(module.Globals, module.Globals, code, nil)`
`66`	`66`	`if err != nil {`
`67`	`67`	`log.Fatal(err)`
`68`	`68`	`}`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ func (f *Function) M__call__(args Tuple, kwargs StringDict) Object {`
`123`	`123`	`} else {`
`124`	`124`	`locals = f.LocalsForCall(args)`
`125`	`125`	`}`
`126`		`- result, err := Run(f.Globals, locals, f.Code)`
	`126`	`+ result, err := Run(f.Globals, locals, f.Code, f.Closure)`
`127`	`127`	`if err != nil {`
`128`	`128`	`// Propagate the error`
`129`	`129`	`panic(err)`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ type Object interface {`
`10`	`10`	`var (`
`11`	`11`	`Ellipsis Object`
`12`	`12`	`// See vm/eval.go - set to avoid circular import`
`13`		`- Run func(globals, locals StringDict, code *Code) (res Object, err error)`
	`13`	`+ Run func(globals, locals StringDict, code *Code, closure Tuple) (res Object, err error)`
`14`	`14`	`RunFrame func(frame *Frame) (res Object, err error)`
`15`	`15`	`)`
`16`	`16`