forked from lcompilers/lpython
-
Notifications
You must be signed in to change notification settings - Fork 0
/
ASR.asdl
120 lines (92 loc) · 3.71 KB
/
ASR.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
-- Abstract Semantic Representation (ASR) definition
-- ASDL's builtin types are:
-- * identifier
-- * int (signed integers of infinite precision)
-- * string
-- We extend these by:
-- * object (any Python object)
-- * constant (.true. / .false.)
-- * symbol_table (scoped Symbol Table implementation)
-- * node (any ASR node)
--
-- Note: `symbol_table` contains `Program`, `Module`, `Subroutine`, `Function`, `Variable`.
-- TODO: Change the sum fn = Function(...) to product Function = (...)
-- make all products subclass asr_t, thus including the location information
-- product is represented by a value, unless it is optional or a sequence.
-- Change to products: TranslationUnit, Program, Module, Subroutine, Function,
-- Variable, Attribute, Bind
module ASR {
unit
= TranslationUnit(symbol_table global_scope, node* items)
prog
= Program(symbol_table symtab, identifier name, stmt* body)
mod
= Module(symbol_table symtab, identifier name)
sub
= Subroutine(symbol_table symtab, identifier name, expr* args, stmt* body,
tbind? bind)
fn
= Function(symbol_table symtab, identifier name, expr* args, stmt* body,
tbind? bind, expr return_var, string? module)
var
-- intent:
-- =0 ... local variable,
-- >0 ... dummy argument: 1=in, 2=out, 3=inout
= Variable(symbol_table parent_symtab, identifier name, intent intent,
ttype type)
stmt
= Assignment(expr target, expr value)
| SubroutineCall(sub 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(do_loop_head? head, stmt* body)
| DoConcurrentLoop(do_loop_head head, stmt* body)
| Select(expr test, case_stmt* body, case_default? default)
| Cycle()
| Exit()
| WhileLoop(expr test, stmt* body)
| Print(string? fmt, expr* values)
expr
= BoolOp(expr left, boolop op, expr right, ttype type)
| BinOp(expr left, operator op, expr right, ttype type)
| UnaryOp(unaryop op, expr operand, ttype type)
| Compare(expr left, cmpop op, expr right, ttype type)
| FuncCall(fn func, expr* args, keyword* keywords, ttype type)
| ArrayInitializer(expr* args, ttype type)
| Num(object n, ttype type) -- TODO: rename to ConstantInteger
| ConstantReal(string r, ttype type)
| Constant(constant value, ttype type) -- TODO: rename to ConstantLogical
| Str(string s, ttype type)
| VariableOld(identifier name, string? intent, int? dummy, ttype type)
| Var(var v)
| ArrayRef(var v, array_index* args, ttype type)
| ImplicitCast(expr arg, cast_kind kind, ttype type)
| ExplicitCast(expr arg, cast_kind kind, ttype type)
ttype
= Integer(int kind, dimension* dims)
| Real(int kind, dimension* dims)
| Complex(int kind, dimension* dims)
| Character(int kind, dimension* dims)
| Logical(int kind, dimension* dims)
| Derived(string name, dimension* dims, string? module)
boolop = And | Or
-- TODO: rename to binop:
operator = Add | Sub | Mul | Div | Pow
unaryop = Invert | Not | UAdd | USub
cmpop = Eq | NotEq | Lt | LtE | Gt | GtE
intent = Local | In | Out | InOut | ReturnVar | External
cast_kind = RealToInteger | IntegerToReal | RealToReal | IntegerToInteger
dimension = (expr? start, expr? end)
attribute = Attribute(identifier name, attribute_arg *args)
attribute_arg = (identifier arg)
arg = (identifier arg)
keyword = (identifier? arg, expr value)
tbind = Bind(string lang, string name)
array_index = (expr? left, expr? right, expr? step)
do_loop_head = (expr v, expr start, expr end, expr? increment)
case_stmt = (expr test, stmt* body)
case_default = (stmt* body)
}