Mercurial > python-compiler.rs

comparison src/ast_convert.rs @ 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
comparison
equal deleted inserted replaced
0:211b0df72e64 1:b90e49ab734b
1 use python_ast::{Module, Statement, Expr, BinOp}; 1 use python_ast::{Module, Statement, Expr, BinOp};
2 2
3 use cpython::{Python, PyObject}; 3 use cpython::{Python, PyObject};
4 use cpython::ObjectProtocol; //for call method 4 use cpython::ObjectProtocol; //for call method
5
6 fn get_str(py: Python, object: PyObject) -> String {
7 let pystring = object.str(py).unwrap();
8 let mut string = pystring.to_string(py).unwrap();
9 string.to_mut().to_string()
10 }
5 11
6 fn parse_expr_vec(py: Python, ast: PyObject) -> Vec<Expr> { 12 fn parse_expr_vec(py: Python, ast: PyObject) -> Vec<Expr> {
7 let builtins_module = py.import("builtins").unwrap(); 13 let builtins_module = py.import("builtins").unwrap();
8 let isinstance = builtins_module.get(py, "isinstance").unwrap(); 14 let isinstance = builtins_module.get(py, "isinstance").unwrap();
9 15
82 let alias_type = ast_module.get(py, "alias").unwrap(); 88 let alias_type = ast_module.get(py, "alias").unwrap();
83 89
84 assert!(is_instance(&ast, &ast_type)); 90 assert!(is_instance(&ast, &ast_type));
85 91
86 if is_instance(&ast, &arg_type) { 92 if is_instance(&ast, &arg_type) {
87 let arg = { 93 let arg = ast.getattr(py, "arg").unwrap();
88 let arg = ast.getattr(py, "arg").unwrap(); 94 let arg = get_str(py, arg);
89 let arg = arg.str(py).unwrap();
90 let mut arg = arg.to_string(py).unwrap();
91 arg.to_mut().to_string()
92 };
93 Expr::Name(arg) 95 Expr::Name(arg)
94 } else if is_instance(&ast, &name_type) { 96 } else if is_instance(&ast, &name_type) {
95 let id = { 97 let id = ast.getattr(py, "id").unwrap();
96 let id = ast.getattr(py, "id").unwrap(); 98 let id = get_str(py, id);
97 let id = id.str(py).unwrap();
98 let mut id = id.to_string(py).unwrap();
99 id.to_mut().to_string()
100 };
101 Expr::Name(id) 99 Expr::Name(id)
102 } else if is_instance(&ast, &name_constant_type) { 100 } else if is_instance(&ast, &name_constant_type) {
103 let value = { 101 let value = ast.getattr(py, "value").unwrap();
104 let value = ast.getattr(py, "value").unwrap(); 102 let value = get_str(py, value);
105 let value = value.str(py).unwrap();
106 let mut value = value.to_string(py).unwrap();
107 value.to_mut().to_string()
108 };
109 Expr::NameConstant(value) 103 Expr::NameConstant(value)
110 } else if is_instance(&ast, &num_type) { 104 } else if is_instance(&ast, &num_type) {
111 let n = { 105 let n = ast.getattr(py, "n").unwrap();
112 let n = ast.getattr(py, "n").unwrap(); 106 let n = get_str(py, n);
113 let n = n.str(py).unwrap();
114 let mut n = n.to_string(py).unwrap();
115 n.to_mut().to_string()
116 };
117 Expr::Num(n) 107 Expr::Num(n)
118 } else if is_instance(&ast, &str_type) { 108 } else if is_instance(&ast, &str_type) {
119 let s = { 109 let s = ast.getattr(py, "s").unwrap();
120 let s = ast.getattr(py, "s").unwrap(); 110 let s = get_str(py, s);
121 let s = s.str(py).unwrap();
122 let mut s = s.to_string(py).unwrap();
123 s.to_mut().to_string()
124 };
125 Expr::Str(s) 111 Expr::Str(s)
126 } else if is_instance(&ast, &bin_op_type) { 112 } else if is_instance(&ast, &bin_op_type) {
127 let left = ast.getattr(py, "left").unwrap(); 113 let left = ast.getattr(py, "left").unwrap();
128 let op = ast.getattr(py, "op").unwrap(); 114 let op = ast.getattr(py, "op").unwrap();
129 let right = ast.getattr(py, "right").unwrap(); 115 let right = ast.getattr(py, "right").unwrap();
149 Expr::Call(Box::new(func), arguments) 135 Expr::Call(Box::new(func), arguments)
150 } else if is_instance(&ast, &alias_type) { 136 } else if is_instance(&ast, &alias_type) {
151 let name = ast.getattr(py, "name").unwrap(); 137 let name = ast.getattr(py, "name").unwrap();
152 let asname = ast.getattr(py, "asname").unwrap(); 138 let asname = ast.getattr(py, "asname").unwrap();
153 139
154 let name = { 140 let name = get_str(py, name);
155 let name = name.str(py).unwrap(); 141 let asname = if asname == py.None() {
156 let mut name = name.to_string(py).unwrap(); 142 None
157 name.to_mut().to_string() 143 } else {
158 }; 144 Some(get_str(py, asname))
159
160 let asname = {
161 let asname = asname.str(py).unwrap();
162 let mut asname = asname.to_string(py).unwrap();
163 let asname = asname.to_mut().to_string();
164 if asname == "None" {
165 "".to_string()
166 } else {
167 asname
168 }
169 }; 145 };
170 146
171 Expr::Alias(name, asname) 147 Expr::Alias(name, asname)
172 } else if is_instance(&ast, &compare_type) { 148 } else if is_instance(&ast, &compare_type) {
173 let left = ast.getattr(py, "left").unwrap(); 149 let left = ast.getattr(py, "left").unwrap();
239 if is_instance(&ast, &function_def_type) { 215 if is_instance(&ast, &function_def_type) {
240 let name = ast.getattr(py, "name").unwrap(); 216 let name = ast.getattr(py, "name").unwrap();
241 let args = ast.getattr(py, "args").unwrap(); 217 let args = ast.getattr(py, "args").unwrap();
242 let body = ast.getattr(py, "body").unwrap(); 218 let body = ast.getattr(py, "body").unwrap();
243 219
244 let name = { 220 let name = get_str(py, name);
245 let name = name.str(py).unwrap();
246 let mut name = name.to_string(py).unwrap();
247 name.to_mut().to_string()
248 };
249
250 let args = parse_expr_vec(py, args); 221 let args = parse_expr_vec(py, args);
251 /* 222 /*
252 let mut arguments = vec!(); 223 let mut arguments = vec!();
253 for arg in args.iter(py).unwrap() { 224 for arg in args.iter(py).unwrap() {
254 let arg = parse_expr(py, arg.unwrap()); 225 let arg = parse_expr(py, arg.unwrap());
266 } else if is_instance(&ast, &global_type) { 237 } else if is_instance(&ast, &global_type) {
267 let names = ast.getattr(py, "names").unwrap(); 238 let names = ast.getattr(py, "names").unwrap();
268 239
269 let mut globals = vec!(); 240 let mut globals = vec!();
270 for name in names.iter(py).unwrap() { 241 for name in names.iter(py).unwrap() {
271 let name = { 242 let name = name.unwrap();
272 let name = name.unwrap().str(py).unwrap(); 243 let name = get_str(py, name);
273 let mut name = name.to_string(py).unwrap();
274 name.to_mut().to_string()
275 };
276 globals.push(name); 244 globals.push(name);
277 } 245 }
278 246
279 Statement::Global(globals) 247 Statement::Global(globals)
280 } else if is_instance(&ast, &if_type) { 248 } else if is_instance(&ast, &if_type) {
284 252
285 let test = parse_expr(py, test); 253 let test = parse_expr(py, test);
286 254
287 let mut statements = vec!(); 255 let mut statements = vec!();
288 for statement in body.iter(py).unwrap() { 256 for statement in body.iter(py).unwrap() {
289 let statement = parse_statement(py, statement.unwrap()); 257 let statement = statement.unwrap();
258 let statement = parse_statement(py, statement);
290 statements.push(statement); 259 statements.push(statement);
291 } 260 }
292 261
293 let mut orelse_ = vec!(); 262 let mut orelse_ = vec!();
294 for statement in orelse.iter(py).unwrap() { 263 for statement in orelse.iter(py).unwrap() {
295 let statement = parse_statement(py, statement.unwrap()); 264 let statement = statement.unwrap();
265 let statement = parse_statement(py, statement);
296 orelse_.push(statement); 266 orelse_.push(statement);
297 } 267 }
298 268
299 Statement::If(test, statements, orelse_) 269 Statement::If(test, statements, orelse_)
300 } else if is_instance(&ast, &assign_type) { 270 } else if is_instance(&ast, &assign_type) {
301 let targets = ast.getattr(py, "targets").unwrap(); 271 let targets = ast.getattr(py, "targets").unwrap();
302 let value = ast.getattr(py, "value").unwrap(); 272 let value = ast.getattr(py, "value").unwrap();
303 273
304 let mut arguments = vec!(); 274 let mut arguments = vec!();
305 for target in targets.iter(py).unwrap() { 275 for target in targets.iter(py).unwrap() {
306 let target = parse_expr(py, target.unwrap()); 276 let target = target.unwrap();
277 let target = parse_expr(py, target);
307 arguments.push(target); 278 arguments.push(target);
308 } 279 }
309 280
310 let value = parse_expr(py, value); 281 let value = parse_expr(py, value);
311 282
313 } else if is_instance(&ast, &import_from_type) { 284 } else if is_instance(&ast, &import_from_type) {
314 let module = ast.getattr(py, "module").unwrap(); 285 let module = ast.getattr(py, "module").unwrap();
315 let names = ast.getattr(py, "names").unwrap(); 286 let names = ast.getattr(py, "names").unwrap();
316 //let level = ast.getattr(py, "level").unwrap(); 287 //let level = ast.getattr(py, "level").unwrap();
317 288
318 let module = { 289 let module = get_str(py, module);
319 let module = module.str(py).unwrap();
320 let mut module = module.to_string(py).unwrap();
321 module.to_mut().to_string()
322 };
323 290
324 let mut names_ = vec!(); 291 let mut names_ = vec!();
325 for alias in names.iter(py).unwrap() { 292 for alias in names.iter(py).unwrap() {
326 let alias = alias.unwrap(); 293 let alias = alias.unwrap();
327 let alias = parse_expr(py, alias); 294 let alias = parse_expr(py, alias);