Add builtin oct function. Add weakref.ref class.

Author: windelbouwman

README.md

@@ -26,6 +26,18 @@ Or use the interactive shell:
 - Full Python-3 environment entirely in Rust (not CPython bindings)
 - A clean implementation without compatibility hacks
 
+# Documentation
+
+Currently the project is in an early phase, and so is the documentation.
+
+You can generate documentation by running:
+
+```shell
+$ cargo doc
+```
+
+Documentation HTML files can then be found in the `target/doc` directory.
+
 # Code organization
 
 - `parser`: python lexing, parsing and ast
@@ -64,6 +76,24 @@ There also are some unittests, you can run those will cargo:
 $ cargo test --all
 ```
 
+# Using another standard library
+
+As of now the standard library is under construction.
+
+You can play around
+with other standard libraries for python. For example,
+the [ouroboros library](https://github.com/pybee/ouroboros).
+
+To do this, follow this method:
+
+```shell
+$ cd ~/GIT
+$ git clone [email protected]:pybee/ouroboros.git
+$ export PYTHONPATH=~/GIT/ouroboros/ouroboros
+$ cd RustPython
+$ cargo run -- -c 'import statistics'
+```
+
 # Compiling to WebAssembly
 
 ## Setup

parser/src/parser.rs

@@ -12,6 +12,7 @@ use super::python;
 use super::token;
 
 pub fn read_file(filename: &Path) -> Result<String, String> {
+    info!("Loading file {:?}", filename);
     match File::open(&filename) {
         Ok(mut file) => {
             let mut s = String::new();

tests/snippets/weakrefs.py

@@ -0,0 +1,12 @@
+from _weakref import ref
+
+
+class X:
+    pass
+
+
+a = X()
+b = ref(a)
+
+assert b() is a
+

vm/src/builtins.rs

@@ -399,7 +399,19 @@ fn builtin_next(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     }
 }
 
-// builtin_oct
+fn builtin_oct(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(number, Some(vm.ctx.int_type()))]);
+
+    let n = objint::get_value(number);
+    let s = if n.is_negative() {
+        format!("-0o{:o}", n.abs())
+    } else {
+        format!("0o{:o}", n)
+    };
+
+    Ok(vm.new_str(s))
+}
+
 // builtin_open
 
 fn builtin_ord(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -576,6 +588,7 @@ pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     dict.insert(String::from("max"), ctx.new_rustfunc(builtin_max));
     dict.insert(String::from("min"), ctx.new_rustfunc(builtin_min));
     dict.insert(String::from("object"), ctx.object());
+    dict.insert(String::from("oct"), ctx.new_rustfunc(builtin_oct));
     dict.insert(String::from("ord"), ctx.new_rustfunc(builtin_ord));
     dict.insert(String::from("next"), ctx.new_rustfunc(builtin_next));
     dict.insert(String::from("pow"), ctx.new_rustfunc(builtin_pow));

vm/src/bytecode.rs

@@ -1,11 +1,5 @@
-/*
- * Implement python as a virtual machine with bytecodes.
- */
-
-/*
-let load_const_string = 0x16;
-let call_function = 0x64;
-*/
+//! Implement python as a virtual machine with bytecodes. This module
+//! implements bytecode structure.
 
 /*
  * Primitive instruction type, which can be encoded and decoded.
@@ -17,6 +11,8 @@ use rustpython_parser::ast;
 use std::collections::HashMap;
 use std::fmt;
 
+/// Primary container of a single code object. Each python function has
+/// a codeobject. Also a module has a codeobject.
 #[derive(Clone, PartialEq)]
 pub struct CodeObject {
     pub instructions: Vec<Instruction>,
@@ -63,6 +59,7 @@ bitflags! {
 
 pub type Label = usize;
 
+/// A Single bytecode instruction.
 #[derive(Debug, Clone, PartialEq)]
 pub enum Instruction {
     Import {

vm/src/pyobject.rs

@@ -24,7 +24,7 @@ use num_traits::{One, Zero};
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt;
-use std::rc::Rc;
+use std::rc::{Rc, Weak};
 
 /* Python objects and references.
 
@@ -53,6 +53,9 @@ pub type PyRef<T> = Rc<RefCell<T>>;
 /// to the python object by 1.
 pub type PyObjectRef = PyRef<PyObject>;
 
+/// Same as PyObjectRef, except for being a weak reference.
+pub type PyObjectWeakRef = Weak<RefCell<PyObject>>;
+
 /// Use this type for function which return a python object or and exception.
 /// Both the python object and the python exception are `PyObjectRef` types
 /// since exceptions are also python objects.
@@ -599,7 +602,7 @@ impl DictProtocol for PyObjectRef {
             PyObjectKind::Scope { ref mut scope } => {
                 scope.locals.set_item(k, v);
             }
-            _ => panic!("TODO"),
+            ref k => panic!("TODO {:?}", k),
         };
     }
 }
@@ -722,6 +725,9 @@ pub enum PyObjectKind {
         dict: PyObjectRef,
         mro: Vec<PyObjectRef>,
     },
+    WeakRef {
+        referent: PyObjectWeakRef,
+    },
     Instance {
         dict: PyObjectRef,
     },
@@ -741,6 +747,7 @@ impl fmt::Debug for PyObjectKind {
             &PyObjectKind::Sequence { elements: _ } => write!(f, "list or tuple"),
             &PyObjectKind::Dict { elements: _ } => write!(f, "dict"),
             &PyObjectKind::Set { elements: _ } => write!(f, "set"),
+            &PyObjectKind::WeakRef { .. } => write!(f, "weakref"),
             &PyObjectKind::Iterator {
                 position: _,
                 iterated_obj: _,
@@ -813,6 +820,7 @@ impl PyObject {
                     .collect::<Vec<_>>()
                     .join(", ")
             ),
+            PyObjectKind::WeakRef { .. } => String::from("weakref"),
             PyObjectKind::None => String::from("None"),
             PyObjectKind::Class {
                 ref name,

vm/src/stdlib/mod.rs

@@ -8,6 +8,7 @@ mod re;
 mod time_module;
 mod tokenize;
 mod types;
+mod weakref;
 use std::collections::HashMap;
 
 use super::pyobject::{PyContext, PyObjectRef};
@@ -29,5 +30,6 @@ pub fn get_module_inits() -> HashMap<String, StdlibInitFunc> {
         tokenize::mk_module as StdlibInitFunc,
     );
     modules.insert("types".to_string(), types::mk_module as StdlibInitFunc);
+    modules.insert("_weakref".to_string(), weakref::mk_module as StdlibInitFunc);
     modules
 }

vm/src/stdlib/weakref.rs

@@ -0,0 +1,55 @@
+//! Implementation in line with the python `weakref` module.
+//!
+//! See also:
+//! - [python weakref module](https://docs.python.org/3/library/weakref.html)
+//! - [rust weak struct](https://doc.rust-lang.org/std/rc/struct.Weak.html)
+//!
+
+use super::super::obj::objtype;
+use super::super::pyobject::{
+    AttributeProtocol, DictProtocol, PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef,
+    PyObjectWeakRef, PyResult, TypeProtocol,
+};
+use super::super::VirtualMachine;
+use std::rc::Rc;
+
+pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
+    let py_mod = ctx.new_module(&"_weakref".to_string(), ctx.new_scope(None));
+
+    let py_ref_class = ctx.new_class("ref", ctx.object());
+    py_ref_class.set_attr("__new__", ctx.new_rustfunc(ref_new));
+    py_ref_class.set_attr("__call__", ctx.new_rustfunc(ref_call));
+    py_mod.set_item("ref", py_ref_class);
+    py_mod
+}
+
+fn ref_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    // TODO: check first argument for subclass of `ref`.
+    arg_check!(vm, args, required = [(cls, None), (referent, None)]);
+    let referent = Rc::downgrade(referent);
+    Ok(PyObject::new(
+        PyObjectKind::WeakRef { referent: referent },
+        cls.clone(),
+    ))
+}
+
+/// Dereference the weakref, and check if we still refer something.
+fn ref_call(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    // TODO: check first argument for subclass of `ref`.
+    arg_check!(vm, args, required = [(cls, None)]);
+    let referent = get_value(cls);
+    let py_obj = if let Some(obj) = referent.upgrade() {
+        obj
+    } else {
+        vm.get_none()
+    };
+    Ok(py_obj)
+}
+
+fn get_value(obj: &PyObjectRef) -> PyObjectWeakRef {
+    if let PyObjectKind::WeakRef { referent } = &obj.borrow().kind {
+        referent.clone()
+    } else {
+        panic!("Inner error getting weak ref {:?}", obj);
+    }
+}

vm/src/vm.rs

@@ -27,6 +27,8 @@ use super::sysmodule;
 
 // Objects are live when they are on stack, or referenced by a name (for now)
 
+/// Top level container of a python virtual machine. In theory you could
+/// create more instances of this struct and have them operate fully isolated.
 pub struct VirtualMachine {
     builtins: PyObjectRef,
     pub sys_module: PyObjectRef,
@@ -45,6 +47,7 @@ impl VirtualMachine {
         self.ctx.new_str(s)
     }
 
+    /// Create a new python bool object.
     pub fn new_bool(&self, b: bool) -> PyObjectRef {
         self.ctx.new_bool(b)
     }
@@ -73,6 +76,8 @@ impl VirtualMachine {
         self.new_exception(type_error, msg)
     }
 
+    /// Create a new python ValueError object. Useful for raising errors from
+    /// python functions implemented in rust.
     pub fn new_value_error(&mut self, msg: String) -> PyObjectRef {
         let value_error = self.ctx.exceptions.value_error.clone();
         self.new_exception(value_error, msg)
@@ -225,7 +230,9 @@ impl VirtualMachine {
             } => self.invoke(function.clone(), args.insert(object.clone())),
             PyObjectKind::Instance { .. } => self.call_method_pyargs(&func_ref, "__call__", args),
             ref kind => {
-                unimplemented!("invoke unimplemented for: {:?}", kind);
+                // TODO: is it safe to just invoke __call__ otherwise?
+                trace!("invoke __call__ for: {:?}", kind);
+                self.call_method_pyargs(&func_ref, "__call__", args)
             }
         }
     }