Move NSIG, reorganize prompt stuff

Author: coolreader18

src/main.rs

@@ -11,7 +11,7 @@ use rustpython_vm::{
     import,
     obj::objstr::PyStringRef,
     print_exception,
-    pyobject::{ItemProtocol, PyResult},
+    pyobject::{ItemProtocol, PyObjectRef, PyResult},
     scope::Scope,
     util, PySettings, VirtualMachine,
 };
@@ -434,40 +434,32 @@ fn test_run_script() {
     assert!(r.is_ok());
 }
 
-fn shell_exec(vm: &VirtualMachine, source: &str, scope: Scope) -> Result<(), CompileError> {
+enum ShellExecResult {
+    Ok,
+    PyErr(PyObjectRef),
+    Continue,
+}
+
+fn shell_exec(vm: &VirtualMachine, source: &str, scope: Scope) -> ShellExecResult {
     match vm.compile(source, compile::Mode::Single, "<stdin>".to_string()) {
         Ok(code) => {
             match vm.run_code_obj(code, scope.clone()) {
                 Ok(value) => {
                     // Save non-None values as "_"
-
-                    use rustpython_vm::pyobject::IdProtocol;
-
-                    if !value.is(&vm.get_none()) {
+                    if !vm.is_none(&value) {
                         let key = "_";
                         scope.globals.set_item(key, value, vm).unwrap();
                     }
+                    ShellExecResult::Ok
                 }
-
-                Err(err) => {
-                    print_exception(vm, &err);
-                }
+                Err(err) => ShellExecResult::PyErr(err),
             }
-
-            Ok(())
-        }
-        // Don't inject syntax errors for line continuation
-        Err(
-            err @ CompileError {
-                error: CompileErrorType::Parse(ParseErrorType::EOF),
-                ..
-            },
-        ) => Err(err),
-        Err(err) => {
-            let exc = vm.new_syntax_error(&err);
-            print_exception(vm, &exc);
-            Err(err)
         }
+        Err(CompileError {
+            error: CompileErrorType::Parse(ParseErrorType::EOF),
+            ..
+        }) => ShellExecResult::Continue,
+        Err(err) => ShellExecResult::PyErr(vm.new_syntax_error(&err)),
     }
 }
 
@@ -519,48 +511,66 @@ fn run_shell(vm: &VirtualMachine, scope: Scope) -> PyResult<()> {
         } else {
             get_prompt(vm, "ps1")
         };
-        let prompt = prompt.as_ref().map(|s| s.as_str()).unwrap_or("");
-        match repl.readline(prompt) {
+        let prompt = match prompt {
+            Some(ref s) => s.as_str(),
+            None => "",
+        };
+        let result = match repl.readline(prompt) {
             Ok(line) => {
                 debug!("You entered {:?}", line);
-                input.push_str(&line);
-                input.push('\n');
+
                 repl.add_history_entry(line.trim_end());
 
+                let stop_continuing = line.is_empty();
+
+                if input.is_empty() {
+                    input = line;
+                } else {
+                    input.push_str(&line);
+                }
+                input.push_str("\n");
+
                 if continuing {
-                    if line.is_empty() {
+                    if stop_continuing {
                         continuing = false;
                     } else {
                         continue;
                     }
                 }
 
                 match shell_exec(vm, &input, scope.clone()) {
-                    Err(CompileError {
-                        error: CompileErrorType::Parse(ParseErrorType::EOF),
-                        ..
-                    }) => {
+                    ShellExecResult::Ok => {
+                        input = String::new();
+                        Ok(())
+                    }
+                    ShellExecResult::Continue => {
                         continuing = true;
+                        Ok(())
                     }
-                    _ => {
+                    ShellExecResult::PyErr(err) => {
                         input = String::new();
+                        Err(err)
                     }
                 }
             }
             Err(ReadlineError::Interrupted) => {
-                let exc = vm
+                continuing = false;
+                let keyboard_interrupt = vm
                     .new_empty_exception(vm.ctx.exceptions.keyboard_interrupt.clone())
                     .unwrap();
-                print_exception(vm, &exc);
-                continuing = false;
+                Err(keyboard_interrupt)
             }
             Err(ReadlineError::Eof) => {
                 break;
             }
             Err(err) => {
-                println!("Error: {:?}", err);
+                eprintln!("Readline error: {:?}", err);
                 break;
             }
+        };
+
+        if let Err(exc) = result {
+            print_exception(vm, &exc);
         }
     }
     repl.save_history(repl_history_path_str).unwrap();
@@ -586,7 +596,11 @@ fn run_shell(vm: &VirtualMachine, scope: Scope) -> PyResult<()> {
     for line in stdin.lock().lines() {
         let mut line = line.expect("line failed");
         line.push('\n');
-        let _ = shell_exec(vm, &line, scope.clone());
+        match shell_exec(vm, &line, scope.clone()) {
+            ShellExecResult::Ok => {}
+            ShellExecResult::Continue => println!("Unexpected EOF"),
+            ShellExecResult::PyErr(exc) => print_exception(vm, &exc),
+        }
         print!("{}", get_prompt(vm, "ps1"));
         stdout.flush().expect("flush failed");
     }

vm/src/stdlib/signal.rs

@@ -1,6 +1,6 @@
 use crate::obj::objint::PyIntRef;
 use crate::pyobject::{PyObjectRef, PyResult, TryFromObject};
-use crate::vm::VirtualMachine;
+use crate::vm::{VirtualMachine, NSIG};
 
 use std::sync::atomic::{AtomicBool, Ordering};
 
@@ -23,8 +23,6 @@ const SIG_IGN: libc::sighandler_t = 1;
 #[cfg(windows)]
 const SIG_ERR: libc::sighandler_t = !0;
 
-pub const NSIG: usize = 64;
-
 // We cannot use the NSIG const in the arr macro. This will fail compilation if NSIG is different.
 static TRIGGERS: [AtomicBool; NSIG] = arr![AtomicBool::new(false); 64];
 
@@ -33,7 +31,7 @@ extern "C" fn run_signal(signum: i32) {
 }
 
 fn assert_in_range(signum: i32, vm: &VirtualMachine) -> PyResult<()> {
-    if (1..=NSIG as i32).contains(&signum) {
+    if (1..NSIG as i32).contains(&signum) {
         Ok(())
     } else {
         Err(vm.new_value_error("signal number out of range".to_owned()))

vm/src/vm.rs

@@ -63,11 +63,12 @@ pub struct VirtualMachine {
     pub profile_func: RefCell<PyObjectRef>,
     pub trace_func: RefCell<PyObjectRef>,
     pub use_tracing: RefCell<bool>,
+    pub signal_handlers: RefCell<[PyObjectRef; NSIG]>,
     pub settings: PySettings,
-    #[cfg(not(target_arch = "wasm32"))]
-    pub signal_handlers: RefCell<[PyObjectRef; stdlib::signal::NSIG]>,
 }
 
+pub const NSIG: usize = 64;
+
 /// Struct containing all kind of settings for the python vm.
 pub struct PySettings {
     /// -d command line switch
@@ -168,10 +169,9 @@ impl VirtualMachine {
         let import_func = RefCell::new(ctx.none());
         let profile_func = RefCell::new(ctx.none());
         let trace_func = RefCell::new(ctx.none());
+        let signal_handlers = RefCell::new(arr![ctx.none(); 64]);
 
         let vm = VirtualMachine {
-            #[cfg(not(target_arch = "wasm32"))]
-            signal_handlers: RefCell::new(arr![ctx.none(); 64]),
             builtins: builtins.clone(),
             sys_module: sysmod.clone(),
             stdlib_inits,
@@ -184,6 +184,7 @@ impl VirtualMachine {
             profile_func,
             trace_func,
             use_tracing: RefCell::new(false),
+            signal_handlers,
             settings,
         };