Mercurial > python-compiler.rs
annotate src/ast_convert.rs @ 2:5fc7c2790d8c
Add class support.
| author | Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> |
|---|---|
| date | Tue, 31 May 2016 02:31:55 +0100 |
| parents | b90e49ab734b |
| children | 326d7f2a94d4 |
| rev | line source |
|---|---|
| 0 | 1 use python_ast::{Module, Statement, Expr, BinOp}; |
| 2 | |
| 3 use cpython::{Python, PyObject}; | |
| 4 use cpython::ObjectProtocol; //for call method | |
| 5 | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
6 fn get_str(py: Python, object: PyObject) -> String { |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
7 let pystring = object.str(py).unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
8 let mut string = pystring.to_string(py).unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
9 string.to_mut().to_string() |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
10 } |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
11 |
| 0 | 12 fn parse_expr_vec(py: Python, ast: PyObject) -> Vec<Expr> { |
| 13 let builtins_module = py.import("builtins").unwrap(); | |
| 14 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 15 | |
| 16 let is_instance = |object: &PyObject, type_: &PyObject| { | |
| 17 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); | |
| 18 }; | |
| 19 | |
| 20 let ast_module = py.import("ast").unwrap(); | |
| 21 let ast_type = ast_module.get(py, "AST").unwrap(); | |
| 22 let arguments_type = ast_module.get(py, "arguments").unwrap(); | |
| 23 | |
| 24 assert!(is_instance(&ast, &ast_type)); | |
| 25 | |
| 26 if is_instance(&ast, &arguments_type) { | |
| 27 let args = ast.getattr(py, "args").unwrap(); | |
| 28 let mut arguments = vec!(); | |
| 29 for arg in args.iter(py).unwrap() { | |
| 30 let arg = parse_expr(py, arg.unwrap()); | |
| 31 arguments.push(arg); | |
| 32 } | |
| 33 arguments | |
| 34 } else { | |
| 35 vec!(Expr::Error) | |
| 36 } | |
| 37 } | |
| 38 | |
| 39 fn parse_binop(py: Python, ast: PyObject) -> BinOp { | |
| 40 let builtins_module = py.import("builtins").unwrap(); | |
| 41 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 42 | |
| 43 let is_instance = |object: &PyObject, type_: &PyObject| { | |
| 44 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); | |
| 45 }; | |
| 46 | |
| 47 let ast_module = py.import("ast").unwrap(); | |
| 48 let ast_type = ast_module.get(py, "AST").unwrap(); | |
| 49 let add_type = ast_module.get(py, "Add").unwrap(); | |
| 50 let mult_type = ast_module.get(py, "Mult").unwrap(); | |
| 51 let eq_type = ast_module.get(py, "Eq").unwrap(); | |
| 52 let lt_type = ast_module.get(py, "Lt").unwrap(); | |
| 53 | |
| 54 assert!(is_instance(&ast, &ast_type)); | |
| 55 | |
| 56 if is_instance(&ast, &add_type) { | |
| 57 BinOp::BinAdd | |
| 58 } else if is_instance(&ast, &mult_type) { | |
| 59 BinOp::BinMult | |
| 60 } else if is_instance(&ast, &eq_type) { | |
| 61 BinOp::BinEq | |
| 62 } else if is_instance(&ast, <_type) { | |
| 63 BinOp::BinLt | |
| 64 } else { | |
| 65 println!("BinOp {}", ast); | |
| 66 BinOp::Error | |
| 67 } | |
| 68 } | |
| 69 | |
| 70 fn parse_expr(py: Python, ast: PyObject) -> Expr { | |
| 71 let builtins_module = py.import("builtins").unwrap(); | |
| 72 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 73 | |
| 74 let is_instance = |object: &PyObject, type_: &PyObject| { | |
| 75 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); | |
| 76 }; | |
| 77 | |
| 78 let ast_module = py.import("ast").unwrap(); | |
| 79 let ast_type = ast_module.get(py, "AST").unwrap(); | |
| 80 let arg_type = ast_module.get(py, "arg").unwrap(); | |
| 81 let bin_op_type = ast_module.get(py, "BinOp").unwrap(); | |
| 82 let name_constant_type = ast_module.get(py, "NameConstant").unwrap(); | |
| 83 let name_type = ast_module.get(py, "Name").unwrap(); | |
| 84 let num_type = ast_module.get(py, "Num").unwrap(); | |
| 85 let str_type = ast_module.get(py, "Str").unwrap(); | |
| 86 let compare_type = ast_module.get(py, "Compare").unwrap(); | |
| 87 let call_type = ast_module.get(py, "Call").unwrap(); | |
| 88 let alias_type = ast_module.get(py, "alias").unwrap(); | |
| 89 | |
| 90 assert!(is_instance(&ast, &ast_type)); | |
| 91 | |
| 92 if is_instance(&ast, &arg_type) { | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
93 let arg = ast.getattr(py, "arg").unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
94 let arg = get_str(py, arg); |
| 0 | 95 Expr::Name(arg) |
| 96 } else if is_instance(&ast, &name_type) { | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
97 let id = ast.getattr(py, "id").unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
98 let id = get_str(py, id); |
| 0 | 99 Expr::Name(id) |
| 100 } else if is_instance(&ast, &name_constant_type) { | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
101 let value = ast.getattr(py, "value").unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
102 let value = get_str(py, value); |
| 0 | 103 Expr::NameConstant(value) |
| 104 } else if is_instance(&ast, &num_type) { | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
105 let n = ast.getattr(py, "n").unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
106 let n = get_str(py, n); |
| 0 | 107 Expr::Num(n) |
| 108 } else if is_instance(&ast, &str_type) { | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
109 let s = ast.getattr(py, "s").unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
110 let s = get_str(py, s); |
| 0 | 111 Expr::Str(s) |
| 112 } else if is_instance(&ast, &bin_op_type) { | |
| 113 let left = ast.getattr(py, "left").unwrap(); | |
| 114 let op = ast.getattr(py, "op").unwrap(); | |
| 115 let right = ast.getattr(py, "right").unwrap(); | |
| 116 | |
| 117 let left = parse_expr(py, left); | |
| 118 let op = parse_binop(py, op); | |
| 119 let right = parse_expr(py, right); | |
| 120 | |
| 121 Expr::BinOp(Box::new(left), op, Box::new(right)) | |
| 122 } else if is_instance(&ast, &call_type) { | |
| 123 let func = ast.getattr(py, "func").unwrap(); | |
| 124 let args = ast.getattr(py, "args").unwrap(); | |
| 125 //let keywords = ast.getattr(py, "keywords").unwrap(); | |
| 126 | |
| 127 let func = parse_expr(py, func); | |
| 128 | |
| 129 let mut arguments = vec!(); | |
| 130 for arg in args.iter(py).unwrap() { | |
| 131 let arg = arg.unwrap(); | |
| 132 arguments.push(parse_expr(py, arg)); | |
| 133 } | |
| 134 | |
| 135 Expr::Call(Box::new(func), arguments) | |
| 136 } else if is_instance(&ast, &alias_type) { | |
| 137 let name = ast.getattr(py, "name").unwrap(); | |
| 138 let asname = ast.getattr(py, "asname").unwrap(); | |
| 139 | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
140 let name = get_str(py, name); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
141 let asname = if asname == py.None() { |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
142 None |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
143 } else { |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
144 Some(get_str(py, asname)) |
| 0 | 145 }; |
| 146 | |
| 147 Expr::Alias(name, asname) | |
| 148 } else if is_instance(&ast, &compare_type) { | |
| 149 let left = ast.getattr(py, "left").unwrap(); | |
| 150 let ops = ast.getattr(py, "ops").unwrap(); | |
| 151 let comparators = ast.getattr(py, "comparators").unwrap(); | |
| 152 | |
| 153 let left = parse_expr(py, left); | |
| 154 let ops = ops.iter(py).unwrap(); | |
| 155 let comparators = comparators.iter(py).unwrap(); | |
| 156 | |
| 157 let mut new_ops = vec!(); | |
| 158 for op in ops { | |
| 159 let op = op.unwrap(); | |
| 160 let op = parse_binop(py, op); | |
| 161 new_ops.push(op); | |
| 162 } | |
| 163 | |
| 164 let mut new_comparators = vec!(); | |
| 165 for comparator in comparators { | |
| 166 let comparator = comparator.unwrap(); | |
| 167 let comparator = parse_expr(py, comparator); | |
| 168 new_comparators.push(comparator); | |
| 169 } | |
| 170 | |
| 171 Expr::Compare(Box::new(left), new_ops, new_comparators) | |
| 172 } else { | |
| 173 println!("Expr {}", ast); | |
| 174 Expr::Error | |
| 175 } | |
| 176 } | |
| 177 | |
| 178 fn parse_statement(py: Python, ast: PyObject) -> Statement { | |
| 179 //Statement::FunctionDef(Expr::Name("function".to_string()), vec!(Expr::Name("a".to_string()), Expr::Name("b".to_string())), vec!()) | |
| 180 //Statement::If(Expr::BinOp(BinOp::BinEq, Box::new(Expr::Name("__name__".to_string())), Box::new(Expr::Str("__main__".to_string()))), vec!(Statement::Expr(Expr::Call(Box::new(Expr::Name("function".to_string())), vec!(Expr::Num(1), Expr::Num(2)))))) | |
| 181 | |
| 182 let builtins_module = py.import("builtins").unwrap(); | |
| 183 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 184 | |
| 185 let is_instance = |object: &PyObject, type_: &PyObject| { | |
| 186 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); | |
| 187 }; | |
| 188 | |
| 189 let ast_module = py.import("ast").unwrap(); | |
| 190 let ast_type = ast_module.get(py, "AST").unwrap(); | |
|
2
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
191 let class_def_type = ast_module.get(py, "ClassDef").unwrap(); |
| 0 | 192 let function_def_type = ast_module.get(py, "FunctionDef").unwrap(); |
| 193 let global_type = ast_module.get(py, "Global").unwrap(); | |
| 194 let assign_type = ast_module.get(py, "Assign").unwrap(); | |
| 195 let return_type = ast_module.get(py, "Return").unwrap(); | |
| 196 let import_from_type = ast_module.get(py, "ImportFrom").unwrap(); | |
| 197 let if_type = ast_module.get(py, "If").unwrap(); | |
| 198 let expr_type = ast_module.get(py, "Expr").unwrap(); | |
| 199 | |
| 200 assert!(is_instance(&ast, &ast_type)); | |
| 201 | |
| 202 /* | |
| 203 // TODO: implement Hash for PyObject. (trivial) | |
| 204 let map = { | |
| 205 let fields = ast.getattr(py, "_fields").unwrap(); | |
| 206 let mut map = HashMap::new(); | |
| 207 for field in fields.iter(py).unwrap() { | |
| 208 let field = field.unwrap(); | |
| 209 let value = ast.getattr(py, field).unwrap(); | |
| 210 map.insert(field, value); | |
| 211 } | |
| 212 map | |
| 213 }; | |
| 214 */ | |
| 215 | |
|
2
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
216 if is_instance(&ast, &class_def_type) { |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
217 let name = ast.getattr(py, "name").unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
218 let bases = ast.getattr(py, "bases").unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
219 //let keywords = ast.getattr(py, "keywords").unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
220 let body = ast.getattr(py, "body").unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
221 //let decorator_list = ast.getattr(py, "decorator_list").unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
222 |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
223 let name = get_str(py, name); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
224 |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
225 let mut nodes = vec!(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
226 for name_node in bases.iter(py).unwrap() { |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
227 let name_node = name_node.unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
228 let name_node = parse_expr(py, name_node); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
229 nodes.push(name_node); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
230 } |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
231 |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
232 let mut statements = vec!(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
233 for statement in body.iter(py).unwrap() { |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
234 let statement = statement.unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
235 let statement = parse_statement(py, statement); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
236 statements.push(statement); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
237 } |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
238 |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
239 Statement::ClassDef(name, nodes, statements) |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
240 } else if is_instance(&ast, &function_def_type) { |
| 0 | 241 let name = ast.getattr(py, "name").unwrap(); |
| 242 let args = ast.getattr(py, "args").unwrap(); | |
| 243 let body = ast.getattr(py, "body").unwrap(); | |
| 244 | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
245 let name = get_str(py, name); |
| 0 | 246 let args = parse_expr_vec(py, args); |
| 247 /* | |
| 248 let mut arguments = vec!(); | |
| 249 for arg in args.iter(py).unwrap() { | |
| 250 let arg = parse_expr(py, arg.unwrap()); | |
| 251 arguments.push(arg); | |
| 252 } | |
| 253 */ | |
| 254 | |
| 255 let mut statements = vec!(); | |
| 256 for statement in body.iter(py).unwrap() { | |
| 257 let statement = parse_statement(py, statement.unwrap()); | |
| 258 statements.push(statement); | |
| 259 } | |
| 260 | |
| 261 Statement::FunctionDef(Expr::Name(name), args, statements) | |
| 262 } else if is_instance(&ast, &global_type) { | |
| 263 let names = ast.getattr(py, "names").unwrap(); | |
| 264 | |
| 265 let mut globals = vec!(); | |
| 266 for name in names.iter(py).unwrap() { | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
267 let name = name.unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
268 let name = get_str(py, name); |
| 0 | 269 globals.push(name); |
| 270 } | |
| 271 | |
| 272 Statement::Global(globals) | |
| 273 } else if is_instance(&ast, &if_type) { | |
| 274 let test = ast.getattr(py, "test").unwrap(); | |
| 275 let body = ast.getattr(py, "body").unwrap(); | |
| 276 let orelse = ast.getattr(py, "orelse").unwrap(); | |
| 277 | |
| 278 let test = parse_expr(py, test); | |
| 279 | |
| 280 let mut statements = vec!(); | |
| 281 for statement in body.iter(py).unwrap() { | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
282 let statement = statement.unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
283 let statement = parse_statement(py, statement); |
| 0 | 284 statements.push(statement); |
| 285 } | |
| 286 | |
| 287 let mut orelse_ = vec!(); | |
| 288 for statement in orelse.iter(py).unwrap() { | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
289 let statement = statement.unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
290 let statement = parse_statement(py, statement); |
| 0 | 291 orelse_.push(statement); |
| 292 } | |
| 293 | |
| 294 Statement::If(test, statements, orelse_) | |
| 295 } else if is_instance(&ast, &assign_type) { | |
| 296 let targets = ast.getattr(py, "targets").unwrap(); | |
| 297 let value = ast.getattr(py, "value").unwrap(); | |
| 298 | |
| 299 let mut arguments = vec!(); | |
| 300 for target in targets.iter(py).unwrap() { | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
301 let target = target.unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
302 let target = parse_expr(py, target); |
| 0 | 303 arguments.push(target); |
| 304 } | |
| 305 | |
| 306 let value = parse_expr(py, value); | |
| 307 | |
| 308 Statement::Assign(arguments, value) | |
| 309 } else if is_instance(&ast, &import_from_type) { | |
| 310 let module = ast.getattr(py, "module").unwrap(); | |
| 311 let names = ast.getattr(py, "names").unwrap(); | |
| 312 //let level = ast.getattr(py, "level").unwrap(); | |
| 313 | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
314 let module = get_str(py, module); |
| 0 | 315 |
| 316 let mut names_ = vec!(); | |
| 317 for alias in names.iter(py).unwrap() { | |
| 318 let alias = alias.unwrap(); | |
| 319 let alias = parse_expr(py, alias); | |
| 320 names_.push(alias); | |
| 321 } | |
| 322 | |
| 323 Statement::ImportFrom(module, names_) | |
| 324 } else if is_instance(&ast, &return_type) { | |
| 325 let value = ast.getattr(py, "value").unwrap(); | |
| 326 let value = parse_expr(py, value); | |
| 327 Statement::Return(value) | |
| 328 } else if is_instance(&ast, &expr_type) { | |
| 329 let value = ast.getattr(py, "value").unwrap(); | |
| 330 let value = parse_expr(py, value); | |
| 331 Statement::Expr(value) | |
| 332 } else { | |
| 333 println!("Statement {}", ast); | |
| 334 Statement::Error | |
| 335 } | |
| 336 } | |
| 337 | |
| 338 #[allow(dead_code)] | |
| 339 pub fn convert_ast(name: String, module: &PyObject) -> Module { | |
| 340 let gil = Python::acquire_gil(); | |
| 341 let py = gil.python(); | |
| 342 | |
| 343 let builtins_module = py.import("builtins").unwrap(); | |
| 344 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 345 | |
| 346 let ast_module = py.import("ast").unwrap(); | |
| 347 let module_type = ast_module.get(py, "Module").unwrap(); | |
| 348 | |
| 349 assert!(isinstance.call(py, (module, module_type), None).unwrap().is_true(py).unwrap()); | |
| 350 | |
| 351 let body = module.getattr(py, "body").unwrap(); | |
| 352 let mut statements = vec!(); | |
| 353 for statement in body.iter(py).unwrap() { | |
| 354 let statement = parse_statement(py, statement.unwrap()); | |
| 355 statements.push(statement) | |
| 356 } | |
| 357 Module{name: name, statements: statements} | |
| 358 } |