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(objObject){
 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(namestring) (objObject){
-varokbool
-
-// Lookup in locals
-// fmt.Printf("locals = %v\n", f.Locals)
-ifobj, ok=f.Locals[name]; ok{
-return
- }
-
+func (f*Frame) LookupGlobal(namestring) (objObject, okbool){
 // Lookup in globals
 // fmt.Printf("globals = %v\n", f.Globals)
 ifobj, 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))
+returnnil, 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(namestring) (objObject, okbool){
+// Lookup in locals
+// fmt.Printf("locals = %v\n", f.Locals)
+ifobj, ok=f.Locals[name]; ok{
+return
+ }
+
+returnf.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.
 funcdo_DELETE_NAME(vm*Vm, nameiint32){
 defervm.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.
 funcdo_DELETE_GLOBAL(vm*Vm, nameiint32){
 defervm.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.
 funcdo_LOAD_NAME(vm*Vm, nameiint32){
 defervm.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.
 funcdo_LOAD_GLOBAL(vm*Vm, nameiint32){
 defervm.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){
 ifvalue, 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
+funcunboundDeref(vm*Vm, iint32){
+varname, free:=_var_name(vm, i)
+iffree{
+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.
 funcdo_LOAD_DEREF(vm*Vm, iint32){
 defervm.CheckException()
 res:=vm.frame.CellAndFreeVars[i].(*py.Cell).Get()
 ifres==nil{
-varname, free:=_var_name(vm, i)
-iffree{
-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.
 funcdo_STORE_DEREF(vm*Vm, iint32){
 defervm.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.
 funcdo_DELETE_DEREF(vm*Vm, iint32){
 defervm.CheckException()
-vm.NotImplemented("DELETE_DEREF", i)
+cell:=vm.frame.CellAndFreeVars[i].(*py.Cell)
+ifcell.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
+deffn():
+return1
+assertfn() ==1
+
+deffn1(x):
+returnx+1
+assertfn1(1) ==2
+
+deffn2(x,y=1):
+returnx+y
+assertfn2(1) ==2
+assertfn2(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
+
+defcounter4(initial):
+x=initial
+definc():
+nonlocalx
+x+=1
+returnx
+returninc
+fn4=counter4(1)
+assertfn4() ==2
+assertfn4() ==3
+
+defcounter5(initial):
+L= [initial]
+definc():
+L[0] +=1
+returnL[0]
+returninc
+fn5=counter5(1)
+assertfn5() ==2
+assertfn5() ==3
+
+
+defdel_deref6(initial):
+x=initial
+definc():
+nonlocalx
+a=x
+delx
+returna+1
+returninc
+fn6=del_deref6(1)
+assertfn6() ==2
+try:
+fn6()
+exceptNameErrorase:
+# FIXME assert str(e) == "free variable 'x' referenced before assignment in enclosing scope"
+pass
+else:
+assertFalse, "NameError not raised"
+
+# check you can't delete it twice!
+
+deffn7(b):
+c=1
+defnested(d):
+nonlocalc
+delc
+delc
+returnnested
+
+try:
+fn7(1)(2)
+exceptNameErrorase:
+# FIXME assert str(e) == "free variable 'c' referenced before assignment in enclosing scope"
+pass
+else:
+assertFalse, "NameError not raised"
+
+# globals
+
+a=1
+deffn8():
+globala
+asserta==1
+a=2
+asserta==2
+fn8()
+asserta==2
+deffn9():
+globala
+dela
+fn9()
+try:
+a
+exceptNameErrorase:
+# FIXME assert str(e) == "name 'a' is not defined"
+pass
+else:
+assertFalse, "NameError not raised"
+try:
+fn9()
+exceptNameErrorase:
+# FIXME assert str(e) == "name 'a' is not defined"
+pass
+else:
+assertFalse, "NameError not raised"
+
+# delete
+deffn10():
+a=1
+asserta==1
+dela
+try:
+a
+exceptNameErrorase:
+# FIXME assert str(e) == "name 'a' is not defined"
+pass
+else:
+assertFalse, "NameError not raised"
+try:
+dela
+exceptNameErrorase:
+# FIXME assert str(e) == "name 'a' is not defined"
+pass
+else:
+assertFalse, "NameError not raised"
+fn10()
+
+# annotations
+deffn11(a:"A") ->"RET":
+returna+1
+assertfn11(1) ==2
+# FIXME check annotations are in place
+
+#kwargs
+deffn12(*args,a=2,b=3,**kwargs) ->"RET":
+returnargs
+# FIXME this blows up: assert fn12() == ()
+# FIXME check kwargs passing