Mercurial > python-compiler.rs

comparison src/ast_convert.rs @ 20:ace12d6b9855

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Replace every loop in ast_convert with parse_list.
author Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
date Fri, 03 Jun 2016 01:22:12 +0100
parents 0cb53a31ac12
children 7af637f444d1
comparison
equal deleted inserted replaced
19:0cb53a31ac12 20:ace12d6b9855
29 } else{ 29 } else{
30 unreachable!(); 30 unreachable!();
31 } 31 }
32 } 32 }
33 33
34 fn parse_expr_vec(py: Python, list: PyObject) -> Vec<expr> { 34 fn parse_list<T, F: Fn(Python, PyObject) -> T>(py: Python, list: PyObject, parse: F) -> Vec<T> {
35 let mut exprs = vec!(); 35 let mut exprs = vec!();
36 for item in list.iter(py).unwrap() { 36 for item in list.iter(py).unwrap() {
37 let item = item.unwrap(); 37 let item = item.unwrap();
38 let item = parse_expr(py, item); 38 let item = parse(py, item);
39 exprs.push(item); 39 exprs.push(item);
40 } 40 }
41 exprs 41 exprs
42 }
43
44 fn parse_string_vec(py: Python, ast: PyObject) -> Vec<String> {
45 let builtins_module = py.import("builtins").unwrap();
46 let isinstance = builtins_module.get(py, "isinstance").unwrap();
47
48 let is_instance = |object: &PyObject, type_: &PyObject| {
49 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap();
50 };
51
52 let ast_module = py.import("ast").unwrap();
53 let ast_type = ast_module.get(py, "AST").unwrap();
54 let arguments_type = ast_module.get(py, "arguments").unwrap();
55
56 assert!(is_instance(&ast, &ast_type));
57
58 if is_instance(&ast, &arguments_type) {
59 let args = ast.getattr(py, "args").unwrap();
60 let mut arguments = vec!();
61 for arg in args.iter(py).unwrap() {
62 let arg = arg.unwrap();
63 let arg = parse_expr(py, arg);
64 arguments.push(match arg {
65 expr::Name(arg, expr_context::Load) => arg,
66 _ => panic!()
67 });
68 }
69 arguments
70 } else {
71 panic!()
72 }
73 } 42 }
74 43
75 fn parse_unaryop(py: Python, ast: PyObject) -> unaryop { 44 fn parse_unaryop(py: Python, ast: PyObject) -> unaryop {
76 let builtins_module = py.import("builtins").unwrap(); 45 let builtins_module = py.import("builtins").unwrap();
77 let isinstance = builtins_module.get(py, "isinstance").unwrap(); 46 let isinstance = builtins_module.get(py, "isinstance").unwrap();
173 unreachable!() 142 unreachable!()
174 } 143 }
175 } 144 }
176 145
177 fn parse_comprehension(py: Python, ast: PyObject) -> comprehension { 146 fn parse_comprehension(py: Python, ast: PyObject) -> comprehension {
178 let target = ast.getattr(py, "target").unwrap(); 147 let target = ast.getattr(py, "target").unwrap();
179 let iter = ast.getattr(py, "iter").unwrap(); 148 let iter = ast.getattr(py, "iter").unwrap();
180 let ifs = ast.getattr(py, "ifs").unwrap(); 149 let ifs = ast.getattr(py, "ifs").unwrap();
181 let ifs = ifs.iter(py).unwrap(); 150
182 151 let target = parse_expr(py, target);
183 let target = parse_expr(py, target); 152 let iter = parse_expr(py, iter);
184 let iter = parse_expr(py, iter); 153 let ifs = parse_list(py, ifs, parse_expr);
185 154
186 let mut new_ifs = vec!(); 155 comprehension {target: target, iter: iter, ifs: ifs}
187 for if_ in ifs {
188 let if_ = parse_expr(py, if_.unwrap());
189 new_ifs.push(if_);
190 }
191 comprehension {target: target, iter: iter, ifs: new_ifs}
192
193 } 156 }
194 157
195 fn parse_operator(py: Python, ast: PyObject) -> operator { 158 fn parse_operator(py: Python, ast: PyObject) -> operator {
196 let builtins_module = py.import("builtins").unwrap(); 159 let builtins_module = py.import("builtins").unwrap();
197 let isinstance = builtins_module.get(py, "isinstance").unwrap(); 160 let isinstance = builtins_module.get(py, "isinstance").unwrap();
306 let s = ast.getattr(py, "s").unwrap(); 269 let s = ast.getattr(py, "s").unwrap();
307 let s = get_str(py, s); 270 let s = get_str(py, s);
308 expr::Str(s) 271 expr::Str(s)
309 } else if is_instance(&ast, &list_type) { 272 } else if is_instance(&ast, &list_type) {
310 let elts = ast.getattr(py, "elts").unwrap(); 273 let elts = ast.getattr(py, "elts").unwrap();
311 274 let elements = parse_list(py, elts, parse_expr);
312 let mut elements = vec!();
313 for elt in elts.iter(py).unwrap() {
314 let elt = elt.unwrap();
315 elements.push(parse_expr(py, elt));
316 }
317
318 expr::List(elements, get_ctx(py, ast)) 275 expr::List(elements, get_ctx(py, ast))
319 } else if is_instance(&ast, &unary_op_type) { 276 } else if is_instance(&ast, &unary_op_type) {
320 let op = ast.getattr(py, "op").unwrap(); 277 let op = ast.getattr(py, "op").unwrap();
321 let operand = ast.getattr(py, "operand").unwrap(); 278 let operand = ast.getattr(py, "operand").unwrap();
322 279
327 } else if is_instance(&ast, &bool_op_type) { 284 } else if is_instance(&ast, &bool_op_type) {
328 let op = ast.getattr(py, "op").unwrap(); 285 let op = ast.getattr(py, "op").unwrap();
329 let values = ast.getattr(py, "values").unwrap(); 286 let values = ast.getattr(py, "values").unwrap();
330 287
331 let op = parse_boolop(py, op); 288 let op = parse_boolop(py, op);
332 let values = parse_expr_vec(py, values); 289 let values = parse_list(py, values, parse_expr);
333 290
334 expr::BoolOp(op, values) 291 expr::BoolOp(op, values)
335 } else if is_instance(&ast, &bin_op_type) { 292 } else if is_instance(&ast, &bin_op_type) {
336 let left = ast.getattr(py, "left").unwrap(); 293 let left = ast.getattr(py, "left").unwrap();
337 let op = ast.getattr(py, "op").unwrap(); 294 let op = ast.getattr(py, "op").unwrap();
346 let func = ast.getattr(py, "func").unwrap(); 303 let func = ast.getattr(py, "func").unwrap();
347 let args = ast.getattr(py, "args").unwrap(); 304 let args = ast.getattr(py, "args").unwrap();
348 let keywords = ast.getattr(py, "keywords").unwrap(); 305 let keywords = ast.getattr(py, "keywords").unwrap();
349 306
350 let func = parse_expr(py, func); 307 let func = parse_expr(py, func);
351 308 let args = parse_list(py, args, parse_expr);
352 let mut arguments = vec!();
353 for arg in args.iter(py).unwrap() {
354 let arg = arg.unwrap();
355 arguments.push(parse_expr(py, arg));
356 }
357 309
358 /* 310 /*
359 let mut kwargs = vec!(); 311 let mut kwargs = vec!();
360 for arg in keywords.iter(py).unwrap() { 312 for arg in keywords.iter(py).unwrap() {
361 let arg = arg.unwrap(); 313 let arg = arg.unwrap();
362 kwargs.push(parse_expr(py, arg)); 314 kwargs.push(parse_expr(py, arg));
363 } 315 }
364 */ 316 */
365 317
366 expr::Call(Box::new(func), arguments, vec!()) 318 expr::Call(Box::new(func), args, vec!())
367 } else if is_instance(&ast, &compare_type) { 319 } else if is_instance(&ast, &compare_type) {
368 let left = ast.getattr(py, "left").unwrap(); 320 let left = ast.getattr(py, "left").unwrap();
369 let ops = ast.getattr(py, "ops").unwrap(); 321 let ops = ast.getattr(py, "ops").unwrap();
370 let comparators = ast.getattr(py, "comparators").unwrap(); 322 let comparators = ast.getattr(py, "comparators").unwrap();
371 323
372 let left = parse_expr(py, left); 324 let left = parse_expr(py, left);
373 let ops = ops.iter(py).unwrap(); 325 let ops = parse_list(py, ops, parse_cmpop);
374 let comparators = comparators.iter(py).unwrap(); 326 let comparators = parse_list(py, comparators, parse_expr);
375 327
376 let mut new_ops = vec!(); 328 expr::Compare(Box::new(left), ops, comparators)
377 for op in ops {
378 let op = op.unwrap();
379 let op = parse_cmpop(py, op);
380 new_ops.push(op);
381 }
382
383 let mut new_comparators = vec!();
384 for comparator in comparators {
385 let comparator = comparator.unwrap();
386 let comparator = parse_expr(py, comparator);
387 new_comparators.push(comparator);
388 }
389
390 expr::Compare(Box::new(left), new_ops, new_comparators)
391 } else if is_instance(&ast, &listcomp_type) { 329 } else if is_instance(&ast, &listcomp_type) {
392 let elt = ast.getattr(py, "elt").unwrap(); 330 let elt = ast.getattr(py, "elt").unwrap();
393 let generators = ast.getattr(py, "generators").unwrap(); 331 let generators = ast.getattr(py, "generators").unwrap();
394 let generators = generators.iter(py).unwrap();
395 332
396 let elt = parse_expr(py, elt); 333 let elt = parse_expr(py, elt);
397 334 let generators = parse_list(py, generators, parse_comprehension);
398 let mut new_gens = vec!(); 335
399 for gen in generators { 336 expr::ListComp(Box::new(elt), generators)
400 let gen = gen.unwrap();
401 let gen = parse_comprehension(py, gen);
402 new_gens.push(gen);
403 }
404 expr::ListComp(Box::new(elt), new_gens)
405 } else if is_instance(&ast, &dictcomp_type) { 337 } else if is_instance(&ast, &dictcomp_type) {
406 let key = ast.getattr(py, "key").unwrap(); 338 let key = ast.getattr(py, "key").unwrap();
407 let value = ast.getattr(py, "value").unwrap(); 339 let value = ast.getattr(py, "value").unwrap();
408 let generators = ast.getattr(py, "generators").unwrap(); 340 let generators = ast.getattr(py, "generators").unwrap();
409 let generators = generators.iter(py).unwrap();
410 341
411 let key = parse_expr(py, key); 342 let key = parse_expr(py, key);
412 let value = parse_expr(py, value); 343 let value = parse_expr(py, value);
413 344 let generators = parse_list(py, generators, parse_comprehension);
414 let mut new_gens = vec!(); 345
415 for gen in generators { 346 expr::DictComp(Box::new(key), Box::new(value), generators)
416 let gen = gen.unwrap();
417 let gen = parse_comprehension(py, gen);
418 new_gens.push(gen);
419 }
420 expr::DictComp(Box::new(key), Box::new(value), new_gens)
421 } else if is_instance(&ast, &tuple_type) { 347 } else if is_instance(&ast, &tuple_type) {
422 let elts = ast.getattr(py, "elts").unwrap(); 348 let elts = ast.getattr(py, "elts").unwrap();
423 let elts = elts.iter(py).unwrap(); 349 let elts = parse_list(py, elts, parse_expr);
424 350 expr::Tuple(elts, get_ctx(py, ast))
425 let mut new_elts = vec!();
426 for elt in elts {
427 let elt = elt.unwrap();
428 let elt = parse_expr(py, elt);
429 new_elts.push(elt);
430 }
431 expr::Tuple(new_elts, get_ctx(py, ast))
432 } else { 351 } else {
433 println!("expr {}", ast); 352 println!("expr {}", ast);
434 unreachable!() 353 unreachable!()
435 } 354 }
436 } 355 }
530 //let keywords = ast.getattr(py, "keywords").unwrap(); 449 //let keywords = ast.getattr(py, "keywords").unwrap();
531 let body = ast.getattr(py, "body").unwrap(); 450 let body = ast.getattr(py, "body").unwrap();
532 //let decorator_list = ast.getattr(py, "decorator_list").unwrap(); 451 //let decorator_list = ast.getattr(py, "decorator_list").unwrap();
533 452
534 let name = get_str(py, name); 453 let name = get_str(py, name);
535 454 let bases = parse_list(py, bases, parse_expr);
536 let mut nodes = vec!(); 455 let body = parse_list(py, body, parse_statement);
537 for name_node in bases.iter(py).unwrap() { 456
538 let name_node = name_node.unwrap(); 457 stmt::ClassDef(name, bases, vec!(), body, vec!())
539 let name_node = parse_expr(py, name_node);
540 nodes.push(name_node);
541 }
542
543 let mut statements = vec!();
544 for statement in body.iter(py).unwrap() {
545 let statement = statement.unwrap();
546 let statement = parse_statement(py, statement);
547 statements.push(statement);
548 }
549
550 stmt::ClassDef(name, nodes, vec!(), statements, vec!())
551 } else if is_instance(&ast, &function_def_type) { 458 } else if is_instance(&ast, &function_def_type) {
552 let name = ast.getattr(py, "name").unwrap(); 459 let name = ast.getattr(py, "name").unwrap();
553 let args = ast.getattr(py, "args").unwrap(); 460 let args = ast.getattr(py, "args").unwrap();
554 let body = ast.getattr(py, "body").unwrap(); 461 let body = ast.getattr(py, "body").unwrap();
555 462
556 let name = get_str(py, name); 463 let name = get_str(py, name);
557 let args = parse_arguments(py, args); 464 let args = parse_arguments(py, args);
558 465 let body = parse_list(py, body, parse_statement);
559 let mut statements = vec!();
560 for statement in body.iter(py).unwrap() {
561 let statement = parse_statement(py, statement.unwrap());
562 statements.push(statement);
563 }
564 466
565 let decorators = vec!(); 467 let decorators = vec!();
566 let returns = None; 468 let returns = None;
567 469
568 stmt::FunctionDef(name, args, statements, decorators, returns) 470 stmt::FunctionDef(name, args, body, decorators, returns)
569 } else if is_instance(&ast, &global_type) { 471 } else if is_instance(&ast, &global_type) {
570 let names = ast.getattr(py, "names").unwrap(); 472 let names = ast.getattr(py, "names").unwrap();
571 473 let names = parse_list(py, names, get_str);
572 let mut globals = vec!(); 474 stmt::Global(names)
573 for name in names.iter(py).unwrap() {
574 let name = name.unwrap();
575 let name = get_str(py, name);
576 globals.push(name);
577 }
578
579 stmt::Global(globals)
580 } else if is_instance(&ast, &if_type) { 475 } else if is_instance(&ast, &if_type) {
581 let test = ast.getattr(py, "test").unwrap(); 476 let test = ast.getattr(py, "test").unwrap();
582 let body = ast.getattr(py, "body").unwrap(); 477 let body = ast.getattr(py, "body").unwrap();
583 let orelse = ast.getattr(py, "orelse").unwrap(); 478 let orelse = ast.getattr(py, "orelse").unwrap();
584 479
585 let test = parse_expr(py, test); 480 let test = parse_expr(py, test);
586 481 let body = parse_list(py, body, parse_statement);
587 let mut statements = vec!(); 482 let orelse = parse_list(py, orelse, parse_statement);
588 for statement in body.iter(py).unwrap() { 483
589 let statement = statement.unwrap(); 484 stmt::If(test, body, orelse)
590 let statement = parse_statement(py, statement);
591 statements.push(statement);
592 }
593
594 let mut orelse_ = vec!();
595 for statement in orelse.iter(py).unwrap() {
596 let statement = statement.unwrap();
597 let statement = parse_statement(py, statement);
598 orelse_.push(statement);
599 }
600
601 stmt::If(test, statements, orelse_)
602 } else if is_instance(&ast, &while_type) { 485 } else if is_instance(&ast, &while_type) {
603 let test = ast.getattr(py, "test").unwrap(); 486 let test = ast.getattr(py, "test").unwrap();
604 let body = ast.getattr(py, "body").unwrap(); 487 let body = ast.getattr(py, "body").unwrap();
605 let orelse = ast.getattr(py, "orelse").unwrap(); 488 let orelse = ast.getattr(py, "orelse").unwrap();
606 489
607 let test = parse_expr(py, test); 490 let test = parse_expr(py, test);
608 491 let body = parse_list(py, body, parse_statement);
609 let mut statements = vec!(); 492 let orelse = parse_list(py, orelse, parse_statement);
610 for statement in body.iter(py).unwrap() { 493
611 let statement = statement.unwrap(); 494 stmt::While(test, body, orelse)
612 let statement = parse_statement(py, statement);
613 statements.push(statement);
614 }
615
616 let mut orelse_ = vec!();
617 for statement in orelse.iter(py).unwrap() {
618 let statement = statement.unwrap();
619 let statement = parse_statement(py, statement);
620 orelse_.push(statement);
621 }
622
623 stmt::While(test, statements, orelse_)
624 } else if is_instance(&ast, &for_type) { 495 } else if is_instance(&ast, &for_type) {
625 let target = ast.getattr(py, "target").unwrap(); 496 let target = ast.getattr(py, "target").unwrap();
626 let iter = ast.getattr(py, "iter").unwrap(); 497 let iter = ast.getattr(py, "iter").unwrap();
627 let body = ast.getattr(py, "body").unwrap(); 498 let body = ast.getattr(py, "body").unwrap();
628 let orelse = ast.getattr(py, "orelse").unwrap(); 499 let orelse = ast.getattr(py, "orelse").unwrap();
629 500
630 let target = parse_expr(py, target); 501 let target = parse_expr(py, target);
631 let iter = parse_expr(py, iter); 502 let iter = parse_expr(py, iter);
632 503 let body = parse_list(py, body, parse_statement);
633 let mut statements = vec!(); 504 let orelse = parse_list(py, orelse, parse_statement);
634 for statement in body.iter(py).unwrap() { 505
635 let statement = statement.unwrap(); 506 stmt::For(target, iter, body, orelse)
636 let statement = parse_statement(py, statement);
637 statements.push(statement);
638 }
639
640 let mut orelse_ = vec!();
641 for statement in orelse.iter(py).unwrap() {
642 let statement = statement.unwrap();
643 let statement = parse_statement(py, statement);
644 orelse_.push(statement);
645 }
646
647 stmt::For(target, iter, statements, orelse_)
648 } else if is_instance(&ast, &assign_type) { 507 } else if is_instance(&ast, &assign_type) {
649 let targets = ast.getattr(py, "targets").unwrap(); 508 let targets = ast.getattr(py, "targets").unwrap();
650 let value = ast.getattr(py, "value").unwrap(); 509 let value = ast.getattr(py, "value").unwrap();
651 510
652 let mut arguments = vec!(); 511 let targets = parse_list(py, targets, parse_expr);
653 for target in targets.iter(py).unwrap() {
654 let target = target.unwrap();
655 let target = parse_expr(py, target);
656 arguments.push(target);
657 }
658
659 let value = parse_expr(py, value); 512 let value = parse_expr(py, value);
660 513
661 stmt::Assign(arguments, value) 514 stmt::Assign(targets, value)
662 } else if is_instance(&ast, &aug_assign_type) { 515 } else if is_instance(&ast, &aug_assign_type) {
663 let target = ast.getattr(py, "target").unwrap(); 516 let target = ast.getattr(py, "target").unwrap();
664 let op = ast.getattr(py, "op").unwrap(); 517 let op = ast.getattr(py, "op").unwrap();
665 let value = ast.getattr(py, "value").unwrap(); 518 let value = ast.getattr(py, "value").unwrap();
666 519
674 let names = ast.getattr(py, "names").unwrap(); 527 let names = ast.getattr(py, "names").unwrap();
675 let level = ast.getattr(py, "level").unwrap(); 528 let level = ast.getattr(py, "level").unwrap();
676 529
677 let module = get_str(py, module); 530 let module = get_str(py, module);
678 531
532 // TODO: move that into another function.
679 let mut names_ = vec!(); 533 let mut names_ = vec!();
680 for alias in names.iter(py).unwrap() { 534 for alias in names.iter(py).unwrap() {
681 let alias = alias.unwrap(); 535 let alias = alias.unwrap();
682 let alias = parse_expr(py, alias); 536 let alias = parse_expr(py, alias);
683 println!("{:?}", alias); 537 println!("{:?}", alias);
718 let module_type = ast_module.get(py, "Module").unwrap(); 572 let module_type = ast_module.get(py, "Module").unwrap();
719 573
720 assert!(isinstance.call(py, (module, module_type), None).unwrap().is_true(py).unwrap()); 574 assert!(isinstance.call(py, (module, module_type), None).unwrap().is_true(py).unwrap());
721 575
722 let body = module.getattr(py, "body").unwrap(); 576 let body = module.getattr(py, "body").unwrap();
723 let mut statements = vec!(); 577 let body = parse_list(py, body, parse_statement);
724 for statement in body.iter(py).unwrap() { 578 Module{name: name, statements: body}
725 let statement = parse_statement(py, statement.unwrap()); 579 }
726 statements.push(statement)
727 }
728 Module{name: name, statements: statements}
729 }