Project

General

Profile

Revision 17abbe95 src/parser_lustre.mly

View differences:

src/parser_lustre.mly
48 48
%token <string> REAL
49 49
%token <float> FLOAT
50 50
%token AUTOMATON STATE UNTIL UNLESS RESTART RESUME LAST
51
%token STATELESS ASSERT OPEN QUOTE FUNCTION
51
%token STATELESS ASSERT INCLUDE QUOTE FUNCTION
52 52
%token <string> IDENT
53 53
%token <LustreSpec.expr_annot> ANNOT
54 54
%token <LustreSpec.node_annot> NODESPEC
......
91 91

  
92 92
%start prog
93 93
%type <Corelang.top_decl list> prog
94
%start header
95
%type <Corelang.top_decl list> header
96 94

  
97 95
%%
98 96

  
99 97
prog:
100 98
    typ_def_list top_decl_list EOF {$1;(List.rev $2)}
101 99

  
102
header:
103
    typ_def_list top_decl_header_list EOF {$1;(List.rev $2)}
104

  
105 100
top_decl_list:
106 101
  top_decl {[$1]}
107 102
| top_decl_list top_decl {$2::$1}
108 103

  
104
top_decl:
105
| CONST cdecl_list { mktop_decl (Consts (List.rev $2)) }
109 106

  
110
top_decl_header_list:
111
  top_decl_header {[$1]}
112
| top_decl_header_list top_decl_header {$2::$1}
107
| NODE IDENT LPAR vdecl_list RPAR RETURNS LPAR vdecl_list SCOL_opt RPAR SCOL_opt locals LET eq_list TEL 
108
    {let eqs, asserts, annots = $14 in
109
     let nd = mktop_decl (Node
110
                            {node_id = $2;
111
                             node_type = Types.new_var ();
112
                             node_clock = Clocks.new_var true;
113
                             node_inputs = List.rev $4;
114
                             node_outputs = List.rev $8;
115
                             node_locals = List.rev $12;
116
			     node_gencalls = [];
117
			     node_checks = [];
118
			     node_asserts = asserts; 
119
                             node_eqs = eqs;
120
			     node_spec = None;
121
			     node_annot = match annots with [] -> None | _ -> Some annots})
122
    in
123
    Hashtbl.add node_table $2 nd; nd}
113 124

  
125
| nodespec_list NODE IDENT LPAR vdecl_list RPAR RETURNS LPAR vdecl_list SCOL_opt RPAR SCOL_opt locals LET eq_list TEL 
126
    {let eqs, asserts, annots = $15 in
127
     let nd = mktop_decl (Node
128
                            {node_id = $3;
129
                             node_type = Types.new_var ();
130
                             node_clock = Clocks.new_var true;
131
                             node_inputs = List.rev $5;
132
                             node_outputs = List.rev $9;
133
                             node_locals = List.rev $13;
134
			     node_gencalls = [];
135
			     node_checks = [];
136
			     node_asserts = asserts; 
137
                             node_eqs = eqs;
138
			     node_spec = Some $1;
139
			     node_annot = match annots with [] -> None | _ -> Some annots})
140
    in
141
    Hashtbl.add node_table $3 nd; nd}
114 142

  
115
top_decl_header:
116
| NODE IDENT LPAR vdecl_list SCOL_opt RPAR RETURNS LPAR vdecl_list SCOL_opt RPAR stateless_opt SCOL
143
| IMPORTED NODE IDENT LPAR vdecl_list RPAR RETURNS LPAR vdecl_list RPAR stateless_opt SCOL
117 144
    {let nd = mktop_decl (ImportedNode
118
                            {nodei_id = $2;
145
                            {nodei_id = $3;
119 146
                             nodei_type = Types.new_var ();
120 147
                             nodei_clock = Clocks.new_var true;
121
                             nodei_inputs = List.rev $4;
148
                             nodei_inputs = List.rev $5;
122 149
                             nodei_outputs = List.rev $9;
123
			     nodei_stateless = $12;
150
			     nodei_stateless = $11;
124 151
			     nodei_spec = None})
125 152
    in
126
    Hashtbl.add node_table $2 nd; nd}
153
    Hashtbl.add node_table $3 nd; nd}
127 154

  
128
| nodespec_list NODE IDENT LPAR vdecl_list SCOL_opt RPAR RETURNS LPAR vdecl_list SCOL_opt RPAR stateless_opt SCOL
155
| nodespec_list IMPORTED NODE IDENT LPAR vdecl_list RPAR RETURNS LPAR vdecl_list RPAR stateless_opt SCOL
129 156
    {let nd = mktop_decl (ImportedNode
130
                            {nodei_id = $3;
157
                            {nodei_id = $4;
131 158
                             nodei_type = Types.new_var ();
132 159
                             nodei_clock = Clocks.new_var true;
133
                             nodei_inputs = List.rev $5;
160
                             nodei_inputs = List.rev $6;
134 161
                             nodei_outputs = List.rev $10;
135
			     nodei_stateless = $13;
162
			     nodei_stateless = $12;
136 163
			     nodei_spec = Some $1})
137 164
    in
138
    Hashtbl.add node_table $3 nd; nd}
165
    Hashtbl.add node_table $4 nd; nd}
139 166

  
140
| FUNCTION IDENT LPAR vdecl_list SCOL_opt RPAR RETURNS LPAR vdecl_list SCOL_opt RPAR SCOL
167
| FUNCTION IDENT LPAR vdecl_list RPAR RETURNS LPAR vdecl_list RPAR SCOL
141 168
    {let nd = mktop_decl (ImportedNode
142 169
                            {nodei_id = $2;
143 170
                             nodei_type = Types.new_var ();
144 171
			     nodei_clock = Clocks.new_var true;
145 172
                             nodei_inputs = List.rev $4;
146
                             nodei_outputs = List.rev $9;
173
                             nodei_outputs = List.rev $8;
147 174
			     nodei_stateless = true;
148 175
			     nodei_spec = None})
149 176
     in
150 177
     Hashtbl.add node_table $2 nd; nd}
151 178

  
152
| nodespec_list FUNCTION IDENT LPAR vdecl_list SCOL_opt RPAR RETURNS LPAR vdecl_list SCOL_opt RPAR SCOL
179
| nodespec_list FUNCTION IDENT LPAR vdecl_list RPAR RETURNS LPAR vdecl_list RPAR SCOL
153 180
    {let nd = mktop_decl (ImportedNode
154 181
                            {nodei_id = $3;
155 182
                             nodei_type = Types.new_var ();
156 183
			     nodei_clock = Clocks.new_var true;
157 184
                             nodei_inputs = List.rev $5;
158
                             nodei_outputs = List.rev $10;
185
                             nodei_outputs = List.rev $9;
159 186
			     nodei_stateless = true;
160 187
			     nodei_spec = Some $1})
161 188
     in
162 189
    Hashtbl.add node_table $3 nd; nd}
163 190

  
164
top_decl:
165
| CONST cdecl_list { mktop_decl (Consts (List.rev $2)) }
166

  
167
| NODE IDENT LPAR vdecl_list SCOL_opt RPAR RETURNS LPAR vdecl_list SCOL_opt RPAR SCOL_opt locals LET eq_list TEL 
168
    {let eqs, asserts, annots = $15 in
169
     let nd = mktop_decl (Node
170
                            {node_id = $2;
171
                             node_type = Types.new_var ();
172
                             node_clock = Clocks.new_var true;
173
                             node_inputs = List.rev $4;
174
                             node_outputs = List.rev $9;
175
                             node_locals = List.rev $13;
176
			     node_gencalls = [];
177
			     node_checks = [];
178
			     node_asserts = asserts; 
179
                             node_eqs = eqs;
180
			     node_spec = None;
181
			     node_annot = match annots with [] -> None | _ -> Some annots})
182
    in
183
    Hashtbl.add node_table $2 nd; nd}
184

  
185
| nodespec_list NODE IDENT LPAR vdecl_list SCOL_opt RPAR RETURNS LPAR vdecl_list SCOL_opt RPAR SCOL_opt locals LET eq_list TEL 
186
    {let eqs, asserts, annots = $16 in
187
     let nd = mktop_decl (Node
188
                            {node_id = $3;
189
                             node_type = Types.new_var ();
190
                             node_clock = Clocks.new_var true;
191
                             node_inputs = List.rev $5;
192
                             node_outputs = List.rev $10;
193
                             node_locals = List.rev $14;
194
			     node_gencalls = [];
195
			     node_checks = [];
196
			     node_asserts = asserts; 
197
                             node_eqs = eqs;
198
			     node_spec = Some $1;
199
			     node_annot = match annots with [] -> None | _ -> Some annots})
200
    in
201
    Hashtbl.add node_table $3 nd; nd}
202

  
203
| OPEN QUOTE IDENT QUOTE { mktop_decl (Open $3) }
191
| INCLUDE QUOTE IDENT QUOTE { mktop_decl (Include $3) }
204 192

  
205 193
nodespec_list:
206 194
NODESPEC { $1 }

Also available in: Unified diff