Add initial types module

Author: windelbouwman

vm/src/stdlib/mod.rs

@@ -5,6 +5,7 @@ mod keyword;
 mod math;
 mod pystruct;
 mod re;
+mod types;
 use std::collections::HashMap;
 
 use super::pyobject::{PyContext, PyObjectRef};
@@ -13,12 +14,13 @@ pub type StdlibInitFunc = fn(&PyContext) -> PyObjectRef;
 
 pub fn get_module_inits() -> HashMap<String, StdlibInitFunc> {
     let mut modules = HashMap::new();
+    modules.insert("ast".to_string(), ast::mk_module as StdlibInitFunc);
     modules.insert("io".to_string(), io::mk_module as StdlibInitFunc);
     modules.insert("json".to_string(), json::mk_module as StdlibInitFunc);
-    modules.insert("ast".to_string(), ast::mk_module as StdlibInitFunc);
     modules.insert("keyword".to_string(), keyword::mk_module as StdlibInitFunc);
     modules.insert("math".to_string(), math::mk_module as StdlibInitFunc);
     modules.insert("re".to_string(), re::mk_module as StdlibInitFunc);
     modules.insert("struct".to_string(), pystruct::mk_module as StdlibInitFunc);
+    modules.insert("types".to_string(), types::mk_module as StdlibInitFunc);
     modules
 }

vm/src/stdlib/types.rs

@@ -0,0 +1,44 @@
+/*
+ * Dynamic type creation and names for built in types.
+ */
+
+use super::super::obj::{objstr, objtuple, objtype};
+use super::super::pyobject::{
+    DictProtocol, PyContext, PyFuncArgs, PyObjectRef, PyResult, TypeProtocol,
+};
+use super::super::VirtualMachine;
+
+fn types_new_class(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(name, Some(vm.ctx.str_type()))],
+        optional = [(bases, None), (_kwds, None), (_exec_body, None)]
+    );
+
+    let name = objstr::get_value(name);
+    let dict = vm.ctx.new_dict();
+
+    let bases = match bases {
+        Some(b) => {
+            if objtype::isinstance(b, vm.ctx.tuple_type()) {
+                objtuple::get_elements(b)
+            } else {
+                return Err(vm.new_type_error("Bases must be a tuple".to_string()));
+            }
+        }
+        None => vec![vm.ctx.object()],
+    };
+
+    objtype::new(vm.ctx.type_type(), &name, bases, dict)
+}
+
+pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
+    let py_mod = ctx.new_module(&"types".to_string(), ctx.new_scope(None));
+
+    // Number theory functions:
+    py_mod.set_item("new_class", ctx.new_rustfunc(types_new_class));
+    py_mod.set_item("FunctionType", ctx.function_type());
+
+    py_mod
+}

vm/src/vm.rs

@@ -122,6 +122,8 @@ impl VirtualMachine {
         let ctx = PyContext::new();
         let builtins = builtins::make_module(&ctx);
         let sysmod = sysmodule::mk_module(&ctx);
+        // Add builtins as builtins module:
+        // sysmod.get_attr("modules").unwrap().set_item("builtins", builtins.clone());
         let stdlib_inits = stdlib::get_module_inits();
         VirtualMachine {
             frames: vec![],