2007-12-15 Jürg Billeter <j@bitron.ch>
+ * vala/valasemanticanalyzer.vala,
+ gobject/valaccodeassignmentbinding.vala,
+ gobject/valaccodegenerator.vala, gobject/valaccodegeneratorclass.vala,
+ compiler/valacompiler.vala, doc/valac.1: remove option to disable
+ automatic memory management, manual memory management is now possible
+ with pointers
+
+2007-12-15 Jürg Billeter <j@bitron.ch>
+
* vala/Makefile.am, vala/valadatatype.vala, vala/valanulltype.vala,
vala/valapointer.vala, vala/valasemanticanalyzer.vala,
vala/valatypesymbol.vala, gobject/valaccodegeneratormethod.vala:
static string library;
[NoArrayLength ()]
static string[] packages;
- static bool disable_memory_management;
static bool ccode_only;
static bool compile_only;
{ "basedir", 'b', 0, OptionArg.FILENAME, out basedir, "Base source directory", "DIRECTORY" },
{ "directory", 'd', 0, OptionArg.FILENAME, out directory, "Output directory", "DIRECTORY" },
{ "version", 0, 0, OptionArg.NONE, ref version, "Display version number", null },
- { "disable-memory-management", 0, 0, OptionArg.NONE, ref disable_memory_management, "Disable memory management", null },
{ "ccode", 'C', 0, OptionArg.NONE, ref ccode_only, "Output C code", null },
{ "compile", 'c', 0, OptionArg.NONE, ref compile_only, "Compile but do not link", null },
{ "output", 'o', 0, OptionArg.FILENAME, out output, "Place output in file FILE", "FILE" },
}
context.library = library;
- context.memory_management = !disable_memory_management;
context.assert = !disable_assert;
context.checking = !disable_checking;
context.optlevel = optlevel;
context.save_temps = save_temps;
- context.codegen = new CCodeGenerator (!disable_memory_management);
+ context.codegen = new CCodeGenerator ();
/* default package */
if (!add_package (context, "glib-2.0")) {
var dbus_binding_provider = new DBusBindingProvider ();
dbus_binding_provider.context = context;
- var analyzer = new SemanticAnalyzer (!disable_memory_management);
+ var analyzer = new SemanticAnalyzer ();
analyzer.add_binding_provider (dbus_binding_provider);
analyzer.analyze (context);
if (Report.get_errors () > 0) {
return quit ();
}
-
- if (!disable_memory_management) {
- var memory_manager = new MemoryManager ();
- memory_manager.analyze (context);
-
- if (Report.get_errors () > 0) {
- return quit ();
- }
+
+ var memory_manager = new MemoryManager ();
+ memory_manager.analyze (context);
+
+ if (Report.get_errors () > 0) {
+ return quit ();
}
-
+
context.codegen.emit (context);
if (Report.get_errors () > 0) {
.TP
.B \---version
Display version number
-.TP
-.B \---disable-memory-management
-Disable memory management
.SH FEATURES
Interfaces, Properties, Signals, Foreach, Lambda expressions, Type
inference for local variables, Assisted memory management
rhs = codegen.get_implicit_cast_expression (rhs, assignment.right.static_type, assignment.left.static_type);
- bool unref_old = (codegen.memory_management && assignment.left.static_type.takes_ownership);
+ bool unref_old = (assignment.left.static_type.takes_ownership);
bool array = false;
if (assignment.left.static_type.data_type is Array) {
array = !(codegen.get_array_length_cexpression (assignment.left, 1) is CCodeConstant);
* Code visitor generating C Code.
*/
public class Vala.CCodeGenerator : CodeGenerator {
- /**
- * Specifies whether automatic memory management is active.
- */
- public bool memory_management { get; set; }
-
private CodeContext context;
Symbol root_symbol;
private bool requires_array_free;
private bool requires_array_move;
- public CCodeGenerator (bool manage_memory = true) {
- memory_management = manage_memory;
+ public CCodeGenerator () {
}
construct {
cblock.add_statement ((CCodeStatement) stmt.ccodenode);
}
}
-
- if (memory_management) {
- foreach (VariableDeclarator decl in local_vars) {
- if (decl.type_reference.takes_ownership) {
- var ma = new MemberAccess.simple (decl.name);
- ma.symbol_reference = decl;
- cblock.add_statement (new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier (get_variable_cname (decl.name)), decl.type_reference, ma)));
- }
+
+ foreach (VariableDeclarator decl in local_vars) {
+ if (decl.type_reference.takes_ownership) {
+ var ma = new MemberAccess.simple (decl.name);
+ ma.symbol_reference = decl;
+ cblock.add_statement (new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier (get_variable_cname (decl.name)), decl.type_reference, ma)));
}
}
-
+
b.ccodenode = cblock;
current_symbol = current_symbol.parent_symbol;
}
public override void visit_end_full_expression (Expression! expr) {
- if (!memory_management) {
- temp_vars.clear ();
- temp_ref_vars.clear ();
- return;
- }
-
/* expr is a full expression, i.e. an initializer, the
* expression in an expression statement, the controlling
* expression in if, while, for, or foreach statements
}
/* free temporary objects */
- if (!memory_management) {
- temp_vars.clear ();
- temp_ref_vars.clear ();
- return;
- }
-
+
if (((Gee.List<VariableDeclarator>) temp_vars).size == 0) {
/* nothing to do without temporary variables */
return;
cblock.add_statement (cwhile);
}
- if (memory_management) {
- foreach (VariableDeclarator decl in stmt.get_local_variables ()) {
- if (decl.type_reference.takes_ownership) {
- var ma = new MemberAccess.simple (decl.name);
- ma.symbol_reference = decl;
- var cunref = new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier (get_variable_cname (decl.name)), decl.type_reference, ma));
- cunref.line = cblock.line;
- cblock.add_statement (cunref);
- }
+ foreach (VariableDeclarator decl in stmt.get_local_variables ()) {
+ if (decl.type_reference.takes_ownership) {
+ var ma = new MemberAccess.simple (decl.name);
+ ma.symbol_reference = decl;
+ var cunref = new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier (get_variable_cname (decl.name)), decl.type_reference, ma));
+ cunref.line = cblock.line;
+ cblock.add_statement (cunref);
}
}
}
}
private void create_local_free (CodeNode stmt, bool stop_at_loop = false) {
- if (!memory_management) {
- return;
- }
-
var cfrag = new CCodeFragment ();
append_local_free (current_symbol, cfrag, stop_at_loop);
}
private void create_local_free_expr (Expression expr) {
- if (!memory_management) {
- return;
- }
-
var return_expr_decl = get_temp_variable_declarator (expr.static_type, true, expr);
var ccomma = new CCodeCommaExpression ();
var cfrag = new CCodeFragment ();
- if (memory_management) {
- /* declare temporary objects */
- append_temp_decl (cfrag, temp_vars);
- }
+ /* declare temporary objects */
+ append_temp_decl (cfrag, temp_vars);
cfrag.append (new CCodeExpressionStatement ((CCodeExpression) stmt.error_expression.ccodenode));
- if (memory_management) {
- /* free temporary objects */
- foreach (VariableDeclarator decl in temp_ref_vars) {
- var ma = new MemberAccess.simple (decl.name);
- ma.symbol_reference = decl;
- cfrag.append (new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier (decl.name), decl.type_reference, ma)));
- }
+ /* free temporary objects */
+ foreach (VariableDeclarator decl in temp_ref_vars) {
+ var ma = new MemberAccess.simple (decl.name);
+ ma.symbol_reference = decl;
+ cfrag.append (new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier (decl.name), decl.type_reference, ma)));
}
temp_vars.clear ();
add_instance_init_function (cl);
if (is_gobject) {
- if ((memory_management && cl.get_fields ().size > 0) || cl.destructor != null) {
+ if (cl.get_fields ().size > 0 || cl.destructor != null) {
add_dispose_function (cl);
}
}
}
/* set dispose function */
- if (memory_management && cl.get_fields ().size > 0) {
+ if (cl.get_fields ().size > 0) {
var ccast = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_CLASS"));
ccast.add_argument (new CCodeIdentifier ("klass"));
init_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (ccast, "dispose"), new CCodeIdentifier ("%s_dispose".printf (cl.get_lower_case_cname (null))))));
* Code visitor analyzing and checking code.
*/
public class Vala.SemanticAnalyzer : CodeVisitor {
- /**
- * Specifies whether automatic memory management is active.
- */
- public bool memory_management { get; set; }
-
private CodeContext context;
Symbol root_symbol;
private Collection<BindingProvider> binding_providers = new ArrayList<BindingProvider> ();
- public SemanticAnalyzer (bool manage_memory = true) {
- memory_management = manage_memory;
+ public SemanticAnalyzer () {
}
public void add_binding_provider (BindingProvider! binding_provider) {
}
}
- if (memory_management) {
- if (decl.initializer.static_type.transfers_ownership) {
- /* rhs transfers ownership of the expression */
- if (!(decl.type_reference is PointerType) && !decl.type_reference.takes_ownership) {
- /* lhs doesn't own the value */
- decl.error = true;
- Report.error (decl.source_reference, "Invalid assignment from owned expression to unowned variable");
- return;
- }
+ if (decl.initializer.static_type.transfers_ownership) {
+ /* rhs transfers ownership of the expression */
+ if (!(decl.type_reference is PointerType) && !decl.type_reference.takes_ownership) {
+ /* lhs doesn't own the value */
+ decl.error = true;
+ Report.error (decl.source_reference, "Invalid assignment from owned expression to unowned variable");
+ return;
}
}
}
return;
}
- if (memory_management) {
- if (a.right.static_type.transfers_ownership) {
- /* rhs transfers ownership of the expression */
- if (!(a.left.static_type is PointerType) && !a.left.static_type.takes_ownership) {
- /* lhs doesn't own the value */
- a.error = true;
- Report.error (a.source_reference, "Invalid assignment from owned expression to unowned variable");
- }
- } else if (a.left.static_type.takes_ownership) {
- /* lhs wants to own the value
- * rhs doesn't transfer the ownership
- * code generator needs to add reference
- * increment calls */
+ if (a.right.static_type.transfers_ownership) {
+ /* rhs transfers ownership of the expression */
+ if (!(a.left.static_type is PointerType) && !a.left.static_type.takes_ownership) {
+ /* lhs doesn't own the value */
+ a.error = true;
+ Report.error (a.source_reference, "Invalid assignment from owned expression to unowned variable");
}
+ } else if (a.left.static_type.takes_ownership) {
+ /* lhs wants to own the value
+ * rhs doesn't transfer the ownership
+ * code generator needs to add reference
+ * increment calls */
}
}
} else if (a.left is ElementAccess) {
return;
}
- if (memory_management) {
- if (a.right.static_type.transfers_ownership) {
- /* rhs transfers ownership of the expression */
+ if (a.right.static_type.transfers_ownership) {
+ /* rhs transfers ownership of the expression */
- var args = ea.container.static_type.get_type_arguments ();
- if (args.size != 1) {
- a.error = true;
- Report.error (ea.source_reference, "internal error: array reference without type arguments");
- return;
- }
- var element_type = args.get (0);
+ var args = ea.container.static_type.get_type_arguments ();
+ if (args.size != 1) {
+ a.error = true;
+ Report.error (ea.source_reference, "internal error: array reference without type arguments");
+ return;
+ }
+ var element_type = args.get (0);
- if (!(element_type is PointerType) && !element_type.takes_ownership) {
- /* lhs doesn't own the value */
- a.error = true;
- Report.error (a.source_reference, "Invalid assignment from owned expression to unowned variable");
- return;
- }
- } else if (a.left.static_type.takes_ownership) {
- /* lhs wants to own the value
- * rhs doesn't transfer the ownership
- * code generator needs to add reference
- * increment calls */
+ if (!(element_type is PointerType) && !element_type.takes_ownership) {
+ /* lhs doesn't own the value */
+ a.error = true;
+ Report.error (a.source_reference, "Invalid assignment from owned expression to unowned variable");
+ return;
}
+ } else if (a.left.static_type.takes_ownership) {
+ /* lhs wants to own the value
+ * rhs doesn't transfer the ownership
+ * code generator needs to add reference
+ * increment calls */
}
} else {
return;
projects / platform / upstream / vala.git / commitdiff