forked from lcompilers/lpython
-
Notifications
You must be signed in to change notification settings - Fork 0
/
AST.asdl
126 lines (101 loc) · 4.18 KB
/
AST.asdl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
-- This is an Abstract Syntax Description Lanuguage (ASDL) that describes the
-- Fortran's Abstract Syntax Tree (AST). See [1] for a short background
-- information and motivation and see the paper [2] for a detailed motivation,
-- explanation and specification of the language. See [3] for further examples
-- of ASDL usage in a real compiler.
--
-- [1] https://eli.thegreenplace.net/2014/06/04/using-asdl-to-describe-asts-in-compilers/
-- [2] Wang, D. C., Appel, A. W., Korn, J. L., & Serra, C. S. (1997). The Zephyr Abstract Syntax Description Language. USENIX Conference on Domain-Specific Languages, (October), 213–228.
-- [3] https://arxiv.org/abs/cs/9810013
--
-- ASDL's builtin types are:
-- * identifier
-- * int (signed integers of infinite precision)
-- * string
-- We extend these by:
-- * object (any Python object)
-- * node (any ASDL node)
-- * constant
--
-- Specific tools may choose to produce language interfaces that represent
-- these types and the ASDL tree in a language specific way (e.g. use finite
-- precision integers and signal an error otherwise).
module AST {
unit
= TranslationUnit(node* items)
mod
= Module(identifier name, unit_decl1* use, unit_decl2* decl,
program_unit* contains)
| Program(identifier name, unit_decl1* use, unit_decl2* decl,
stmt* body, program_unit* contains)
program_unit
= Subroutine(identifier name, arg* args, unit_decl1* use, unit_decl2* decl,
stmt* body, program_unit* contains)
| Function(identifier name, arg* args, string? return_type,
expr? return_var, tbind? bind, unit_decl1* use, unit_decl2* decl,
stmt* body, program_unit* contains)
attributes (int lineno, int col_offset)
unit_decl1
= Use(identifier module, use_symbol* symbols)
attributes (int lineno, int col_offset)
unit_decl2
= Declaration(decl* vars)
| Private(identifier* vars)
| Public(identifier* vars)
| Interface(identifier name, identifier* procs)
| Interface2(identifier? name, program_unit* procs)
attributes (int lineno, int col_offset)
stmt
= Assignment(expr target, expr value)
| Associate(expr target, expr value)
| SubroutineCall(identifier name, expr* args)
| BuiltinCall(identifier name, expr* args)
| If(expr test, stmt* body, stmt* orelse)
| Where(expr test, stmt* body, stmt* orelse)
| Stop(expr? code)
| ErrorStop(expr? code)
| DoLoop(identifier? var, expr? start, expr? end, expr? increment,
stmt* body)
| DoConcurrentLoop(identifier? var, expr? start, expr? end, expr? increment,
reduce? reduce, stmt* body)
| Select(expr test, case_stmt* body, stmt* default)
| Cycle()
| Exit()
| Return()
| WhileLoop(expr test, stmt* body)
| Print(string? fmt, expr* values)
attributes (int lineno, int col_offset)
expr
= BoolOp(expr left, boolop op, expr right)
| BinOp(expr left, operator op, expr right)
| UnaryOp(unaryop op, expr operand)
| Compare(expr left, cmpop op, expr right)
| FuncCall(identifier func, expr* args, keyword* keywords)
| FuncCallOrArray(identifier func, expr* args, keyword* keywords)
| Array(identifier name, array_index* args)
| ArrayInitializer(expr* args)
| Num(object n)
| Real(string n)
| Str(string s)
| Name(identifier id)
| Constant(constant value)
attributes (int lineno, int col_offset)
boolop = And | Or | Eqv | NEqv
operator = Add | Sub | Mul | Div | Pow
unaryop = Invert | Not | UAdd | USub
cmpop = Eq | NotEq | Lt | LtE | Gt | GtE
decl = (identifier sym, string? sym_type, dimension* dims, attribute *attrs,
expr? initializer)
dimension = (expr? start, expr? end)
attribute = Attribute(identifier name, attribute_arg *args, dimension* dims)
attribute_arg = (identifier arg)
arg = (identifier arg)
attributes (int lineno, int col_offset)
keyword = (identifier? arg, expr value)
tbind = Bind(keyword* args)
array_index = ArrayIndex(expr? left, expr? right, expr? step)
case_stmt = CaseStmt(expr test, stmt* body)
use_symbol = UseSymbol(identifier sym, identifier? rename)
reduce = Reduce(reduce_op op, identifier *vars)
reduce_op = ReduceAdd | ReduceMul | ReduceMIN | ReduceMAX
}