Mercurial > python-compiler.rs
annotate src/ast_convert.rs @ 9:fa7e285f88e7
Add a scoping pass, associating each module/statement with a block.
| author | Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> |
|---|---|
| date | Wed, 01 Jun 2016 22:17:28 +0100 |
| parents | 94ff501bf336 |
| children | 38b0d63697b1 |
| rev | line source |
|---|---|
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
1 use python_ast::{Module, Statement, Expr, BinOp, UnaryOp}; |
| 0 | 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 |
|
9
fa7e285f88e7
Add a scoping pass, associating each module/statement with a block.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
8
diff
changeset
|
12 fn parse_expr_vec(py: Python, ast: PyObject) -> Vec<String> { |
| 0 | 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() { | |
|
9
fa7e285f88e7
Add a scoping pass, associating each module/statement with a block.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
8
diff
changeset
|
30 let arg = arg.unwrap(); |
|
fa7e285f88e7
Add a scoping pass, associating each module/statement with a block.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
8
diff
changeset
|
31 let arg = parse_expr(py, arg); |
|
fa7e285f88e7
Add a scoping pass, associating each module/statement with a block.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
8
diff
changeset
|
32 arguments.push(match arg { |
|
fa7e285f88e7
Add a scoping pass, associating each module/statement with a block.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
8
diff
changeset
|
33 Expr::Name(arg) => arg, |
|
fa7e285f88e7
Add a scoping pass, associating each module/statement with a block.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
8
diff
changeset
|
34 _ => panic!() |
|
fa7e285f88e7
Add a scoping pass, associating each module/statement with a block.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
8
diff
changeset
|
35 }); |
| 0 | 36 } |
| 37 arguments | |
| 38 } else { | |
|
9
fa7e285f88e7
Add a scoping pass, associating each module/statement with a block.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
8
diff
changeset
|
39 panic!() |
| 0 | 40 } |
| 41 } | |
| 42 | |
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
43 fn parse_unaryop(py: Python, ast: PyObject) -> UnaryOp { |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
44 let builtins_module = py.import("builtins").unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
45 let isinstance = builtins_module.get(py, "isinstance").unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
46 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
47 let is_instance = |object: &PyObject, type_: &PyObject| { |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
48 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
49 }; |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
50 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
51 let ast_module = py.import("ast").unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
52 let ast_type = ast_module.get(py, "AST").unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
53 let uadd_type = ast_module.get(py, "UAdd").unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
54 let usub_type = ast_module.get(py, "USub").unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
55 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
56 assert!(is_instance(&ast, &ast_type)); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
57 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
58 if is_instance(&ast, &uadd_type) { |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
59 UnaryOp::UAdd |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
60 } else if is_instance(&ast, &usub_type) { |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
61 UnaryOp::USub |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
62 } else { |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
63 println!("UnaryOp {}", ast); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
64 UnaryOp::Error |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
65 } |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
66 } |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
67 |
| 0 | 68 fn parse_binop(py: Python, ast: PyObject) -> BinOp { |
| 69 let builtins_module = py.import("builtins").unwrap(); | |
| 70 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 71 | |
| 72 let is_instance = |object: &PyObject, type_: &PyObject| { | |
| 73 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); | |
| 74 }; | |
| 75 | |
| 76 let ast_module = py.import("ast").unwrap(); | |
| 77 let ast_type = ast_module.get(py, "AST").unwrap(); | |
| 78 let add_type = ast_module.get(py, "Add").unwrap(); | |
| 79 let mult_type = ast_module.get(py, "Mult").unwrap(); | |
| 80 let eq_type = ast_module.get(py, "Eq").unwrap(); | |
| 81 let lt_type = ast_module.get(py, "Lt").unwrap(); | |
|
6
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
82 let gt_type = ast_module.get(py, "Gt").unwrap(); |
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
83 let sub_type = ast_module.get(py, "Sub").unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
84 let div_type = ast_module.get(py, "Div").unwrap(); |
| 0 | 85 |
| 86 assert!(is_instance(&ast, &ast_type)); | |
| 87 | |
| 88 if is_instance(&ast, &add_type) { | |
| 89 BinOp::BinAdd | |
| 90 } else if is_instance(&ast, &mult_type) { | |
| 91 BinOp::BinMult | |
| 92 } else if is_instance(&ast, &eq_type) { | |
| 93 BinOp::BinEq | |
| 94 } else if is_instance(&ast, <_type) { | |
| 95 BinOp::BinLt | |
|
6
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
96 } else if is_instance(&ast, >_type) { |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
97 BinOp::BinGt |
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
98 } else if is_instance(&ast, &sub_type) { |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
99 BinOp::Sub |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
100 } else if is_instance(&ast, &div_type) { |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
101 BinOp::Div |
| 0 | 102 } else { |
| 103 println!("BinOp {}", ast); | |
| 104 BinOp::Error | |
| 105 } | |
| 106 } | |
| 107 | |
| 108 fn parse_expr(py: Python, ast: PyObject) -> Expr { | |
| 109 let builtins_module = py.import("builtins").unwrap(); | |
| 110 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 111 | |
| 112 let is_instance = |object: &PyObject, type_: &PyObject| { | |
| 113 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); | |
| 114 }; | |
| 115 | |
| 116 let ast_module = py.import("ast").unwrap(); | |
| 117 let ast_type = ast_module.get(py, "AST").unwrap(); | |
| 118 let arg_type = ast_module.get(py, "arg").unwrap(); | |
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
119 let unary_op_type = ast_module.get(py, "UnaryOp").unwrap(); |
| 0 | 120 let bin_op_type = ast_module.get(py, "BinOp").unwrap(); |
| 121 let name_constant_type = ast_module.get(py, "NameConstant").unwrap(); | |
|
4
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
122 let attribute_type = ast_module.get(py, "Attribute").unwrap(); |
| 0 | 123 let name_type = ast_module.get(py, "Name").unwrap(); |
| 124 let num_type = ast_module.get(py, "Num").unwrap(); | |
| 125 let str_type = ast_module.get(py, "Str").unwrap(); | |
|
7
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
126 let list_type = ast_module.get(py, "List").unwrap(); |
| 0 | 127 let compare_type = ast_module.get(py, "Compare").unwrap(); |
| 128 let call_type = ast_module.get(py, "Call").unwrap(); | |
| 129 let alias_type = ast_module.get(py, "alias").unwrap(); | |
| 130 | |
| 131 assert!(is_instance(&ast, &ast_type)); | |
| 132 | |
| 133 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
|
134 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
|
135 let arg = get_str(py, arg); |
| 0 | 136 Expr::Name(arg) |
|
4
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
137 } else if is_instance(&ast, &attribute_type) { |
|
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
138 let value = ast.getattr(py, "value").unwrap(); |
|
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
139 let attr = ast.getattr(py, "attr").unwrap(); |
|
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
140 |
|
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
141 let value = parse_expr(py, value); |
|
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
142 let attr = get_str(py, attr); |
|
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
143 |
|
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
144 Expr::Attribute(Box::new(value), attr) |
| 0 | 145 } 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
|
146 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
|
147 let id = get_str(py, id); |
| 0 | 148 Expr::Name(id) |
| 149 } 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
|
150 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
|
151 let value = get_str(py, value); |
| 0 | 152 Expr::NameConstant(value) |
| 153 } 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
|
154 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
|
155 let n = get_str(py, n); |
| 0 | 156 Expr::Num(n) |
| 157 } 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
|
158 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
|
159 let s = get_str(py, s); |
| 0 | 160 Expr::Str(s) |
|
7
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
161 } else if is_instance(&ast, &list_type) { |
|
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
162 let elts = ast.getattr(py, "elts").unwrap(); |
|
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
163 |
|
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
164 let mut elements = vec!(); |
|
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
165 for elt in elts.iter(py).unwrap() { |
|
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
166 let elt = elt.unwrap(); |
|
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
167 elements.push(parse_expr(py, elt)); |
|
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
168 } |
|
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
169 |
|
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
170 Expr::List(elements) |
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
171 } else if is_instance(&ast, &unary_op_type) { |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
172 let op = ast.getattr(py, "op").unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
173 let operand = ast.getattr(py, "operand").unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
174 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
175 let op = parse_unaryop(py, op); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
176 let operand = parse_expr(py, operand); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
177 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
178 Expr::UnaryOp(op, Box::new(operand)) |
| 0 | 179 } else if is_instance(&ast, &bin_op_type) { |
| 180 let left = ast.getattr(py, "left").unwrap(); | |
| 181 let op = ast.getattr(py, "op").unwrap(); | |
| 182 let right = ast.getattr(py, "right").unwrap(); | |
| 183 | |
| 184 let left = parse_expr(py, left); | |
| 185 let op = parse_binop(py, op); | |
| 186 let right = parse_expr(py, right); | |
| 187 | |
| 188 Expr::BinOp(Box::new(left), op, Box::new(right)) | |
| 189 } else if is_instance(&ast, &call_type) { | |
| 190 let func = ast.getattr(py, "func").unwrap(); | |
| 191 let args = ast.getattr(py, "args").unwrap(); | |
| 192 //let keywords = ast.getattr(py, "keywords").unwrap(); | |
| 193 | |
| 194 let func = parse_expr(py, func); | |
| 195 | |
| 196 let mut arguments = vec!(); | |
| 197 for arg in args.iter(py).unwrap() { | |
| 198 let arg = arg.unwrap(); | |
| 199 arguments.push(parse_expr(py, arg)); | |
| 200 } | |
| 201 | |
| 202 Expr::Call(Box::new(func), arguments) | |
| 203 } else if is_instance(&ast, &alias_type) { | |
| 204 let name = ast.getattr(py, "name").unwrap(); | |
| 205 let asname = ast.getattr(py, "asname").unwrap(); | |
| 206 | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
207 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
|
208 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
|
209 None |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
210 } else { |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
211 Some(get_str(py, asname)) |
| 0 | 212 }; |
| 213 | |
| 214 Expr::Alias(name, asname) | |
| 215 } else if is_instance(&ast, &compare_type) { | |
| 216 let left = ast.getattr(py, "left").unwrap(); | |
| 217 let ops = ast.getattr(py, "ops").unwrap(); | |
| 218 let comparators = ast.getattr(py, "comparators").unwrap(); | |
| 219 | |
| 220 let left = parse_expr(py, left); | |
| 221 let ops = ops.iter(py).unwrap(); | |
| 222 let comparators = comparators.iter(py).unwrap(); | |
| 223 | |
| 224 let mut new_ops = vec!(); | |
| 225 for op in ops { | |
| 226 let op = op.unwrap(); | |
| 227 let op = parse_binop(py, op); | |
| 228 new_ops.push(op); | |
| 229 } | |
| 230 | |
| 231 let mut new_comparators = vec!(); | |
| 232 for comparator in comparators { | |
| 233 let comparator = comparator.unwrap(); | |
| 234 let comparator = parse_expr(py, comparator); | |
| 235 new_comparators.push(comparator); | |
| 236 } | |
| 237 | |
| 238 Expr::Compare(Box::new(left), new_ops, new_comparators) | |
| 239 } else { | |
| 240 println!("Expr {}", ast); | |
| 241 Expr::Error | |
| 242 } | |
| 243 } | |
| 244 | |
| 245 fn parse_statement(py: Python, ast: PyObject) -> Statement { | |
| 246 //Statement::FunctionDef(Expr::Name("function".to_string()), vec!(Expr::Name("a".to_string()), Expr::Name("b".to_string())), vec!()) | |
| 247 //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)))))) | |
| 248 | |
| 249 let builtins_module = py.import("builtins").unwrap(); | |
| 250 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 251 | |
| 252 let is_instance = |object: &PyObject, type_: &PyObject| { | |
| 253 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); | |
| 254 }; | |
| 255 | |
| 256 let ast_module = py.import("ast").unwrap(); | |
| 257 let ast_type = ast_module.get(py, "AST").unwrap(); | |
|
2
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
258 let class_def_type = ast_module.get(py, "ClassDef").unwrap(); |
| 0 | 259 let function_def_type = ast_module.get(py, "FunctionDef").unwrap(); |
| 260 let global_type = ast_module.get(py, "Global").unwrap(); | |
| 261 let assign_type = ast_module.get(py, "Assign").unwrap(); | |
|
8
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
262 let aug_assign_type = ast_module.get(py, "AugAssign").unwrap(); |
| 0 | 263 let return_type = ast_module.get(py, "Return").unwrap(); |
| 264 let import_from_type = ast_module.get(py, "ImportFrom").unwrap(); | |
| 265 let if_type = ast_module.get(py, "If").unwrap(); | |
|
6
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
266 let while_type = ast_module.get(py, "While").unwrap(); |
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
267 let for_type = ast_module.get(py, "For").unwrap(); |
| 0 | 268 let expr_type = ast_module.get(py, "Expr").unwrap(); |
|
6
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
269 let break_type = ast_module.get(py, "Break").unwrap(); |
| 0 | 270 |
| 271 assert!(is_instance(&ast, &ast_type)); | |
| 272 | |
| 273 /* | |
| 274 // TODO: implement Hash for PyObject. (trivial) | |
| 275 let map = { | |
| 276 let fields = ast.getattr(py, "_fields").unwrap(); | |
| 277 let mut map = HashMap::new(); | |
| 278 for field in fields.iter(py).unwrap() { | |
| 279 let field = field.unwrap(); | |
| 280 let value = ast.getattr(py, field).unwrap(); | |
| 281 map.insert(field, value); | |
| 282 } | |
| 283 map | |
| 284 }; | |
| 285 */ | |
| 286 | |
|
2
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
287 if is_instance(&ast, &class_def_type) { |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
288 let name = ast.getattr(py, "name").unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
289 let bases = ast.getattr(py, "bases").unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
290 //let keywords = ast.getattr(py, "keywords").unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
291 let body = ast.getattr(py, "body").unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
292 //let decorator_list = ast.getattr(py, "decorator_list").unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
293 |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
294 let name = get_str(py, name); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
295 |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
296 let mut nodes = vec!(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
297 for name_node in bases.iter(py).unwrap() { |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
298 let name_node = name_node.unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
299 let name_node = parse_expr(py, name_node); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
300 nodes.push(name_node); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
301 } |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
302 |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
303 let mut statements = vec!(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
304 for statement in body.iter(py).unwrap() { |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
305 let statement = statement.unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
306 let statement = parse_statement(py, statement); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
307 statements.push(statement); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
308 } |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
309 |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
310 Statement::ClassDef(name, nodes, statements) |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
311 } else if is_instance(&ast, &function_def_type) { |
| 0 | 312 let name = ast.getattr(py, "name").unwrap(); |
| 313 let args = ast.getattr(py, "args").unwrap(); | |
| 314 let body = ast.getattr(py, "body").unwrap(); | |
| 315 | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
316 let name = get_str(py, name); |
| 0 | 317 let args = parse_expr_vec(py, args); |
| 318 /* | |
| 319 let mut arguments = vec!(); | |
| 320 for arg in args.iter(py).unwrap() { | |
| 321 let arg = parse_expr(py, arg.unwrap()); | |
| 322 arguments.push(arg); | |
| 323 } | |
| 324 */ | |
| 325 | |
| 326 let mut statements = vec!(); | |
| 327 for statement in body.iter(py).unwrap() { | |
| 328 let statement = parse_statement(py, statement.unwrap()); | |
| 329 statements.push(statement); | |
| 330 } | |
| 331 | |
|
3
326d7f2a94d4
Remove useless abstraction of function name as Expr.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
2
diff
changeset
|
332 Statement::FunctionDef(name, args, statements) |
| 0 | 333 } else if is_instance(&ast, &global_type) { |
| 334 let names = ast.getattr(py, "names").unwrap(); | |
| 335 | |
| 336 let mut globals = vec!(); | |
| 337 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
|
338 let name = name.unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
339 let name = get_str(py, name); |
| 0 | 340 globals.push(name); |
| 341 } | |
| 342 | |
| 343 Statement::Global(globals) | |
| 344 } else if is_instance(&ast, &if_type) { | |
| 345 let test = ast.getattr(py, "test").unwrap(); | |
| 346 let body = ast.getattr(py, "body").unwrap(); | |
| 347 let orelse = ast.getattr(py, "orelse").unwrap(); | |
| 348 | |
| 349 let test = parse_expr(py, test); | |
| 350 | |
| 351 let mut statements = vec!(); | |
| 352 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
|
353 let statement = statement.unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
354 let statement = parse_statement(py, statement); |
| 0 | 355 statements.push(statement); |
| 356 } | |
| 357 | |
| 358 let mut orelse_ = vec!(); | |
| 359 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
|
360 let statement = statement.unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
361 let statement = parse_statement(py, statement); |
| 0 | 362 orelse_.push(statement); |
| 363 } | |
| 364 | |
| 365 Statement::If(test, statements, orelse_) | |
|
6
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
366 } else if is_instance(&ast, &while_type) { |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
367 let test = ast.getattr(py, "test").unwrap(); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
368 let body = ast.getattr(py, "body").unwrap(); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
369 let orelse = ast.getattr(py, "orelse").unwrap(); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
370 |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
371 let test = parse_expr(py, test); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
372 |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
373 let mut statements = vec!(); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
374 for statement in body.iter(py).unwrap() { |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
375 let statement = statement.unwrap(); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
376 let statement = parse_statement(py, statement); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
377 statements.push(statement); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
378 } |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
379 |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
380 let mut orelse_ = vec!(); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
381 for statement in orelse.iter(py).unwrap() { |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
382 let statement = statement.unwrap(); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
383 let statement = parse_statement(py, statement); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
384 orelse_.push(statement); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
385 } |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
386 |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
387 Statement::While(test, statements, orelse_) |
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
388 } else if is_instance(&ast, &for_type) { |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
389 let target = ast.getattr(py, "target").unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
390 let iter = ast.getattr(py, "iter").unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
391 let body = ast.getattr(py, "body").unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
392 let orelse = ast.getattr(py, "orelse").unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
393 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
394 let target = parse_expr(py, target); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
395 let iter = parse_expr(py, iter); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
396 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
397 let mut statements = vec!(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
398 for statement in body.iter(py).unwrap() { |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
399 let statement = statement.unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
400 let statement = parse_statement(py, statement); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
401 statements.push(statement); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
402 } |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
403 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
404 let mut orelse_ = vec!(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
405 for statement in orelse.iter(py).unwrap() { |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
406 let statement = statement.unwrap(); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
407 let statement = parse_statement(py, statement); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
408 orelse_.push(statement); |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
409 } |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
410 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
411 Statement::For(target, iter, statements, orelse_) |
| 0 | 412 } else if is_instance(&ast, &assign_type) { |
| 413 let targets = ast.getattr(py, "targets").unwrap(); | |
| 414 let value = ast.getattr(py, "value").unwrap(); | |
| 415 | |
| 416 let mut arguments = vec!(); | |
| 417 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
|
418 let target = target.unwrap(); |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
419 let target = parse_expr(py, target); |
| 0 | 420 arguments.push(target); |
| 421 } | |
| 422 | |
| 423 let value = parse_expr(py, value); | |
| 424 | |
| 425 Statement::Assign(arguments, value) | |
|
8
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
426 } else if is_instance(&ast, &aug_assign_type) { |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
427 let target = ast.getattr(py, "target").unwrap(); |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
428 let op = ast.getattr(py, "op").unwrap(); |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
429 let value = ast.getattr(py, "value").unwrap(); |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
430 |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
431 let target = parse_expr(py, target); |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
432 let op = parse_binop(py, op); |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
433 let value = parse_expr(py, value); |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
434 |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
435 Statement::AugAssign(target, op, value) |
| 0 | 436 } else if is_instance(&ast, &import_from_type) { |
| 437 let module = ast.getattr(py, "module").unwrap(); | |
| 438 let names = ast.getattr(py, "names").unwrap(); | |
| 439 //let level = ast.getattr(py, "level").unwrap(); | |
| 440 | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
441 let module = get_str(py, module); |
| 0 | 442 |
| 443 let mut names_ = vec!(); | |
| 444 for alias in names.iter(py).unwrap() { | |
| 445 let alias = alias.unwrap(); | |
| 446 let alias = parse_expr(py, alias); | |
| 447 names_.push(alias); | |
| 448 } | |
| 449 | |
| 450 Statement::ImportFrom(module, names_) | |
| 451 } else if is_instance(&ast, &return_type) { | |
| 452 let value = ast.getattr(py, "value").unwrap(); | |
| 453 let value = parse_expr(py, value); | |
| 454 Statement::Return(value) | |
| 455 } else if is_instance(&ast, &expr_type) { | |
| 456 let value = ast.getattr(py, "value").unwrap(); | |
| 457 let value = parse_expr(py, value); | |
| 458 Statement::Expr(value) | |
|
6
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
459 } else if is_instance(&ast, &break_type) { |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
460 Statement::Break |
| 0 | 461 } else { |
| 462 println!("Statement {}", ast); | |
| 463 Statement::Error | |
| 464 } | |
| 465 } | |
| 466 | |
| 467 #[allow(dead_code)] | |
| 468 pub fn convert_ast(name: String, module: &PyObject) -> Module { | |
| 469 let gil = Python::acquire_gil(); | |
| 470 let py = gil.python(); | |
| 471 | |
| 472 let builtins_module = py.import("builtins").unwrap(); | |
| 473 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 474 | |
| 475 let ast_module = py.import("ast").unwrap(); | |
| 476 let module_type = ast_module.get(py, "Module").unwrap(); | |
| 477 | |
| 478 assert!(isinstance.call(py, (module, module_type), None).unwrap().is_true(py).unwrap()); | |
| 479 | |
| 480 let body = module.getattr(py, "body").unwrap(); | |
| 481 let mut statements = vec!(); | |
| 482 for statement in body.iter(py).unwrap() { | |
| 483 let statement = parse_statement(py, statement.unwrap()); | |
| 484 statements.push(statement) | |
| 485 } | |
| 486 Module{name: name, statements: statements} | |
| 487 } |