Mercurial > python-compiler.rs

changeset 1:b90e49ab734b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Factorise conversion of Python str into Rust String.
author Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
date Tue, 31 May 2016 00:52:00 +0100
parents 211b0df72e64
children 5fc7c2790d8c
files src/ast_convert.rs src/ast_dump.rs src/python_ast.rs src/python_dump.rs
diffstat 4 files changed, 43 insertions(+), 80 deletions(-) [+]
line wrap: on
line diff
--- a/src/ast_convert.rs
+++ b/src/ast_convert.rs
@@ -3,6 +3,12 @@ use python_ast::{Module, Statement, Expr
 use cpython::{Python, PyObject};
 use cpython::ObjectProtocol; //for call method
 
+fn get_str(py: Python, object: PyObject) -> String {
+    let pystring = object.str(py).unwrap();
+    let mut string = pystring.to_string(py).unwrap();
+    string.to_mut().to_string()
+}
+
 fn parse_expr_vec(py: Python, ast: PyObject) -> Vec<Expr> {
     let builtins_module = py.import("builtins").unwrap();
     let isinstance = builtins_module.get(py, "isinstance").unwrap();
@@ -84,44 +90,24 @@ fn parse_expr(py: Python, ast: PyObject)
     assert!(is_instance(&ast, &ast_type));
 
     if is_instance(&ast, &arg_type) {
-        let arg = {
-            let arg = ast.getattr(py, "arg").unwrap();
-            let arg = arg.str(py).unwrap();
-            let mut arg = arg.to_string(py).unwrap();
-            arg.to_mut().to_string()
-        };
+        let arg = ast.getattr(py, "arg").unwrap();
+        let arg = get_str(py, arg);
         Expr::Name(arg)
     } else if is_instance(&ast, &name_type) {
-        let id = {
-            let id = ast.getattr(py, "id").unwrap();
-            let id = id.str(py).unwrap();
-            let mut id = id.to_string(py).unwrap();
-            id.to_mut().to_string()
-        };
+        let id = ast.getattr(py, "id").unwrap();
+        let id = get_str(py, id);
         Expr::Name(id)
     } else if is_instance(&ast, &name_constant_type) {
-        let value = {
-            let value = ast.getattr(py, "value").unwrap();
-            let value = value.str(py).unwrap();
-            let mut value = value.to_string(py).unwrap();
-            value.to_mut().to_string()
-        };
+        let value = ast.getattr(py, "value").unwrap();
+        let value = get_str(py, value);
         Expr::NameConstant(value)
     } else if is_instance(&ast, &num_type) {
-        let n = {
-            let n = ast.getattr(py, "n").unwrap();
-            let n = n.str(py).unwrap();
-            let mut n = n.to_string(py).unwrap();
-            n.to_mut().to_string()
-        };
+        let n = ast.getattr(py, "n").unwrap();
+        let n = get_str(py, n);
         Expr::Num(n)
     } else if is_instance(&ast, &str_type) {
-        let s = {
-            let s = ast.getattr(py, "s").unwrap();
-            let s = s.str(py).unwrap();
-            let mut s = s.to_string(py).unwrap();
-            s.to_mut().to_string()
-        };
+        let s = ast.getattr(py, "s").unwrap();
+        let s = get_str(py, s);
         Expr::Str(s)
     } else if is_instance(&ast, &bin_op_type) {
         let left = ast.getattr(py, "left").unwrap();
@@ -151,21 +137,11 @@ fn parse_expr(py: Python, ast: PyObject)
         let name = ast.getattr(py, "name").unwrap();
         let asname = ast.getattr(py, "asname").unwrap();
 
-        let name = {
-            let name = name.str(py).unwrap();
-            let mut name = name.to_string(py).unwrap();
-            name.to_mut().to_string()
-        };
-
-        let asname = {
-            let asname = asname.str(py).unwrap();
-            let mut asname = asname.to_string(py).unwrap();
-            let asname = asname.to_mut().to_string();
-            if asname == "None" {
-                "".to_string()
-            } else {
-                asname
-            }
+        let name = get_str(py, name);
+        let asname = if asname == py.None() {
+            None
+        } else {
+            Some(get_str(py, asname))
         };
 
         Expr::Alias(name, asname)
@@ -241,12 +217,7 @@ fn parse_statement(py: Python, ast: PyOb
         let args = ast.getattr(py, "args").unwrap();
         let body = ast.getattr(py, "body").unwrap();
 
-        let name = {
-            let name = name.str(py).unwrap();
-            let mut name = name.to_string(py).unwrap();
-            name.to_mut().to_string()
-        };
-
+        let name = get_str(py, name);
         let args = parse_expr_vec(py, args);
         /*
         let mut arguments = vec!();
@@ -268,11 +239,8 @@ fn parse_statement(py: Python, ast: PyOb
 
         let mut globals = vec!();
         for name in names.iter(py).unwrap() {
-            let name = {
-                let name = name.unwrap().str(py).unwrap();
-                let mut name = name.to_string(py).unwrap();
-                name.to_mut().to_string()
-            };
+            let name = name.unwrap();
+            let name = get_str(py, name);
             globals.push(name);
         }
 
@@ -286,13 +254,15 @@ fn parse_statement(py: Python, ast: PyOb
 
         let mut statements = vec!();
         for statement in body.iter(py).unwrap() {
-            let statement = parse_statement(py, statement.unwrap());
+            let statement = statement.unwrap();
+            let statement = parse_statement(py, statement);
             statements.push(statement);
         }
 
         let mut orelse_ = vec!();
         for statement in orelse.iter(py).unwrap() {
-            let statement = parse_statement(py, statement.unwrap());
+            let statement = statement.unwrap();
+            let statement = parse_statement(py, statement);
             orelse_.push(statement);
         }
 
@@ -303,7 +273,8 @@ fn parse_statement(py: Python, ast: PyOb
 
         let mut arguments = vec!();
         for target in targets.iter(py).unwrap() {
-            let target = parse_expr(py, target.unwrap());
+            let target = target.unwrap();
+            let target = parse_expr(py, target);
             arguments.push(target);
         }
 
@@ -315,11 +286,7 @@ fn parse_statement(py: Python, ast: PyOb
         let names = ast.getattr(py, "names").unwrap();
         //let level = ast.getattr(py, "level").unwrap();
 
-        let module = {
-            let module = module.str(py).unwrap();
-            let mut module = module.to_string(py).unwrap();
-            module.to_mut().to_string()
-        };
+        let module = get_str(py, module);
 
         let mut names_ = vec!();
         for alias in names.iter(py).unwrap() {
--- a/src/ast_dump.rs
+++ b/src/ast_dump.rs
@@ -46,10 +46,9 @@ impl Expr {
                 arguments.join(", ")
             }),
             Expr::Alias(name, asname) => {
-                if asname.is_empty() {
-                    format!("{}", name)
-                } else {
-                    format!("{} as {}", name, asname)
+                match asname {
+                    None => format!("{}", name),
+                    Some(asname) => format!("{} as {}", name, asname)
                 }
             }
             Expr::Name(name) => format!("{}", name),
--- a/src/python_ast.rs
+++ b/src/python_ast.rs
@@ -21,7 +21,7 @@ pub enum Expr {
     BinOp(Box<Expr>, BinOp, Box<Expr>),
     Compare(Box<Expr>, Vec<BinOp>, Vec<Expr>),
     Call(Box<Expr>, Vec<Expr>),
-    Alias(String, String),
+    Alias(String, Option<String>),
     Name(String),
     NameConstant(String),
     Str(String),
--- a/src/python_dump.rs
+++ b/src/python_dump.rs
@@ -52,6 +52,12 @@ fn dump(py: Python, indent: usize, ast: 
     };
     */
 
+    fn get_str(py: Python, object: PyObject) -> String {
+        let pystring = object.str(py).unwrap();
+        let mut string = pystring.to_string(py).unwrap();
+        string.to_mut().to_string()
+    }
+
     if is_instance(&ast, &function_def_type) {
         let name = ast.getattr(py, "name").unwrap();
         let args = ast.getattr(py, "args").unwrap();
@@ -181,17 +187,8 @@ fn dump(py: Python, indent: usize, ast: 
         let name = ast.getattr(py, "name").unwrap();
         let asname = ast.getattr(py, "asname").unwrap();
 
-        let name = {
-            let name = name.str(py).unwrap();
-            let mut name = name.to_string(py).unwrap();
-            name.to_mut().to_string()
-        };
-
-        let asname = {
-            let asname = asname.str(py).unwrap();
-            let mut asname = asname.to_string(py).unwrap();
-            asname.to_mut().to_string()
-        };
+        let name = get_str(py, name);
+        let asname = get_str(py, asname);
 
         if asname == "None" {
             format!("{}", name)