Mercurial > python-compiler.rs
annotate src/ast_dump.rs @ 4:f27a4aee9dfa
Add ast.Attribute.
| author | Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> |
|---|---|
| date | Tue, 31 May 2016 03:59:05 +0100 |
| parents | 326d7f2a94d4 |
| children | ddf372373a77 |
| rev | line source |
|---|---|
| 0 | 1 use python_ast::{Module, Statement, Expr, BinOp}; |
| 2 | |
| 3 use std::iter; | |
| 4 | |
| 5 impl BinOp { | |
| 6 fn to_string(&self) -> &'static str { | |
| 7 match *self { | |
| 8 BinOp::BinAdd => "+", | |
| 9 BinOp::BinMult => "*", | |
| 10 BinOp::BinEq => "==", | |
| 11 BinOp::BinLt => "<", | |
| 12 BinOp::Error => "BinOp::Error" | |
| 13 } | |
| 14 } | |
| 15 } | |
| 16 | |
| 17 impl Expr { | |
| 18 fn to_string(&self) -> String { | |
| 19 match self.clone() { | |
| 20 Expr::BinOp(a, op, b) => format!("{} {} {}", a.to_string(), op.to_string(), b.to_string()), | |
| 21 Expr::Compare(left, ops, comparators) => format!("{} {}", left.to_string(), { | |
| 22 let mut arguments = vec!(); | |
| 23 | |
| 24 // XXX: wrong order! | |
| 25 for op in ops { | |
| 26 arguments.push(op.to_string().to_string()) | |
| 27 } | |
| 28 for comparator in comparators { | |
| 29 arguments.push(comparator.to_string()) | |
| 30 } | |
| 31 /* | |
| 32 for (op, comparator) in ops.zip(comparators) { | |
| 33 let op = op.unwrap(); | |
| 34 let comparator = comparator.unwrap(); | |
| 35 arguments.push(format!("{} {}", op.to_string(), comparator.to_string())) | |
| 36 } | |
| 37 */ | |
| 38 | |
| 39 arguments.join(" ") | |
| 40 }), | |
| 41 Expr::Call(func, args) => format!("{}({})", func.to_string(), { | |
| 42 let mut arguments = vec!(); | |
| 43 for arg in args { | |
| 44 arguments.push(arg.to_string()); | |
| 45 } | |
| 46 arguments.join(", ") | |
| 47 }), | |
| 48 Expr::Alias(name, asname) => { | |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
49 match asname { |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
50 None => format!("{}", name), |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
51 Some(asname) => format!("{} as {}", name, asname) |
| 0 | 52 } |
| 53 } | |
|
4
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
54 Expr::Attribute(lhs, rhs) => format!("{}.{}", lhs.to_string(), rhs), |
| 0 | 55 Expr::Name(name) => format!("{}", name), |
| 56 Expr::NameConstant(name) => format!("{}", name), | |
| 57 Expr::Str(s) => format!("\"{}\"", s), | |
| 58 Expr::Num(n) => format!("{}", n), | |
| 59 Expr::Error => "Expr::Error".to_string() | |
| 60 } | |
| 61 } | |
| 62 } | |
| 63 | |
| 64 fn make_indent(indent: usize) -> String { | |
| 65 let indent: String = iter::repeat(" ").take(indent).collect(); | |
| 66 indent | |
| 67 } | |
| 68 | |
| 69 impl Statement { | |
| 70 fn to_string(&self, indent: usize) -> String { | |
| 71 match self.clone() { | |
|
2
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
72 Statement::ClassDef(name, classes, body) => format!("{}def {}({}):\n{}", make_indent(indent), name, { |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
73 let mut bases = vec!(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
74 for class in classes { |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
75 bases.push(class.to_string()); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
76 } |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
77 bases.join(", ") |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
78 }, { |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
79 let mut statements = vec!(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
80 for statement in body { |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
81 statements.push(statement.to_string(indent + 1)); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
82 } |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
83 statements.join("\n") |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
84 }), |
|
3
326d7f2a94d4
Remove useless abstraction of function name as Expr.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
2
diff
changeset
|
85 Statement::FunctionDef(name, arguments, body) => format!("{}def {}({}):\n{}", make_indent(indent), name, { |
| 0 | 86 let mut args = vec!(); |
| 87 for arg in arguments { | |
| 88 args.push(arg.to_string()); | |
| 89 } | |
| 90 args.join(", ") | |
| 91 }, { | |
| 92 let mut statements = vec!(); | |
| 93 for statement in body { | |
| 94 statements.push(statement.to_string(indent + 1)); | |
| 95 } | |
| 96 statements.join("\n") | |
| 97 }), | |
| 98 Statement::Global(names) => format!("{}global {}", make_indent(indent), names.join(", ")), | |
| 99 Statement::If(test, body, orelse) => format!("{}if {}:\n{}", make_indent(indent), test.to_string(), { | |
| 100 let mut statements = vec!(); | |
| 101 for arg in body { | |
| 102 statements.push(arg.to_string(indent + 1)); | |
| 103 } | |
| 104 | |
| 105 let mut orelse_ = vec!(); | |
| 106 for arg in orelse { | |
| 107 orelse_.push(arg.to_string(indent + 1)); | |
| 108 } | |
| 109 | |
| 110 if orelse_.is_empty() { | |
| 111 statements.join("\n") | |
| 112 } else { | |
| 113 format!("{}\n{}else:\n{}", statements.join("\n"), make_indent(indent), orelse_.join("\n")) | |
| 114 } | |
| 115 }), | |
| 116 Statement::Assign(targets, value) => format!("{}{} = {}", make_indent(indent), { | |
| 117 let mut exprs = vec!(); | |
| 118 for target in targets { | |
| 119 exprs.push(target.to_string()); | |
| 120 } | |
| 121 exprs.join(", ") | |
| 122 }, value.to_string()), | |
| 123 Statement::Return(expr) => format!("{}return {}", make_indent(indent), expr.to_string()), | |
| 124 Statement::ImportFrom(module, names) => format!("{}from {} import {}", make_indent(indent), module.to_string(), { | |
| 125 let mut exprs = vec!(); | |
| 126 for alias in names.iter() { | |
| 127 let alias = alias.to_string(); | |
| 128 exprs.push(alias); | |
| 129 } | |
| 130 exprs.join(", ") | |
| 131 }), | |
| 132 Statement::Expr(expr) => format!("{}{}", make_indent(indent), expr.to_string()), | |
| 133 Statement::Error => format!("{}Statement::Error", make_indent(indent)) | |
| 134 } | |
| 135 } | |
| 136 } | |
| 137 | |
| 138 #[allow(dead_code)] | |
| 139 pub fn dump_ast(ast: &Module) { | |
| 140 for statement in &ast.statements { | |
| 141 println!("{}", statement.to_string(0)); | |
| 142 } | |
| 143 } |