Mercurial > python-compiler.rs
annotate src/ast_convert.rs @ 91:859d44f143b8
Implement Bytes in the AST.
| author | Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> |
|---|---|
| date | Sat, 25 Jun 2016 02:08:50 +0100 |
| parents | 5923cd4bfc36 |
| children |
| rev | line source |
|---|---|
|
86
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
1 use python_ast::{Module, stmt, expr, expr_context, cmpop, boolop, operator, unaryop, arguments, arg, alias, comprehension, keyword, withitem, excepthandler, slice, name_constant}; |
| 0 | 2 |
|
91
859d44f143b8
Implement Bytes in the AST.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
88
diff
changeset
|
3 use cpython::{Python, PyObject, PyBool, PyResult, PyBytes}; |
| 0 | 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 { |
|
87
624393ed3b0b
Don’t cast anything to str, except Num for now.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
86
diff
changeset
|
7 object.extract(py).unwrap() |
|
624393ed3b0b
Don’t cast anything to str, except Num for now.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
86
diff
changeset
|
8 } |
|
624393ed3b0b
Don’t cast anything to str, except Num for now.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
86
diff
changeset
|
9 |
|
624393ed3b0b
Don’t cast anything to str, except Num for now.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
86
diff
changeset
|
10 fn convert_to_str(py: Python, object: PyObject) -> String { |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
11 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
|
12 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
|
13 string.to_mut().to_string() |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
14 } |
|
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
15 |
| 18 | 16 fn get_ctx(py: Python, object: PyObject) -> expr_context { |
| 17 let builtins_module = py.import("builtins").unwrap(); | |
| 18 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 19 | |
| 20 let is_instance = |object: &PyObject, type_: &PyObject| { | |
| 21 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); | |
| 22 }; | |
| 23 | |
| 24 let ast_module = py.import("ast").unwrap(); | |
| 25 let store_type = ast_module.get(py, "Store").unwrap(); | |
| 26 let load_type = ast_module.get(py, "Load").unwrap(); | |
| 21 | 27 let del_type = ast_module.get(py, "Del").unwrap(); |
| 18 | 28 |
| 29 let ctx = object.getattr(py, "ctx").unwrap(); | |
| 30 if is_instance(&ctx, &store_type) { | |
| 31 expr_context::Store | |
| 32 } else if is_instance(&ctx, &load_type) { | |
| 33 expr_context::Load | |
| 21 | 34 } else if is_instance(&ctx, &del_type) { |
| 35 expr_context::Del | |
| 18 | 36 } else{ |
| 37 unreachable!(); | |
| 38 } | |
| 39 } | |
| 40 | |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
41 fn parse_list<T, F: Fn(Python, PyObject) -> T>(py: Python, list: PyObject, parse: F) -> Vec<T> { |
|
19
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
42 let mut exprs = vec!(); |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
43 for item in list.iter(py).unwrap() { |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
44 let item = item.unwrap(); |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
45 let item = parse(py, item); |
|
19
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
46 exprs.push(item); |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
47 } |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
48 exprs |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
49 } |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
50 |
|
44
5f1d285471af
Finish ImportFrom conversion and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
21
diff
changeset
|
51 fn parse_alias(py: Python, ast: PyObject) -> alias { |
|
5f1d285471af
Finish ImportFrom conversion and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
21
diff
changeset
|
52 let ast_alias = get_str(py, ast.getattr(py, "name").unwrap()); |
|
5f1d285471af
Finish ImportFrom conversion and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
21
diff
changeset
|
53 let asname = ast.getattr(py, "asname").unwrap(); |
|
5f1d285471af
Finish ImportFrom conversion and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
21
diff
changeset
|
54 if asname == py.None() { |
|
5f1d285471af
Finish ImportFrom conversion and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
21
diff
changeset
|
55 alias{name: ast_alias, asname: None} |
|
5f1d285471af
Finish ImportFrom conversion and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
21
diff
changeset
|
56 } else { |
|
5f1d285471af
Finish ImportFrom conversion and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
21
diff
changeset
|
57 alias{name: ast_alias, asname: Some(get_str(py, asname))} |
|
5f1d285471af
Finish ImportFrom conversion and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
21
diff
changeset
|
58 } |
|
5f1d285471af
Finish ImportFrom conversion and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
21
diff
changeset
|
59 } |
|
5f1d285471af
Finish ImportFrom conversion and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
21
diff
changeset
|
60 |
| 59 | 61 fn parse_withitem(py: Python, ast: PyObject) -> withitem { |
| 62 let context_expr = ast.getattr(py, "context_expr").unwrap(); | |
| 63 let optional_vars = ast.getattr(py, "optional_vars").unwrap(); | |
| 64 | |
| 65 let context_expr = parse_expr(py, context_expr); | |
| 66 | |
| 67 if optional_vars == py.None() { | |
| 68 withitem{context_expr: context_expr, optional_vars: None} | |
| 69 } else { | |
| 70 let optional_vars = parse_expr(py, optional_vars); | |
| 71 withitem{context_expr: context_expr, optional_vars: Some(optional_vars)} | |
| 72 } | |
| 73 } | |
| 74 | |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
75 fn parse_unaryop(py: Python, ast: PyObject) -> unaryop { |
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
76 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
|
77 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
|
78 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
79 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
|
80 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
|
81 }; |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
82 |
|
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 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
|
84 let ast_type = ast_module.get(py, "AST").unwrap(); |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
85 let invert_type = ast_module.get(py, "Invert").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
86 let not_type = ast_module.get(py, "Not").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
|
87 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
|
88 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
|
89 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
90 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
|
91 |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
92 if is_instance(&ast, &invert_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
93 unaryop::Invert |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
94 } else if is_instance(&ast, ¬_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
95 unaryop::Not |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
96 } else if is_instance(&ast, &uadd_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
97 unaryop::UAdd |
|
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, &usub_type) { |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
99 unaryop::USub |
|
5
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 { |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
101 unreachable!() |
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
102 } |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
103 } |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
104 |
|
19
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
105 fn parse_boolop(py: Python, ast: PyObject) -> boolop { |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
106 let builtins_module = py.import("builtins").unwrap(); |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
107 let isinstance = builtins_module.get(py, "isinstance").unwrap(); |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
108 |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
109 let is_instance = |object: &PyObject, type_: &PyObject| { |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
110 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
111 }; |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
112 |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
113 let ast_module = py.import("ast").unwrap(); |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
114 let ast_type = ast_module.get(py, "AST").unwrap(); |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
115 let and_type = ast_module.get(py, "And").unwrap(); |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
116 let or_type = ast_module.get(py, "Or").unwrap(); |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
117 |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
118 assert!(is_instance(&ast, &ast_type)); |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
119 |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
120 if is_instance(&ast, &and_type) { |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
121 boolop::And |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
122 } else if is_instance(&ast, &or_type) { |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
123 boolop::Or |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
124 } else { |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
125 unreachable!() |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
126 } |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
127 } |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
128 |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
129 fn parse_cmpop(py: Python, ast: PyObject) -> cmpop { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
130 let builtins_module = py.import("builtins").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
131 let isinstance = builtins_module.get(py, "isinstance").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
132 |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
133 let is_instance = |object: &PyObject, type_: &PyObject| { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
134 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
135 }; |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
136 |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
137 let ast_module = py.import("ast").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
138 let ast_type = ast_module.get(py, "AST").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
139 let eq_type = ast_module.get(py, "Eq").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
140 let noteq_type = ast_module.get(py, "NotEq").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
141 let lt_type = ast_module.get(py, "Lt").unwrap(); |
|
15
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
142 let lte_type = ast_module.get(py, "LtE").unwrap(); |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
143 let gt_type = ast_module.get(py, "Gt").unwrap(); |
|
15
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
144 let gte_type = ast_module.get(py, "GtE").unwrap(); |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
145 let is_type = ast_module.get(py, "Is").unwrap(); |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
146 let is_not_type = ast_module.get(py, "IsNot").unwrap(); |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
147 let in_type = ast_module.get(py, "In").unwrap(); |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
148 let not_in_type = ast_module.get(py, "NotIn").unwrap(); |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
149 |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
150 assert!(is_instance(&ast, &ast_type)); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
151 |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
152 if is_instance(&ast, &eq_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
153 cmpop::Eq |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
154 } else if is_instance(&ast, ¬eq_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
155 cmpop::NotEq |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
156 } else if is_instance(&ast, <_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
157 cmpop::Lt |
|
15
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
158 } else if is_instance(&ast, <e_type) { |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
159 cmpop::LtE |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
160 } else if is_instance(&ast, >_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
161 cmpop::Gt |
|
15
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
162 } else if is_instance(&ast, >e_type) { |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
163 cmpop::GtE |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
164 } else if is_instance(&ast, &is_type) { |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
165 cmpop::Is |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
166 } else if is_instance(&ast, &is_not_type) { |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
167 cmpop::IsNot |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
168 } else if is_instance(&ast, &in_type) { |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
169 cmpop::In |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
170 } else if is_instance(&ast, ¬_in_type) { |
|
a0fb169fe0f9
Add forgotten cmpop values.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
14
diff
changeset
|
171 cmpop::NotIn |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
172 } else { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
173 unreachable!() |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
174 } |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
175 } |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
176 |
| 14 | 177 fn parse_comprehension(py: Python, ast: PyObject) -> comprehension { |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
178 let target = ast.getattr(py, "target").unwrap(); |
|
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
179 let iter = ast.getattr(py, "iter").unwrap(); |
|
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
180 let ifs = ast.getattr(py, "ifs").unwrap(); |
| 14 | 181 |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
182 let target = parse_expr(py, target); |
|
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
183 let iter = parse_expr(py, iter); |
|
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
184 let ifs = parse_list(py, ifs, parse_expr); |
| 14 | 185 |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
186 comprehension {target: target, iter: iter, ifs: ifs} |
| 14 | 187 } |
| 188 | |
|
53
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
189 fn parse_keyword(py: Python, ast: PyObject) -> keyword { |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
190 let arg = ast.getattr(py, "arg").unwrap(); |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
191 let value = ast.getattr(py, "value").unwrap(); |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
192 |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
193 let arg = if arg == py.None() { |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
194 None |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
195 } else { |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
196 let arg = get_str(py, arg); |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
197 Some(arg) |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
198 }; |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
199 let value = parse_expr(py, value); |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
200 |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
201 keyword {arg: arg, value: value} |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
202 } |
|
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
203 |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
204 fn parse_operator(py: Python, ast: PyObject) -> operator { |
| 0 | 205 let builtins_module = py.import("builtins").unwrap(); |
| 206 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 207 | |
| 208 let is_instance = |object: &PyObject, type_: &PyObject| { | |
| 209 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); | |
| 210 }; | |
| 211 | |
| 212 let ast_module = py.import("ast").unwrap(); | |
| 213 let ast_type = ast_module.get(py, "AST").unwrap(); | |
| 214 let add_type = ast_module.get(py, "Add").unwrap(); | |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
215 let sub_type = ast_module.get(py, "Sub").unwrap(); |
| 0 | 216 let mult_type = ast_module.get(py, "Mult").unwrap(); |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
217 let matmult_type = ast_module.get(py, "MatMult").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
|
218 let div_type = ast_module.get(py, "Div").unwrap(); |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
219 let mod_type = ast_module.get(py, "Mod").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
220 let pow_type = ast_module.get(py, "Pow").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
221 let lshift_type = ast_module.get(py, "LShift").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
222 let rshift_type = ast_module.get(py, "RShift").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
223 let bitor_type = ast_module.get(py, "BitOr").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
224 let bitxor_type = ast_module.get(py, "BitXor").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
225 let bitand_type = ast_module.get(py, "BitAnd").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
226 let floordiv_type = ast_module.get(py, "FloorDiv").unwrap(); |
| 0 | 227 |
| 228 assert!(is_instance(&ast, &ast_type)); | |
| 229 | |
| 230 if is_instance(&ast, &add_type) { | |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
231 operator::Add |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
232 } else if is_instance(&ast, &sub_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
233 operator::Sub |
| 0 | 234 } else if is_instance(&ast, &mult_type) { |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
235 operator::Mult |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
236 } else if is_instance(&ast, &matmult_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
237 operator::MatMult |
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
238 } else if is_instance(&ast, &div_type) { |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
239 operator::Div |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
240 } else if is_instance(&ast, &mod_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
241 operator::Mod |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
242 } else if is_instance(&ast, &pow_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
243 operator::Pow |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
244 } else if is_instance(&ast, &lshift_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
245 operator::LShift |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
246 } else if is_instance(&ast, &rshift_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
247 operator::RShift |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
248 } else if is_instance(&ast, &bitor_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
249 operator::BitOr |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
250 } else if is_instance(&ast, &bitxor_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
251 operator::BitXor |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
252 } else if is_instance(&ast, &bitand_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
253 operator::BitAnd |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
254 } else if is_instance(&ast, &floordiv_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
255 operator::FloorDiv |
| 0 | 256 } else { |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
257 println!("operator {}", ast); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
258 panic!() |
| 0 | 259 } |
| 260 } | |
| 261 | |
| 68 | 262 fn parse_excepthandler(py: Python, ast: PyObject) -> excepthandler { |
| 263 let type_ = ast.getattr(py, "type").unwrap(); | |
| 264 let name = ast.getattr(py, "name").unwrap(); | |
| 265 let body = ast.getattr(py, "body").unwrap(); | |
| 266 | |
| 267 let type_ = parse_optional_expr(py, type_); | |
| 268 let name = if name == py.None() { None } else { Some(get_str(py, name)) }; | |
| 269 let body = parse_list(py, body, parse_statement); | |
| 270 | |
| 271 excepthandler{type_: type_, name: name, body: body} | |
| 272 } | |
| 273 | |
| 82 | 274 fn parse_slice(py: Python, ast: PyObject) -> slice { |
| 275 let builtins_module = py.import("builtins").unwrap(); | |
| 276 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 277 | |
| 278 let is_instance = |object: &PyObject, type_: &PyObject| { | |
| 279 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); | |
| 280 }; | |
| 281 | |
| 282 let ast_module = py.import("ast").unwrap(); | |
| 283 let ast_type = ast_module.get(py, "AST").unwrap(); | |
| 284 let index_type = ast_module.get(py, "Index").unwrap(); | |
| 285 let slice_type = ast_module.get(py, "Slice").unwrap(); | |
| 286 let ext_slice_type = ast_module.get(py, "ExtSlice").unwrap(); | |
| 287 | |
| 288 assert!(is_instance(&ast, &ast_type)); | |
| 289 | |
| 290 if is_instance(&ast, &index_type) { | |
| 291 let value = ast.getattr(py, "value").unwrap(); | |
| 292 let value = parse_expr(py, value); | |
| 293 | |
| 294 slice::Index(value) | |
| 295 } else if is_instance(&ast, &slice_type) { | |
| 296 let lower = ast.getattr(py, "lower").unwrap(); | |
| 297 let upper = ast.getattr(py, "upper").unwrap(); | |
| 298 let step = ast.getattr(py, "step").unwrap(); | |
| 299 | |
| 300 let lower = parse_optional_expr(py, lower); | |
| 301 let upper = parse_optional_expr(py, upper); | |
| 302 let step = parse_optional_expr(py, step); | |
| 303 slice::Slice(lower, upper, step) | |
| 304 } else if is_instance(&ast, &ext_slice_type) { | |
| 305 let dims = ast.getattr(py, "dims").unwrap(); | |
| 306 let dims = parse_list(py, dims, parse_slice); | |
| 307 | |
| 308 slice::ExtSlice(dims) | |
| 309 } else { | |
| 310 unreachable!() | |
| 311 } | |
| 312 } | |
| 313 | |
|
61
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
314 fn parse_optional_expr(py: Python, ast: PyObject) -> Option<expr> { |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
315 if ast == py.None() { |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
316 None |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
317 } else { |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
318 let ast = parse_expr(py, ast); |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
319 Some(ast) |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
320 } |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
321 } |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
322 |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
323 fn parse_expr(py: Python, ast: PyObject) -> expr { |
| 0 | 324 let builtins_module = py.import("builtins").unwrap(); |
| 325 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 326 | |
| 327 let is_instance = |object: &PyObject, type_: &PyObject| { | |
| 328 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); | |
| 329 }; | |
| 330 | |
| 331 let ast_module = py.import("ast").unwrap(); | |
| 332 let ast_type = ast_module.get(py, "AST").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
|
333 let unary_op_type = ast_module.get(py, "UnaryOp").unwrap(); |
|
19
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
334 let bool_op_type = ast_module.get(py, "BoolOp").unwrap(); |
| 0 | 335 let bin_op_type = ast_module.get(py, "BinOp").unwrap(); |
| 336 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
|
337 let attribute_type = ast_module.get(py, "Attribute").unwrap(); |
| 0 | 338 let name_type = ast_module.get(py, "Name").unwrap(); |
| 339 let num_type = ast_module.get(py, "Num").unwrap(); | |
| 340 let str_type = ast_module.get(py, "Str").unwrap(); | |
|
91
859d44f143b8
Implement Bytes in the AST.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
88
diff
changeset
|
341 let bytes_type = ast_module.get(py, "Bytes").unwrap(); |
|
7
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
342 let list_type = ast_module.get(py, "List").unwrap(); |
| 0 | 343 let compare_type = ast_module.get(py, "Compare").unwrap(); |
| 344 let call_type = ast_module.get(py, "Call").unwrap(); | |
| 14 | 345 let listcomp_type = ast_module.get(py, "ListComp").unwrap(); |
| 16 | 346 let dictcomp_type = ast_module.get(py, "DictComp").unwrap(); |
| 17 | 347 let tuple_type = ast_module.get(py, "Tuple").unwrap(); |
| 52 | 348 let ellipsis_type = ast_module.get(py, "Ellipsis").unwrap(); |
| 73 | 349 let await_type = ast_module.get(py, "Await").unwrap(); |
| 74 | 350 let yield_type = ast_module.get(py, "Yield").unwrap(); |
| 75 | 351 let yield_from_type = ast_module.get(py, "YieldFrom").unwrap(); |
| 76 | 352 let set_type = ast_module.get(py, "Set").unwrap(); |
| 77 | 353 let setcomp_type = ast_module.get(py, "SetComp").unwrap(); |
| 78 | 354 let generatorexp_type = ast_module.get(py, "GeneratorExp").unwrap(); |
| 79 | 355 let lambda_type = ast_module.get(py, "Lambda").unwrap(); |
| 80 | 356 let ifexp_type = ast_module.get(py, "IfExp").unwrap(); |
| 81 | 357 let dict_type = ast_module.get(py, "Dict").unwrap(); |
| 82 | 358 let subscript_type = ast_module.get(py, "Subscript").unwrap(); |
| 83 | 359 let starred_type = ast_module.get(py, "Starred").unwrap(); |
| 0 | 360 |
| 361 assert!(is_instance(&ast, &ast_type)); | |
| 362 | |
|
56
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
363 if is_instance(&ast, &attribute_type) { |
|
4
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
364 let value = ast.getattr(py, "value").unwrap(); |
|
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
365 let attr = ast.getattr(py, "attr").unwrap(); |
|
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
366 |
|
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
367 let value = parse_expr(py, value); |
|
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
368 let attr = get_str(py, attr); |
|
f27a4aee9dfa
Add ast.Attribute.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
3
diff
changeset
|
369 |
| 18 | 370 expr::Attribute(Box::new(value), attr, get_ctx(py, ast)) |
| 0 | 371 } 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
|
372 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
|
373 let id = get_str(py, id); |
| 18 | 374 expr::Name(id, get_ctx(py, ast)) |
| 0 | 375 } 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
|
376 let value = ast.getattr(py, "value").unwrap(); |
|
86
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
377 let boolean: PyResult<PyBool> = value.extract(py); |
|
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
378 let constant = match boolean { |
|
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
379 Ok(boolean) => if boolean.is_true() { |
|
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
380 name_constant::True |
|
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
381 } else { |
|
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
382 name_constant::False |
|
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
383 }, |
|
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
384 Err(_) => { |
|
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
385 assert!(value == py.None()); |
|
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
386 name_constant::None_ |
|
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
387 } |
|
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
388 }; |
|
a7b1db623f41
Implement NameConstant correctly.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
83
diff
changeset
|
389 expr::NameConstant(constant) |
| 0 | 390 } 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
|
391 let n = ast.getattr(py, "n").unwrap(); |
|
87
624393ed3b0b
Don’t cast anything to str, except Num for now.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
86
diff
changeset
|
392 // FIXME: we should convert these to either bigint, double or complex. |
|
624393ed3b0b
Don’t cast anything to str, except Num for now.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
86
diff
changeset
|
393 // TODO: find a suitable bigint library. |
|
624393ed3b0b
Don’t cast anything to str, except Num for now.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
86
diff
changeset
|
394 let n = convert_to_str(py, n); |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
395 expr::Num(n) |
| 0 | 396 } 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
|
397 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
|
398 let s = get_str(py, s); |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
399 expr::Str(s) |
|
91
859d44f143b8
Implement Bytes in the AST.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
88
diff
changeset
|
400 } else if is_instance(&ast, &bytes_type) { |
|
859d44f143b8
Implement Bytes in the AST.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
88
diff
changeset
|
401 let s = ast.getattr(py, "s").unwrap(); |
|
859d44f143b8
Implement Bytes in the AST.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
88
diff
changeset
|
402 let s: PyBytes = s.extract(py).unwrap(); |
|
859d44f143b8
Implement Bytes in the AST.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
88
diff
changeset
|
403 let s = s.as_slice(py).to_vec(); |
|
859d44f143b8
Implement Bytes in the AST.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
88
diff
changeset
|
404 expr::Bytes(s) |
|
7
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
405 } else if is_instance(&ast, &list_type) { |
|
680d15073f55
Add ast.List literal.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
6
diff
changeset
|
406 let elts = ast.getattr(py, "elts").unwrap(); |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
407 let elements = parse_list(py, elts, parse_expr); |
| 18 | 408 expr::List(elements, get_ctx(py, ast)) |
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
409 } 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
|
410 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
|
411 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
|
412 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
413 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
|
414 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
|
415 |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
416 expr::UnaryOp(op, Box::new(operand)) |
|
19
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
417 } else if is_instance(&ast, &bool_op_type) { |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
418 let op = ast.getattr(py, "op").unwrap(); |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
419 let values = ast.getattr(py, "values").unwrap(); |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
420 |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
421 let op = parse_boolop(py, op); |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
422 let values = parse_list(py, values, parse_expr); |
|
19
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
423 |
|
0cb53a31ac12
Implement ast.BoolOp, and improve its display.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
18
diff
changeset
|
424 expr::BoolOp(op, values) |
| 0 | 425 } else if is_instance(&ast, &bin_op_type) { |
| 426 let left = ast.getattr(py, "left").unwrap(); | |
| 427 let op = ast.getattr(py, "op").unwrap(); | |
| 428 let right = ast.getattr(py, "right").unwrap(); | |
| 429 | |
| 430 let left = parse_expr(py, left); | |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
431 let op = parse_operator(py, op); |
| 0 | 432 let right = parse_expr(py, right); |
| 433 | |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
434 expr::BinOp(Box::new(left), op, Box::new(right)) |
| 0 | 435 } else if is_instance(&ast, &call_type) { |
| 436 let func = ast.getattr(py, "func").unwrap(); | |
| 437 let args = ast.getattr(py, "args").unwrap(); | |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
438 let keywords = ast.getattr(py, "keywords").unwrap(); |
| 0 | 439 |
| 440 let func = parse_expr(py, func); | |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
441 let args = parse_list(py, args, parse_expr); |
|
53
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
442 let keywords = parse_list(py, keywords, parse_keyword); |
| 0 | 443 |
|
53
1a815946c2e5
Implement keywords in expr::Call, and add some tests.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
52
diff
changeset
|
444 expr::Call(Box::new(func), args, keywords) |
| 0 | 445 } else if is_instance(&ast, &compare_type) { |
| 446 let left = ast.getattr(py, "left").unwrap(); | |
| 447 let ops = ast.getattr(py, "ops").unwrap(); | |
| 448 let comparators = ast.getattr(py, "comparators").unwrap(); | |
| 449 | |
| 450 let left = parse_expr(py, left); | |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
451 let ops = parse_list(py, ops, parse_cmpop); |
|
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
452 let comparators = parse_list(py, comparators, parse_expr); |
| 0 | 453 |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
454 expr::Compare(Box::new(left), ops, comparators) |
| 14 | 455 } else if is_instance(&ast, &listcomp_type) { |
| 456 let elt = ast.getattr(py, "elt").unwrap(); | |
| 457 let generators = ast.getattr(py, "generators").unwrap(); | |
| 458 | |
| 459 let elt = parse_expr(py, elt); | |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
460 let generators = parse_list(py, generators, parse_comprehension); |
| 14 | 461 |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
462 expr::ListComp(Box::new(elt), generators) |
| 16 | 463 } else if is_instance(&ast, &dictcomp_type) { |
| 464 let key = ast.getattr(py, "key").unwrap(); | |
| 465 let value = ast.getattr(py, "value").unwrap(); | |
| 466 let generators = ast.getattr(py, "generators").unwrap(); | |
| 467 | |
| 468 let key = parse_expr(py, key); | |
| 469 let value = parse_expr(py, value); | |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
470 let generators = parse_list(py, generators, parse_comprehension); |
| 16 | 471 |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
472 expr::DictComp(Box::new(key), Box::new(value), generators) |
| 17 | 473 } else if is_instance(&ast, &tuple_type) { |
| 474 let elts = ast.getattr(py, "elts").unwrap(); | |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
475 let elts = parse_list(py, elts, parse_expr); |
|
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
476 expr::Tuple(elts, get_ctx(py, ast)) |
| 52 | 477 } else if is_instance(&ast, &ellipsis_type) { |
| 478 expr::Ellipsis | |
| 73 | 479 } else if is_instance(&ast, &await_type) { |
| 480 let value = ast.getattr(py, "value").unwrap(); | |
| 481 let value = parse_expr(py, value); | |
| 482 | |
| 483 expr::Await(Box::new(value)) | |
| 74 | 484 } else if is_instance(&ast, &yield_type) { |
| 485 let value = ast.getattr(py, "value").unwrap(); | |
| 486 let value = parse_optional_expr(py, value); | |
| 487 | |
| 488 expr::Yield(Box::new(value)) | |
| 75 | 489 } else if is_instance(&ast, &yield_from_type) { |
| 490 let value = ast.getattr(py, "value").unwrap(); | |
| 491 let value = parse_expr(py, value); | |
| 492 | |
| 493 expr::YieldFrom(Box::new(value)) | |
| 76 | 494 } else if is_instance(&ast, &set_type) { |
| 495 let elts = ast.getattr(py, "elts").unwrap(); | |
| 496 let elements = parse_list(py, elts, parse_expr); | |
| 497 | |
| 498 expr::Set(elements) | |
| 77 | 499 } else if is_instance(&ast, &setcomp_type) { |
| 500 let elt = ast.getattr(py, "elt").unwrap(); | |
| 501 let generators = ast.getattr(py, "generators").unwrap(); | |
| 502 | |
| 503 let elt = parse_expr(py, elt); | |
| 504 let generators = parse_list(py, generators, parse_comprehension); | |
| 505 | |
| 506 expr::SetComp(Box::new(elt), generators) | |
| 78 | 507 } else if is_instance(&ast, &generatorexp_type) { |
| 508 let elt = ast.getattr(py, "elt").unwrap(); | |
| 509 let generators = ast.getattr(py, "generators").unwrap(); | |
| 510 | |
| 511 let elt = parse_expr(py, elt); | |
| 512 let generators = parse_list(py, generators, parse_comprehension); | |
| 513 | |
| 514 expr::GeneratorExp(Box::new(elt), generators) | |
| 79 | 515 } else if is_instance(&ast, &lambda_type) { |
| 516 let args = ast.getattr(py, "args").unwrap(); | |
| 517 let body = ast.getattr(py, "body").unwrap(); | |
| 518 | |
| 519 let args = parse_arguments(py, args); | |
| 520 let body = parse_expr(py, body); | |
| 521 | |
| 522 expr::Lambda(Box::new(args), Box::new(body)) | |
| 80 | 523 } else if is_instance(&ast, &ifexp_type) { |
| 524 let test = ast.getattr(py, "test").unwrap(); | |
| 525 let body = ast.getattr(py, "body").unwrap(); | |
| 526 let orelse = ast.getattr(py, "orelse").unwrap(); | |
| 527 | |
| 528 let test = parse_expr(py, test); | |
| 529 let body = parse_expr(py, body); | |
| 530 let orelse = parse_expr(py, orelse); | |
| 531 | |
| 532 expr::IfExp(Box::new(test), Box::new(body), Box::new(orelse)) | |
| 81 | 533 } else if is_instance(&ast, &dict_type) { |
| 534 let keys = ast.getattr(py, "keys").unwrap(); | |
| 535 let values = ast.getattr(py, "values").unwrap(); | |
| 536 | |
| 537 let keys = parse_list(py, keys, parse_optional_expr); | |
| 538 let values = parse_list(py, values, parse_expr); | |
| 539 | |
| 540 expr::Dict(keys, values) | |
| 82 | 541 } else if is_instance(&ast, &subscript_type) { |
| 542 let value = ast.getattr(py, "value").unwrap(); | |
| 543 let slice = ast.getattr(py, "slice").unwrap(); | |
| 544 let ctx = get_ctx(py, ast); | |
| 545 | |
| 546 let value = parse_expr(py, value); | |
| 547 let slice = parse_slice(py, slice); | |
| 548 | |
| 549 expr::Subscript(Box::new(value), Box::new(slice), ctx) | |
| 83 | 550 } else if is_instance(&ast, &starred_type) { |
| 551 let value = ast.getattr(py, "value").unwrap(); | |
| 552 let ctx = get_ctx(py, ast); | |
| 553 | |
| 554 let value = parse_expr(py, value); | |
| 555 | |
| 556 expr::Starred(Box::new(value), ctx) | |
| 16 | 557 } else { |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
558 println!("expr {}", ast); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
559 unreachable!() |
| 0 | 560 } |
| 561 } | |
| 562 | |
|
56
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
563 fn parse_arg(py: Python, ast: PyObject) -> arg { |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
564 let arg = ast.getattr(py, "arg").unwrap(); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
565 let annotation = ast.getattr(py, "annotation").unwrap(); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
566 |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
567 let arg = get_str(py, arg); |
|
61
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
568 let annotation = parse_optional_expr(py, annotation); |
|
56
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
569 |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
570 arg{arg: arg, annotation: annotation} |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
571 } |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
572 |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
573 fn parse_arguments(py: Python, ast: PyObject) -> arguments { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
574 let builtins_module = py.import("builtins").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
575 let isinstance = builtins_module.get(py, "isinstance").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
576 |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
577 let is_instance = |object: &PyObject, type_: &PyObject| { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
578 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
579 }; |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
580 |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
581 let ast_module = py.import("ast").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
582 let ast_type = ast_module.get(py, "AST").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
583 let arguments_type = ast_module.get(py, "arguments").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
584 let arg_type = ast_module.get(py, "arg").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
585 |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
586 assert!(is_instance(&ast, &ast_type)); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
587 |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
588 if is_instance(&ast, &arguments_type) { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
589 let args = arguments{ |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
590 //args: Vec<arg>, |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
591 args: { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
592 let args = ast.getattr(py, "args").unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
593 let mut arguments = vec!(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
594 for arg in args.iter(py).unwrap() { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
595 let arg = arg.unwrap(); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
596 assert!(is_instance(&arg, &arg_type)); |
|
56
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
597 let arg = parse_arg(py, arg); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
598 arguments.push(arg); |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
599 } |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
600 arguments |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
601 }, |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
602 //vararg: Option<arg>, |
|
56
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
603 vararg: { |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
604 let vararg = ast.getattr(py, "vararg").unwrap(); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
605 if vararg == py.None() { |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
606 None |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
607 } else { |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
608 let arg = parse_arg(py, vararg); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
609 Some(arg) |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
610 } |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
611 }, |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
612 //kwonlyargs: Vec<arg>, |
|
56
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
613 kwonlyargs: { |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
614 let kwonlyargs = ast.getattr(py, "kwonlyargs").unwrap(); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
615 let mut arguments = vec!(); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
616 for arg in kwonlyargs.iter(py).unwrap() { |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
617 let arg = arg.unwrap(); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
618 assert!(is_instance(&arg, &arg_type)); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
619 let arg = parse_arg(py, arg); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
620 arguments.push(arg); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
621 } |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
622 arguments |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
623 }, |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
624 //kw_defaults: Vec<Option<expr>>, |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
625 kw_defaults: { |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
626 let kw_defaults = ast.getattr(py, "kw_defaults").unwrap(); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
627 let mut arguments = vec!(); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
628 for arg in kw_defaults.iter(py).unwrap() { |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
629 let arg = arg.unwrap(); |
|
61
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
630 let arg = parse_optional_expr(py, arg); |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
631 |
|
56
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
632 arguments.push(arg); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
633 } |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
634 arguments |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
635 }, |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
636 //kwarg: Option<arg>, |
|
56
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
637 kwarg: { |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
638 let kwarg = ast.getattr(py, "kwarg").unwrap(); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
639 if kwarg == py.None() { |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
640 None |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
641 } else { |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
642 let arg = parse_arg(py, kwarg); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
643 Some(arg) |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
644 } |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
645 }, |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
646 //defaults: Vec<expr> |
|
56
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
647 defaults: { |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
648 let defaults = ast.getattr(py, "defaults").unwrap(); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
649 let mut arguments = vec!(); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
650 for arg in defaults.iter(py).unwrap() { |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
651 let arg = arg.unwrap(); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
652 let arg = parse_expr(py, arg); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
653 arguments.push(arg); |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
654 } |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
655 arguments |
|
c3cc16b933d2
Implement function arguments of all kinds.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
53
diff
changeset
|
656 } |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
657 }; |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
658 args |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
659 } else { |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
660 println!("arguments {}", ast); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
661 panic!() |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
662 } |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
663 } |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
664 |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
665 fn parse_statement(py: Python, ast: PyObject) -> stmt { |
| 0 | 666 let builtins_module = py.import("builtins").unwrap(); |
| 667 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 668 | |
| 669 let is_instance = |object: &PyObject, type_: &PyObject| { | |
| 670 return isinstance.call(py, (object, type_), None).unwrap().is_true(py).unwrap(); | |
| 671 }; | |
| 672 | |
| 673 let ast_module = py.import("ast").unwrap(); | |
| 674 let ast_type = ast_module.get(py, "AST").unwrap(); | |
|
2
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
675 let class_def_type = ast_module.get(py, "ClassDef").unwrap(); |
| 0 | 676 let function_def_type = ast_module.get(py, "FunctionDef").unwrap(); |
|
69
a73eaf42bea1
Add ast.AsyncDefFunction.
Bastien Orivel <eijebong@bananium.fr>
parents:
68
diff
changeset
|
677 let async_function_def_type = ast_module.get(py, "AsyncFunctionDef").unwrap(); |
| 0 | 678 let global_type = ast_module.get(py, "Global").unwrap(); |
| 51 | 679 let nonlocal_type = ast_module.get(py, "Nonlocal").unwrap(); |
| 0 | 680 let assign_type = ast_module.get(py, "Assign").unwrap(); |
|
8
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
681 let aug_assign_type = ast_module.get(py, "AugAssign").unwrap(); |
| 0 | 682 let return_type = ast_module.get(py, "Return").unwrap(); |
| 683 let import_from_type = ast_module.get(py, "ImportFrom").unwrap(); | |
|
47
38f59b0efc2c
Handle Import and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
44
diff
changeset
|
684 let import_type = ast_module.get(py, "Import").unwrap(); |
| 0 | 685 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
|
686 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
|
687 let for_type = ast_module.get(py, "For").unwrap(); |
| 71 | 688 let async_for_type = ast_module.get(py, "AsyncFor").unwrap(); |
| 0 | 689 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
|
690 let break_type = ast_module.get(py, "Break").unwrap(); |
| 21 | 691 let delete_type = ast_module.get(py, "Delete").unwrap(); |
| 49 | 692 let pass_type = ast_module.get(py, "Pass").unwrap(); |
| 50 | 693 let continue_type = ast_module.get(py, "Continue").unwrap(); |
| 57 | 694 let assert_type = ast_module.get(py, "Assert").unwrap(); |
| 59 | 695 let with_type = ast_module.get(py, "With").unwrap(); |
| 72 | 696 let async_with_type = ast_module.get(py, "AsyncWith").unwrap(); |
| 60 | 697 let raise_type = ast_module.get(py, "Raise").unwrap(); |
| 68 | 698 let try_type = ast_module.get(py, "Try").unwrap(); |
| 0 | 699 |
| 700 assert!(is_instance(&ast, &ast_type)); | |
| 701 | |
| 702 /* | |
| 703 // TODO: implement Hash for PyObject. (trivial) | |
| 704 let map = { | |
| 705 let fields = ast.getattr(py, "_fields").unwrap(); | |
| 706 let mut map = HashMap::new(); | |
| 707 for field in fields.iter(py).unwrap() { | |
| 708 let field = field.unwrap(); | |
| 709 let value = ast.getattr(py, field).unwrap(); | |
| 710 map.insert(field, value); | |
| 711 } | |
| 712 map | |
| 713 }; | |
| 714 */ | |
| 715 | |
|
2
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
716 if is_instance(&ast, &class_def_type) { |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
717 let name = ast.getattr(py, "name").unwrap(); |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
718 let bases = ast.getattr(py, "bases").unwrap(); |
|
67
8ce78e2ba48c
Implement class keywords.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
65
diff
changeset
|
719 let keywords = ast.getattr(py, "keywords").unwrap(); |
|
2
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
720 let body = ast.getattr(py, "body").unwrap(); |
|
65
ce5e27a3f277
Add ClassDef.decorator_list support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
64
diff
changeset
|
721 let decorator_list = ast.getattr(py, "decorator_list").unwrap(); |
|
2
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
722 |
|
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
723 let name = get_str(py, name); |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
724 let bases = parse_list(py, bases, parse_expr); |
|
67
8ce78e2ba48c
Implement class keywords.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
65
diff
changeset
|
725 let keywords = parse_list(py, keywords, parse_keyword); |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
726 let body = parse_list(py, body, parse_statement); |
|
65
ce5e27a3f277
Add ClassDef.decorator_list support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
64
diff
changeset
|
727 let decorator_list = parse_list(py, decorator_list, parse_expr); |
|
2
5fc7c2790d8c
Add class support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
1
diff
changeset
|
728 |
|
67
8ce78e2ba48c
Implement class keywords.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
65
diff
changeset
|
729 stmt::ClassDef(name, bases, keywords, body, decorator_list) |
|
69
a73eaf42bea1
Add ast.AsyncDefFunction.
Bastien Orivel <eijebong@bananium.fr>
parents:
68
diff
changeset
|
730 } else if is_instance(&ast, &function_def_type) || is_instance(&ast, &async_function_def_type) { |
| 0 | 731 let name = ast.getattr(py, "name").unwrap(); |
| 732 let args = ast.getattr(py, "args").unwrap(); | |
| 733 let body = ast.getattr(py, "body").unwrap(); | |
|
64
53817b39f139
Add FunctionDef.decorator_list support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
63
diff
changeset
|
734 let decorator_list = ast.getattr(py, "decorator_list").unwrap(); |
|
63
5df52b40fe54
Implement FunctionDef.returns.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
61
diff
changeset
|
735 let returns = ast.getattr(py, "returns").unwrap(); |
| 0 | 736 |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
737 let name = get_str(py, name); |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
738 let args = parse_arguments(py, args); |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
739 let body = parse_list(py, body, parse_statement); |
|
64
53817b39f139
Add FunctionDef.decorator_list support.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
63
diff
changeset
|
740 let decorator_list = parse_list(py, decorator_list, parse_expr); |
|
63
5df52b40fe54
Implement FunctionDef.returns.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
61
diff
changeset
|
741 let returns = parse_optional_expr(py, returns); |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
742 |
|
69
a73eaf42bea1
Add ast.AsyncDefFunction.
Bastien Orivel <eijebong@bananium.fr>
parents:
68
diff
changeset
|
743 stmt::FunctionDef(name, args, body, decorator_list, returns, is_instance(&ast, &async_function_def_type)) |
| 0 | 744 } else if is_instance(&ast, &global_type) { |
| 745 let names = ast.getattr(py, "names").unwrap(); | |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
746 let names = parse_list(py, names, get_str); |
|
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
747 stmt::Global(names) |
| 51 | 748 } else if is_instance(&ast, &nonlocal_type) { |
| 749 let names = ast.getattr(py, "names").unwrap(); | |
| 750 let names = parse_list(py, names, get_str); | |
| 751 stmt::Nonlocal(names) | |
| 0 | 752 } else if is_instance(&ast, &if_type) { |
| 753 let test = ast.getattr(py, "test").unwrap(); | |
| 754 let body = ast.getattr(py, "body").unwrap(); | |
| 755 let orelse = ast.getattr(py, "orelse").unwrap(); | |
| 756 | |
| 757 let test = parse_expr(py, test); | |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
758 let body = parse_list(py, body, parse_statement); |
|
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
759 let orelse = parse_list(py, orelse, parse_statement); |
| 0 | 760 |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
761 stmt::If(test, body, orelse) |
|
6
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
762 } else if is_instance(&ast, &while_type) { |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
763 let test = ast.getattr(py, "test").unwrap(); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
764 let body = ast.getattr(py, "body").unwrap(); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
765 let orelse = ast.getattr(py, "orelse").unwrap(); |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
766 |
|
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
767 let test = parse_expr(py, test); |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
768 let body = parse_list(py, body, parse_statement); |
|
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
769 let orelse = parse_list(py, orelse, parse_statement); |
|
6
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
770 |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
771 stmt::While(test, body, orelse) |
| 71 | 772 } else if is_instance(&ast, &for_type) || is_instance(&ast, &async_for_type) { |
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
773 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
|
774 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
|
775 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
|
776 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
|
777 |
|
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
778 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
|
779 let iter = parse_expr(py, iter); |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
780 let body = parse_list(py, body, parse_statement); |
|
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
781 let orelse = parse_list(py, orelse, parse_statement); |
|
5
ddf372373a77
Add ast.For, ast.UnaryOp, and Sub and Div to ast.BinOp.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
4
diff
changeset
|
782 |
| 71 | 783 stmt::For(target, iter, body, orelse, is_instance(&ast, &async_for_type)) |
| 0 | 784 } else if is_instance(&ast, &assign_type) { |
| 785 let targets = ast.getattr(py, "targets").unwrap(); | |
| 786 let value = ast.getattr(py, "value").unwrap(); | |
| 787 | |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
788 let targets = parse_list(py, targets, parse_expr); |
| 0 | 789 let value = parse_expr(py, value); |
| 790 | |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
791 stmt::Assign(targets, value) |
|
8
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
792 } else if is_instance(&ast, &aug_assign_type) { |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
793 let target = ast.getattr(py, "target").unwrap(); |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
794 let op = ast.getattr(py, "op").unwrap(); |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
795 let value = ast.getattr(py, "value").unwrap(); |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
796 |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
797 let target = parse_expr(py, target); |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
798 let op = parse_operator(py, op); |
|
8
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
799 let value = parse_expr(py, value); |
|
94ff501bf336
Add ast.AugAssign.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
7
diff
changeset
|
800 |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
801 stmt::AugAssign(target, op, value) |
| 0 | 802 } else if is_instance(&ast, &import_from_type) { |
| 803 let module = ast.getattr(py, "module").unwrap(); | |
| 804 let names = ast.getattr(py, "names").unwrap(); | |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
805 let level = ast.getattr(py, "level").unwrap(); |
| 0 | 806 |
|
1
b90e49ab734b
Factorise conversion of Python str into Rust String.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
0
diff
changeset
|
807 let module = get_str(py, module); |
|
44
5f1d285471af
Finish ImportFrom conversion and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
21
diff
changeset
|
808 let names = parse_list(py, names, parse_alias); |
| 0 | 809 |
|
48
039f85b187f2
Also handle relative imports.
Bastien Orivel <eijebong@bananium.fr>
parents:
47
diff
changeset
|
810 if level == py.None() { |
|
039f85b187f2
Also handle relative imports.
Bastien Orivel <eijebong@bananium.fr>
parents:
47
diff
changeset
|
811 stmt::ImportFrom(module, names, None) |
|
039f85b187f2
Also handle relative imports.
Bastien Orivel <eijebong@bananium.fr>
parents:
47
diff
changeset
|
812 } else { |
|
039f85b187f2
Also handle relative imports.
Bastien Orivel <eijebong@bananium.fr>
parents:
47
diff
changeset
|
813 let level = level.extract(py).unwrap(); |
|
039f85b187f2
Also handle relative imports.
Bastien Orivel <eijebong@bananium.fr>
parents:
47
diff
changeset
|
814 stmt::ImportFrom(module, names, Some(level)) |
|
039f85b187f2
Also handle relative imports.
Bastien Orivel <eijebong@bananium.fr>
parents:
47
diff
changeset
|
815 } |
|
47
38f59b0efc2c
Handle Import and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
44
diff
changeset
|
816 } else if is_instance(&ast, &import_type) { |
|
38f59b0efc2c
Handle Import and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
44
diff
changeset
|
817 let names = ast.getattr(py, "names").unwrap(); |
|
38f59b0efc2c
Handle Import and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
44
diff
changeset
|
818 let names = parse_list(py, names, parse_alias); |
|
38f59b0efc2c
Handle Import and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
44
diff
changeset
|
819 |
|
38f59b0efc2c
Handle Import and add a test for it.
Bastien Orivel <eijebong@bananium.fr>
parents:
44
diff
changeset
|
820 stmt::Import(names) |
| 0 | 821 } else if is_instance(&ast, &return_type) { |
| 822 let value = ast.getattr(py, "value").unwrap(); | |
|
61
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
823 let value = parse_optional_expr(py, value); |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
824 |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
825 stmt::Return(value) |
| 0 | 826 } else if is_instance(&ast, &expr_type) { |
| 827 let value = ast.getattr(py, "value").unwrap(); | |
| 828 let value = parse_expr(py, value); | |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
829 stmt::Expr(value) |
|
6
6f2bf13f4cb5
Add ast.While and ast.Break.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
5
diff
changeset
|
830 } else if is_instance(&ast, &break_type) { |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
831 stmt::Break |
| 21 | 832 } else if is_instance(&ast, &delete_type) { |
| 833 let targets = ast.getattr(py, "targets").unwrap(); | |
| 834 let targets = parse_list(py, targets, parse_expr); | |
| 835 stmt::Delete(targets) | |
| 49 | 836 } else if is_instance(&ast, &pass_type) { |
| 837 stmt::Pass | |
| 50 | 838 } else if is_instance(&ast, &continue_type) { |
| 839 stmt::Continue | |
| 57 | 840 } else if is_instance(&ast, &assert_type) { |
| 841 let test = ast.getattr(py, "test").unwrap(); | |
| 842 let msg = ast.getattr(py, "msg").unwrap(); | |
| 843 | |
|
61
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
844 let test = parse_expr(py, test); |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
845 let msg = parse_optional_expr(py, msg); |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
846 |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
847 stmt::Assert(test, msg) |
| 72 | 848 } else if is_instance(&ast, &with_type) || is_instance(&ast, &async_with_type) { |
| 59 | 849 let items = ast.getattr(py, "items").unwrap(); |
| 850 let body = ast.getattr(py, "body").unwrap(); | |
| 851 | |
| 852 let items = parse_list(py, items, parse_withitem); | |
| 853 let body = parse_list(py, body, parse_statement); | |
| 72 | 854 stmt::With(items, body, is_instance(&ast, &async_with_type)) |
| 60 | 855 } else if is_instance(&ast, &raise_type) { |
| 856 let exc = ast.getattr(py, "exc").unwrap(); | |
| 857 let cause = ast.getattr(py, "cause").unwrap(); | |
| 858 | |
|
61
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
859 let exc = parse_optional_expr(py, exc); |
|
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
860 let cause = parse_optional_expr(py, cause); |
| 60 | 861 |
|
61
6b73843c5b4a
Add a parse_optional_expr function and use it instead of let var = if var == py.None() { None } else { Some(parse_expr(var) };
Bastien Orivel <eijebong@bananium.fr>
parents:
60
diff
changeset
|
862 stmt::Raise(exc, cause) |
| 68 | 863 } else if is_instance(&ast, &try_type) { |
| 864 let body = ast.getattr(py, "body").unwrap(); | |
| 865 let excepthandlers = ast.getattr(py, "handlers").unwrap(); | |
| 866 let orelse = ast.getattr(py, "orelse").unwrap(); | |
| 867 let finalbody = ast.getattr(py, "finalbody").unwrap(); | |
| 868 | |
| 869 let body = parse_list(py, body, parse_statement); | |
| 870 let excepthandlers = parse_list(py, excepthandlers, parse_excepthandler); | |
| 871 let orelse = parse_list(py, orelse, parse_statement); | |
| 872 let finalbody = parse_list(py, finalbody, parse_statement); | |
| 873 | |
| 874 stmt::Try(body, excepthandlers, orelse, finalbody) | |
| 0 | 875 } else { |
|
13
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
876 println!("stmt {}", ast); |
|
38b0d63697b1
Import the full AST grammar from CPython 3.5.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
9
diff
changeset
|
877 panic!() |
| 0 | 878 } |
| 879 } | |
| 880 | |
| 881 #[allow(dead_code)] | |
| 882 pub fn convert_ast(name: String, module: &PyObject) -> Module { | |
| 883 let gil = Python::acquire_gil(); | |
| 884 let py = gil.python(); | |
| 885 | |
| 886 let builtins_module = py.import("builtins").unwrap(); | |
| 887 let isinstance = builtins_module.get(py, "isinstance").unwrap(); | |
| 888 | |
| 889 let ast_module = py.import("ast").unwrap(); | |
| 890 let module_type = ast_module.get(py, "Module").unwrap(); | |
| 891 | |
| 892 assert!(isinstance.call(py, (module, module_type), None).unwrap().is_true(py).unwrap()); | |
| 893 | |
| 894 let body = module.getattr(py, "body").unwrap(); | |
|
20
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
895 let body = parse_list(py, body, parse_statement); |
|
ace12d6b9855
Replace every loop in ast_convert with parse_list.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
19
diff
changeset
|
896 Module{name: name, statements: body} |
| 0 | 897 } |