Replace error parameter by global variable.
public int next_temp_var_id = 0;
public int next_wrapper_id = 0;
public bool in_creation_method { get { return current_method is CreationMethod; } }
- public bool current_method_inner_error = false;
int next_block_id = 0;
Map<Block,int> block_map = new HashMap<Block,int> ();
reserved_identifiers.add ("while");
// reserved for Vala naming conventions
- reserved_identifiers.add ("error");
reserved_identifiers.add ("result");
reserved_identifiers.add ("this");
}
}
public override void visit_destructor (Destructor d) {
- bool old_method_inner_error = current_method_inner_error;
- current_method_inner_error = false;
-
d.accept_children (codegen);
CCodeFragment cfrag = new CCodeFragment ();
cfrag.append (d.body.ccodenode);
d.ccodenode = cfrag;
-
- current_method_inner_error = old_method_inner_error;
}
public int get_block_id (Block b) {
creation_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, instance));
}
- if (expr.tree_can_fail) {
- // method can fail
- current_method_inner_error = true;
- creation_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_inner_error_")));
- }
-
if (ellipsis) {
/* ensure variable argument list ends with NULL
* except when using printf-style arguments */
var cfrag = new CCodeFragment ();
// method will fail
- current_method_inner_error = true;
- var cassign = new CCodeAssignment (get_variable_cexpression ("_inner_error_"), (CCodeExpression) stmt.error_expression.ccodenode);
+ var cassign = new CCodeAssignment (new CCodeIdentifier ("dova_error"), (CCodeExpression) stmt.error_expression.ccodenode);
cfrag.append (new CCodeExpressionStatement (cassign));
head.add_simple_check (stmt, cfrag, true);
}
public virtual CCodeStatement return_with_exception () {
- // propagate error
var cerror_block = new CCodeBlock ();
- cerror_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("error")), get_variable_cexpression ("_inner_error_"))));
- cerror_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression ("_inner_error_"), new CCodeConstant ("NULL"))));
+
+ // propagate error
+ // nothing to do
// free local variables
var free_frag = new CCodeFragment ();
append_local_free (current_symbol, free_frag, false);
cerror_block.add_statement (free_frag);
- if (current_method is CreationMethod) {
+ if (current_method is CreationMethod && current_method.parent_symbol is Class) {
var cl = current_method.parent_symbol as Class;
var unref_call = new CCodeFunctionCall (new CCodeIdentifier (cl.get_unref_function ()));
unref_call.add_argument (new CCodeIdentifier ("this"));
return cerror_block;
}
- CCodeStatement uncaught_error_statement (CCodeExpression inner_error, CCodeBlock? block = null, bool unexpected = false) {
+ CCodeStatement uncaught_error_statement (CCodeBlock? block = null, bool unexpected = false) {
var cerror_block = block;
if (cerror_block == null) {
cerror_block = new CCodeBlock ();
}
public override void add_simple_check (CodeNode node, CCodeFragment cfrag, bool always_fails = false) {
- current_method_inner_error = true;
-
- var inner_error = get_variable_cexpression ("_inner_error_");
-
CCodeStatement cerror_handler = null;
if (current_try != null) {
var cgoto_block = new CCodeBlock ();
cgoto_block.add_statement (cgoto_stmt);
- var type_check = new CCodeFunctionCall (new CCodeIdentifier ("dova_object_is_a"));
- type_check.add_argument (inner_error);
+ var type_check = new CCodeFunctionCall (new CCodeIdentifier ("any_is_a"));
+ type_check.add_argument (new CCodeIdentifier ("dova_error"));
type_check.add_argument (new CCodeFunctionCall (new CCodeIdentifier ("%s_type_get".printf (catch_type.type_symbol.get_lower_case_cname ()))));
cerror_block.add_statement (new CCodeIfStatement (type_check, cgoto_block));
// as jump out of finally block is not supported
} else {
// should never happen with correct bindings
- uncaught_error_statement (inner_error, cerror_block, true);
+ uncaught_error_statement (cerror_block, true);
}
cerror_handler = cerror_block;
}
// Check the allowed error domains to propagate
- var type_check = new CCodeFunctionCall (new CCodeIdentifier ("dova_object_is_a"));
- type_check.add_argument (inner_error);
+ var type_check = new CCodeFunctionCall (new CCodeIdentifier ("any_is_a"));
+ type_check.add_argument (new CCodeIdentifier ("dova_error"));
type_check.add_argument (new CCodeFunctionCall (new CCodeIdentifier ("%s_type_get".printf (error_class.get_lower_case_cname ()))));
if (ccond == null) {
ccond = type_check;
var cerror_block = new CCodeBlock ();
cerror_block.add_statement (new CCodeIfStatement (ccond,
return_with_exception (),
- uncaught_error_statement (inner_error)));
+ uncaught_error_statement ()));
cerror_handler = cerror_block;
}
} else {
- cerror_handler = uncaught_error_statement (inner_error);
+ cerror_handler = uncaught_error_statement ();
}
if (always_fails) {
// eliminates C warnings
cfrag.append (cerror_handler);
} else {
- var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, inner_error, new CCodeConstant ("NULL"));
+ var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, new CCodeIdentifier ("dova_error"), new CCodeConstant ("NULL"));
cfrag.append (new CCodeIfStatement (ccond, cerror_handler));
}
}
clause.error_variable.active = true;
}
- current_method_inner_error = true;
-
generate_type_declaration (clause.error_type, source_declarations);
clause.accept_children (codegen);
if (clause.variable_name != null) {
var cdecl = new CCodeDeclaration (clause.error_type.get_cname ());
- cdecl.add_declarator (new CCodeVariableDeclarator (variable_name, get_variable_cexpression ("_inner_error_")));
+ cdecl.add_declarator (new CCodeVariableDeclarator (variable_name, new CCodeIdentifier ("dova_error")));
cblock.add_statement (cdecl);
} else {
// error object is not used within catch statement, clear it
var cclear = new CCodeFunctionCall (new CCodeIdentifier ("dova_object_unref"));
- cclear.add_argument (get_variable_cexpression ("_inner_error_"));
+ cclear.add_argument (new CCodeIdentifier ("dova_error"));
cblock.add_statement (new CCodeExpressionStatement (cclear));
}
- cblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression ("_inner_error_"), new CCodeConstant ("NULL"))));
+ cblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("dova_error"), new CCodeConstant ("NULL"))));
cblock.add_statement (clause.body.ccodenode);
ccall_expr = ccomma;
}
- if (expr.tree_can_fail) {
- // method can fail
- current_method_inner_error = true;
- // add &inner_error before the ellipsis arguments
- ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression ("_inner_error_")));
- }
-
expr.ccodenode = ccall_expr;
}
}
public override void visit_property_accessor (PropertyAccessor acc) {
var old_symbol = current_symbol;
- bool old_method_inner_error = current_method_inner_error;
current_symbol = acc;
- current_method_inner_error = false;
var prop = (Property) acc.prop;
}
current_symbol = old_symbol;
- current_method_inner_error = old_method_inner_error;
}
public override void generate_interface_declaration (Interface iface, CCodeDeclarationSpace decl_space) {
if (m.return_type is GenericType) {
param_list += ", void *";
}
- if (m.get_error_types ().size > 0) {
- param_list += ", DovaError **";
- }
param_list += ")";
var override_func = new CCodeFunction ("%soverride_%s".printf (m.parent_symbol.get_lower_case_cprefix (), m.name));
public override void visit_method (Method m) {
var old_symbol = current_symbol;
- bool old_method_inner_error = current_method_inner_error;
int old_next_temp_var_id = next_temp_var_id;
var old_temp_vars = temp_vars;
var old_temp_ref_vars = temp_ref_vars;
var old_variable_name_map = variable_name_map;
var old_try = current_try;
current_symbol = m;
- current_method_inner_error = false;
next_temp_var_id = 0;
temp_vars = new ArrayList<LocalVariable> ();
temp_ref_vars = new ArrayList<LocalVariable> ();
m.accept_children (codegen);
- bool inner_error = current_method_inner_error;
-
current_symbol = old_symbol;
- current_method_inner_error = old_method_inner_error;
next_temp_var_id = old_next_temp_var_id;
temp_vars = old_temp_vars;
temp_ref_vars = old_temp_ref_vars;
function.block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("result")));
}
- if (inner_error) {
- var cdecl = new CCodeDeclaration ("DovaError *");
- cdecl.add_declarator (new CCodeVariableDeclarator ("_inner_error_", new CCodeConstant ("NULL")));
- cinit.append (cdecl);
- }
-
var st = m.parent_symbol as Struct;
if (m is CreationMethod && st != null && (st.is_boolean_type () || st.is_integer_type () || st.is_floating_type ())) {
var cdecl = new CCodeDeclaration (st.get_cname ());
if (m.return_type is GenericType) {
vfunc.add_parameter (new CCodeFormalParameter ("result", "void *"));
}
- if (m.get_error_types ().size > 0) {
- var cparam = new CCodeFormalParameter ("error", "DovaError**");
- vfunc.add_parameter (cparam);
- }
var vcast = get_type_private_from_type ((ObjectTypeSymbol) m.parent_symbol, get_type_from_instance (new CCodeIdentifier ("this")));
if (m.return_type is GenericType) {
vcall.add_argument (new CCodeIdentifier ("result"));
}
- if (m.get_error_types ().size > 0) {
- vcall.add_argument (new CCodeIdentifier ("error"));
- }
if (m.return_type is VoidType || m.return_type is GenericType) {
vfunc.block.add_statement (new CCodeExpressionStatement (vcall));
if (m.return_type is GenericType) {
vfunc.add_parameter (new CCodeFormalParameter ("result", "void *"));
}
- if (m.get_error_types ().size > 0) {
- var cparam = new CCodeFormalParameter ("error", "DovaError**");
- vfunc.add_parameter (cparam);
- }
var base_type = new CCodeIdentifier ("base_type");
if (m.return_type is GenericType) {
vcall.add_argument (new CCodeIdentifier ("result"));
}
- if (m.get_error_types ().size > 0) {
- vcall.add_argument (new CCodeIdentifier ("error"));
- }
if (m.return_type is VoidType || m.return_type is GenericType) {
vfunc.block.add_statement (new CCodeExpressionStatement (vcall));
if (m.return_type is GenericType) {
param_list += ", void *";
}
- if (m.get_error_types ().size > 0) {
- param_list += ", DovaError **";
- }
param_list += ")";
var override_func = new CCodeFunction ("%soverride_%s".printf (m.parent_symbol.get_lower_case_cprefix (), m.name));
generate_type_declaration (m.return_type, decl_space);
}
-
- if (m.get_error_types ().size > 0 || (m.base_method != null && m.base_method.get_error_types ().size > 0)) {
- var cparam = new CCodeFormalParameter ("error", "DovaError**");
- func.add_parameter (cparam);
- if (vdeclarator != null) {
- vdeclarator.add_parameter (cparam);
- }
- if (vcall != null) {
- vcall.add_argument (new CCodeIdentifier ("error"));
- }
- }
}
public override void visit_element_access (ElementAccess expr) {
}
write_params (m.get_parameters ());
- write_error_domains (m.get_error_types ());
+
+ if (context.profile != Profile.DOVA) {
+ write_error_domains (m.get_error_types ());
+ }
write_code_block (m.body);
entry_point = true;
analyzer.context.entry_point = this;
- if (tree_can_fail) {
+ if (tree_can_fail && analyzer.context.profile != Profile.DOVA) {
Report.error (source_reference, "\"main\" method cannot throw errors");
}
}
if (parent_node is LocalVariable || parent_node is ExpressionStatement) {
// simple statements, no side effects after method call
} else if (!(analyzer.current_symbol is Block)) {
- // can't handle errors in field initializers
- Report.error (source_reference, "Field initializers must not throw errors");
+ if (analyzer.context.profile != Profile.DOVA) {
+ // can't handle errors in field initializers
+ Report.error (source_reference, "Field initializers must not throw errors");
+ }
} else {
// store parent_node as we need to replace the expression in the old parent node later on
var old_parent_node = parent_node;
if (parent_node is LocalVariable || parent_node is ExpressionStatement) {
// simple statements, no side effects after method call
} else if (!(analyzer.current_symbol is Block)) {
- // can't handle errors in field initializers
- Report.error (source_reference, "Field initializers must not throw errors");
+ if (analyzer.context.profile != Profile.DOVA) {
+ // can't handle errors in field initializers
+ Report.error (source_reference, "Field initializers must not throw errors");
+ }
} else {
// store parent_node as we need to replace the expression in the old parent node later on
var old_parent_node = parent_node;
} while (accept (TokenType.COMMA));
}
expect (TokenType.CLOSE_PARENS);
- if (accept (TokenType.THROWS)) {
- do {
- method.add_error_type (parse_type (true, false));
- } while (accept (TokenType.COMMA));
+ if (context.profile == Profile.DOVA) {
+ var error_type = new UnresolvedType.from_symbol (new UnresolvedSymbol (new UnresolvedSymbol (null, "Dova"), "Error"), method.source_reference);
+ method.add_error_type (error_type);
+ if (accept (TokenType.THROWS)) {
+ do {
+ parse_type (true, false);
+ } while (accept (TokenType.COMMA));
+ Report.warning (method.source_reference, "`throws' is ignored in the Dova profile");
+ }
+ } else {
+ if (accept (TokenType.THROWS)) {
+ do {
+ method.add_error_type (parse_type (true, false));
+ } while (accept (TokenType.COMMA));
+ }
}
while (accept (TokenType.REQUIRES)) {
expect (TokenType.OPEN_PARENS);
if (ModifierFlags.EXTERN in flags || scanner.source_file.external_package) {
prop.external = true;
}
- if (accept (TokenType.THROWS)) {
- do {
- prop.add_error_type (parse_type (true, false));
- } while (accept (TokenType.COMMA));
- Report.error (prop.source_reference, "properties throwing errors are not supported yet");
+ if (context.profile == Profile.DOVA) {
+ } else {
+ if (accept (TokenType.THROWS)) {
+ do {
+ prop.add_error_type (parse_type (true, false));
+ } while (accept (TokenType.COMMA));
+ Report.error (prop.source_reference, "properties throwing errors are not supported yet");
+ }
}
expect (TokenType.OPEN_BRACE);
while (current () != TokenType.CLOSE_BRACE) {
} while (accept (TokenType.COMMA));
}
expect (TokenType.CLOSE_PARENS);
- if (accept (TokenType.THROWS)) {
- do {
- method.add_error_type (parse_type (true, false));
- } while (accept (TokenType.COMMA));
+ if (context.profile == Profile.DOVA) {
+ var error_type = new UnresolvedType.from_symbol (new UnresolvedSymbol (new UnresolvedSymbol (null, "Dova"), "Error"), method.source_reference);
+ method.add_error_type (error_type);
+ if (accept (TokenType.THROWS)) {
+ do {
+ parse_type (true, false);
+ } while (accept (TokenType.COMMA));
+ Report.warning (method.source_reference, "`throws' is ignored in the Dova profile");
+ }
+ } else {
+ if (accept (TokenType.THROWS)) {
+ do {
+ method.add_error_type (parse_type (true, false));
+ } while (accept (TokenType.COMMA));
+ }
}
while (accept (TokenType.REQUIRES)) {
expect (TokenType.OPEN_PARENS);
} while (accept (TokenType.COMMA));
}
expect (TokenType.CLOSE_PARENS);
- if (accept (TokenType.THROWS)) {
- do {
- d.add_error_type (parse_type (true, false));
- } while (accept (TokenType.COMMA));
+ if (context.profile == Profile.DOVA) {
+ var error_type = new UnresolvedType.from_symbol (new UnresolvedSymbol (new UnresolvedSymbol (null, "Dova"), "Error"), d.source_reference);
+ d.add_error_type (error_type);
+ if (accept (TokenType.THROWS)) {
+ do {
+ parse_type (true, false);
+ } while (accept (TokenType.COMMA));
+ Report.warning (d.source_reference, "`throws' is ignored in the Dova profile");
+ }
+ } else {
+ if (accept (TokenType.THROWS)) {
+ do {
+ d.add_error_type (parse_type (true, false));
+ } while (accept (TokenType.COMMA));
+ }
}
expect (TokenType.SEMICOLON);
/* valapropertyaccessor.vala
*
- * Copyright (C) 2006-2009 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
body.check (analyzer);
- foreach (DataType body_error_type in body.get_error_types ()) {
- if (!((ErrorType) body_error_type).dynamic_error) {
- Report.warning (body_error_type.source_reference, "unhandled error `%s'".printf (body_error_type.to_string()));
+ if (analyzer.context.profile != Profile.DOVA) {
+ foreach (DataType body_error_type in body.get_error_types ()) {
+ if (!((ErrorType) body_error_type).dynamic_error) {
+ Report.warning (body_error_type.source_reference, "unhandled error `%s'".printf (body_error_type.to_string()));
+ }
}
}
}
projects / thirdparty / vala.git / commitdiff
