builtin: implement exec() and eval()

Author: ncw

builtin/builtin.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/ncw/gpython/compile"
 	"github.com/ncw/gpython/py"
-	"github.com/ncw/gpython/vm"
 )
 
 const builtin_doc = `Built-in functions, exceptions, and other objects.
@@ -30,8 +29,8 @@ func init() {
 		// py.MustNewMethod("delattr", builtin_delattr, 0, delattr_doc),
 		// py.MustNewMethod("dir", builtin_dir, 0, dir_doc),
 		py.MustNewMethod("divmod", builtin_divmod, 0, divmod_doc),
-		// py.MustNewMethod("eval", builtin_eval, 0, eval_doc),
-		// py.MustNewMethod("exec", builtin_exec, 0, exec_doc),
+		py.MustNewMethod("eval", py.InternalMethodEval, 0, eval_doc),
+		py.MustNewMethod("exec", py.InternalMethodExec, 0, exec_doc),
 		// py.MustNewMethod("format", builtin_format, 0, format_doc),
 		py.MustNewMethod("getattr", builtin_getattr, 0, getattr_doc),
 		py.MustNewMethod("globals", py.InternalMethodGlobals, 0, globals_doc),
@@ -323,7 +322,7 @@ func builtin___build_class__(self py.Object, args py.Tuple, kwargs py.StringDict
 	}
 	// fmt.Printf("Calling %v with %v and %v\n", fn.Name, fn.Globals, ns)
 	// fmt.Printf("Code = %#v\n", fn.Code)
-	cell, err = vm.Run(fn.Globals, ns, fn.Code, fn.Closure)
+	cell, err = py.VmRun(fn.Globals, ns, fn.Code, fn.Closure)
 	if err != nil {
 		return nil, err
 	}
@@ -599,6 +598,26 @@ func builtin_divmod(self py.Object, args py.Tuple) (py.Object, error) {
 	return py.Tuple{q, r}, nil
 }
 
+const eval_doc = `"eval(source[, globals[, locals]]) -> value
+
+Evaluate the source in the context of globals and locals.
+The source may be a string representing a Python expression
+or a code object as returned by compile().
+The globals must be a dictionary and locals can be any mapping,
+defaulting to the current globals and locals.
+If only globals is given, locals defaults to it.`
+
+// For code see vm/builtin.go
+
+const exec_doc = `exec(object[, globals[, locals]])
+
+Read and execute code from an object, which can be a string or a code
+object.
+The globals and locals are dictionaries, defaulting to the current
+globals and locals.  If only globals is given, locals defaults to it.`
+
+// For code see vm/builtin.go
+
 const len_doc = `len(object) -> integer
 
 Return the number of items of a sequence or mapping.`

builtin/tests/builtin.py

@@ -16,6 +16,16 @@
 doc="divmod"
 assert divmod(34,7) == (4, 6)
 
+doc="eval"
+# smoke test only - see vm/tests/builtin.py for more tests
+assert eval("1+2") == 3
+
+doc="exec"
+# smoke test only - see vm/tests/builtin.py for more tests
+glob = {"a":100}
+assert exec("b = a+100", glob) == None
+assert glob["b"] == 200
+
 doc="getattr"
 class C:
     def __init__(self):

notes.txt

@@ -37,6 +37,8 @@ Limitations & Missing parts
   * repr/str
   * subclassing built in types - how? Need to make sure we have called the appropriate method everywhere rather than just .(String)
   * FIXME how do mapping types work?
+    * PyMapping_Check
+    * is it just an interface?
 
 Type ideas
 ==========

py/code.go

@@ -214,6 +214,11 @@ func NewCode(argcount int32, kwonlyargcount int32,
 	}
 }
 
+// Return number of free variables
+func (co *Code) GetNumFree() int {
+	return len(co.Freevars)
+}
+
 // Use co_lnotab to compute the line number from a bytecode index,
 // addrq.  See lnotab_notes.txt for the details of the lnotab
 // representation.

py/dict.go

@@ -52,6 +52,12 @@ func DictCheckExact(obj Object) (StringDict, error) {
 	return dict, nil
 }
 
+// Checks that obj is exactly a dictionary and returns an error if not
+func DictCheck(obj Object) (StringDict, error) {
+	// FIXME should be checking subclasses
+	return DictCheckExact(obj)
+}
+
 // Copy a dictionary
 func (d StringDict) Copy() StringDict {
 	e := make(StringDict, len(d))

py/method.go

@@ -72,6 +72,8 @@ const (
 	InternalMethodGlobals
 	InternalMethodLocals
 	InternalMethodImport
+	InternalMethodEval
+	InternalMethodExec
 )
 
 var MethodType = NewType("method", "method object")

vm/builtin.go

@@ -0,0 +1,81 @@
+// Implement builtin functions eval and exec
+
+package vm
+
+import (
+	"strings"
+
+	"github.com/ncw/gpython/py"
+)
+
+func builtinEvalOrExec(self py.Object, args py.Tuple, kwargs, currentLocals, currentGlobals, builtins py.StringDict, mode string) (py.Object, error) {
+	var (
+		cmd     py.Object
+		globals py.Object = py.None
+		locals  py.Object = py.None
+	)
+	err := py.UnpackTuple(args, kwargs, mode, 1, 3, &cmd, &globals, &locals)
+	if err != nil {
+		return nil, err
+	}
+	if globals == py.None {
+		globals = currentGlobals
+		if locals == py.None {
+			locals = currentLocals
+		}
+	} else if locals == py.None {
+		locals = globals
+	}
+	// FIXME this can be a mapping too
+	globalsDict, err := py.DictCheck(globals)
+	if err != nil {
+		return nil, py.ExceptionNewf(py.TypeError, "globals must be a dict")
+	}
+	localsDict, err := py.DictCheck(locals)
+	if err != nil {
+		return nil, py.ExceptionNewf(py.TypeError, "locals must be a dict")
+	}
+
+	// Set __builtins__ if not set
+	if _, ok := globalsDict["__builtins__"]; !ok {
+		globalsDict["__builtins__"] = builtins
+	}
+
+	var codeStr string
+	var code *py.Code
+	switch x := cmd.(type) {
+	case *py.Code:
+		code = x
+	case py.String:
+		codeStr = string(x)
+	case py.Bytes:
+		codeStr = string(x)
+	default:
+		return nil, py.ExceptionNewf(py.TypeError, "%s() arg 1 must be a string, bytes or code object", mode)
+
+	}
+	if code == nil {
+		codeStr = strings.TrimLeft(codeStr, " \t")
+		obj, err := py.Compile(codeStr, "<string>", mode, 0, true)
+		if err != nil {
+			return nil, err
+		}
+		code = obj.(*py.Code)
+	}
+	if code.GetNumFree() > 0 {
+		return nil, py.ExceptionNewf(py.TypeError, "code passed to %s() may not contain free variables", mode)
+	}
+	return EvalCode(code, globalsDict, localsDict)
+}
+
+func builtinEval(self py.Object, args py.Tuple, kwargs, currentLocals, currentGlobals, builtins py.StringDict) (py.Object, error) {
+	return builtinEvalOrExec(self, args, kwargs, currentLocals, currentGlobals, builtins, "eval")
+}
+
+func builtinExec(self py.Object, args py.Tuple, kwargs, currentLocals, currentGlobals, builtins py.StringDict) (py.Object, error) {
+	_, err := builtinEvalOrExec(self, args, kwargs, currentLocals, currentGlobals, builtins, "exec")
+	if err != nil {
+		return nil, err
+	}
+	return py.None, nil
+}

vm/eval.go

@@ -1582,6 +1582,12 @@ func callInternal(fn py.Object, args py.Tuple, kwargs py.StringDict, f *py.Frame
 			return f.Locals, nil
 		case py.InternalMethodImport:
 			return py.BuiltinImport(nil, args, kwargs, f.Globals)
+		case py.InternalMethodEval:
+			f.FastToLocals()
+			return builtinEval(nil, args, kwargs, f.Locals, f.Globals, f.Builtins)
+		case py.InternalMethodExec:
+			f.FastToLocals()
+			return builtinExec(nil, args, kwargs, f.Locals, f.Globals, f.Builtins)
 		default:
 			return nil, py.ExceptionNewf(py.SystemError, "Internal method %v not found", x)
 		}

vm/tests/builtin.py

@@ -0,0 +1,64 @@
+doc="eval"
+assert eval("1+2") == 3
+glob ={'a':1}
+assert eval("a+2", glob) == 3
+loc ={'b':2}
+assert eval("a+b", glob, loc) == 3
+co = compile("a+b+1", "s", "eval")
+assert eval(co, glob, loc) == 4
+assert eval(b"2+3") == 5
+
+try:
+    eval(())
+except TypeError as e:
+    pass
+else:
+    assert False, "SyntaxError not raised"
+    
+try:
+    eval("a = 26")
+except SyntaxError as e:
+    pass
+else:
+    assert False, "SyntaxError not raised"
+    
+try:
+    eval(1,2,3,4)
+except TypeError as e:
+    pass
+else:
+    assert False, "TypeError not raised"
+    
+try:
+    eval("1", ())
+except TypeError as e:
+    pass
+else:
+    assert False, "TypeError not raised"
+
+try:
+    eval("1", {}, ())
+except TypeError as e:
+    pass
+else:
+    assert False, "TypeError not raised"
+    
+doc="exec"
+glob = {"a":100}
+assert exec("b = a+100", glob) == None
+assert glob["b"] == 200
+loc = {"c":23}
+assert exec("d = a+b+c", glob, loc) == None
+assert loc["d"] == 323
+co = compile("d = a+b+c+1", "s", "exec")
+assert eval(co, glob, loc) == None
+assert loc["d"] == 324
+
+try:
+    exec("if")
+except SyntaxError as e:
+    pass
+else:
+    assert False, "SyntaxError not raised"
+
+doc="finished"