vm: functions & DELETE_NAME, DELETE_GLOBAL, LOAD_NAME, LOAD_GLOBAL, STORE_DEREF, DELETE_DEREF

Author: ncw

py/cell.go

@@ -34,3 +34,8 @@ func (c *Cell) Get() Object {
 func (c *Cell) Set(obj Object) {
 	c.obj = &obj
 }
+
+// Delete the contents of the Cell
+func (c *Cell) Delete() {
+	c.obj = nil
+}

py/frame.go

@@ -87,20 +87,11 @@ func NewFrame(globals, locals StringDict, code *Code, closure Tuple) *Frame {
 	}
 }
 
-// Python names are looked up in three scopes
+// Python globals  are looked up in two scopes
 //
-// First the local scope
-// Next the module global scope
+// The module global scope
 // And finally the builtins
-func (f *Frame) Lookup(name string) (obj Object) {
-	var ok bool
-
-	// Lookup in locals
-	// fmt.Printf("locals = %v\n", f.Locals)
-	if obj, ok = f.Locals[name]; ok {
-		return
-	}
-
+func (f *Frame) LookupGlobal(name string) (obj Object, ok bool) {
 	// Lookup in globals
 	// fmt.Printf("globals = %v\n", f.Globals)
 	if obj, ok = f.Globals[name]; ok {
@@ -113,7 +104,22 @@ func (f *Frame) Lookup(name string) (obj Object) {
 		return
 	}
 
-	panic(ExceptionNewf(NameError, "name '%s' is not defined", name))
+	return nil, false
+}
+
+// Python names are looked up in three scopes
+//
+// First the local scope
+// Next the module global scope
+// And finally the builtins
+func (f *Frame) Lookup(name string) (obj Object, ok bool) {
+	// Lookup in locals
+	// fmt.Printf("locals = %v\n", f.Locals)
+	if obj, ok = f.Locals[name]; ok {
+		return
+	}
+
+	return f.LookupGlobal(name)
 }
 
 // Make a new Block (try/for/while)

vm/eval.go

@@ -4,6 +4,8 @@ package vm
 // FIXME use LocalVars instead of storing everything in the Locals dict
 // see frameobject.c dict_to_map and LocalsToFast
 
+// FIXME *_FAST aren't using the fast path
+
 /* FIXME
 
 cpython has one stack per frame, not one stack in total
@@ -32,7 +34,6 @@ objects so they can be GCed
 */
 
 import (
-	// "fmt"
 	"runtime/debug"
 
 	"github.com/ncw/gpython/py"
@@ -749,7 +750,12 @@ func do_STORE_NAME(vm *Vm, namei int32) {
 // attribute of the code object.
 func do_DELETE_NAME(vm *Vm, namei int32) {
 	defer vm.CheckException()
-	vm.NotImplemented("DELETE_NAME", namei)
+	name := vm.frame.Code.Names[namei]
+	if _, ok := vm.frame.Locals[name]; !ok {
+		vm.SetException(py.ExceptionNewf(py.NameError, nameErrorMsg, name))
+	} else {
+		delete(vm.frame.Locals, name)
+	}
 }
 
 // Unpacks TOS into count individual values, which are put onto the
@@ -798,7 +804,12 @@ func do_STORE_GLOBAL(vm *Vm, namei int32) {
 // Works as DELETE_NAME, but deletes a global name.
 func do_DELETE_GLOBAL(vm *Vm, namei int32) {
 	defer vm.CheckException()
-	vm.NotImplemented("DELETE_GLOBAL", namei)
+	name := vm.frame.Code.Names[namei]
+	if _, ok := vm.frame.Globals[name]; !ok {
+		vm.SetException(py.ExceptionNewf(py.NameError, nameErrorMsg, name))
+	} else {
+		delete(vm.frame.Globals, name)
+	}
 }
 
 // Pushes co_consts[consti] onto the stack.
@@ -811,8 +822,14 @@ func do_LOAD_CONST(vm *Vm, consti int32) {
 // Pushes the value associated with co_names[namei] onto the stack.
 func do_LOAD_NAME(vm *Vm, namei int32) {
 	defer vm.CheckException()
-	debugf("LOAD_NAME %v\n", vm.frame.Code.Names[namei])
-	vm.PUSH(vm.frame.Lookup(vm.frame.Code.Names[namei]))
+	name := vm.frame.Code.Names[namei]
+	debugf("LOAD_NAME %v\n", name)
+	obj, ok := vm.frame.Lookup(name)
+	if !ok {
+		vm.SetException(py.ExceptionNewf(py.NameError, nameErrorMsg, name))
+	} else {
+		vm.PUSH(obj)
+	}
 }
 
 // Creates a tuple consuming count items from the stack, and pushes
@@ -1023,9 +1040,14 @@ func do_FOR_ITER(vm *Vm, delta int32) {
 // Loads the global named co_names[namei] onto the stack.
 func do_LOAD_GLOBAL(vm *Vm, namei int32) {
 	defer vm.CheckException()
-	// FIXME this is looking in local scope too - is that correct?
-	debugf("LOAD_GLOBAL %v\n", vm.frame.Code.Names[namei])
-	vm.PUSH(vm.frame.Lookup(vm.frame.Code.Names[namei]))
+	name := vm.frame.Code.Names[namei]
+	debugf("LOAD_GLOBAL %v\n", name)
+	obj, ok := vm.frame.LookupGlobal(name)
+	if !ok {
+		vm.SetException(py.ExceptionNewf(py.NameError, nameErrorMsg, name))
+	} else {
+		vm.PUSH(obj)
+	}
 }
 
 // Pushes a block for a loop onto the block stack. The block spans
@@ -1069,7 +1091,9 @@ func do_LOAD_FAST(vm *Vm, var_num int32) {
 	if value, ok := vm.frame.Locals[varname]; ok {
 		vm.PUSH(value)
 	} else {
-		vm.SetException(py.ExceptionNewf(py.UnboundLocalError, unboundLocalErrorMsg, varname))
+		vm.SetException(py.ExceptionNewf(py.NameError, nameErrorMsg, varname))
+		// FIXME ceval.c says this, but it python3.4 returns the above
+		// vm.SetException(py.ExceptionNewf(py.UnboundLocalError, unboundLocalErrorMsg, varname))
 	}
 }
 
@@ -1086,7 +1110,8 @@ func do_DELETE_FAST(vm *Vm, var_num int32) {
 	if _, ok := vm.frame.Locals[varname]; ok {
 		delete(vm.frame.Locals, varname)
 	} else {
-		vm.SetException(py.ExceptionNewf(py.UnboundLocalError, unboundLocalErrorMsg, varname))
+		vm.SetException(py.ExceptionNewf(py.NameError, nameErrorMsg, varname))
+		// FIXME ceval.c says this vm.SetException(py.ExceptionNewf(py.UnboundLocalError, unboundLocalErrorMsg, varname))
 	}
 }
 
@@ -1111,19 +1136,24 @@ func do_LOAD_CLOSURE(vm *Vm, i int32) {
 	vm.PUSH(vm.frame.CellAndFreeVars[i])
 }
 
+// writes the correct errors for an unbound deref
+func unboundDeref(vm *Vm, i int32) {
+	varname, free := _var_name(vm, i)
+	if free {
+		vm.SetException(py.ExceptionNewf(py.NameError, unboundFreeErrorMsg, varname))
+	} else {
+		vm.SetException(py.ExceptionNewf(py.UnboundLocalError, unboundLocalErrorMsg, 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()
 	res := vm.frame.CellAndFreeVars[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))
-		}
+		unboundDeref(vm, i)
 	}
 	vm.PUSH(res)
 }
@@ -1140,14 +1170,19 @@ func do_LOAD_CLASSDEREF(vm *Vm, i int32) {
 // variable storage.
 func do_STORE_DEREF(vm *Vm, i int32) {
 	defer vm.CheckException()
-	vm.NotImplemented("STORE_DEREF", i)
+	cell := vm.frame.CellAndFreeVars[i].(*py.Cell)
+	cell.Set(vm.POP())
 }
 
 // Empties the cell contained in slot i of the cell and free variable
 // storage. Used by the del statement.
 func do_DELETE_DEREF(vm *Vm, i int32) {
 	defer vm.CheckException()
-	vm.NotImplemented("DELETE_DEREF", i)
+	cell := vm.frame.CellAndFreeVars[i].(*py.Cell)
+	if cell.Get() == nil {
+		unboundDeref(vm, i)
+	}
+	cell.Delete()
 }
 
 // Logic for the raise statement

vm/tests/README.md

@@ -0,0 +1,8 @@
+Tests for VM
+============
+
+These simple programs are designed to exercise the VM.
+
+They should run with no errors raised.
+
+They should also all run clean with python3.4

vm/tests/functions.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3.4
+
+# Test functions
+def fn():
+    return 1
+assert fn() == 1
+
+def fn1(x):
+    return x+1
+assert fn1(1) == 2
+
+def fn2(x,y=1):
+    return x+y
+assert fn2(1) == 2
+assert fn2(1,3) == 4
+# FIXME not implemented assert fn2(1,y=4) == 5
+
+# FIXME check *arg and **kwarg
+
+
+# Closure
+
+# FIXME something wrong with closures over function arguments...
+# def counter3(x):
+#     def inc():
+#         nonlocal x
+#         x += 1
+#         return x
+#     return inc
+# fn3 = counter3(1)
+# assert fn3() == 2
+# assert fn3() == 3
+
+def counter4(initial):
+    x = initial
+    def inc():
+        nonlocal x
+        x += 1
+        return x
+    return inc
+fn4 = counter4(1)
+assert fn4() == 2
+assert fn4() == 3
+
+def counter5(initial):
+    L = [initial]
+    def inc():
+        L[0] += 1
+        return L[0]
+    return inc
+fn5 = counter5(1)
+assert fn5() == 2
+assert fn5() == 3
+
+
+def del_deref6(initial):
+    x = initial
+    def inc():
+        nonlocal x
+        a = x
+        del x
+        return a+1
+    return inc
+fn6 = del_deref6(1)
+assert fn6() == 2
+try:
+    fn6()
+except NameError as e:
+    # FIXME assert str(e) == "free variable 'x' referenced before assignment in enclosing scope"
+    pass
+else:
+    assert False, "NameError not raised"
+
+# check you can't delete it twice!
+
+def fn7(b):
+ c = 1
+ def nested(d):
+   nonlocal c
+   del c
+   del c
+ return nested
+
+try:
+    fn7(1)(2)
+except NameError as e:
+    # FIXME assert str(e) == "free variable 'c' referenced before assignment in enclosing scope"
+    pass
+else:
+    assert False, "NameError not raised"
+
+# globals
+
+a = 1
+def fn8():
+    global a
+    assert a == 1
+    a = 2
+    assert a == 2
+fn8()
+assert a == 2
+def fn9():
+    global a
+    del a
+fn9()
+try:
+    a
+except NameError as e:
+    # FIXME assert str(e) == "name 'a' is not defined"
+    pass
+else:
+    assert False, "NameError not raised"
+try:
+    fn9()
+except NameError as e:
+    # FIXME assert str(e) == "name 'a' is not defined"
+    pass
+else:
+    assert False, "NameError not raised"
+
+# delete
+def fn10():
+    a = 1
+    assert a == 1
+    del a
+    try:
+        a
+    except NameError as e:
+        # FIXME assert str(e) == "name 'a' is not defined"
+        pass
+    else:
+        assert False, "NameError not raised"
+    try:
+        del a
+    except NameError as e:
+        # FIXME assert str(e) == "name 'a' is not defined"
+        pass
+    else:
+        assert False, "NameError not raised"
+fn10()
+
+# annotations
+def fn11(a:"A") -> "RET":
+    return a+1
+assert fn11(1) == 2
+# FIXME check annotations are in place
+
+#kwargs
+def fn12(*args,a=2,b=3,**kwargs) -> "RET":
+    return args
+# FIXME this blows up: assert fn12() == ()
+# FIXME check kwargs passing