Added Parser

Author: vkobinski

Cargo.lock

@@ -0,0 +1,17 @@
+[package]
+name = "benda"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+name = "benda"
+crate-type = ["cdylib"]
+
+[dependencies]
+bend-lang = "=0.2.18"
+num-bigint = "0.4.5"
+num-traits = "0.2.19"
+pyo3 = "0.21.2"
+rustpython-parser = "0.3.1"
+indexmap = "2.2.3"

crates/benda/Cargo.toml

@@ -0,0 +1,15 @@
+use bend::{
+    diagnostics::{ Diagnostics, DiagnosticsConfig },
+    fun::{ Book, Term },
+    CompileOpts,
+    RunOpts,
+};
+
+pub fn run(book: &Book) -> Option<(Term, String, Diagnostics)> {
+    let run_opts = RunOpts { linear_readback: false, pretty: false };
+    let compile_opts = CompileOpts::default();
+    let diagnostics_cfg = DiagnosticsConfig::default();
+    let args = None;
+
+    bend::run_book(book.clone(), run_opts, compile_opts, diagnostics_cfg, args, "run").unwrap()
+}

crates/benda/src/benda_ffi/mod.rs

@@ -0,0 +1,64 @@
+use parser::Parser;
+use pyo3::{ prelude::*, types::{ PyFunction, PyString } };
+use rustpython_parser::{ parse, Mode };
+use types::u24::u24;
+mod types;
+mod parser;
+mod benda_ffi;
+
+#[pyfunction]
+fn sum_as_string(a: usize, b: usize) -> PyResult<String> {
+    Ok((a + b).to_string())
+}
+
+#[pyfunction]
+fn switch() -> PyResult<String> {
+    Ok("Ok".to_string())
+}
+
+#[pyfunction]
+fn bjit(fun: Bound<PyFunction>, py: Python) -> PyResult<PyObject> {
+    let (name, filename) = match fun.downcast::<PyFunction>() {
+        Ok(inner) => {
+            let name = inner.getattr("__name__");
+            let filename = inner.getattr("__code__").unwrap().getattr("co_filename");
+
+            (name.unwrap(), filename.unwrap())
+        }
+        Err(_) => todo!(),
+    };
+
+    let code = std::fs::read_to_string(filename.to_string()).unwrap();
+    let module = parse(code.as_str(), Mode::Module, "main.py").unwrap();
+
+    let mut val: Option<Bound<PyString>> = None;
+
+    match module {
+        rustpython_parser::ast::Mod::Module(mods) => {
+            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(), 0);
+
+                        let mut parser = Parser::new(mods.body.clone(), 0);
+                        let return_val = parser.parse(fun_def.name.as_ref());
+                        val = Some(PyString::new_bound(py, return_val.as_str()));
+                    }
+                }
+            }
+        }
+        _ => unimplemented!(),
+    }
+
+    Ok(val.unwrap().to_object(py))
+}
+
+/// A Python module implemented in Rust.
+#[pymodule]
+fn benda(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(sum_as_string, m)?)?;
+    m.add_function(wrap_pyfunction!(bjit, m)?)?;
+    m.add_function(wrap_pyfunction!(switch, m)?)?;
+    m.add_class::<u24>()?;
+    Ok(())
+}

crates/benda/src/lib.rs

@@ -0,0 +1,25 @@
+mod parser;
+
+use parser::Parser;
+use pyo3::prelude::*;
+
+use rustpython_parser::{ parse, Mode };
+
+mod benda_ffi;
+
+fn main() -> PyResult<()> {
+    let filename = String::from("main.py");
+
+    let code = std::fs::read_to_string(&filename).unwrap();
+    let module = parse(code.as_str(), Mode::Module, "main.py").unwrap();
+
+    match module {
+        rustpython_parser::ast::Mod::Module(mods) => {
+            let mut parser = Parser::new(mods.body, 0);
+            parser.parse(&String::from("gen_tree"));
+        }
+        _ => todo!(),
+    }
+
+    Ok(())
+}

crates/benda/src/main.rs

@@ -0,0 +1,3 @@
+pub enum BuiltIn {
+    Switch,
+}