Mercurial > python-compiler.rs

comparison src/ast_convert.rs @ 56:c3cc16b933d2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Implement function arguments of all kinds.
author Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
date Sun, 12 Jun 2016 03:48:24 +0100
parents 1a815946c2e5
children e5a808ec31c0
comparison
equal deleted inserted replaced
55:32c78b275d5a 56:c3cc16b933d2
249 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); 249 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap();
250 }; 250 };
251 251
252 let ast_module = py.import("ast").unwrap(); 252 let ast_module = py.import("ast").unwrap();
253 let ast_type = ast_module.get(py, "AST").unwrap(); 253 let ast_type = ast_module.get(py, "AST").unwrap();
254 let arg_type = ast_module.get(py, "arg").unwrap();
255 let unary_op_type = ast_module.get(py, "UnaryOp").unwrap(); 254 let unary_op_type = ast_module.get(py, "UnaryOp").unwrap();
256 let bool_op_type = ast_module.get(py, "BoolOp").unwrap(); 255 let bool_op_type = ast_module.get(py, "BoolOp").unwrap();
257 let bin_op_type = ast_module.get(py, "BinOp").unwrap(); 256 let bin_op_type = ast_module.get(py, "BinOp").unwrap();
258 let name_constant_type = ast_module.get(py, "NameConstant").unwrap(); 257 let name_constant_type = ast_module.get(py, "NameConstant").unwrap();
259 let attribute_type = ast_module.get(py, "Attribute").unwrap(); 258 let attribute_type = ast_module.get(py, "Attribute").unwrap();
268 let tuple_type = ast_module.get(py, "Tuple").unwrap(); 267 let tuple_type = ast_module.get(py, "Tuple").unwrap();
269 let ellipsis_type = ast_module.get(py, "Ellipsis").unwrap(); 268 let ellipsis_type = ast_module.get(py, "Ellipsis").unwrap();
270 269
271 assert!(is_instance(&ast, &ast_type)); 270 assert!(is_instance(&ast, &ast_type));
272 271
273 if is_instance(&ast, &arg_type) { 272 if is_instance(&ast, &attribute_type) {
274 let arg = ast.getattr(py, "arg").unwrap();
275 let arg = get_str(py, arg);
276 expr::Name(arg, get_ctx(py, ast))
277 } else if is_instance(&ast, &attribute_type) {
278 let value = ast.getattr(py, "value").unwrap(); 273 let value = ast.getattr(py, "value").unwrap();
279 let attr = ast.getattr(py, "attr").unwrap(); 274 let attr = ast.getattr(py, "attr").unwrap();
280 275
281 let value = parse_expr(py, value); 276 let value = parse_expr(py, value);
282 let attr = get_str(py, attr); 277 let attr = get_str(py, attr);
376 println!("expr {}", ast); 371 println!("expr {}", ast);
377 unreachable!() 372 unreachable!()
378 } 373 }
379 } 374 }
380 375
376 fn parse_arg(py: Python, ast: PyObject) -> arg {
377 let arg = ast.getattr(py, "arg").unwrap();
378 let annotation = ast.getattr(py, "annotation").unwrap();
379
380 let arg = get_str(py, arg);
381 let annotation = if annotation == py.None() {
382 None
383 } else {
384 Some(parse_expr(py, annotation))
385 };
386
387 arg{arg: arg, annotation: annotation}
388 }
389
381 fn parse_arguments(py: Python, ast: PyObject) -> arguments { 390 fn parse_arguments(py: Python, ast: PyObject) -> arguments {
382 let builtins_module = py.import("builtins").unwrap(); 391 let builtins_module = py.import("builtins").unwrap();
383 let isinstance = builtins_module.get(py, "isinstance").unwrap(); 392 let isinstance = builtins_module.get(py, "isinstance").unwrap();
384 393
385 let is_instance = |object: &PyObject, type_: &PyObject| { 394 let is_instance = |object: &PyObject, type_: &PyObject| {
400 let args = ast.getattr(py, "args").unwrap(); 409 let args = ast.getattr(py, "args").unwrap();
401 let mut arguments = vec!(); 410 let mut arguments = vec!();
402 for arg in args.iter(py).unwrap() { 411 for arg in args.iter(py).unwrap() {
403 let arg = arg.unwrap(); 412 let arg = arg.unwrap();
404 assert!(is_instance(&arg, &arg_type)); 413 assert!(is_instance(&arg, &arg_type));
405 let arg = get_str(py, arg); 414 let arg = parse_arg(py, arg);
406 arguments.push(arg{arg: arg, annotation: None}); 415 arguments.push(arg);
407 } 416 }
408 arguments 417 arguments
409 }, 418 },
410 //vararg: Option<arg>, 419 //vararg: Option<arg>,
411 vararg: None, 420 vararg: {
421 let vararg = ast.getattr(py, "vararg").unwrap();
422 if vararg == py.None() {
423 None
424 } else {
425 let arg = parse_arg(py, vararg);
426 Some(arg)
427 }
428 },
412 //kwonlyargs: Vec<arg>, 429 //kwonlyargs: Vec<arg>,
413 kwonlyargs: vec!(), 430 kwonlyargs: {
414 //kw_defaults: Vec<expr>, 431 let kwonlyargs = ast.getattr(py, "kwonlyargs").unwrap();
415 kw_defaults: vec!(), 432 let mut arguments = vec!();
433 for arg in kwonlyargs.iter(py).unwrap() {
434 let arg = arg.unwrap();
435 assert!(is_instance(&arg, &arg_type));
436 let arg = parse_arg(py, arg);
437 arguments.push(arg);
438 }
439 arguments
440 },
441 //kw_defaults: Vec<Option<expr>>,
442 kw_defaults: {
443 let kw_defaults = ast.getattr(py, "kw_defaults").unwrap();
444 let mut arguments = vec!();
445 for arg in kw_defaults.iter(py).unwrap() {
446 let arg = arg.unwrap();
447 let arg = if arg == py.None() {
448 None
449 } else {
450 Some(parse_expr(py, arg))
451 };
452 arguments.push(arg);
453 }
454 arguments
455 },
416 //kwarg: Option<arg>, 456 //kwarg: Option<arg>,
417 kwarg: None, 457 kwarg: {
458 let kwarg = ast.getattr(py, "kwarg").unwrap();
459 if kwarg == py.None() {
460 None
461 } else {
462 let arg = parse_arg(py, kwarg);
463 Some(arg)
464 }
465 },
418 //defaults: Vec<expr> 466 //defaults: Vec<expr>
419 defaults: vec!() 467 defaults: {
468 let defaults = ast.getattr(py, "defaults").unwrap();
469 let mut arguments = vec!();
470 for arg in defaults.iter(py).unwrap() {
471 let arg = arg.unwrap();
472 let arg = parse_expr(py, arg);
473 arguments.push(arg);
474 }
475 arguments
476 }
420 }; 477 };
421 args 478 args
422 } else { 479 } else {
423 println!("arguments {}", ast); 480 println!("arguments {}", ast);
424 panic!() 481 panic!()