← Back to branch summary

~eda-qa/leaflang/misc

« back to all changes in this revision

Viewing changes to src/lang/dump/statement.inc.cpp

  • Committer: edA-qa mort-ora-y
  • Date: 2017-05-13 04:00:12 UTC
  • mfrom: (96.1.42 sortfile)
  • Revision ID: eda-qa@disemia.com-20170513040012-ieshuqv2vkjt0xc3
merging sortfile

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lang/dump/statement.inc.cpp
 
1
void dump::dump_assign_statement( assign_statement const * as ) {
 
2
        CHECK_NULL(as,"assign_statement")
 
3
        dump_expression( as->left.get() );
 
4
        switch( as->how ) {
 
5
                case assign_statement::h_value: out << " = "; break;
 
6
                case assign_statement::h_init_refer: out << " := "; break;
 
7
                case assign_statement::h_default: out << " |= "; break;
 
8
        }
 
9
        dump_expression( as->right.get() );
 
10
}
 
11
 
 
12
void dump::dump_declaration( declaration const * decl, unsigned flags ) {
 
13
        CHECK_NULL( decl, "declaration" );
 
14
        
 
15
        if( decl->is_export ) {
 
16
                out << "@export ";
 
17
        }
 
18
        
 
19
        switch( decl->lifetime ) {
 
20
                case declaration::l_local: break;
 
21
                case declaration::l_global: out << "@lifetime(global) "; break;
 
22
        }
 
23
        
 
24
        if( decl->import_type != declaration::it_none) {
 
25
                switch( decl->import_type ) {
 
26
                        case declaration::it_none: break;
 
27
                        case declaration::it_abi_code: out << "@import("; break;
 
28
                        case declaration::it_abi_data: out << "@import_data("; break;
 
29
                }
 
30
                if( decl->import_module.size() ) {
 
31
                        out << decl->import_module << ".";
 
32
                }
 
33
                out << decl->import_name;
 
34
                switch( decl->name_form ) {
 
35
                        case declaration::nf_bare: out << ",bare"; break;
 
36
                        case declaration::nf_leaf: out << ",leaf"; break;
 
37
                        case declaration::nf_auto: out << ",auto"; break;
 
38
                }
 
39
                out << ") ";
 
40
        }
 
41
        
 
42
        switch( decl->form ) {
 
43
                case declaration::f_single: out << "single "; break;
 
44
                case declaration::f_multi: out << "multi "; break;
 
45
                case declaration::f_arg: out << "arg "; break; //internal (not in code directly)
 
46
                case declaration::f_return: out << "return "; break; //internal
 
47
                case declaration::f_capture: out << "capture "; break; //internal
 
48
        }
 
49
        
 
50
        out << decl->symbol;
 
51
 
 
52
        if( show_spec_type ) {
 
53
                if( decl->spec_type ) {
 
54
                        out << " : ";
 
55
                        dump_type_spec( decl->spec_type.get() );
 
56
                }
 
57
        } else {
 
58
                out << " : ";
 
59
                //the decl itself need not be valid, only the values (relevant for class parametric functions)
 
60
                dump_type_ref( decl->type, tf_no_validate );
 
61
        }
 
62
 
 
63
        if( decl->literal_value && !omit_value && !(flags & df_omit_value) ) {
 
64
                out << " = ";
 
65
                dump_expression( decl->literal_value.get(), ef_expand_name );
 
66
        }
 
67
}
 
68
 
 
69
void dump::dump_var_statement( var_statement const * vs ) {
 
70
        CHECK_NULL( vs, "var_statement" )
 
71
        
 
72
        dump_declaration( vs->decl.get() );
 
73
        
 
74
        if( vs->value ) {
 
75
                if( vs->init_refer_value )
 
76
                        out << " := ";
 
77
                else
 
78
                        out << " = ";
 
79
                dump_expression( vs->value.get() );
 
80
        }
 
81
}
 
82
 
 
83
void dump::dump_init_statement( init_statement const * is ) {
 
84
        CHECK_NULL( is, "init_statement" )
 
85
        auto decl = is->sref;
 
86
 
 
87
        out << "init ";
 
88
        dump_declaration( decl.get(), df_omit_value );
 
89
 
 
90
        if( is->undefined ) {
 
91
                out << " = undefined";
 
92
        }
 
93
                
 
94
        if( is->value ) {
 
95
                if( is->init_refer_value )
 
96
                        out << " := ";
 
97
                else
 
98
                        out << " = ";
 
99
                dump_expression( is->value.get(), ef_expand_name );
 
100
        }
 
101
        
 
102
        if( is->no_release ) {
 
103
                out << " no_release";
 
104
        }
 
105
                
 
106
        if( is->code ) {
 
107
                out << "{";
 
108
                out << endl();
 
109
                indent();
 
110
                dump_statement( is->code.get() );
 
111
                unindent();
 
112
                out << indent_str() << "}" << endl();
 
113
        }
 
114
}
 
115
 
 
116
void dump::dump_defer_statement( defer_statement const * defer ) {
 
117
        CHECK_NULL( defer, "defer_statement" )
 
118
        out << (defer->error_only ? "defer_error" : "defer");
 
119
        dump_statement_block( defer->block.get() );
 
120
}
 
121
 
 
122
void dump::dump_do_statement( do_statement const * ds ) {
 
123
        CHECK_NULL( ds, "do_statement" )
 
124
        if( ds->loop ) {
 
125
                out << "loop ";
 
126
        } else {
 
127
                out << "do ";
 
128
        }
 
129
 
 
130
        out << "switch {" << endl();
 
131
        indent();
 
132
        for( auto & v : ds->expr_list ) {
 
133
                out << indent_str();
 
134
                if( v.cond ) {
 
135
                        dump_expression( v.cond.get(), ef_isolated );
 
136
                        out << " then ";
 
137
                } else {
 
138
                        out << "else";
 
139
                }
 
140
                dump_statement_block( v.block.get() );
 
141
                out << endl();
 
142
        }
 
143
        unindent();
 
144
        out << indent_str() << "}";
 
145
 
 
146
        dump_error_statement( *ds );
 
147
}
 
148
 
 
149
void dump::dump_statement( statement const * st ) {
 
150
        CHECK_NULL(st, "statement")
 
151
        validate(*st);
 
152
        
 
153
        out << indent_str();
 
154
        switch( st->statement_form() )
 
155
        {
 
156
                #define DS(type) \
 
157
                        case sf_##type: \
 
158
                                dump_##type( static_cast<type const*>(st) ); \
 
159
                                break;
 
160
                DS(assign_statement)
 
161
                DS(defer_statement)
 
162
                DS(do_statement)
 
163
                DS(expression_statement)
 
164
                DS(fail_statement)
 
165
                DS(for_statement)
 
166
                DS(import_statement)
 
167
                DS(init_statement)
 
168
                DS(loop_flow_statement)
 
169
                DS(noop_statement)
 
170
                DS(return_statement)
 
171
                DS(typedef_statement)
 
172
                DS(var_statement)
 
173
                #undef DS
 
174
        }
 
175
        out << endl();
 
176
}
 
177
 
 
178
void dump::dump_statement_block( statement_block const * block ) {
 
179
        CHECK_NULL(block, "statement_block")
 
180
        
 
181
        //prevent recursion
 
182
        if( shown.find(block) != shown.end() ) {
 
183
                out << "...";
 
184
                return;
 
185
        }
 
186
        shown.insert( block );
 
187
        
 
188
        if( block->reference_text.size() ) {
 
189
                out << "/* " << block->reference_text << " */ ";
 
190
        }
 
191
        out << "{" << endl();
 
192
        indent();
 
193
        
 
194
        //global symbols will already be in the static init block...?
 
195
        if( block->symbols->get_level() > 0 ) {
 
196
                out << indent_str() << "// local_decls" << endl();
 
197
                auto const & locals = block->symbols->get_local_decls(true);
 
198
                for( auto & local : locals ) {
 
199
                        out << indent_str();
 
200
                        dump_declaration( local.get() );
 
201
                        out << endl();
 
202
                }
 
203
                out << indent_str() << "// end local_decls" << endl();
 
204
        }
 
205
        
 
206
        for( size_t i=0; i < block->list.size(); ++i ) {
 
207
                dump_statement( block->list[i].get() );         
 
208
                if( SHOW_COMPLETENESS && !block->list[i]->is_resolved() ) {
 
209
                        out << " //UNRESOLVED";
 
210
                }
 
211
        }
 
212
        
 
213
        unindent();
 
214
        out << indent_str() << "} ";
 
215
        
 
216
        if( SHOW_COMPLETENESS && !block->is_complete() ) {
 
217
                out << " /* INCOMPLETE */";
 
218
        }
 
219
}
 
220
 
 
221
void dump::dump_typedef_statement( typedef_statement const * ts ) {
 
222
        CHECK_NULL(ts,"typedef_statement" );
 
223
        
 
224
        if( ts->is_export ) {
 
225
                out << "@export ";
 
226
        }
 
227
        
 
228
        switch( ts->what ) {
 
229
                case typedef_statement::w_prototype:
 
230
                        out << "typedef " << ts->name;
 
231
                        if( show_spec_type ) {
 
232
                                if( ts->spec_type ) {
 
233
                                        out << " : ";
 
234
                                        dump_type_spec( ts->spec_type.get() );
 
235
                                }
 
236
                        } else {
 
237
                                out << " : ";
 
238
                                dump_type_ref( ts->type, true );
 
239
                        }
 
240
                        break;
 
241
                        
 
242
                case typedef_statement::w_alias: {
 
243
                        out << "alias " << ts->name << " : ";
 
244
                        dump_type_spec( ts->spec_type.get() );
 
245
                        break;
 
246
                }
 
247
                
 
248
                case typedef_statement::w_class: {
 
249
                        out << "class " << ts->name << " ";
 
250
                        if( ts->spec_type ) {
 
251
                                dump_type_spec( ts->spec_type.get() );
 
252
                        }
 
253
                        dump_statement_block( ts->class_block.get() );
 
254
                        break;
 
255
                }
 
256
        };
 
257
        
 
258
}
 
259
 
 
260
void dump::dump_return_statement( return_statement const * rs ) {
 
261
        CHECK_NULL(rs,"return_statement" );
 
262
        
 
263
        out << "return";
 
264
        
 
265
        if( rs->value ) {
 
266
                out << " ";
 
267
                dump_expression( rs->value.get(), ef_isolated );
 
268
        }
 
269
}
 
270
 
 
271
void dump::dump_expression_statement( expression_statement const * es ) {
 
272
        CHECK_NULL( es, "expression_statement" );
 
273
        if( es->ignore ) {
 
274
                out << "ignore ";
 
275
        }
 
276
        dump_expression( es->expr.get(), ef_isolated );
 
277
        dump_error_statement( *es );
 
278
}
 
279
 
 
280
void dump::dump_error_statement( error_statement const & ds ) {
 
281
        if( ds.on_error ) {
 
282
                out << " on ";
 
283
                switch( ds.on_match ) {
 
284
                        case fail_level::resume: out << "resume_error"; break;
 
285
                        case fail_level::cancel: out << "cancel"; break;
 
286
                        case fail_level::fail: out << "fail"; break;
 
287
                        case fail_level::abandon: out << "abandon"; break;
 
288
                }
 
289
                out << " ";
 
290
                dump_statement_block( ds.on_error.get() );
 
291
        }
 
292
}
 
293
 
 
294
void dump::dump_fail_statement( fail_statement const * fs ) {
 
295
        CHECK_NULL( fs, "fail_statement" );
 
296
        switch( fs->level ) {
 
297
                case fail_level::resume: out << "resume_error"; break;
 
298
                case fail_level::cancel: out << "cancel"; break;
 
299
                case fail_level::fail: out << "fail"; break;
 
300
                case fail_level::abandon: out << "abandon"; break;
 
301
        }
 
302
}
 
303
 
 
304
void dump::dump_loop_flow_statement( loop_flow_statement const * ls ) {
 
305
        CHECK_NULL( ls, "loop_flow_statement" );
 
306
        switch( ls->flow ) {
 
307
                case loop_flow_statement::f_break: out << "break"; break;
 
308
                case loop_flow_statement::f_next: out << "next"; break;
 
309
        }
 
310
}
 
311
 
 
312
void dump::dump_noop_statement( noop_statement const * ns ) { 
 
313
        CHECK_NULL( ns, "noop_statement" );
 
314
        out << "noop";
 
315
}
 
316
 
 
317
void dump::dump_import_statement( import_statement const * is ) {
 
318
        CHECK_NULL( is, "import_statement" );
 
319
        out << "import " << is->mod_name;
 
320
}
 
321
 
 
322
void dump::dump_for_statement( for_statement const * fs ) {
 
323
        CHECK_NULL( fs, "for_statement" );
 
324
        out << "for " << fs->item << " in ";
 
325
        dump_expression( fs->iterable.get() );
 
326
        out << " ";
 
327
        dump_statement_block( fs->block.get() );
 
328
}