Merge pull request RustPython#672 from coolreader18/wasm-vm-exec_single

Use compile::Mode::Single for the demo terminal

Author: windelbouwman

vm/src/frame.rs

@@ -691,13 +691,10 @@ impl Frame {
                 let expr = self.pop_value();
                 if !expr.is(&vm.get_none()) {
                     let repr = vm.to_repr(&expr)?;
-                    builtins::builtin_print(
-                        vm,
-                        PyFuncArgs {
-                            args: vec![repr],
-                            kwargs: vec![],
-                        },
-                    )?;
+                    // TODO: implement sys.displayhook
+                    if let Some(print) = vm.ctx.get_attr(&vm.builtins, "print") {
+                        vm.invoke(print, vec![repr])?;
+                    }
                 }
                 Ok(None)
             }

wasm/demo/src/main.js

@@ -113,7 +113,7 @@ term.on('data', data => {
         } else {
             term.write('\r\n');
             try {
-                terminalVM.exec(input);
+                terminalVM.execSingle(input);
             } catch (err) {
                 if (err instanceof WebAssembly.RuntimeError) {
                     err = window.__RUSTPYTHON_ERROR || err;

wasm/lib/src/vm_class.rs

@@ -266,46 +266,40 @@ impl WASMVirtualMachine {
 
     #[wasm_bindgen(js_name = setStdout)]
     pub fn set_stdout(&self, stdout: JsValue) -> Result<(), JsValue> {
-        self.with(
-            move |StoredVirtualMachine {
-                      ref mut vm,
-                      ref mut scope,
-                      ..
-                  }| {
-                fn error() -> JsValue {
-                    TypeError::new("Unknown stdout option, please pass a function or 'console'")
-                        .into()
-                }
-                let print_fn: Box<Fn(&mut VirtualMachine, PyFuncArgs) -> PyResult> =
-                    if let Some(s) = stdout.as_string() {
-                        match s.as_str() {
-                            "console" => Box::new(wasm_builtins::builtin_print_console),
-                            _ => return Err(error()),
-                        }
-                    } else if stdout.is_function() {
-                        let func = js_sys::Function::from(stdout);
-                        Box::new(
-                            move |vm: &mut VirtualMachine, args: PyFuncArgs| -> PyResult {
-                                func.call1(
-                                    &JsValue::UNDEFINED,
-                                    &wasm_builtins::format_print_args(vm, args)?.into(),
-                                )
-                                .map_err(|err| convert::js_to_py(vm, err))?;
-                                Ok(vm.get_none())
-                            },
-                        )
-                    } else if stdout.is_undefined() || stdout.is_null() {
-                        fn noop(vm: &mut VirtualMachine, _args: PyFuncArgs) -> PyResult {
+        self.with(move |StoredVirtualMachine { ref mut vm, .. }| {
+            fn error() -> JsValue {
+                TypeError::new("Unknown stdout option, please pass a function or 'console'").into()
+            }
+            let print_fn: Box<Fn(&mut VirtualMachine, PyFuncArgs) -> PyResult> =
+                if let Some(s) = stdout.as_string() {
+                    match s.as_str() {
+                        "console" => Box::new(wasm_builtins::builtin_print_console),
+                        _ => return Err(error()),
+                    }
+                } else if stdout.is_function() {
+                    let func = js_sys::Function::from(stdout);
+                    Box::new(
+                        move |vm: &mut VirtualMachine, args: PyFuncArgs| -> PyResult {
+                            func.call1(
+                                &JsValue::UNDEFINED,
+                                &wasm_builtins::format_print_args(vm, args)?.into(),
+                            )
+                            .map_err(|err| convert::js_to_py(vm, err))?;
                             Ok(vm.get_none())
-                        }
-                        Box::new(noop)
-                    } else {
-                        return Err(error());
-                    };
-                scope.store_name(&vm, "print", vm.ctx.new_rustfunc(print_fn));
-                Ok(())
-            },
-        )?
+                        },
+                    )
+                } else if stdout.is_undefined() || stdout.is_null() {
+                    fn noop(vm: &mut VirtualMachine, _args: PyFuncArgs) -> PyResult {
+                        Ok(vm.get_none())
+                    }
+                    Box::new(noop)
+                } else {
+                    return Err(error());
+                };
+            let rustfunc = vm.ctx.new_rustfunc(print_fn);
+            vm.ctx.set_attr(&vm.builtins, "print", rustfunc);
+            Ok(())
+        })?
     }
 
     #[wasm_bindgen(js_name = injectModule)]
@@ -395,4 +389,9 @@ impl WASMVirtualMachine {
     pub fn eval(&self, source: String) -> Result<JsValue, JsValue> {
         self.run(source, compile::Mode::Eval)
     }
+
+    #[wasm_bindgen(js_name = execSingle)]
+    pub fn exec_single(&self, source: String) -> Result<JsValue, JsValue> {
+        self.run(source, compile::Mode::Single)
+    }
 }