Bend ADTS in Python

.gitignore

@@ -13,3 +13,4 @@ __pycache__
 **/*.rs.bk
 # MSVC Windows builds of rustc generate these, which store debugging information
 *.pdb
+.vscode/

Makefile

@@ -17,3 +17,6 @@ rust-fmt:
 build:
 	cd crates/benda; \
 		maturin develop
+
+run: build
+	python3 tmp/quicksort.py

crates/benda/Cargo.toml

@@ -6,10 +6,13 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
 name = "benda"
-crate-type = ["cdylib"]
+#crate-type = ["cdylib"]
+
+# Debug purposes
+crate-type = ["lib"]
 
 [dependencies]
-pyo3 = { version = "0.21.2", features = [] }
+pyo3 = { version = "0.21.2", features = ["extension-module"] }
 bend-lang = "0.2.33"
 num-bigint = "0.4.5"
 num-traits = "0.2.19"

crates/benda/src/lib.rs

@@ -1,10 +1,13 @@
+use std::path::Path;
+
 use num_traits::ToPrimitive;
 use parser::Parser;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyFunction, PyString, PyTuple};
 use rustpython_parser::{parse, Mode};
+use types::book::Book;
 use types::tree::{Leaf, Node, Tree};
-use types::u24;
+use types::u24::U24;
 mod benda_ffi;
 mod parser;
 mod types;
@@ -14,6 +17,26 @@ fn switch() -> PyResult<String> {
     Ok("Ok".to_string())
 }
 
+#[pyfunction]
+fn load_book_from_file(py: Python, path: Py<PyString>) -> PyResult<Py<Book>> {
+    let binding = path.to_string();
+    let new_path = Path::new(&binding);
+    let bend_book = bend::load_file_to_book(new_path);
+
+    //let code = std::fs::read_to_string(new_path)
+    //    .map_err(|e| e.to_string())
+    //    .unwrap();
+    //let bend_book = bend::fun::load_book::do_parse_book(
+    //    &code,
+    //    new_path,
+    //    BendBook::default(),
+    //);
+
+    let book = Book::new(bend_book.unwrap());
+
+    Ok(Py::new(py, book).unwrap())
+}
+
 #[pyclass(name = "bjit")]
 pub struct PyBjit {
     wraps: Py<PyAny>,
@@ -83,14 +106,13 @@ impl PyBjit {
 
         match module {
             rustpython_parser::ast::Mod::Module(mods) => {
-                for (index, stmt) in mods.body.iter().enumerate() {
+                for stmt in mods.body.iter() {
                     if let rustpython_parser::ast::Stmt::FunctionDef(fun_def) =
                         stmt
                     {
                         if fun_def.name == name.to_string() {
                             let mut parser = Parser::new(
                                 mods.body.clone(),
-                                index,
                                 parsed_types.clone(),
                             );
                             let return_val =
@@ -114,8 +136,9 @@ impl PyBjit {
 #[pymodule]
 fn benda(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(switch, m)?)?;
+    m.add_function(wrap_pyfunction!(load_book_from_file, m)?)?;
     m.add_class::<PyBjit>()?;
-    m.add_class::<u24::u24>()?;
+    m.add_class::<U24>()?;
     m.add_class::<Tree>()?;
     m.add_class::<Node>()?;
     m.add_class::<Leaf>()?;

crates/benda/src/parser/mod.rs

@@ -24,20 +24,6 @@ enum FromExpr {
 }
 
 impl FromExpr {
-    pub fn to_expr(&self) -> Option<Expr> {
-        if let FromExpr::Expr(exp) = self {
-            return Some(exp.clone());
-        }
-        None
-    }
-
-    pub fn to_stmt(&self) -> Option<Stmt> {
-        if let FromExpr::Statement(stmt) = self {
-            return Some(stmt.clone());
-        }
-        None
-    }
-
     pub fn get_var_name(&self) -> Option<Name> {
         if let FromExpr::Expr(Expr::Var { nam }) = self {
             Some(nam.clone())
@@ -64,21 +50,18 @@ pub struct Parser<'py> {
     book: Book,
     definitions: Vec<imp::Definition>,
     ctx: Option<Context>,
-    index: usize,
     fun_args: Vec<(String, Bound<'py, PyAny>)>,
 }
 
 impl<'py> Parser<'py> {
     pub fn new(
         statements: Vec<rStmt>,
-        index: usize,
         fun_args: Vec<(String, Bound<'py, PyAny>)>,
     ) -> Self {
         Self {
             statements,
             book: bend::fun::Book::builtins(),
             definitions: vec![],
-            index,
             ctx: None,
             fun_args,
         }
@@ -488,7 +471,7 @@ impl<'py> Parser<'py> {
                 }
             }
 
-            if ctx.now == CurContext::Main && !ctx.vars.contains(&name) {
+            if ctx.now == CurContext::Main && !ctx.vars.contains(name) {
                 return self.parse_vec(stmts, index + 1);
             }
         }
@@ -530,12 +513,7 @@ impl<'py> Parser<'py> {
         }
     }
 
-    fn parse_stmt_expr(
-        &mut self,
-        expr: &StmtExpr,
-        stmts: &Vec<rStmt>,
-        index: usize,
-    ) -> Option<FromExpr> {
+    fn parse_stmt_expr(&mut self, expr: &StmtExpr) -> Option<FromExpr> {
         if let Some(ctx) = &self.ctx {
             if ctx.now == CurContext::Main {
                 let val = self.parse_expr_type(*expr.value.clone());
@@ -649,7 +627,7 @@ impl<'py> Parser<'py> {
                 }
                 None => None,
             },
-            rStmt::Expr(expr) => self.parse_stmt_expr(expr, stmts, index),
+            rStmt::Expr(expr) => self.parse_stmt_expr(expr),
             rStmt::Match(m) => {
                 if let Some(val) = self.parse_match(m, stmts, &index) {
                     return Some(FromExpr::Statement(val));
@@ -745,7 +723,7 @@ impl<'py> Parser<'py> {
 
         for arg in parsed_types.clone() {
             match arg.1 {
-                imp::Expr::Var { nam } => {}
+                imp::Expr::Var { nam: _ } => {}
                 _ => new_args.push(Expr::Var {
                     nam: Name::new(arg.0),
                 }),
@@ -762,13 +740,11 @@ impl<'py> Parser<'py> {
             }),
         };
 
-        return Some(imp::Definition {
+        Some(imp::Definition {
             name: Name::new("main"),
             params: vec![],
             body: first,
-        });
-
-        None
+        })
     }
 
     fn parse_class_def(&mut self, class: &StmtClassDef) {
@@ -859,20 +835,6 @@ impl<'py> Parser<'py> {
     }
 
     fn parse_function_def(&mut self, fun_def: &StmtFunctionDef) {
-        let mut is_bjit = false;
-
-        for dec in &fun_def.decorator_list {
-            if let rExpr::Name(nam) = dec {
-                if nam.id.to_string() == "bjit" {
-                    is_bjit = true;
-                }
-            }
-        }
-
-        //if !is_bjit {
-        //return;
-        //}
-
         let args = *fun_def.args.clone();
         let mut names: Vec<Name> = vec![];
 
@@ -899,7 +861,7 @@ impl<'py> Parser<'py> {
                 rStmt::FunctionDef(fun_def) => {
                     self.parse_function_def(&fun_def)
                 }
-                // Treats a type alias, example: Type = A | B
+                // Treats an type alias, example: Type = A | B
                 rStmt::Assign(assign) => self.parse_type_alias(&assign),
                 rStmt::ClassDef(class) => self.parse_class_def(&class),
                 _ => {}

crates/benda/src/test.rs

@@ -0,0 +1,26 @@
+mod parser;
+
+use std::path::{self, Path};
+
+use pyo3::prelude::*;
+use rustpython_parser::{parse, Mode};
+use types::book::Book;
+
+mod benda_ffi;
+mod types;
+
+fn main() {
+    let new_path = Path::new("./examples/quicksort.bend");
+    let bend_book = bend::load_file_to_book(new_path);
+
+    //let code = std::fs::read_to_string(new_path)
+    //    .map_err(|e| e.to_string())
+    //    .unwrap();
+    //let bend_book = bend::fun::load_book::do_parse_book(
+    //    &code,
+    //    new_path,
+    //    BendBook::default(),
+    //);
+
+    let book = Book::new(bend_book.unwrap());
+}