fixup! add a scope class to manage the context of interaction with Python and simplify the variable exchanging

yagweb · yagweb · commit 69598cfc89ed · 2017-02-19T10:45:39.000+08:00
diff --git a/src/embed_tests/pyscope.cs b/src/embed_tests/pyscope.cs
@@ -17,7 +17,7 @@ public PyScopeTest()
         [SetUp]
         public void SetUp()
         {
-            ps = session.Scope();
+            ps = session.SubScope();
         }
 
         [TearDown]
@@ -48,23 +48,25 @@ public void TestExec()
         }
 
         [Test]
-        public void TestExecIn()
+        public void TestSubScope()
         {
             ps.SetGlobal("bb", 100); //declare a global variable
             ps.SetLocal("cc", 10); //declare a local variable
-            ps.ExecIn("aa=bb+cc+3");
-            PyInt result = PyInt.AsInt(ps.Get("aa") as PyObject);
-            Assert.AreEqual(result.ToInt32(), 113);
+
+            PyScope scope = ps.SubScope();
+            scope.Exec("aa=bb+cc+3");
+            int result = scope.Get<System.Int32>("aa");
+            Assert.AreEqual(result, 113); //
+            scope.Dispose();
+
+            Assert.IsFalse(ps.Exists("aa"));
         }
 
         [Test]
         public void TestImport()
         {
-            ps.SetGlobal("bb", 100); //declare a global variable
-            ps.SetLocal("cc", 10); //declare a local variable
-            ps.ExecIn("aa=bb+cc+3");
-            PyInt result = PyInt.AsInt(ps.Get("aa") as PyObject);
-            Assert.AreEqual(result.ToInt32(), 113);
+            ps.Import("sys", "sys1");
+            Assert.IsTrue(ps.Exists("sys1"));
         }
 
         [Test]
@@ -78,7 +80,7 @@ public void TestSuspend()
             {
                 PythonEngine.RunSimpleString("import sys;");
             }
-            ps.ExecIn("aa=bb+cc+3");
+            ps.Exec("aa=bb+cc+3");
             int result = ps.Get<System.Int32>("aa");
             Assert.AreEqual(result, 113);
         }
diff --git a/src/runtime/pythonengine.cs b/src/runtime/pythonengine.cs
@@ -511,16 +511,6 @@ public void Dispose()
 
         private GILState state;
 
-        /// <summary>
-        /// the dict for global variables
-        /// </summary>
-        private IntPtr globals;
-
-        /// <summary>
-        /// the dict for local variables
-        /// </summary>
-        private IntPtr locals;
-
         internal PyScope()
             : this(null, new GILState())
         {
@@ -536,18 +526,52 @@ internal PyScope(PyScope parent, GILState state)
             {
                 throw new PythonException();
             }
-            Runtime.PyDict_SetItemString(
-                globals, "__builtins__",
-                Runtime.PyEval_GetBuiltins()
-            );
             locals = Runtime.PyDict_New();
             if (locals == IntPtr.Zero)
             {
                 throw new PythonException();
             }
+            if(parent == null)
+            {
+                Runtime.PyDict_SetItemString(
+                    globals, "__builtins__",
+                    Runtime.PyEval_GetBuiltins()
+                );
+            }
+            else
+            {
+                int result = Runtime.PyDict_Update(globals, parent.globals);
+                if (result < 0)
+                {
+                    throw new PythonException();
+                }
+                result = Runtime.PyDict_Update(globals, parent.locals);
+                if (result < 0)
+                {
+                    throw new PythonException();
+                }
+            }
+        }
+
+        /// <summary>
+        /// the dict for global variables
+        /// </summary>
+        public IntPtr globals
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// the dict for local variables
+        /// </summary>
+        public IntPtr locals
+        {
+            get;
+            private set;
         }
 
-        public PyScope Scope()
+        public PyScope SubScope()
         {
             return new PyScope(this, this.state);
         }
@@ -558,18 +582,21 @@ public void Suspend()
         }
 
         /// <summary>
-        /// ImportModule Method
+        /// Import Method
         /// </summary>
         /// <remarks>
-        /// Given a fully-qualified module or package name, import the
-        /// module , add it to the global variable dict and return the resulting module object as a PyObject
-        /// or null if an exception is raised.
+        /// The import .. as .. statement in Python.
+        /// Import a module ,add it to the local variable dict and return the resulting module object as a PyObject.
         /// </remarks>
-        public PyObject Import(string name)
+        public PyObject Import(string name, string asname = null)
         {
             this.state.AcquireLock();
             PyObject module = PythonEngine.ImportModule(name);
-            SetGlobal(name, module);
+            if(asname == null)
+            {
+                asname = name;
+            }
+            SetLocal(asname, module);
             return module;
         }
 
@@ -592,28 +619,22 @@ public PyObject Eval(string code)
         }
 
         /// <summary>
-        /// ExecIn Method
+        /// Exec Method
         /// </summary>
         /// <remarks>
-        /// Evaluate a Python script and save its local variables in local variable dict.
+        /// Evaluate a Python script and save its local variables in the current local variable dict.
         /// </remarks>
-        public void ExecIn(string code)
+        public void Exec(string code)
         {
-            Exec(code, locals);
+            this.state.AcquireLock();
+            Exec(code, this.globals, this.locals);
         }
-
-        /// <summary>
-        /// ExecIn Method
-        /// </summary>
-        /// <remarks>
-        /// Evaluate a Python script and save its local variables in local variable dict.
-        /// </remarks>
-        private void Exec(string code, IntPtr _locals)
+        
+        private void Exec(string code, IntPtr _globals, IntPtr _locals)
         {
-            this.state.AcquireLock();
             var flag = (IntPtr)Runtime.Py_file_input;
             IntPtr ptr = Runtime.PyRun_String(
-                code, flag, globals, locals
+                code, flag, _globals, _locals
             );
             Py.Throw();
             if (ptr != Runtime.PyNone)
@@ -622,30 +643,7 @@ private void Exec(string code, IntPtr _locals)
             }
             Runtime.XDecref(ptr);
         }
-
-        /// <summary>
-        /// Exec Method
-        /// </summary>
-        /// <remarks>
-        /// Evaluate a Python script and discard its local variables.
-        /// </remarks>
-        public void Exec(string code)
-        {
-            this.state.AcquireLock();
-            IntPtr _locals = Runtime.PyDict_New();
-            if (_locals == IntPtr.Zero)
-            {
-                throw new PythonException();
-            }
-            int result = Runtime.PyDict_Update(_locals, locals);
-            if (result < 0)
-            {
-                throw new PythonException();
-            }
-            Exec(code, _locals);
-            Runtime.XDecref(_locals);
-        }
-
+        
         /// <summary>
         /// SetGlobal Method
         /// </summary>

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public PyScopeTest()`
`17`	`17`	`[SetUp]`
`18`	`18`	`public void SetUp()`
`19`	`19`	`{`
`20`		`- ps = session.Scope();`
	`20`	`+ ps = session.SubScope();`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`[TearDown]`
`@@ -48,23 +48,25 @@ public void TestExec()`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`[Test]`
`51`		`- public void TestExecIn()`
	`51`	`+ public void TestSubScope()`
`52`	`52`	`{`
`53`	`53`	`ps.SetGlobal("bb", 100); //declare a global variable`
`54`	`54`	`ps.SetLocal("cc", 10); //declare a local variable`
`55`		`- ps.ExecIn("aa=bb+cc+3");`
`56`		`- PyInt result = PyInt.AsInt(ps.Get("aa") as PyObject);`
`57`		`- Assert.AreEqual(result.ToInt32(), 113);`
	`55`	`+`
	`56`	`+ PyScope scope = ps.SubScope();`
	`57`	`+ scope.Exec("aa=bb+cc+3");`
	`58`	`+ int result = scope.Get<System.Int32>("aa");`
	`59`	`+ Assert.AreEqual(result, 113); //`
	`60`	`+ scope.Dispose();`
	`61`	`+`
	`62`	`+ Assert.IsFalse(ps.Exists("aa"));`
`58`	`63`	`}`
`59`	`64`
`60`	`65`	`[Test]`
`61`	`66`	`public void TestImport()`
`62`	`67`	`{`
`63`		`- ps.SetGlobal("bb", 100); //declare a global variable`
`64`		`- ps.SetLocal("cc", 10); //declare a local variable`
`65`		`- ps.ExecIn("aa=bb+cc+3");`
`66`		`- PyInt result = PyInt.AsInt(ps.Get("aa") as PyObject);`
`67`		`- Assert.AreEqual(result.ToInt32(), 113);`
	`68`	`+ ps.Import("sys", "sys1");`
	`69`	`+ Assert.IsTrue(ps.Exists("sys1"));`
`68`	`70`	`}`
`69`	`71`
`70`	`72`	`[Test]`
`@@ -78,7 +80,7 @@ public void TestSuspend()`
`78`	`80`	`{`
`79`	`81`	`PythonEngine.RunSimpleString("import sys;");`
`80`	`82`	`}`
`81`		`- ps.ExecIn("aa=bb+cc+3");`
	`83`	`+ ps.Exec("aa=bb+cc+3");`
`82`	`84`	`int result = ps.Get<System.Int32>("aa");`
`83`	`85`	`Assert.AreEqual(result, 113);`
`84`	`86`	`}`