Use enum for initialize parameters

Author: yanganto

src/main.rs

@@ -12,7 +12,7 @@ use rustpython_vm::{
     print_exception,
     pyobject::{ItemProtocol, PyResult},
     scope::Scope,
-    util, PySettings, VirtualMachine,
+    util, InitParameter, PySettings, VirtualMachine,
 };
 
 use std::convert::TryInto;
@@ -32,7 +32,9 @@ fn main() {
     let mut settings = create_settings(&matches);
 
     // We only include the standard library bytecode in WASI when initializing
-    settings.initialize_with_external_importer = Some(cfg!(not(target_os = "wasi")));
+    if cfg!(target_os = "wasi") {
+        settings.initialization_parameter = InitParameter::InitializeInternal;
+    }
 
     let vm = VirtualMachine::new(settings);
 

vm/src/import.rs

@@ -9,31 +9,38 @@ use crate::obj::{objcode, objtype};
 use crate::pyobject::{ItemProtocol, PyObjectRef, PyResult, PyValue};
 use crate::scope::Scope;
 use crate::version::get_git_revision;
-use crate::vm::VirtualMachine;
+use crate::vm::{InitParameter, VirtualMachine};
 #[cfg(feature = "rustpython-compiler")]
 use rustpython_compiler::compile;
 
-pub fn init_importlib(vm: &VirtualMachine, external: bool) -> PyResult {
+pub fn init_importlib(vm: &VirtualMachine, initialize_parameter: InitParameter) -> PyResult {
     flame_guard!("init importlib");
     let importlib = import_frozen(vm, "_frozen_importlib")?;
     let impmod = import_builtin(vm, "_imp")?;
     let install = vm.get_attribute(importlib.clone(), "_install")?;
     vm.invoke(&install, vec![vm.sys_module.clone(), impmod])?;
     vm.import_func
         .replace(vm.get_attribute(importlib.clone(), "__import__")?);
-    if external && cfg!(feature = "rustpython-compiler") {
-        flame_guard!("install_external");
-        let install_external =
-            vm.get_attribute(importlib.clone(), "_install_external_importers")?;
-        vm.invoke(&install_external, vec![])?;
-        // Set pyc magic number to commit hash. Should be changed when bytecode will be more stable.
-        let importlib_external = vm.import("_frozen_importlib_external", &[], 0)?;
-        let mut magic = get_git_revision().into_bytes();
-        magic.truncate(4);
-        if magic.len() != 4 {
-            magic = rand::thread_rng().gen::<[u8; 4]>().to_vec();
+
+    match initialize_parameter {
+        InitParameter::InitializeExternal if cfg!(feature = "rustpython-compiler") => {
+            flame_guard!("install_external");
+            let install_external =
+                vm.get_attribute(importlib.clone(), "_install_external_importers")?;
+            vm.invoke(&install_external, vec![])?;
+            // Set pyc magic number to commit hash. Should be changed when bytecode will be more stable.
+            let importlib_external = vm.import("_frozen_importlib_external", &[], 0)?;
+            let mut magic = get_git_revision().into_bytes();
+            magic.truncate(4);
+            if magic.len() != 4 {
+                magic = rand::thread_rng().gen::<[u8; 4]>().to_vec();
+            }
+            vm.set_attr(&importlib_external, "MAGIC_NUMBER", vm.ctx.new_bytes(magic))?;
+        }
+        InitParameter::NoInitialize => {
+            panic!("Import library initialize should be InitializeInternal or InitializeExternal");
         }
-        vm.set_attr(&importlib_external, "MAGIC_NUMBER", vm.ctx.new_bytes(magic))?;
+        _ => {}
     }
     Ok(vm.get_none())
 }

vm/src/lib.rs

@@ -73,7 +73,7 @@ mod vm;
 
 // pub use self::pyobject::Executor;
 pub use self::exceptions::{print_exception, write_exception};
-pub use self::vm::{PySettings, VirtualMachine};
+pub use self::vm::{InitParameter, PySettings, VirtualMachine};
 pub use rustpython_bytecode::*;
 
 #[doc(hidden)]

vm/src/vm.rs

@@ -74,6 +74,13 @@ pub struct VirtualMachine {
 
 pub const NSIG: usize = 64;
 
+#[derive(Copy, Clone)]
+pub enum InitParameter {
+    NoInitialize,
+    InitializeInternal,
+    InitializeExternal,
+}
+
 /// Struct containing all kind of settings for the python vm.
 pub struct PySettings {
     /// -d command line switch
@@ -109,17 +116,9 @@ pub struct PySettings {
     /// sys.argv
     pub argv: Vec<String>,
 
-    /// Initialize VM after VM created
-    /// - Some(true):
-    ///     VM will be created and initialized with the importers, which require external
-    ///     filesystem access
-    /// - Some(false):
-    ///     VM will be created and initialized with the importers wihout external filesystem access
-    /// - None:
-    ///     VM will be created but not initialized, so it is ready to be injected with modules.
-    ///     After injection, the `initialize_as_external` or `initialize_without_external`
-    ///     should be called, such that the VM will be ready to use.
-    pub initialize_with_external_importer: Option<bool>,
+    /// Initialization parameter to decide to initialize or not,
+    /// and to decide the importer required external filesystem access or not
+    pub initialization_parameter: InitParameter,
 }
 
 /// Trace events for sys.settrace and sys.setprofile.
@@ -153,7 +152,7 @@ impl Default for PySettings {
             dont_write_bytecode: false,
             path_list: vec![],
             argv: vec![],
-            initialize_with_external_importer: Some(true),
+            initialization_parameter: InitParameter::InitializeExternal,
         }
     }
 }
@@ -181,7 +180,7 @@ impl VirtualMachine {
         let profile_func = RefCell::new(ctx.none());
         let trace_func = RefCell::new(ctx.none());
         let signal_handlers = RefCell::new(arr![ctx.none(); 64]);
-        let initialize_parameter = settings.initialize_with_external_importer;
+        let initialize_parameter = settings.initialization_parameter;
 
         let mut vm = VirtualMachine {
             builtins: builtins.clone(),
@@ -215,37 +214,32 @@ impl VirtualMachine {
             vm.new_str("sys".to_owned()),
             vm.get_none(),
         );
-        if let Some(with_external_importer) = initialize_parameter {
-            vm._initialize(with_external_importer);
-            vm.initialized = true;
-        }
+        vm.initialize(initialize_parameter);
         vm
     }
 
-    fn _initialize(&mut self, with_external_importer: bool) {
+    pub fn initialize(&mut self, initialize_parameter: InitParameter) {
         flame_guard!("init VirtualMachine");
 
-        if self.initialized {
-            panic!("Double Initialize Error");
-        }
-
-        builtins::make_module(self, self.builtins.clone());
-        sysmodule::make_module(self, self.sys_module.clone(), self.builtins.clone());
-
-        #[cfg(not(target_arch = "wasm32"))]
-        import::import_builtin(self, "signal").expect("Couldn't initialize signal module");
+        match initialize_parameter {
+            InitParameter::NoInitialize => {}
+            _ => {
+                if self.initialized {
+                    panic!("Double Initialize Error");
+                }
 
-        import::init_importlib(self, with_external_importer).expect("Initialize importlib fail");
+                builtins::make_module(self, self.builtins.clone());
+                sysmodule::make_module(self, self.sys_module.clone(), self.builtins.clone());
 
-        self.initialized = true;
-    }
+                #[cfg(not(target_arch = "wasm32"))]
+                import::import_builtin(self, "signal").expect("Couldn't initialize signal module");
 
-    pub fn initialize_with_external_importer(&mut self) {
-        self._initialize(true);
-    }
+                import::init_importlib(self, initialize_parameter)
+                    .expect("Initialize importlib fail");
 
-    pub fn initialize_without_external_importer(&mut self) {
-        self._initialize(false);
+                self.initialized = true;
+            }
+        }
     }
 
     pub fn run_code_obj(&self, code: PyCodeRef, scope: Scope) -> PyResult {

wasm/lib/src/vm_class.rs

@@ -9,7 +9,7 @@ use rustpython_compiler::compile;
 use rustpython_vm::function::PyFuncArgs;
 use rustpython_vm::pyobject::{PyObject, PyObjectPayload, PyObjectRef, PyResult, PyValue};
 use rustpython_vm::scope::{NameProtocol, Scope};
-use rustpython_vm::{PySettings, VirtualMachine};
+use rustpython_vm::{InitParameter, PySettings, VirtualMachine};
 
 use crate::browser_module::setup_browser_module;
 use crate::convert;
@@ -28,9 +28,8 @@ impl StoredVirtualMachine {
     fn new(id: String, inject_browser_module: bool) -> StoredVirtualMachine {
         let mut settings = PySettings::default();
 
-        // The VM will not be initialized.
-        // It will be initialized after js module injected.
-        settings.initialize_with_external_importer = None;
+        // After js, browser modules injected, the VM will not be initialized.
+        settings.initialization_parameter = InitParameter::NoInitialize;
 
         let mut vm: VirtualMachine = VirtualMachine::new(settings);
 
@@ -50,7 +49,7 @@ impl StoredVirtualMachine {
             setup_browser_module(&vm);
         }
 
-        vm.initialize_without_external_importer();
+        vm.initialize(InitParameter::InitializeInternal);
 
         StoredVirtualMachine {
             vm,