← Back to branch summary

~ubuntu-branches/ubuntu/vivid/vala/vivid

« back to all changes in this revision

Viewing changes to codegen/valadovaerrormodule.vala

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2010-07-28 07:58:01 UTC
  • mfrom: (1.5.5 upstream) (7.3.14 experimental)
  • Revision ID: james.westby@ubuntu.com-20100728075801-18u9cg5hv5oety6m
Tags: 0.9.4-1
New upstream development release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
codegen/valadovaerrormodule.vala
38
38
                var cfrag = new CCodeFragment ();
39
39
 
40
40
                // method will fail
41
 
                current_method_inner_error = true;
42
 
                var cassign = new CCodeAssignment (get_variable_cexpression ("_inner_error_"), (CCodeExpression) stmt.error_expression.ccodenode);
 
41
                var cassign = new CCodeAssignment (new CCodeIdentifier ("dova_error"), (CCodeExpression) stmt.error_expression.ccodenode);
43
42
                cfrag.append (new CCodeExpressionStatement (cassign));
44
43
 
45
44
                head.add_simple_check (stmt, cfrag, true);
50
49
        }
51
50
 
52
51
        public virtual CCodeStatement return_with_exception () {
 
52
                var cerror_block = new CCodeBlock ();
 
53
 
53
54
                // propagate error
54
 
                var cerror_block = new CCodeBlock ();
55
 
                cerror_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("error")), get_variable_cexpression ("_inner_error_"))));
56
 
                cerror_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression ("_inner_error_"), new CCodeConstant ("NULL"))));
 
55
                // nothing to do
57
56
 
58
57
                // free local variables
59
58
                var free_frag = new CCodeFragment ();
60
59
                append_local_free (current_symbol, free_frag, false);
61
60
                cerror_block.add_statement (free_frag);
62
61
 
63
 
                if (current_method is CreationMethod) {
 
62
                if (current_method is CreationMethod && current_method.parent_symbol is Class) {
64
63
                        var cl = current_method.parent_symbol as Class;
65
64
                        var unref_call = new CCodeFunctionCall (new CCodeIdentifier (cl.get_unref_function ()));
66
65
                        unref_call.add_argument (new CCodeIdentifier ("this"));
75
74
                return cerror_block;
76
75
        }
77
76
 
78
 
        CCodeStatement uncaught_error_statement (CCodeExpression inner_error, CCodeBlock? block = null, bool unexpected = false) {
 
77
        CCodeStatement uncaught_error_statement (CCodeBlock? block = null, bool unexpected = false) {
79
78
                var cerror_block = block;
80
79
                if (cerror_block == null) {
81
80
                        cerror_block = new CCodeBlock ();
112
111
        }
113
112
 
114
113
        public override void add_simple_check (CodeNode node, CCodeFragment cfrag, bool always_fails = false) {
115
 
                current_method_inner_error = true;
116
 
 
117
 
                var inner_error = get_variable_cexpression ("_inner_error_");
118
 
 
119
114
                CCodeStatement cerror_handler = null;
120
115
 
121
116
                if (current_try != null) {
161
156
                                                var cgoto_block = new CCodeBlock ();
162
157
                                                cgoto_block.add_statement (cgoto_stmt);
163
158
 
164
 
                                                var type_check = new CCodeFunctionCall (new CCodeIdentifier ("dova_object_is_a"));
165
 
                                                type_check.add_argument (inner_error);
 
159
                                                var type_check = new CCodeFunctionCall (new CCodeIdentifier ("any_is_a"));
 
160
                                                type_check.add_argument (new CCodeIdentifier ("dova_error"));
166
161
                                                type_check.add_argument (new CCodeFunctionCall (new CCodeIdentifier ("%s_type_get".printf (catch_type.type_symbol.get_lower_case_cname ()))));
167
162
 
168
163
                                                cerror_block.add_statement (new CCodeIfStatement (type_check, cgoto_block));
183
178
                                // as jump out of finally block is not supported
184
179
                        } else {
185
180
                                // should never happen with correct bindings
186
 
                                uncaught_error_statement (inner_error, cerror_block, true);
 
181
                                uncaught_error_statement (cerror_block, true);
187
182
                        }
188
183
 
189
184
                        cerror_handler = cerror_block;
199
194
                                }
200
195
 
201
196
                                // Check the allowed error domains to propagate
202
 
                                var type_check = new CCodeFunctionCall (new CCodeIdentifier ("dova_object_is_a"));
203
 
                                type_check.add_argument (inner_error);
 
197
                                var type_check = new CCodeFunctionCall (new CCodeIdentifier ("any_is_a"));
 
198
                                type_check.add_argument (new CCodeIdentifier ("dova_error"));
204
199
                                type_check.add_argument (new CCodeFunctionCall (new CCodeIdentifier ("%s_type_get".printf (error_class.get_lower_case_cname ()))));
205
200
                                if (ccond == null) {
206
201
                                        ccond = type_check;
215
210
                                var cerror_block = new CCodeBlock ();
216
211
                                cerror_block.add_statement (new CCodeIfStatement (ccond,
217
212
                                        return_with_exception (),
218
 
                                        uncaught_error_statement (inner_error)));
 
213
                                        uncaught_error_statement ()));
219
214
                                cerror_handler = cerror_block;
220
215
                        }
221
216
                } else {
222
 
                        cerror_handler = uncaught_error_statement (inner_error);
 
217
                        cerror_handler = uncaught_error_statement ();
223
218
                }
224
219
 
225
220
                if (always_fails) {
227
222
                        // eliminates C warnings
228
223
                        cfrag.append (cerror_handler);
229
224
                } else {
230
 
                        var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, inner_error, new CCodeConstant ("NULL"));
 
225
                        var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, new CCodeIdentifier ("dova_error"), new CCodeConstant ("NULL"));
231
226
                        cfrag.append (new CCodeIfStatement (ccond, cerror_handler));
232
227
                }
233
228
        }
287
282
                        clause.error_variable.active = true;
288
283
                }
289
284
 
290
 
                current_method_inner_error = true;
291
 
 
292
285
                generate_type_declaration (clause.error_type, source_declarations);
293
286
 
294
287
                clause.accept_children (codegen);
307
300
 
308
301
                if (clause.variable_name != null) {
309
302
                        var cdecl = new CCodeDeclaration (clause.error_type.get_cname ());
310
 
                        cdecl.add_declarator (new CCodeVariableDeclarator (variable_name, get_variable_cexpression ("_inner_error_")));
 
303
                        cdecl.add_declarator (new CCodeVariableDeclarator (variable_name, new CCodeIdentifier ("dova_error")));
311
304
                        cblock.add_statement (cdecl);
312
305
                } else {
313
306
                        // error object is not used within catch statement, clear it
314
307
                        var cclear = new CCodeFunctionCall (new CCodeIdentifier ("dova_object_unref"));
315
 
                        cclear.add_argument (get_variable_cexpression ("_inner_error_"));
 
308
                        cclear.add_argument (new CCodeIdentifier ("dova_error"));
316
309
                        cblock.add_statement (new CCodeExpressionStatement (cclear));
317
310
                }
318
 
                cblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression ("_inner_error_"), new CCodeConstant ("NULL"))));
 
311
                cblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("dova_error"), new CCodeConstant ("NULL"))));
319
312
 
320
313
                cblock.add_statement (clause.body.ccodenode);
321
314