It was about time to do this.
* Left hand side of the assignment.
*/
public CCodeExpression left { get; set; }
-
+
/**
* Assignment operator.
*/
* Right hand side of the assignment.
*/
public CCodeExpression right { get; set; }
-
+
public CCodeAssignment (CCodeExpression l, CCodeExpression r, CCodeAssignmentOperator op = CCodeAssignmentOperator.SIMPLE) {
left = l;
operator = op;
right = r;
}
-
+
public override void write (CCodeWriter writer) {
left.write (writer);
writer.write_string (")");
}
}
-
+
public enum Vala.CCodeAssignmentOperator {
SIMPLE,
BITWISE_OR,
* The right operand.
*/
public CCodeExpression right { get; set; }
-
+
public CCodeBinaryExpression (CCodeBinaryOperator op, CCodeExpression l, CCodeExpression r) {
operator = op;
left = l;
right = r;
}
-
+
public override void write (CCodeWriter writer) {
left.write_inner (writer);
public bool suppress_newline { get; set; }
private List<CCodeNode> statements = new ArrayList<CCodeNode> ();
-
+
/**
* Prepend the specified statement to the list of statements.
*/
public void prepend_statement (CCodeNode statement) {
statements.insert (0, statement);
}
-
+
/**
* Append the specified statement to the list of statements.
*/
/* allow generic nodes to include comments */
statements.add (statement);
}
-
+
public override void write (CCodeWriter writer) {
// the last reachable statement
CCodeNode last_statement = null;
* The case expression.
*/
public CCodeExpression expression { get; set; }
-
+
public CCodeCaseStatement (CCodeExpression expression) {
this.expression = expression;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_indent (line);
writer.write_string ("case ");
* The expression to be cast.
*/
public CCodeExpression inner { get; set; }
-
+
/**
* The target type.
*/
public string type_name { get; set; }
-
+
public CCodeCastExpression (CCodeExpression expr, string type) {
inner = expr;
type_name = type;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_string ("(");
writer.write_string (type_name);
*/
public class Vala.CCodeCommaExpression : CCodeExpression {
private List<CCodeExpression> inner = new ArrayList<CCodeExpression> ();
-
+
/**
* Appends the specified expression to the expression list.
*
public override void write (CCodeWriter writer) {
bool first = true;
-
+
writer.write_string ("(");
foreach (CCodeExpression expr in inner) {
if (!first) {
* The text content of the comment.
*/
public string text { get; set; }
-
+
public CCodeComment (string _text) {
text = _text;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_comment (text);
}
* The condition.
*/
public CCodeExpression condition { get; set; }
-
+
/**
* The expression to be evaluated if the condition holds.
*/
public CCodeExpression true_expression { get; set; }
-
+
/**
* The expression to be evaluated if the condition doesn't hold.
*/
public CCodeExpression false_expression { get; set; }
-
+
public CCodeConditionalExpression (CCodeExpression cond, CCodeExpression true_expr, CCodeExpression false_expr) {
condition = cond;
true_expression = true_expr;
false_expression = false_expr;
}
-
+
public override void write (CCodeWriter writer) {
condition.write_inner (writer);
writer.write_string (" ? ");
public string type_name { get; set; }
private List<CCodeDeclarator> declarators = new ArrayList<CCodeDeclarator> ();
-
+
public CCodeDeclaration (string type_name) {
this.type_name = type_name;
}
-
+
/**
* Adds the specified declarator to this declaration.
*
public void add_declarator (CCodeDeclarator decl) {
declarators.add (decl);
}
-
+
public override void write (CCodeWriter writer) {
if ((modifiers & (CCodeModifiers.STATIC | CCodeModifiers.INTERNAL | CCodeModifiers.EXTERN)) == 0) {
foreach (CCodeDeclarator decl in declarators) {
}
writer.write_string (type_name);
writer.write_string (" ");
-
+
bool first = true;
foreach (CCodeDeclarator decl in declarators) {
if (!first) {
* The loop condition.
*/
public CCodeExpression condition { get; set; }
-
+
public CCodeDoStatement (CCodeStatement stmt, CCodeExpression cond) {
body = stmt;
condition = cond;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_indent (line);
writer.write_string ("do");
* Expression representing the container on which we want to access.
*/
public CCodeExpression container { get; set; }
-
+
/**
* Expression representing the index we want to access inside the
* container.
*/
public CCodeExpression index { get; set; }
-
+
public CCodeElementAccess (CCodeExpression cont, CCodeExpression i) {
container = cont;
index = i;
}
-
+
public override void write (CCodeWriter writer) {
container.write_inner (writer);
writer.write_string ("[");
public string name { get; set; }
private List<CCodeEnumValue> values = new ArrayList<CCodeEnumValue> ();
-
+
public CCodeEnum (string? name = null) {
this.name = name;
}
-
+
/**
* Adds the specified value to this enum.
*
public void add_value (CCodeEnumValue value) {
values.add (value);
}
-
+
public override void write (CCodeWriter writer) {
if (name != null) {
writer.write_string ("typedef ");
* The numerical representation of this enum value.
*/
public CCodeExpression? value { get; set; }
-
+
public CCodeEnumValue (string name, CCodeExpression? value = null) {
this.name = name;
this.value = value;
* The expression to evaluate.
*/
public CCodeExpression expression { get; set; }
-
+
public CCodeExpressionStatement (CCodeExpression expr) {
expression = expr;
}
* The loop condition.
*/
public CCodeExpression? condition { get; set; }
-
+
/**
* The loop body.
*/
public CCodeStatement body { get; set; }
-
+
private List<CCodeExpression> initializer = new ArrayList<CCodeExpression> ();
private List<CCodeExpression> iterator = new ArrayList<CCodeExpression> ();
-
+
public CCodeForStatement (CCodeExpression? condition, CCodeStatement? body = null) {
this.condition = condition;
this.body = body;
public void add_iterator (CCodeExpression expr) {
iterator.add (expr);
}
-
+
public override void write (CCodeWriter writer) {
bool first;
-
+
writer.write_indent (line);
writer.write_string ("for (");
-
+
first = true;
foreach (CCodeExpression init_expr in initializer) {
if (!first) {
condition.write (writer);
}
writer.write_string ("; ");
-
+
first = true;
foreach (CCodeExpression it_expr in iterator) {
if (!first) {
*/
public class Vala.CCodeFragment : CCodeNode {
private List<CCodeNode> children = new ArrayList<CCodeNode> ();
-
+
/**
* Appends the specified code node to this code fragment.
*
public void append (CCodeNode node) {
children.add (node);
}
-
+
/**
* Returns a copy of the list of children.
*
* The name of this function.
*/
public string name { get; set; }
-
+
/**
* The function return type.
*/
this.block = new CCodeBlock ();
current_block = block;
}
-
+
/**
* Appends the specified parameter to the list of function parameters.
*
foreach (CCodeParameter param in parameters) {
func.parameters.add (param);
}
-
+
func.is_declaration = is_declaration;
func.block = block;
return func;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_indent (line);
if (CCodeModifiers.INTERNAL in modifiers) {
writer.write_string (name);
writer.write_string (" (");
int param_pos_begin = (is_declaration ? return_type.char_count () + 1 : 0 ) + name.char_count () + 2;
-
+
bool has_args = (CCodeModifiers.PRINTF in modifiers || CCodeModifiers.SCANF in modifiers);
int i = 0;
int format_arg_index = -1;
if (i == 0) {
writer.write_string ("void");
}
-
+
writer.write_string (")");
if (is_declaration) {
* The function to be called.
*/
public CCodeExpression? call { get; set; }
-
+
private List<CCodeExpression> arguments = new ArrayList<CCodeExpression> ();
-
+
public CCodeFunctionCall (CCodeExpression? call = null) {
this.call = call;
}
-
+
/**
* Appends the specified expression to the list of arguments.
*
} else {
first = false;
}
-
+
if (expr != null) {
expr.write (writer);
}
* The declarator name.
*/
public string name { get; set; }
-
+
private List<CCodeParameter> parameters = new ArrayList<CCodeParameter> ();
-
+
public CCodeFunctionDeclarator (string name) {
this.name = name;
}
-
+
/**
* Appends the specified parameter to the list of function parameters.
*
public void add_parameter (CCodeParameter param) {
parameters.add (param);
}
-
+
public override void write (CCodeWriter writer) {
write_declaration (writer);
}
-
+
public override void write_declaration (CCodeWriter writer) {
writer.write_string ("(*");
writer.write_string (name);
writer.write_string (") (");
-
+
bool has_args = (CCodeModifiers.PRINTF in modifiers || CCodeModifiers.SCANF in modifiers);
int i = 0;
int format_arg_index = -1;
}
i++;
}
-
+
writer.write_string (")");
if (CCodeModifiers.DEPRECATED in modifiers) {
public CCodeGotoStatement (string name) {
this.name = name;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_indent ();
writer.write_string ("goto ");
* The name of this identifier.
*/
public string name { get; set; }
-
+
public CCodeIdentifier (string _name) {
name = _name;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_string (name);
}
* The boolean condition to evaluate.
*/
public CCodeExpression condition { get; set; }
-
+
/**
* The statement to be evaluated if the condition holds.
*/
public CCodeStatement true_statement { get; set; }
-
+
/**
* The optional statement to be evaluated if the condition doesn't hold.
*/
public CCodeStatement? false_statement { get; set; }
-
+
public CCodeIfStatement (CCodeExpression cond, CCodeStatement true_stmt, CCodeStatement? false_stmt = null) {
condition = cond;
true_statement = true_stmt;
false_statement = false_stmt;
}
-
+
/**
* Specifies whether this if statement is part of an else if statement.
* This only affects the output formatting.
*/
public bool else_if { get; set; }
-
+
public override void write (CCodeWriter writer) {
if (!else_if) {
writer.write_indent (line);
condition.write (writer);
}
writer.write_string (")");
-
+
/* else shouldn't be on a separate line */
if (false_statement != null && true_statement is CCodeBlock) {
var cblock = (CCodeBlock) true_statement;
cblock.suppress_newline = true;
}
-
+
true_statement.write (writer);
if (false_statement != null) {
if (writer.bol) {
} else {
writer.write_string (" else");
}
-
+
/* else if should be on one line */
if (false_statement is CCodeIfStatement) {
var cif = (CCodeIfStatement) false_statement;
cif.else_if = true;
}
-
+
false_statement.write (writer);
}
}
* The file to be included.
*/
public string filename { get; set; }
-
+
/**
* Specifies whether the specified file should be searched in the local
* directory.
*/
public bool local { get; set; }
-
+
public CCodeIncludeDirective (string _filename, bool _local = false) {
filename = _filename;
local = _local;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_indent ();
writer.write_string ("#include ");
*/
public class Vala.CCodeInitializerList : CCodeExpression {
private List<CCodeExpression> initializers = new ArrayList<CCodeExpression> ();
-
+
/**
* Appends the specified expression to this initializer list.
*
public void append (CCodeExpression expr) {
initializers.add (expr);
}
-
+
public override void write (CCodeWriter writer) {
writer.write_string ("{");
} else {
first = false;
}
-
+
if (expr != null) {
expr.write (writer);
}
public CCodeLabel (string name) {
this.name = name;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_indent ();
writer.write_string (name);
* The name of the source file to be presumed.
*/
public string filename { get; set; }
-
+
/**
* The line number in the source file to be presumed.
*/
public int line_number { get; set; }
-
+
public CCodeLineDirective (string _filename, int _line) {
filename = _filename;
line_number = _line;
* The parent of the member.
*/
public CCodeExpression inner { get; set; }
-
+
/**
* The name of the member.
*/
public string member_name { get; set; }
-
+
/**
* Specifies whether the member access happens by pointer dereferencing.
*/
public bool is_pointer { get; set; }
-
+
public CCodeMemberAccess (CCodeExpression container, string member, bool pointer = false) {
inner = container;
member_name = member;
is_pointer = pointer;
}
-
+
public CCodeMemberAccess.pointer (CCodeExpression container, string member) {
inner = container;
member_name = member;
is_pointer = true;
}
-
+
public override void write (CCodeWriter writer) {
inner.write_inner (writer);
if (is_pointer) {
* The name of the guarding define.
*/
public string define { get; set; }
-
+
public CCodeOnceSection (string def) {
define = def;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_indent ();
writer.write_string ("#ifndef ");
writer.write_string ("#endif");
writer.write_newline ();
}
-
+
public override void write_declaration (CCodeWriter writer) {
}
}
* The parameter name.
*/
public string name { get; set; }
-
+
/**
* The parameter type.
*/
* The expression in the parenthesis.
*/
public CCodeExpression inner { get; set; }
-
+
public CCodeParenthesizedExpression (CCodeExpression expr) {
inner = expr;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_string ("(");
-
+
inner.write (writer);
writer.write_string (")");
* The optional expression to return.
*/
public CCodeExpression? return_expression { get; set; }
-
+
public CCodeReturnStatement (CCodeExpression? expr = null) {
return_expression = expr;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_indent (line);
writer.write_string ("return");
-
+
if (return_expression != null) {
writer.write_string (" ");
return_expression.write (writer);
public bool is_empty { get { return declarations.size == 0; } }
private List<CCodeDeclaration> declarations = new ArrayList<CCodeDeclaration> ();
-
+
public CCodeStruct (string name) {
this.name = name;
}
-
+
/**
* Adds the specified declaration as member to this struct.
*
public void add_declaration (CCodeDeclaration decl) {
declarations.add (decl);
}
-
+
/**
* Adds a variable with the specified type and name to this struct.
*
decl.modifiers = modifiers;
add_declaration (decl);
}
-
+
public override void write (CCodeWriter writer) {
writer.write_string ("struct ");
writer.write_string (name);
* The switch expression.
*/
public CCodeExpression expression { get; set; }
-
+
public CCodeSwitchStatement (CCodeExpression expression) {
this.expression = expression;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_indent (line);
writer.write_string ("switch (");
* The type name.
*/
public string type_name { get; set; }
-
+
/**
* The type declarator.
*/
type_name = type;
declarator = decl;
}
-
+
public override void write (CCodeWriter writer) {
}
-
+
public override void write_declaration (CCodeWriter writer) {
writer.write_indent ();
writer.write_string ("typedef ");
-
+
writer.write_string (type_name);
-
+
writer.write_string (" ");
-
+
declarator.write_declaration (writer);
if (CCodeModifiers.DEPRECATED in modifiers) {
* The unary operator.
*/
public CCodeUnaryOperator operator { get; set; }
-
+
/**
* The operand.
*/
public CCodeExpression inner { get; set; }
-
+
public CCodeUnaryExpression (CCodeUnaryOperator op, CCodeExpression expr) {
operator = op;
inner = expr;
}
-
+
public override void write (CCodeWriter writer) {
switch (operator) {
case CCodeUnaryOperator.PLUS: writer.write_string ("+"); inner.write_inner (writer); break;
* The variable name.
*/
public string name { get; set; }
-
+
/**
* The optional initializer expression.
*/
* The loop condition.
*/
public CCodeExpression condition { get; set; }
-
+
/**
* The loop body.
*/
public CCodeStatement body { get; set; }
-
+
public CCodeWhileStatement (CCodeExpression cond, CCodeStatement? stmt = null) {
condition = cond;
body = stmt;
}
-
+
public override void write (CCodeWriter writer) {
writer.write_indent (line);
writer.write_string ("while (");
private bool file_exists;
private FileStream? stream;
-
+
private int indent;
private int current_line_number = 1;
private bool using_line_directive;
/* at begin of line */
private bool _bol = true;
-
+
public CCodeWriter (string filename, string? source_filename = null) {
this.filename = filename;
this.source_filename = source_filename;
*/
public void close () {
stream = null;
-
+
if (file_exists) {
var changed = true;
} catch (FileError e) {
// assume changed if mmap comparison doesn't work
}
-
+
if (changed) {
FileUtils.rename (temp_filename, filename);
} else {
}
}
}
-
+
/**
* Writes tabs according to the current indent level.
*/
if (!_bol) {
write_newline ();
}
-
+
stream.puts (string.nfill (indent, '\t'));
_bol = false;
}
-
+
/**
* Writes n spaces.
*/
stream.puts (s);
_bol = false;
}
-
+
/**
* Writes a newline.
*/
current_line_number++;
_bol = true;
}
-
+
/**
* Opens a new block, increasing the indent level.
*/
write_newline ();
indent++;
}
-
+
/**
* Closes the current block, decreasing the indent level.
*/
public void write_end_block () {
assert (indent > 0);
-
+
indent--;
write_indent ();
stream.putc ('}');
}
-
+
/**
* Writes the specified text as comment.
*
cexpr = new CCodeBinaryExpression (CCodeBinaryOperator.MUL, cexpr, csize);
}
}
-
+
// add extra item to have array NULL-terminated for all reference types
if (expr.element_type.data_type != null && expr.element_type.data_type.is_reference_type ()) {
cexpr = new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, cexpr, new CCodeConstant ("1"));
}
-
+
gnew.add_argument (cexpr);
var temp_var = get_temp_variable (expr.value_type, true, expr);
if (param.direction != ParameterDirection.IN) {
length_ctype = "%s*".printf (length_ctype);
}
-
+
for (int dim = 1; dim <= array_type.rank; dim++) {
var cparam = new CCodeParameter (get_parameter_array_length_cname (param, dim), length_ctype);
cparam_map.set (get_param_pos (get_ccode_array_length_pos (param) + 0.01 * dim), cparam);
public EmitContext base_finalize_context;
public EmitContext instance_init_context;
public EmitContext instance_finalize_context;
-
+
public CCodeStruct param_spec_struct;
public CCodeStruct closure_struct;
public CCodeEnum prop_enum;
public Set<string> predefined_marshal_set;
/* (constant) hash table with all reserved identifiers in the generated code */
Set<string> reserved_identifiers;
-
+
public int next_temp_var_id {
get { return emit_context.next_temp_var_id; }
set { emit_context.next_temp_var_id = value; }
public bool in_plugin = false;
public string module_init_param_name;
-
+
public bool gvaluecollector_h_needed;
public bool requires_assert;
public bool requires_array_free;
public override void visit_source_file (SourceFile source_file) {
cfile = new CCodeFile ();
-
+
user_marshal_set = new HashSet<string> (str_hash, str_equal);
-
+
next_regex_id = 0;
-
+
gvaluecollector_h_needed = false;
requires_assert = false;
requires_array_free = false;
var rhs = get_cvalue (f.initializer);
if (!is_simple_struct_creation (f, f.initializer)) {
// otherwise handled in visit_object_creation_expression
-
+
ccode.add_assignment (lhs, rhs);
-
+
if (f.variable_type is ArrayType && get_ccode_array_length (f)) {
var array_type = (ArrayType) f.variable_type;
var field_value = get_field_cvalue (f, load_this_parameter ((TypeSymbol) f.parent_symbol));
-
+
var glib_value = (GLibValue) f.initializer.target_value;
if (glib_value.array_length_cvalues != null) {
for (int dim = 1; dim <= array_type.rank; dim++) {
requires_array_length = true;
var len_call = new CCodeFunctionCall (new CCodeIdentifier ("_vala_array_length"));
len_call.add_argument (get_cvalue_ (glib_value));
-
+
ccode.add_assignment (get_array_length_cvalue (field_value, 1), len_call);
} else {
for (int dim = 1; dim <= array_type.rank; dim++) {
ccode.add_assignment (get_array_length_cvalue (field_value, dim), new CCodeConstant ("-1"));
}
}
-
+
if (array_type.rank == 1 && f.is_internal_symbol ()) {
var lhs_array_size = get_array_size_cvalue (field_value);
var rhs_array_len = get_array_length_cvalue (field_value, 1);
pop_context ();
}
-
+
if (requires_destroy (f.variable_type) && instance_finalize_context != null) {
push_context (instance_finalize_context);
ccode.add_expression (destroy_field (f, load_this_parameter ((TypeSymbol) f.parent_symbol)));
var unref_fun = new CCodeFunction ("block%d_data_unref".printf (block_id), "void");
unref_fun.add_parameter (new CCodeParameter ("_userdata_", "void *"));
unref_fun.modifiers = CCodeModifiers.STATIC;
-
+
push_function (unref_fun);
ccode.add_declaration (struct_name + "*", new CCodeVariableDeclarator ("_data%d_".printf (block_id), new CCodeCastExpression (new CCodeIdentifier ("_userdata_"), struct_name + "*")));
}
next_temp_var_id++;
-
+
return local;
}
generic_elements = (type_arg is GenericType);
}
}
-
+
if (elements_require_free) {
CCodeExpression? cexpr = null;
if (element_destroy_func_expression is CCodeIdentifier || element_destroy_func_expression is CCodeMemberAccess) {
}
/* (foo == NULL ? NULL : foo = (unref (foo), NULL)) */
-
+
/* can be simplified to
* foo = (unref (foo), NULL)
* if foo is of static type non-null
}
}
}
-
+
ccomma.append_expression (ccall);
ccomma.append_expression (new CCodeConstant ("NULL"));
-
+
var cassign = new CCodeAssignment (cvar, ccomma);
// g_free (NULL) is allowed
return new CCodeConditionalExpression (cisnull, new CCodeConstant ("NULL"), cassign);
}
-
+
public override void visit_end_full_expression (Expression expr) {
/* expr is a full expression, i.e. an initializer, the
* expression in an expression statement, the controlling
temp_ref_values.clear ();
}
-
+
public void emit_temp_var (LocalVariable local) {
var init = (!local.name.has_prefix ("*") && local.init);
if (is_in_coroutine ()) {
var inner_node = ((MemberAccess)resource).inner;
var member = resource.symbol_reference;
var parent = (TypeSymbol)resource.symbol_reference.parent_symbol;
-
+
if (member.is_instance_member ()) {
if (inner_node == null) {
l = new CCodeIdentifier ("self");
}
return l;
}
-
+
public override void visit_lock_statement (LockStatement stmt) {
var l = get_lock_expression (stmt, stmt.resource);
ccode.add_expression (fc);
}
-
+
public override void visit_unlock_statement (UnlockStatement stmt) {
var l = get_lock_expression (stmt, stmt.resource);
-
+
var fc = new CCodeFunctionCall (new CCodeIdentifier (get_ccode_name (mutex_type.scope.lookup ("unlock"))));
fc.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, l));
-
+
ccode.add_expression (fc);
}
// return previous value
expr.target_value = temp_value;
}
-
+
private MemberAccess? find_property_access (Expression expr) {
if (!(expr is MemberAccess)) {
return null;
}
-
+
var ma = (MemberAccess) expr;
if (ma.symbol_reference is Property) {
return ma;
}
-
+
return null;
}
* ref (expr)
* if static type of expr is non-null
*/
-
+
var dupexpr = get_dup_func_expression (type, node.source_reference);
if (dupexpr == null) {
if (!(type is ArrayType) && get_non_null (value) && !is_ref_function_void (type)) {
// expression is non-null
ccall.add_argument (cexpr);
-
+
return store_temp_value (new GLibValue (type, ccall), node);
} else {
var cnotnull = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, cexpr, new CCodeConstant ("NULL"));
cexpr = handle_struct_argument (null, arg, cexpr);
arg_pos = get_param_pos (i, ellipsis);
}
-
+
carg_map.set (arg_pos, cexpr);
i++;
}
if (params_it.next ()) {
var param = params_it.get ();
-
+
/* if there are more parameters than arguments,
* the additional parameter is an ellipsis parameter
* otherwise there is a bug in the semantic analyzer
}
}
}
-
+
public override void visit_named_argument (NamedArgument expr) {
set_cvalue (expr, get_cvalue (expr.inner));
}
}
} else {
ccode.add_assignment (get_cvalue (expr.inner), new CCodeConstant ("NULL"));
- }
+ }
}
public override void visit_binary_expression (BinaryExpression expr) {
} else {
assert_not_reached ();
}
-
+
if (expr.operator == BinaryOperator.EQUALITY ||
expr.operator == BinaryOperator.INEQUALITY) {
var left_type = expr.left.target_type;
array_needs_copy = requires_copy (target_array.element_type);
}
}
-
+
if (!gvalue_boxing && !gvariant_boxing && target_type.value_owned && (!type.value_owned || boxing || unboxing || array_needs_copy) && requires_copy (target_type) && !(type is NullType)) {
// need to copy value
var copy = (GLibValue) copy_value (result, node);
var base_class = (Class) prop.base_property.parent_symbol;
var vcast = new CCodeFunctionCall (new CCodeIdentifier ("%s_CLASS".printf (get_ccode_upper_case_name (base_class, null))));
vcast.add_argument (new CCodeIdentifier ("%s_parent_class".printf (get_ccode_lower_case_name (current_class, null))));
-
+
var ccall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (vcast, "set_%s".printf (prop.name)));
ccall.add_argument ((CCodeExpression) get_ccodenode (instance));
var cexpr = get_cvalue_ (value);
}
var set_func = "g_object_set";
-
+
var base_property = prop;
if (!get_ccode_no_accessor_method (prop)) {
if (prop.base_property != null) {
}
}
}
-
+
var ccall = new CCodeFunctionCall (new CCodeIdentifier (set_func));
if (prop.binding == MemberBinding.INSTANCE) {
}
return null;
}
-
+
private void create_property_type_check_statement (Property prop, bool check_return_type, TypeSymbol t, bool non_null, string var_name) {
if (check_return_type) {
create_type_check_statement (prop, prop.property_type, t, non_null, var_name);
n++;
}
-
+
if (default_section != null) {
if (n > 0) {
ccode.add_else ();
visit_local_variable (collection_backup);
ccode.add_assignment (get_variable_cexpression (get_local_cname (collection_backup)), get_cvalue (stmt.collection));
-
+
if (stmt.tree_can_fail && stmt.collection.tree_can_fail) {
// exception handling
add_simple_check (stmt.collection);
var iterator_variable = new LocalVariable (int_type.copy (), stmt.variable_name + "_it");
visit_local_variable (iterator_variable);
var it_name = get_local_cname (iterator_variable);
-
+
var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.LESS_THAN, get_variable_cexpression (it_name), array_len);
ccode.open_for (new CCodeAssignment (get_variable_cexpression (it_name), new CCodeConstant ("0")),
var iterator_variable = new LocalVariable (collection_type.copy (), stmt.variable_name + "_it");
visit_local_variable (iterator_variable);
var it_name = get_local_cname (iterator_variable);
-
+
var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, get_variable_cexpression (it_name), new CCodeConstant ("NULL"));
ccode.open_for (new CCodeAssignment (get_variable_cexpression (it_name), get_variable_cexpression (get_local_cname (collection_backup))),
// handle array parameters
if (get_ccode_array_length (param) && param.variable_type is ArrayType) {
var array_type = (ArrayType) param.variable_type;
-
+
var length_ctype = "int";
if (param.direction != ParameterDirection.IN) {
length_ctype = "int*";
}
-
+
for (int dim = 1; dim <= array_type.rank; dim++) {
cparam = new CCodeParameter (get_parameter_array_length_cname (param, dim), length_ctype);
cfundecl.add_parameter (cparam);
public abstract class Vala.CCodeMemberAccessModule : CCodeControlFlowModule {
public override void visit_member_access (MemberAccess expr) {
CCodeExpression pub_inst = null;
-
+
if (expr.inner != null) {
pub_inst = get_cvalue (expr.inner);
}
var base_class = (Class) m.base_method.parent_symbol;
var vcast = new CCodeFunctionCall (new CCodeIdentifier ("%s_CLASS".printf (get_ccode_upper_case_name (base_class, null))));
vcast.add_argument (new CCodeIdentifier ("%s_parent_class".printf (get_ccode_lower_case_name (current_class, null))));
-
+
set_cvalue (expr, new CCodeMemberAccess.pointer (vcast, get_ccode_vfunc_name (m)));
return;
} else if (m.base_interface_method != null) {
var base_class = (Class) base_prop.parent_symbol;
var vcast = new CCodeFunctionCall (new CCodeIdentifier ("%s_CLASS".printf (get_ccode_upper_case_name (base_class, null))));
vcast.add_argument (new CCodeIdentifier ("%s_parent_class".printf (get_ccode_lower_case_name (current_class, null))));
-
+
var ccall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (vcast, "get_%s".printf (prop.name)));
ccall.add_argument (get_cvalue (expr.inner));
if (prop.property_type.is_real_non_null_struct_type ()) {
Method m = null;
Delegate deleg = null;
List<Parameter> params;
-
+
var ma = expr.call as MemberAccess;
-
+
var itype = expr.call.value_type;
params = itype.get_parameters ();
-
+
if (itype is MethodType) {
assert (ma != null);
m = ((MethodType) itype).method_symbol;
} else if (m != null && m.binding == MemberBinding.CLASS) {
var cl = (Class) m.parent_symbol;
var cast = new CCodeFunctionCall (new CCodeIdentifier (get_ccode_upper_case_name (cl, null) + "_CLASS"));
-
+
CCodeExpression klass;
if (ma.inner == null) {
if (get_this_type () == null) {
}
bool ellipsis = false;
-
+
int i = 1;
int arg_pos;
Iterator<Parameter> params_it = params.iterator ();
}
// append C arguments in the right order
-
+
int last_pos;
int min_pos;
params_it = params.iterator ();
foreach (Expression arg in expr.get_argument_list ()) {
Parameter param = null;
-
+
if (params_it.next ()) {
param = params_it.get ();
if (param.params_array || param.ellipsis) {
requires_array_length = true;
var len_call = new CCodeFunctionCall (new CCodeIdentifier ("_vala_array_length"));
len_call.add_argument (get_cvalue_ (unary.inner.target_value));
-
+
ccode.add_assignment (get_array_length_cvalue (unary.inner.target_value, 1), len_call);
}
}
vcast = new CCodeIdentifier ("self");
}
}
-
+
cname = get_ccode_vfunc_name (m);
if (suffix == "_finish" && cname.has_suffix ("_async")) {
cname = cname.substring (0, cname.length - "_async".length);
return;
}
}
-
+
ccode.add_expression (ccheck);
}
public ClassRegisterFunction (Class cl) {
class_reference = cl;
}
-
+
public override TypeSymbol get_type_declaration () {
return class_reference;
}
-
+
public override string get_type_struct_name () {
return "%sClass".printf (get_ccode_name (class_reference));
}
public override string get_class_init_func_name () {
return "%s_class_init".printf (get_ccode_lower_case_name (class_reference, null));
}
-
+
public override string get_instance_struct_size () {
return "sizeof (%s)".printf (get_ccode_name (class_reference));
}
-
+
public override string get_instance_init_func_name () {
return "%s_instance_init".printf (get_ccode_lower_case_name (class_reference, null));
}
-
+
public override string get_parent_type_name () {
return get_ccode_type_id (class_reference.base_class);
}
public override CCodeFragment get_type_interface_init_declaration () {
var frag = new CCodeFragment ();
-
+
foreach (DataType base_type in class_reference.get_base_types ()) {
if (!(base_type.data_type is Interface)) {
continue;
}
-
+
var iface = (Interface) base_type.data_type;
-
+
var iface_info_name = "%s_info".printf (get_ccode_lower_case_name (iface, null));
-
+
var ctypedecl = new CCodeDeclaration ("const GInterfaceInfo");
ctypedecl.modifiers = CCodeModifiers.STATIC;
ctypedecl.add_declarator (new CCodeVariableDeclarator (iface_info_name, new CCodeConstant ("{ (GInterfaceInitFunc) %s_%s_interface_init, (GInterfaceFinalizeFunc) NULL, NULL}".printf (get_ccode_lower_case_name (class_reference), get_ccode_lower_case_name (iface)))));
frag.append (ctypedecl);
}
-
+
return frag;
}
if (!(base_type.data_type is Interface)) {
continue;
}
-
+
var iface = (Interface) base_type.data_type;
-
+
var iface_info_name = "%s_info".printf (get_ccode_lower_case_name (iface, null));
if (!plugin) {
var reg_call = new CCodeFunctionCall (new CCodeIdentifier ("g_type_add_interface_static"));
block.add_statement (new CCodeExpressionStatement (reg_call));
}
}
-
+
((CCodeBaseModule) context.codegen).register_dbus_info (block, class_reference);
}
}
write_indent ();
buffer.append_printf ("</%s>\n", tag_name);
}
-
+
public override void visit_creation_method (CreationMethod m) {
if (m.external_package) {
return;
if (sig.emitter != null) {
sig.emitter.accept (this);
}
-
+
write_indent ();
buffer.append_printf ("<glib:signal name=\"%s\"", get_ccode_name (sig));
write_symbol_attributes (sig);
private void write_indent () {
int i;
-
+
for (i = 0; i < indent; i++) {
buffer.append_c ('\t');
}
if (class_has_writable_properties (cl) || cl.get_type_parameters ().size > 0) {
ccode.add_assignment (new CCodeMemberAccess.pointer (ccall, "set_property"), new CCodeIdentifier ("_vala_%s_set_property".printf (get_ccode_lower_case_name (cl, null))));
}
-
+
/* set constructor */
if (cl.constructor != null) {
var ccast = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_CLASS"));
get_prop.add_parameter (new CCodeParameter ("pspec", "GParamSpec *"));
push_function (get_prop);
-
+
CCodeFunctionCall ccall = generate_instance_cast (new CCodeIdentifier ("object"), cl);
ccode.add_declaration ("%s *".printf (get_ccode_name (cl)), new CCodeVariableDeclarator ("self", ccall));
cfile.add_function_declaration (get_prop);
cfile.add_function (get_prop);
}
-
+
private void add_set_property_function (Class cl) {
var set_prop = new CCodeFunction ("_vala_%s_set_property".printf (get_ccode_lower_case_name (cl, null)), "void");
set_prop.modifiers = CCodeModifiers.STATIC;
set_prop.add_parameter (new CCodeParameter ("pspec", "GParamSpec *"));
push_function (set_prop);
-
+
CCodeFunctionCall ccall = generate_instance_cast (new CCodeIdentifier ("object"), cl);
ccode.add_declaration ("%s *".printf (get_ccode_name (cl)), new CCodeVariableDeclarator ("self", ccall));
var function = new CCodeFunction ("%s_constructor".printf (get_ccode_lower_case_name (cl, null)), "GObject *");
function.modifiers = CCodeModifiers.STATIC;
-
+
function.add_parameter (new CCodeParameter ("type", "GType"));
function.add_parameter (new CCodeParameter ("n_construct_properties", "guint"));
function.add_parameter (new CCodeParameter ("construct_properties", "GObjectConstructParam *"));
-
+
cfile.add_function_declaration (function);
push_function (function);
inst_ma.target_value = new GLibValue (get_data_type_for_symbol ((Class) prop.parent_symbol), new CCodeIdentifier ("self"), true);
store_property (prop, inst_ma, prop.initializer.target_value);
- temp_ref_values.clear ();
+ temp_ref_values.clear ();
pop_context ();
}
}
prefix = "g_cclosure_user_marshal";
}
}
-
+
ret = "%s_%s_".printf (prefix, get_ccode_marshaller_type_name (return_type));
-
+
if (params == null || params.size == 0) {
ret = ret + "_VOID";
} else {
ret = "%s_%s".printf (ret, get_ccode_marshaller_type_name (p).replace (",", "_"));
}
}
-
+
return ret;
}
-
+
private string? get_value_type_name_from_type_reference (DataType t) {
if (t is PointerType || t is GenericType) {
return "gpointer";
} else if (t is ErrorType) {
return "gpointer";
}
-
+
return null;
}
-
+
private string? get_value_type_name_from_parameter (Parameter p) {
if (p.direction != ParameterDirection.IN) {
return "gpointer";
return get_value_type_name_from_type_reference (p.variable_type);
}
}
-
+
private string get_marshaller_signature (List<Parameter> params, DataType return_type) {
string signature;
-
+
signature = "%s:".printf (get_ccode_marshaller_type_name (return_type));
if (params == null || params.size == 0) {
signature = signature + "VOID";
}
}
}
-
+
return signature;
}
void generate_marshaller (List<Parameter> params, DataType return_type) {
string signature;
int n_params, i;
-
+
/* check whether a signal with the same signature already exists for this source file (or predefined) */
signature = get_marshaller_signature (params, return_type);
if (predefined_marshal_set.contains (signature) || user_marshal_set.contains (signature)) {
return;
}
-
+
var signal_marshaller = new CCodeFunction (get_marshaller_function (params, return_type, null), "void");
signal_marshaller.modifiers = CCodeModifiers.STATIC;
-
+
signal_marshaller.add_parameter (new CCodeParameter ("closure", "GClosure *"));
signal_marshaller.add_parameter (new CCodeParameter ("return_value", "GValue *"));
signal_marshaller.add_parameter (new CCodeParameter ("n_param_values", "guint"));
if (return_type.data_type != null || return_type.is_array ()) {
ccode.add_declaration (get_value_type_name_from_type_reference (return_type), new CCodeVariableDeclarator ("v_return"));
-
+
fc = new CCodeFunctionCall (new CCodeIdentifier ("g_return_if_fail"));
fc.add_argument (new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, new CCodeIdentifier ("return_value"), new CCodeConstant ("NULL")));
ccode.add_expression (fc);
var c_assign_rhs = new CCodeCastExpression (new CCodeConditionalExpression (new CCodeIdentifier ("marshal_data"), new CCodeIdentifier ("marshal_data"), new CCodeMemberAccess (new CCodeIdentifier ("cc"), "callback", true)), get_marshaller_function (params, return_type, "GMarshalFunc"));
ccode.add_assignment (new CCodeIdentifier ("callback"), c_assign_rhs);
-
+
fc = new CCodeFunctionCall (new CCodeIdentifier ("callback"));
fc.add_argument (new CCodeIdentifier ("data1"));
i = 1;
}
}
fc.add_argument (new CCodeIdentifier ("data2"));
-
+
if (return_type.data_type != null || return_type.is_array ()) {
ccode.add_assignment (new CCodeIdentifier ("v_return"), fc);
-
+
CCodeFunctionCall set_fc;
if (return_type.is_array ()) {
if (((ArrayType) return_type).element_type.data_type == string_type.data_type) {
}
set_fc.add_argument (new CCodeIdentifier ("return_value"));
set_fc.add_argument (new CCodeIdentifier ("v_return"));
-
+
ccode.add_expression (set_fc);
} else {
ccode.add_expression (fc);
}
-
+
pop_function ();
-
+
cfile.add_function_declaration (signal_marshaller);
cfile.add_function (signal_marshaller);
user_marshal_set.add (signature);
public override void visit_member_access (MemberAccess expr) {
if (expr.symbol_reference is Signal) {
CCodeExpression pub_inst = null;
-
+
if (expr.inner != null) {
pub_inst = get_cvalue (expr.inner);
}
var sig = (Signal) expr.symbol_reference;
var cl = (TypeSymbol) sig.parent_symbol;
-
+
if (expr.inner is BaseAccess && sig.is_virtual) {
var m = sig.default_handler;
var base_class = (Class) m.parent_symbol;
var vcast = new CCodeFunctionCall (new CCodeIdentifier ("%s_CLASS".printf (get_ccode_upper_case_name (base_class, null))));
vcast.add_argument (new CCodeIdentifier ("%s_parent_class".printf (get_ccode_lower_case_name (current_class))));
-
+
set_cvalue (expr, new CCodeMemberAccess.pointer (vcast, m.name));
return;
}
ccall.add_argument (pub_inst);
ccall.add_argument (get_signal_canonical_constant (sig));
-
+
set_cvalue (expr, ccall);
}
} else {
// detailed signal, we don't care about the detail
signal_name = signal_name.substring (0, sep_idx);
}
-
+
var sig = SemanticAnalyzer.symbol_lookup_inherited (current_class, signal_name.replace ("-", "_")) as Signal;
if (sig != null) {
current_handler_to_signal_map.set (handler_name, sig);
ccode.add_expression (call);
pop_context ();
-
+
if (!field_class.external && !field_class.external_package) {
current_required_app_classes.add (field_class);
}
call.add_argument (get_type_id_expression (SemanticAnalyzer.get_data_type_for_symbol (req)));
ccode.add_expression (call);
}
-
+
var call = new CCodeFunctionCall (new CCodeIdentifier ("gtk_widget_init_template"));
call.add_argument (new CCodeIdentifier ("GTK_WIDGET (self)"));
ccode.add_expression (call);
add_interface_init_function (cl, (Interface) base_type.data_type);
}
}
-
+
add_instance_init_function (cl);
if (!cl.is_compact && (cl.get_fields ().size > 0 || cl.destructor != null || cl.is_fundamental ())) {
function.modifiers = CCodeModifiers.STATIC;
push_function (function);
-
+
var vpointer = new CCodeMemberAccess(new CCodeMemberAccess.pointer (new CCodeIdentifier ("value"), "data[0]"),"v_pointer");
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("%sunref".printf (get_ccode_lower_case_prefix (cl))));
ccall.add_argument (vpointer);
func.modifiers = CCodeModifiers.STATIC;
CCodeFunctionCall ccall;
-
+
/* save pointer to parent class */
var parent_decl = new CCodeDeclaration ("gpointer");
var parent_var_decl = new CCodeVariableDeclarator ("%s_parent_class".printf (get_ccode_lower_case_name (cl, null)));
ccall.add_argument (new CCodeIdentifier ("klass"));
var parent_assignment = new CCodeAssignment (new CCodeIdentifier ("%s_parent_class".printf (get_ccode_lower_case_name (cl, null))), ccall);
ccode.add_expression (parent_assignment);
-
+
if (!cl.is_compact && !cl.is_subtype_of (gobject_type) && (cl.get_fields ().size > 0 || cl.destructor != null || cl.is_fundamental ())) {
// set finalize function
continue;
}
var base_type = prop.base_property.parent_symbol;
-
+
var ccast = new CCodeFunctionCall (new CCodeIdentifier ("%s_CLASS".printf (get_ccode_upper_case_name (base_type))));
ccast.add_argument (new CCodeIdentifier ("klass"));
private void add_class_init_function (Class cl) {
cfile.add_function (class_init_context.ccode);
}
-
+
private void add_generic_accessor_function (string base_name, string return_type, CCodeExpression? expression, TypeParameter p, Class cl, Interface iface) {
string name = "%s_%s_%s".printf (get_ccode_lower_case_name (cl), get_ccode_lower_case_name (iface), base_name);
iface_init.modifiers = CCodeModifiers.STATIC;
push_function (iface_init);
-
+
CCodeFunctionCall ccall;
-
+
/* save pointer to parent vtable */
string parent_iface_var = "%s_%s_parent_iface".printf (get_ccode_lower_case_name (cl), get_ccode_lower_case_name (iface));
var parent_decl = new CCodeDeclaration ("%s *".printf (get_ccode_type_name (iface)));
if (base_type != iface) {
continue;
}
-
+
var ciface = new CCodeIdentifier ("iface");
CCodeExpression cfunc;
if (m.is_abstract || m.is_virtual) {
if (base_type != iface) {
continue;
}
-
+
var ciface = new CCodeIdentifier ("iface");
if (!get_ccode_no_accessor_method (prop.base_interface_property) && !get_ccode_concrete_accessor (prop.base_interface_property)) {
push_context (instance_init_context);
end_instance_init (cl);
pop_context ();
-
+
cfile.add_function (instance_init_context.ccode);
}
} else {
cspec.call = new CCodeIdentifier ("g_param_spec_pointer");
}
-
+
var pflags = "G_PARAM_STATIC_STRINGS";
if (prop.get_accessor != null && prop.get_accessor.access != SymbolAccessibility.PRIVATE) {
pflags = "%s%s".printf (pflags, " | G_PARAM_READABLE");
}
var type_struct = new CCodeStruct ("_%s".printf (get_ccode_type_name (iface)));
-
+
decl_space.add_type_declaration (new CCodeNewline ());
var macro = "(%s_get_type ())".printf (get_ccode_lower_case_name (iface, null));
decl_space.add_type_declaration (new CCodeMacroReplacement (get_ccode_type_id (iface), macro));
hash_table_new.add_argument (new CCodeIdentifier ("g_direct_hash"));
hash_table_new.add_argument (new CCodeIdentifier ("g_direct_equal"));
}
-
+
if (key_type.data_type.is_subtype_of (string_type.data_type)) {
hash_table_new.add_argument (new CCodeIdentifier ("g_free"));
} else if (key_type.data_type == gvariant_type) {
} else {
hash_table_new.add_argument (new CCodeIdentifier ("NULL"));
}
-
+
if (value_type.data_type.is_subtype_of (string_type.data_type)) {
hash_table_new.add_argument (new CCodeIdentifier ("g_free"));
} else if (value_type.data_type == gvariant_type) {
* Specifies the interface to be registered.
*/
public weak Interface interface_reference { get; set; }
-
+
public InterfaceRegisterFunction (Interface iface) {
interface_reference = iface;
}
-
+
public override TypeSymbol get_type_declaration () {
return interface_reference;
}
-
+
public override string get_type_struct_name () {
return get_ccode_type_name (interface_reference);
}
public override string get_instance_struct_size () {
return "0";
}
-
+
public override string get_instance_init_func_name () {
return "NULL";
}
-
+
public override string get_parent_type_name () {
return "G_TYPE_INTERFACE";
}
/* register all prerequisites */
foreach (DataType prereq_ref in interface_reference.get_prerequisites ()) {
var prereq = prereq_ref.data_type;
-
+
var func = new CCodeFunctionCall (new CCodeIdentifier ("g_type_interface_add_prerequisite"));
func.add_argument (new CCodeIdentifier ("%s_type_id".printf (get_ccode_lower_case_name (interface_reference))));
func.add_argument (new CCodeIdentifier (get_ccode_type_id (prereq)));
-
+
block.add_statement (new CCodeExpressionStatement (func));
}
public StructRegisterFunction (Struct st) {
struct_reference = st;
}
-
+
public override TypeSymbol get_type_declaration () {
return struct_reference;
}
definition_fragment.append (fun);
}
-
+
/**
* Returns the data type to be registered.
*
*/
public virtual void get_type_interface_init_statements (CodeContext context, CCodeBlock block, bool plugin) {
}
-
+
public CCodeFragment get_source_declaration () {
return source_declaration_fragment;
}
public CCodeFragment get_declaration () {
return declaration_fragment;
}
-
+
/**
* Returns the definition for this type register function in C code.
*
#endif
Slice<G> a = (owned) pending[index];
Slice<G> b = (owned) pending[index + 1];
-
+
assert (a.length > 0);
assert (b.length > 0);
assert (a.index + a.length == b.index);
this.index = index;
this.length = length;
}
-
+
~Slice () {
if (new_list != null)
free (new_list);
}
builder.append_attribute ("]");
-
+
return builder.get ();
}
}
}
/**
- * Adds text onto the end of the builder.
+ * Adds text onto the end of the builder.
*
* @param text a string
* @param spaced add a space at the front of the string if necessary
}
/**
- * Adds text onto the end of the builder.
+ * Adds text onto the end of the builder.
*
* @param text a string
* @param spaced add a space at the front of the string if necessary
}
/**
- * Adds highlighted text onto the end of the builder.
+ * Adds highlighted text onto the end of the builder.
*
* @param text a string
* @param spaced add a space at the front of the string if necessary
}
/**
- * Adds a Inline onto the end of the builder.
+ * Adds a Inline onto the end of the builder.
*
* @param content a content
* @param spaced add a space at the front of the inline if necessary
}
/**
- * Adds a keyword onto the end of the builder.
+ * Adds a keyword onto the end of the builder.
*
* @param keyword a keyword
* @param spaced add a space at the front of the keyword if necessary
}
/**
- * Adds a symbol onto the end of the builder.
+ * Adds a symbol onto the end of the builder.
*
* @param node a node
* @param spaced add a space at the front of the node if necessary
}
/**
- * Adds a type onto the end of the builder.
+ * Adds a type onto the end of the builder.
*
* @param node a node
* @param spaced add a space at the front of the node if necessary
}
/**
- * Adds a type name onto the end of the builder.
+ * Adds a type name onto the end of the builder.
*
* @param name a type name
* @param spaced add a space at the front of the type name if necessary
}
/**
- * Adds a literal onto the end of the builder.
+ * Adds a literal onto the end of the builder.
*
* @param literal a literal
* @param spaced add a space at the front of the literal if necessary
public class Valadoc.Api.SourceComment {
public SourceFile file {
private set;
- get;
+ get;
}
/**
_cresolver = new CTypeResolver (this);
}
- return _cresolver.resolve_symbol_type (cname);
+ return _cresolver.resolve_symbol_type (cname);
}
public Node? search_symbol_cstr (Node? element, string cname) {
/**
* {@inheritDoc}
- */
+ */
protected override Inline build_signature () {
return new SignatureBuilder ()
.append_symbol (this)
/**
* {@inheritDoc}
- */
+ */
public override NodeType node_type { get { return NodeType.TYPE_PARAMETER; } }
/**
* {@inheritDoc}
- */
+ */
public override void accept (Visitor visitor) {
visitor.visit_type_parameter (this);
}
/**
* {@inheritDoc}
- */
+ */
protected override Inline build_signature () {
var signature = new SignatureBuilder ();
public override void check (Api.Tree api_root, Api.Node container, string file_path,
ErrorReporter reporter, Settings settings)
{
-
+
// Internal gktdoc-id? (gir-importer)
if (id_registrar != null) {
Api.Node? node = id_registrar.map_symbol_id (url);
replacement.check (api_root, container, file_path, reporter, settings);
_parent.replace_node (this, replacement);
return ;
- }
+ }
string _url = id_registrar.map_url_id (url);
LANG_PREPROCESSOR,
LANG_COMMENT,
LANG_ESCAPE,
-
+
XML_ESCAPE,
XML_ELEMENT,
XML_ATTRIBUTE,
return Style.UNDERLINED;
case "monospaced":
- return Style.MONOSPACED;
+ return Style.MONOSPACED;
case "stroke":
return Style.STROKE;
private CommentScanner _comment_scanner;
private Parser _wiki_parser;
private Parser _comment_parser;
-
+
private Parser _parser;
private Scanner _scanner;
Rule.many ({ TokenType.SPACE })
});
- Rule optional_spaces =
+ Rule optional_spaces =
Rule.option ({
Rule.many ({
TokenType.SPACE.action (add_content_space)
//TODO: Find a nicer way to allow empty tags (''run?'' won't work)
Rule bold =
Rule.seq ({
- TokenType.SINGLE_QUOTE_2,
+ TokenType.SINGLE_QUOTE_2,
Rule.one_of ({
TokenType.SINGLE_QUOTE_2,
Rule.seq ({ optional_spaces, run, TokenType.SINGLE_QUOTE_2 })
Rule? taglet_rule;
if (taglet is BlockContent) {
- taglet_rule = taglet.get_parser_rule (multiline_block_run);
+ taglet_rule = taglet.get_parser_rule (multiline_block_run);
} else {
taglet_rule = taglet.get_parser_rule (multiline_run);
}
next ();
ListItem item = factory.create_list_item ();
-
+
item.content.add_all (parse_mixed_content ());
if (!check_xml_close_tag ("listitem")) {
}
parse_docbook_spaces ();
- ListItem? desc = parse_docbook_listitem ();
+ ListItem? desc = parse_docbook_listitem ();
if (desc == null) {
return null;
}
builder.append_c ('>');
}
}
- }
+ }
if (&txt == &start) {
return txt;
unowned string start = this.pos;
int column_start = this.column;
- next_char ();
+ next_char ();
int id_len = 0;
}
} else if (this.pos.has_prefix ("->") || this.pos.has_prefix (".")) {
unowned string sep_start = this.pos;
- int sep_column_start = this.column;
+ int sep_column_start = this.column;
int separator_len = 1;
if (this.pos.has_prefix ("->")) {
separator_len = 2;
- next_char ();
+ next_char ();
}
next_char ();
private inline Token? gtkdoc_property_prefix () {
if (get () != ':') {
return null;
- }
+ }
unowned string start = this.pos;
int column_start = this.column;
- next_char ();
+ next_char ();
int id_len = 0;
private inline Token? gtkdoc_signal_prefix () {
if (get () != ':') {
return null;
- }
+ }
unowned string start = this.pos;
int column_start = this.column;
start = this.pos;
- next_char ();
+ next_char ();
int id_len = 0;
Valadoc.TokenType.MARKDOWN_PARAMETER.action ((token) => {
Run _run = null;
- if (token.value == gir_comment.instance_param_name) {
+ if (token.value == gir_comment.instance_param_name) {
_run = _factory.create_run (Run.Style.LANG_KEYWORD);
_run.content.add (_factory.create_text ("this"));
} else if (is_error_parameter (token.value)) {
.set_start (() => {
var siblings = ((BlockContent) peek ()).content;
if (siblings.size > 0 && siblings.last () is Content.List) {
- push (siblings.last ());
+ push (siblings.last ());
} else {
Content.List list = _factory.create_list ();
list.bullet = Content.List.Bullet.UNORDERED;
.set_start (() => {
var siblings = ((BlockContent) peek ()).content;
if (siblings.size > 0 && siblings.last () is Content.List) {
- push (siblings.last ());
+ push (siblings.last ());
} else {
Content.List list = _factory.create_list ();
list.bullet = Content.List.Bullet.ORDERED_NUMBER;
.set_start (() => { push (_factory.create_headline ()); })
.set_reduce (() => {
Headline h = (Headline) pop ();
- ((BlockContent) peek ()).content.add (h);
+ ((BlockContent) peek ()).content.add (h);
})
.set_name ("Headline");
_skip = 0;
_current_string.erase (0, -1);
contains_at = false;
-
+
states.clear ();
push_state (State.NORMAL);
}
while (!_stop && _index.get_char () != 0) {
unichar c = _index.get_char ();
accept (c);
-
+
_index = _index.next_char ();
}
// Close open blocks:
while (peek_state () != State.NORMAL) {
if (peek_state () == State.BLOCK) {
- emit_token (Valadoc.TokenType.MARKDOWN_BLOCK_END);
+ emit_token (Valadoc.TokenType.MARKDOWN_BLOCK_END);
pop_state ();
} else {
close_block ();
// In headline:
string? hash = null;
-
+
if (headline_end != null && is_headline_end (ref _index, headline_end, out hash)) {
if (hash != null) {
emit_token (Valadoc.TokenType.MARKDOWN_HEADLINE_HASH, hash);
_iter = _iter.offset (1);
_skip++;
}
-
+
if (_iter[0].tolower () == 'f' || _iter[0].tolower () == 'l') {
_iter = _iter.offset (1);
_skip++;
headline_end = "#";
} else {
emit_token (Valadoc.TokenType.MARKDOWN_HEADLINE_2);
- _iter = _iter.offset (2);
+ _iter = _iter.offset (2);
headline_end = "##";
}
unowned string id_start = _iter;
int hash_len = 0;
-
+
while (_iter[0] != '}' && _iter[0] != '\n' && _iter[0] != '\0') {
_iter = _iter.offset (1);
hash_len++;
public extern const string icons_dir;
/**
- * Makes a copy of the file src to dest.
+ * Makes a copy of the file src to dest.
*
* @param src the file to copy
* @param dest the destination path
}
/**
- * Makes a copy of the directory src to dest.
+ * Makes a copy of the directory src to dest.
*
* @param src the directory to copy
* @param dest the destination path
}
element.accept_children (this);
-
+
writer.end_tag (tag);
}
pos = pos.offset (1);
skipped = true;
}
-
+
return skipped;
}
if (pos.has_prefix ("<!--")) {
return true;
}
-
+
// CDATA:
if (pos.has_prefix ("<![CDATA[")) {
return true;
symbol_map = new Vala.HashMap<string, Api.Node> (str_hash, str_equal);
}
-
+
public void register_symbol (string id, Api.Node symbol) {
this.symbol_map.set (id, symbol);
}
_scanner.set_parser (_parser);
_comment = new StringBuilder ();
-
+
// init parser rules:
Rule unprinted_spaces = Rule.many ({
Rule.one_of ({
/**
* Initializes a new instance of the MarkupWriter
- *
+ *
* @param write stream a WriteFunc
* @param xml_declaration specifies whether this file starts with an xml-declaration
*/
void main () {
Object o1 = new Object ();
Object o2 = new Object ();
-
+
(unowned Object)[] test = new (unowned Object)[] { o1 };
assert (o1.ref_count == 1);
test[0] = o2;
assert (o1.ref_count == 1);
assert (o2.ref_count == 1);
-
- test = null;
+
+ test = null;
assert (o1.ref_count == 1);
assert (o2.ref_count == 1);
void main() {
foo = "foo";
-
+
string[] keys = bar();
foo = null;
-
+
foreach (unowned string k in keys) {
assert (k == "foo");
}
class Maman.Bar : Object {
public static int main () {
stdout.printf ("Break Test: 1");
-
+
int i;
for (i = 0; i < 10; i++) {
stdout.printf (" 2");
break;
}
-
+
stdout.printf (" 3\n");
-
+
return 0;
}
}
void main() {
string t = (true ? "1" : "2") ?? "3";
assert (t == "1");
-
+
t = (false ? "1" : "2") ?? "3";
assert (t == "2");
-
+
t = (true ? null : "2") ?? "3";
assert (t == "3");
-
+
t = (false ? "1" : null) ?? "3";
assert (t == "3");
-
+
t = test()[0] ?? "2";
assert (t == "2");
-
+
t = test()[1] ?? "2";
assert (t == "1");
}
for (i = 2; i < 7; i++) {
stdout.printf (" %d", i);
}
-
+
stdout.printf (" 7\n");
stdout.printf ("Switch statement: 1");
class Maman.Foo : Object {
public void run () {
stdout.printf (" 2");
-
+
switch (23) {
case 23:
stdout.printf (" 3");
stdout.printf (" BAD");
break;
}
-
+
switch (inc ()) {
case 0:
stdout.printf (" 4");
stdout.printf (" BAD");
break;
}
-
+
switch (42) {
case 0:
stdout.printf (" BAD");
stdout.printf (" BAD");
break;
}
-
+
stdout.printf (" 6");
}
-
+
public int inc () {
return counter++;
}
-
+
private int counter = 0;
}
public static int main () {
stdout.printf ("Delegate Test: 1");
-
+
VoidCallback void_cb = do_void_action;
void_cb ();
stdout.printf (" 3");
ActionCallback cb = do_action;
-
+
stdout.printf (" %d", cb ());
stdout.printf (" 5");
stdout.printf (" %d", Foo.VAL3);
stdout.printf (" 4");
-
+
stdout.printf (" %d", Foo.VAL5);
}
public static int main () {
stdout.printf ("Enum Test: 1");
-
+
var bar = new Bar ();
bar.run ();
public static int main () {
stdout.printf ("Exception Test: 1");
-
+
var bar = new Bar ();
bar.run ();
var obj1 = new Obj1 ();
var iface1 = (Iface1) obj1;
var iface2 = (Iface2) obj1;
-
+
assert (iface1.foo () == 1);
assert (iface2.foo () == 2);
var obj2 = new Obj2 ();
iface1 = (Iface1) obj2;
iface2 = (Iface2) obj2;
-
+
assert (iface1.foo () == 1);
assert (iface2.foo () == 2);
}
\ No newline at end of file
var baz = new Baz ();
baz.foo<Object> (bar);
assert (baz.ref_count == 1);
-
+
assert (is_check<Bar> ());
assert (!is_check<Baz> ());
}
class FooIterator {
bool called = false;
-
+
public bool next () {
return !called;
}
class FooIterator2 {
bool called = false;
-
+
public Foo? next_value () {
if (called)
return null;
assert (do_action (i => { return i * 3; }) == 3);
assert (do_out_action ((out i) => { i = 4; }) == 4);
assert (do_ref_action ((ref i) => { i += 4; }) == 5);
-
+
return 0;
}
}
public FObject o { get; set; }
public FStruct t { get; set; }
public void* p { get; set; }
-
+
public int foo { get { return i; } }
public int bar { set { i = value; } }
var o = new FObject ();
FStruct t = {};
void* p = &o;
-
+
var foo = new Foo ();
foo.s = s;
foo.a = a;
foo.o = o;
foo.t = t;
foo.p = p;
-
+
foo.notify["s"].connect (() => error ("string-type equality failed"));
foo.notify["a"].connect (() => error ("array-type equality failed"));
foo.notify["i"].connect (() => error ("simple-type equality failed"));
void main() {
string[]? strings;
var f = new Foo();
-
+
f.set("strings", new string[]{ "foo", "bar" });
f.get("strings", out strings);
assert (strings[0] == "foo");
assert (strings[1] == "bar");
-
+
f.set("strings", null);
f.get("strings", out strings);
assert(strings == null);
-
+
f.set("strings", new string[]{ "foo", "bar" });
f.get("strings", out strings);
assert (strings[0] == "foo");
public class Foo : Object {
int i = 42;
-
+
public int bar {
get {
return i;
private int private_field = 4;
private static int private_static_field = 5;
public static int public_static_field = 6;
- private class int private_class_field;
+ private class int private_class_field;
public class int public_class_field;
class construct {
static construct {
public_class_field = 8;
}
-
+
void do_action () {
stdout.printf (" %d %d %d %d %d %d %d", public_base_field, public_field,
- private_field, private_static_field, public_static_field,
+ private_field, private_static_field, public_static_field,
private_class_field, public_class_field);
public_base_field = 9;
public_field = 10;
public_class_field = 15;
}
stdout.printf (" %d %d %d %d %d %d %d", public_base_field, public_field,
- private_field, private_static_field, public_static_field,
+ private_field, private_static_field, public_static_field,
private_class_field, public_class_field);
}
class void do_action_class () {
- stdout.printf (" %d %d %d %d", private_static_field, public_static_field,
+ stdout.printf (" %d %d %d %d", private_static_field, public_static_field,
private_class_field, public_class_field);
lock (private_static_field) {
private_static_field = 12;
lock (public_class_field) {
public_class_field = 15;
}
- stdout.printf (" %d %d %d %d", private_static_field, public_static_field,
+ stdout.printf (" %d %d %d %d", private_static_field, public_static_field,
private_class_field, public_class_field);
}
public static int main () {
stdout.printf ("Field Test: 1");
-
+
var bar = new Bar ();
bar.do_action ();
bar.do_action_class ();
bar.private_class_field = 21;
((Foo)bar).public_class_field = 22;
stdout.printf (" %d %d %d %d %d %d %d", bar.public_base_field, bar.public_field,
- bar.private_field, bar.private_static_field, bar.public_static_field,
+ bar.private_field, bar.private_static_field, bar.public_static_field,
bar.private_class_field, ((Foo)bar).public_class_field);
var foo = new Foo ();
stdout.printf (" %d", foo.public_class_field);
-
+
var compact = new CompactTest ();
stdout.printf (" %d", compact.initialized_field);
ibaz.do_action ();
ibaz.public_mixin();
(ibaz as Baz).do_mixin();
-
+
stdout.printf (" 3");
ibaz.do_virtual_action ();
var bar = new SubBar ();
bar.do_action ();
-
+
stdout.printf (" 3\n");
stdout.printf ("Static Inheritance Test: 1");
stdout.printf ("Virtual Method Test: 1");
bar.do_virtual_action ();
-
+
stdout.printf (" 3\n");
// test symbol resolving to check that methods of implemented
var foobar = new SubFooBar ();
foobar.do_action ();
-
+
stdout.printf (" 3\n");
test_classes_methods_ref_parameters ();
Maman.Ibaz ibaz = new Maman.Baz ();
ibaz.simple_method ();
-
+
stdout.printf (" 3\n");
var nonpriv = new NonPrivAccess ();
public static void run () {
stdout.printf ("Property Test: 1");
-
+
var bar = new Bar ();
bar.do_action ();
-
+
Foo foo = bar;
foo.abstract_base_property = 6;
stdout.printf (" %d", foo.abstract_base_property);
public void run () {
stdout.printf (" 2");
-
+
var foo = new Foo ();
-
+
foo.activated.connect ((foo, b) => {
if (b) {
stdout.printf (" 8");
foo.activated.connect (activated);
stdout.printf (" 3");
-
+
foo.do_action (false);
stdout.printf (" 6");
-
+
foo.activated.disconnect (activated);
stdout.printf (" 7");
class Maman.UserBar : Object {
public void run () {
stdout.printf (" 2");
-
+
var foo = new UserFoo ();
-
+
foo.activated.connect ((foo, i1, i2) => {
stdout.printf (" %d", i1 + i2);
});
stdout.printf (" 3");
-
+
foo.do_action ();
stdout.printf (" 5");
var bar = new SubBar ();
bar.run ();
-
+
stdout.printf (" 5\n");
return 0;
var bar = new SubBar ();
bar.run ();
-
+
stdout.printf (" 5\n");
return 0;
class Maman.Foo : Object {
public int p1 { get; set; }
public int p2 { get; set; }
-
+
public Foo (int i, int p2) {
p1 = 2 * i;
this.p2 = p2;
}
-
+
public static int main () {
stdout.printf ("Construct Formal Parameter Test: 1");
-
+
var foo = new Foo (2, 3);
-
+
stdout.printf (" 2");
stdout.printf (" %d", foo.p2);
stdout.printf (" %d", foo.p1);
-
+
stdout.printf (" 5\n");
-
+
return 0;
}
}
_inner.parent_node = this;
}
}
-
+
private Expression _inner;
/**
this.source_reference = source_reference;
this.inner = inner;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_addressof_expression (this);
_element_type.parent_node = this;
}
}
-
+
/**
* The rank of the array.
*/
public int rank { get; set; }
-
+
/**
* The size for each dimension ascending from left to right.
*/
private List<Expression> sizes = new ArrayList<Expression> ();
-
+
/**
* The root array initializer list.
*/
size.parent_node = this;
}
}
-
+
/**
* Get the sizes for all dimensions ascending from left to right.
*/
public List<Expression> get_sizes () {
return sizes;
}
-
+
public ArrayCreationExpression (DataType element_type, int rank, InitializerList? initializer_list, SourceReference source_reference) {
this.element_type = element_type;
this.rank = rank;
resize_method.access = SymbolAccessibility.PUBLIC;
resize_method.set_attribute_string ("CCode", "cname", "g_renew");
-
+
var root_symbol = source_reference.file.context.root;
var int_type = new IntegerType ((Struct) root_symbol.scope.lookup ("int"));
resize_method.add_parameter (new Parameter ("length", int_type));
-
+
resize_method.returns_modified_pointer = true;
}
return resize_method;
if (element_type.is_weak () && !(parent_node is Constant)) {
elem_str = "(unowned %s)".printf (elem_str);
}
-
+
if (!fixed_length) {
return "%s[%s]%s".printf (elem_str, string.nfill (rank - 1, ','), nullable ? "?" : "");
} else {
_left.parent_node = this;
}
}
-
+
/**
* Assignment operator.
*/
public AssignmentOperator operator { get; set; }
-
+
/**
* Right hand side of the assignment.
*/
_right.parent_node = this;
}
}
-
+
private Expression _left;
private Expression _right;
-
+
/**
* Creates a new assignment.
*
this.source_reference = source_reference;
this.left = left;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_assignment (this);
right.get_used_variables (collection);
}
}
-
+
public enum Vala.AssignmentOperator {
NONE,
SIMPLE,
public void add_argument (string key, string value) {
args.set (key, value);
}
-
+
/**
* Returns whether this attribute has the specified named argument.
*
public bool has_argument (string name) {
return args.contains (name);
}
-
+
/**
* Returns the string value of the specified named argument.
*
/* unescape string */
return noquotes.compress ();
}
-
+
/**
* Returns the integer value of the specified named argument.
*
public BaseAccess (SourceReference? source = null) {
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_base_access (this);
* The binary operator.
*/
public BinaryOperator operator { get; set; }
-
+
/**
* The left operand.
*/
_left.parent_node = this;
}
}
-
+
/**
* The right operand.
*/
_right.parent_node = this;
}
}
-
+
public bool is_chained { get; private set; }
private Expression _left;
private Expression _right;
-
+
/**
* Creates a new binary expression.
*
public override void accept_children (CodeVisitor visitor) {
left.accept (visitor);
- right.accept (visitor);
+ right.accept (visitor);
}
public override void replace_expression (Expression old_node, Expression new_node) {
} else if (right.value_type != null) {
local_type = right.value_type.copy ();
}
-
+
var local = new LocalVariable (local_type, get_temp_name (), left, source_reference);
var decl = new DeclarationStatement (local, source_reference);
parent_node.replace_expression (this, contains_call);
return contains_call.check (context);
}
-
+
value_type = context.analyzer.bool_type;
-
+
} else {
assert_not_reached ();
}
private List<Statement> statement_list = new ArrayList<Statement> ();
private List<LocalVariable> local_variables = new ArrayList<LocalVariable> ();
private List<Constant> local_constants = new ArrayList<Constant> ();
-
+
/**
* Creates a new block.
*
public Block (SourceReference? source_reference) {
base (null, source_reference);
}
-
+
/**
* Append a statement to this block.
*
}
return list;
}
-
+
/**
* Add a local variable to this block.
*
value = b;
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_boolean_literal (this);
public BreakStatement (SourceReference? source) {
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_break_statement (this);
}
_inner.parent_node = this;
}
}
-
+
/**
* The target type.
*/
}
}
}
-
+
/**
* Specifies the error variable name.
*/
public string? variable_name { get; set; }
-
+
/**
* Specifies the error handler body.
*/
_body.parent_node = this;
}
}
-
+
/**
* Specifies the declarator for the generated error variable.
*/
}
set {
_value = value;
-
+
if (!value.validate ()) {
error = true;
}
}
}
-
+
private string _value;
/**
visitor.visit_expression (this);
}
-
+
/**
* Returns the unicode character value this character literal
* represents.
* Specifies the base class.
*/
public Class base_class { get; set; }
-
+
/**
* Specifies whether this class is abstract. Abstract classes may not be
* instantiated.
* Specifies whether this class has private fields.
*/
public bool has_private_fields { get; set; }
-
+
/**
* Specifies whether this class has class fields.
*/
* Specifies the default construction method.
*/
public CreationMethod default_construction_method { get; set; }
-
+
/**
* Specifies the instance constructor.
*/
* Specifies the class destructor.
*/
public Destructor? static_destructor { get; set; }
-
+
/**
* Specifies the class destructor.
*/
has_class_private_fields = true;
}
}
-
+
/**
* Adds the specified method as a member to this class.
*
add_field (prop.field);
}
}
-
+
public override void add_constructor (Constructor c) {
if (c.binding == MemberBinding.INSTANCE) {
if (constructor != null) {
foreach (Field f in get_fields ()) {
f.accept (visitor);
}
-
+
foreach (Constant c in get_constants ()) {
c.accept (visitor);
}
-
+
foreach (Method m in get_methods ()) {
m.accept (visitor);
}
-
+
foreach (Property prop in get_properties ()) {
prop.accept (visitor);
}
-
+
foreach (Signal sig in get_signals ()) {
sig.accept (visitor);
}
-
+
if (constructor != null) {
constructor.accept (visitor);
}
if (class_destructor != null) {
class_destructor.accept (visitor);
}
-
+
foreach (Class cl in get_classes ()) {
cl.accept (visitor);
}
-
+
foreach (Struct st in get_structs ()) {
st.accept (visitor);
}
return true;
}
}
-
+
return false;
}
foreach (Field f in get_fields ()) {
f.check (context);
}
-
+
foreach (Constant c in get_constants ()) {
c.check (context);
}
-
+
foreach (Method m in get_methods ()) {
m.check (context);
}
-
+
foreach (Property prop in get_properties ()) {
if (prop.get_attribute ("NoAccessorMethod") != null && !is_subtype_of (context.analyzer.object_type)) {
error = true;
}
prop.check (context);
}
-
+
foreach (Signal sig in get_signals ()) {
sig.check (context);
}
-
+
if (constructor != null) {
constructor.check (context);
}
if (static_destructor != null) {
static_destructor.check (context);
}
-
+
if (class_destructor != null) {
class_destructor.check (context);
}
-
+
foreach (Class cl in get_classes ()) {
cl.check (context);
}
-
+
foreach (Struct st in get_structs ()) {
st.check (context);
}
result.nullable = nullable;
result.is_dynamic = is_dynamic;
result.floating_reference = floating_reference;
-
+
foreach (DataType arg in get_type_arguments ()) {
result.add_type_argument (arg.copy ());
}
-
+
return result;
}
}
public bool vapi_comments { get; set; }
/**
- * Returns true if the target version of glib is greater than or
+ * Returns true if the target version of glib is greater than or
* equal to the specified version.
*/
public bool require_glib_version (int major, int minor) {
public List<string> get_c_source_files () {
return c_source_files;
}
-
+
/**
* Adds the specified file to the list of source files.
*
/**
* Specifies that this node or a child node may throw an exception.
*/
- public bool tree_can_fail {
+ public bool tree_can_fail {
get { return _error_types != null && _error_types.size > 0; }
}
/**
* Specifies the exceptions that can be thrown by this node or a child node
*/
- public List<DataType> get_error_types () {
+ public List<DataType> get_error_types () {
if (_error_types != null) {
return _error_types;
}
/**
* Adds an error type to the exceptions that can be thrown by this node
- * or a child node
+ * or a child node
*/
public void add_error_type (DataType error_type) {
if (_error_types == null) {
/**
* Adds a collection of error types to the exceptions that can be thrown by this node
- * or a child node
+ * or a child node
*/
public void add_error_types (List<DataType> error_types) {
foreach (DataType error_type in error_types) {
*/
public virtual void visit_method_call (MethodCall expr) {
}
-
+
/**
* Visit operation called for element access expressions.
*
static GLib.Regex fix_indent_regex;
private CodeContext context;
-
+
FileStream stream;
-
+
int indent;
/* at begin of line */
bool bol = true;
}
write_attributes (cl);
-
+
write_indent ();
write_accessibility (cl);
if (cl.is_abstract) {
var base_types = cl.get_base_types ();
if (base_types.size > 0) {
write_string (" : ");
-
+
bool first = true;
foreach (DataType base_type in base_types) {
if (!first) {
var prerequisites = iface.get_prerequisites ();
if (prerequisites.size > 0) {
write_string (" : ");
-
+
bool first = true;
foreach (DataType prerequisite in prerequisites) {
if (!first) {
write_string ("const ");
write_type (c.type_reference);
-
+
write_string (" ");
write_identifier (c.name);
write_type_suffix (c.type_reference);
}
write_type (f.variable_type);
-
+
write_string (" ");
write_identifier (f.name);
write_type_suffix (f.variable_type);
write_string (";");
write_newline ();
}
-
+
private void write_error_domains (List<DataType> error_domains) {
if (error_domains.size > 0) {
write_string (" throws ");
if (i > 1) {
write_string (", ");
}
-
+
if (param.ellipsis) {
write_string ("...");
continue;
}
-
+
write_attributes (param);
if (param.params_array) {
write_string (" ");
write_identifier (param.name);
write_type_suffix (param.variable_type);
-
+
if (param.initializer != null) {
write_string (" = ");
param.initializer.accept (this);
write_accessibility (cb);
write_string ("delegate ");
-
+
write_return_type (cb.return_type);
-
+
write_string (" ");
write_identifier (cb.name);
write_type_parameters (cb.get_type_parameters ());
write_string (" ");
-
+
write_params (cb.get_parameters ());
write_error_domains (cb.get_error_types ());
write_indent ();
write_accessibility (m);
-
+
if (m is CreationMethod) {
if (m.coroutine) {
write_string ("async ");
if (m.coroutine) {
write_string ("async ");
}
-
+
write_return_type (m.return_type);
write_string (" ");
write_string (" ");
}
-
+
write_params (m.get_parameters ());
write_error_domains (m.get_error_types ());
if (!check_accessibility (sig)) {
return;
}
-
+
if (context.vapi_comments && sig.comment != null) {
write_comment (sig.comment);
}
write_attributes (sig);
-
+
write_indent ();
write_accessibility (sig);
}
write_string ("signal ");
-
+
write_return_type (sig.return_type);
-
+
write_string (" ");
write_identifier (sig.name);
-
+
write_string (" ");
-
+
write_params (sig.get_parameters ());
write_string (";");
write_string (")");
}
-
+
public override void visit_element_access (ElementAccess expr) {
expr.container.accept (this);
write_string ("[");
write_string (fixed_content);
write_string ("*/");
}
-
+
private void write_identifier (string s) {
char* id = (char*)s;
int id_length = (int)s.length;
if (Vala.Scanner.get_identifier_or_keyword (id, id_length) != Vala.TokenType.IDENTIFIER ||
s.get_char ().isdigit ()) {
- stream.putc ('@');
+ stream.putc ('@');
}
write_string (s);
}
stream.puts (s);
bol = false;
}
-
+
private void write_newline () {
stream.putc ('\n');
bol = true;
}
-
+
void write_code_block (Block? block) {
if (block == null || type != CodeWriterType.DUMP) {
write_string (";");
write_newline ();
indent++;
}
-
+
private void write_end_block () {
indent--;
write_indent ();
false_expression = false_expr;
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_conditional_expression (this);
public bool get_lock_used () {
return lock_used;
}
-
+
public void set_lock_used (bool used) {
lock_used = used;
}
public ContinueStatement (SourceReference source) {
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_continue_statement (this);
}
* The referred data type.
*/
public weak TypeSymbol data_type { get; set; }
-
+
/**
* Specifies that the expression transfers a floating reference.
*/
type_argument_list.add (arg);
arg.parent_node = this;
}
-
+
/**
* Returns a copy of the list of generic type arguments.
*
return s;
}
-
+
/**
* Creates a shallow copy of this type reference.
*
if (!type2_args[i].equals (type_args[i]))
return false;
}
-
+
return true;
}
-
+
/**
* Checks whether this type reference is at least as strict as the
* specified type reference type2.
if (type2.is_disposable () != is_disposable ()) {
return false;
}
-
+
if (!type2.nullable && nullable) {
return false;
}
if (type2.floating_reference != floating_reference) {
return false;
}
-
+
return true;
}
public List<Parameter> get_parameters () {
return parameters;
}
-
+
/**
* Checks whether the arguments and return type of the specified method
* matches this callback.
if (!m.return_type.stricter (return_type.get_actual_type (dt, null, this))) {
return false;
}
-
+
var method_params = m.get_parameters ();
Iterator<Parameter> method_params_it = method_params.iterator ();
return false;
}
}
-
+
/* method may not expect more arguments */
if (method_params_it.next ()) {
return false;
foreach (TypeParameter p in type_parameters) {
p.accept (visitor);
}
-
+
return_type.accept (visitor);
-
+
foreach (Parameter param in parameters) {
param.accept (visitor);
}
foreach (TypeParameter p in type_parameters) {
p.check (context);
}
-
+
return_type.check (context);
-
+
foreach (Parameter param in parameters) {
param.check (context);
}
body.accept (visitor);
condition.accept (visitor);
-
+
visitor.visit_end_full_expression (condition);
}
public List<Expression> get_indices () {
return indices;
}
-
+
public ElementAccess (Expression container, SourceReference source_reference) {
this.source_reference = source_reference;
this.container = container;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_element_access (this);
if (container == old_node) {
container = new_node;
}
-
+
int index = indices.index_of (old_node);
if (index >= 0 && new_node.parent_node == null) {
indices[index] = new_node;
public EmptyStatement (SourceReference source) {
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_empty_statement (this);
}
public Enum (string name, SourceReference? source_reference = null, Comment? comment = null) {
base (name, source_reference, comment);
}
-
+
/**
* Appends the specified enum value to the list of values.
*
public override void add_method (Method m) {
if (m is CreationMethod) {
Report.error (m.source_reference, "construction methods may only be declared within classes and structs");
-
+
m.error = true;
return;
}
public EnumValue (string name, Expression? value, SourceReference? source_reference = null, Comment? comment = null) {
base (name, null, value, source_reference, comment);
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_enum_value (this);
}
this (name, source_reference);
this.value = value;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_error_code (this);
}
public ErrorDomain (string name, SourceReference? source_reference = null, Comment? comment = null) {
base (name, source_reference, comment);
}
-
+
/**
* Appends the specified code to the list of error codes.
*
public override void add_method (Method m) {
if (m is CreationMethod) {
Report.error (m.source_reference, "construction methods may only be declared within classes and structs");
-
+
m.error = true;
return;
}
public override bool is_reference_type () {
return false;
}
-
+
public override bool check (CodeContext context) {
if (checked) {
return !error;
public abstract class Vala.Expression : CodeNode {
/**
* The static type of the value of this expression.
- *
+ *
* The semantic analyzer computes this value.
*/
public DataType value_type { get; set; }
public override void accept_children (CodeVisitor visitor) {
variable_type.accept (visitor);
-
+
if (initializer != null) {
initializer.accept (visitor);
}
public bool get_lock_used () {
return lock_used;
}
-
+
public void set_lock_used (bool used) {
lock_used = used;
}
foreach (CodeNode node in block.get_nodes ()) {
var used_variables = new ArrayList<Variable> ();
node.get_used_variables (used_variables);
-
+
foreach (Variable var_symbol in used_variables) {
var variable_stack = var_map.get (var_symbol);
if (variable_stack == null || variable_stack.size == 0) {
}
}
}
-
+
/**
* Specifies the element variable name.
*/
public string variable_name { get; set; }
-
+
/**
* Specifies the container.
*/
_collection.parent_node = this;
}
}
-
+
/**
* Specifies the loop body.
*/
this.body = body;
this.type_reference = type_reference;
}
-
+
public override void accept (CodeVisitor visitor) {
if (use_iterator) {
base.accept (visitor);
var collection_type = collection.value_type.copy ();
collection.target_type = collection_type.copy ();
-
+
if (collection_type.is_array ()) {
var array_type = (ArrayType) collection_type;
}
}
}
-
+
/**
* Specifies the loop body.
*/
this.body = body;
this.source_reference = source_reference;
}
-
+
/**
* Appends the specified expression to the list of initializers.
*
init.parent_node = this;
initializer.add (init);
}
-
+
/**
* Returns a copy of the list of initializers.
*
public List<Expression> get_initializer () {
return initializer;
}
-
+
/**
* Appends the specified expression to the iterator.
*
iter.parent_node = this;
iterator.add (iter);
}
-
+
/**
* Returns a copy of the iterator.
*
public List<Expression> get_iterator () {
return iterator;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_for_statement (this);
}
-
+
public override void accept_children (CodeVisitor visitor) {
foreach (Expression init_expr in initializer) {
init_expr.accept (visitor);
it_expr.accept (visitor);
visitor.visit_end_full_expression (it_expr);
}
-
+
body.accept (visitor);
}
int size;
Comment comment;
-
+
string class_name;
-
+
/* hack needed to know if any part of an expression is a lambda one */
bool current_expr_is_lambda;
}
return false;
}
-
+
inline bool accept_block () {
-
+
bool has_term = accept_terminator ();
if (accept (TokenType.INDENT)) {
inline SourceLocation get_location () {
return tokens[index].begin;
}
-
+
string get_current_string () {
var token = tokens[index];
return ((string) token.begin.pos).substring (0, (int) (token.end.pos - token.begin.pos));
SourceReference src_begin = get_src (begin);
expect (TokenType.CLOSE_REGEX_LITERAL);
string close_token = get_last_string ();
- return new RegexLiteral ("%s/%s".printf (close_token, match_part), src_begin);
+ return new RegexLiteral ("%s/%s".printf (close_token, match_part), src_begin);
case TokenType.STRING_LITERAL:
next ();
return new StringLiteral (get_last_string (), get_src (begin));
next ();
string raw_string = get_last_string ();
string escaped_string = raw_string.substring (3, raw_string.length - 6).escape ("");
- return new StringLiteral ("\"%s\"".printf (escaped_string), get_src (begin));
+ return new StringLiteral ("\"%s\"".printf (escaped_string), get_src (begin));
case TokenType.NULL:
next ();
return new NullLiteral (get_src (begin));
scanner.indent_spaces = 0;
index = -1;
size = 0;
-
+
next ();
try {
rollback (begin);
}
}
-
+
parse_using_directives (context.root);
parse_declarations (context.root, true);
} catch (ParseError e) {
report_parse_error (e);
}
-
+
scanner = null;
if (!has_global_context) {
context = null;
}
void skip_type () throws ParseError {
-
+
accept (TokenType.DYNAMIC);
accept (TokenType.OWNED);
accept (TokenType.UNOWNED);
accept (TokenType.WEAK);
-
+
if (accept (TokenType.ARRAY) || accept (TokenType.LIST) || accept (TokenType.DICT)) {
accept (TokenType.OF);
}
-
+
if (accept (TokenType.VOID)) {
} else {
skip_symbol_name ();
skip_type_argument_list ();
}
-
- while (accept (TokenType.OPEN_BRACKET)) {
+
+ while (accept (TokenType.OPEN_BRACKET)) {
do {
if (current () != TokenType.COMMA && current () != TokenType.CLOSE_BRACKET) {
parse_expression ();
accept (TokenType.INTERR);
accept (TokenType.HASH);
}
-
-
+
+
Expression parse_regex_literal () throws ParseError {
expect (TokenType.OPEN_REGEX_LITERAL);
List<DataType> type_arg_list = null;
UnresolvedSymbol sym = null;
-
+
bool is_dynamic = accept (TokenType.DYNAMIC);
bool value_owned = owned_by_default;
-
+
if (owned_by_default) {
if (accept (TokenType.UNOWNED)) {
value_owned = false;
/* handle arrays */
bool is_array = false;
-
+
if (accept (TokenType.ARRAY)) {
expect (TokenType.OF);
is_array = true;
}
-
+
/* handle lists */
bool is_list = false;
-
+
if (accept (TokenType.LIST)) {
expect (TokenType.OF);
prev ();
is_list = true;
}
-
+
/* handle dicts */
bool is_dict = false;
-
+
if (accept (TokenType.DICT)) {
expect (TokenType.OF);
prev ();
is_dict = true;
}
-
+
DataType type;
-
+
if (!is_dynamic && value_owned == owned_by_default && accept (TokenType.VOID)) {
type = new VoidType (get_src (begin));
} else {
-
+
if (is_list) {
var sym_parent = new UnresolvedSymbol (null, "Gee", get_src (begin));
sym = new UnresolvedSymbol (sym_parent, "ArrayList", get_src (begin));
} else {
sym = parse_symbol_name ();
}
-
+
type_arg_list = parse_type_argument_list (false);
type = new UnresolvedType.from_symbol (sym, get_src (begin));
}
}
}
-
+
while (accept (TokenType.STAR)) {
type = new PointerType (type, get_src (begin));
}
}
if (is_array) {
-
+
if (!accept (TokenType.OPEN_BRACKET)) {
type.value_owned = true;
type = new ArrayType (type, 1, get_src (begin));
type.nullable = accept (TokenType.INTERR);
-
+
} else {
prev ();
-
- while (accept (TokenType.OPEN_BRACKET)) {
+
+ while (accept (TokenType.OPEN_BRACKET)) {
bool invalid_array = false;
int array_rank = 0;
do {
type.value_owned = true;
var array_type = new ArrayType (type, array_rank, get_src (begin));
array_type.nullable = accept (TokenType.INTERR);
-
+
array_type.invalid_syntax = invalid_array;
-
+
type = array_type;
}
}
}
-
+
if (!owned_by_default) {
value_owned = accept (TokenType.HASH);
}
if (type is PointerType) {
value_owned = false;
}
-
+
type.is_dynamic = is_dynamic;
type.value_owned = value_owned;
return type;
}
return list;
}
-
+
Expression parse_argument () throws ParseError {
var begin = get_location ();
expr = parse_literal ();
break;
case TokenType.ASSERT:
- return parse_assert_expression ();
+ return parse_assert_expression ();
case TokenType.OPEN_BRACE:
expr = parse_initializer ();
break;
break;
case TokenType.YIELD:
expr = parse_yield_expression ();
- break;
+ break;
default:
expr = parse_simple_name ();
break;
case TokenType.OP_DEC:
expr = parse_post_decrement_expression (begin, expr);
break;
-
+
default:
found = false;
break;
var p_expr = parse_expression ();
if (i == 0) {
i++;
-
- if (p_expr != null) {
+
+ if (p_expr != null) {
if (p_expr is StringLiteral) {
var s_exp = (StringLiteral) p_expr;
var len = s_exp.value.length;
-
+
if (len > 2) {
string s = "\\n\"";
var st = s_exp.value.substring (0, len-1);
list.add (s_exp);
}
}
- }
+ }
list.add (p_expr);
} while (accept (TokenType.COMMA));
Expression parse_print_expression () throws ParseError {
var begin = get_location ();
-
+
expect (TokenType.PRINT);
bool parens = accept (TokenType.OPEN_PARENS);
var expr = new MemberAccess (null, "print", get_src (begin));
-
+
var arg_list = parse_print_argument_list ();
if (parens) {
}
var print_expr = new MethodCall (expr, get_src (begin));
-
+
foreach (Expression arg in arg_list) {
print_expr.add_argument (arg);
}
-
+
return print_expr;
-
+
}
-
+
Expression parse_assert_expression () throws ParseError {
var begin = get_location ();
-
+
expect (TokenType.ASSERT);
bool parens = accept (TokenType.OPEN_PARENS);
var expr = new MemberAccess (null, "assert", get_src (begin));
-
+
var arg_list = parse_argument_list ();
if (parens) {
}
var assert_expr = new MethodCall (expr, get_src (begin));
-
+
foreach (Expression arg in arg_list) {
assert_expr.add_argument (arg);
}
-
+
return assert_expr;
-
+
}
Expression parse_method_call (SourceLocation begin, Expression inner) throws ParseError {
expect (TokenType.OPEN_PARENS);
var arg_list = parse_argument_list ();
expect (TokenType.CLOSE_PARENS);
-
+
var init_list = parse_object_initializer ();
if (init_list.size > 0 && inner is MemberAccess) {
Expression parse_object_or_array_creation_expression () throws ParseError {
var begin = get_location ();
expect (TokenType.NEW);
-
+
if (accept (TokenType.ARRAY)) {
expect (TokenType.OF);
var mtype = parse_type (true, false);
var expr = parse_array_creation_expression (begin, mtype);
return expr;
}
-
+
if (accept (TokenType.LIST)) {
expect (TokenType.OF);
var mtype = parse_type (true, false);
var expr = parse_list_creation_expression (begin, mtype);
return expr;
}
-
+
if (accept (TokenType.DICT)) {
expect (TokenType.OF);
var mtype1 = parse_type (true, false);
var expr = parse_dict_creation_expression (begin, mtype1, mtype2);
return expr;
}
-
-
+
+
var member = parse_member_name ();
var expr = parse_object_creation_expression (begin, member);
return expr;
-
+
}
Expression parse_object_creation_expression (SourceLocation begin, MemberAccess member) throws ParseError {
} else {
arg_list = new ArrayList<Expression> ();
}
-
+
var init_list = parse_object_initializer ();
var expr = new ObjectCreationExpression (member, get_src (begin));
List<Expression> size_specifier_list = null;
bool first = true;
DataType etype = element_type.copy ();
-
+
var has_bracket = accept (TokenType.OPEN_BRACKET);
-
+
do {
if (!first) {
// array of arrays: new T[][42]
-
+
if (size_specified) {
throw new ParseError.SYNTAX ("size of inner arrays must not be specified in array creation expression");
}
-
+
etype = new ArrayType (etype, size_specifier_list.size, etype.source_reference);
} else {
first = false;
}
size_specifier_list.add (size);
} while (accept (TokenType.COMMA));
-
+
if (has_bracket) {
expect (TokenType.CLOSE_BRACKET);
}
if (accept (TokenType.ASSIGN)) {
initializer = parse_initializer ();
}
-
+
var expr = new ArrayCreationExpression (etype, size_specifier_list.size, initializer, get_src (begin));
if (size_specified) {
foreach (Expression size in size_specifier_list) {
}
return expr;
}
-
-
+
+
Expression parse_list_creation_expression (SourceLocation begin, DataType element_type) throws ParseError {
-
+
MemberAccess list_member = null, parent_member = null;
-
+
parent_member = new MemberAccess (null, "Gee", get_src (begin));
list_member = new MemberAccess (parent_member, "ArrayList", get_src (begin));
list_member.add_type_argument (element_type);
-
+
list_member.creation_member = true;
-
+
var expr = new ObjectCreationExpression (list_member, get_src (begin));
return expr;
}
-
+
Expression parse_dict_creation_expression (SourceLocation begin, DataType key_type, DataType value_type) throws ParseError {
-
+
MemberAccess dict_member = null, parent_member = null;
-
+
parent_member = new MemberAccess (null, "Gee", get_src (begin));
dict_member = new MemberAccess (parent_member, "HashMap", get_src (begin));
dict_member.add_type_argument (key_type);
dict_member.add_type_argument (value_type);
-
+
dict_member.creation_member = true;
-
+
var expr = new ObjectCreationExpression (dict_member, get_src (begin));
return expr;
}
-
+
List<MemberInitializer> parse_object_initializer () throws ParseError {
var list = new ArrayList<MemberInitializer> ();
case TokenType.HASH:
if (!context.deprecated) {
Report.warning (get_src (begin), "deprecated syntax, use `(owned)` cast");
- }
+ }
next ();
var op = parse_unary_expression ();
return new ReferenceTransferExpression (op, get_src (begin));
return new CastExpression.non_null (inner, get_src (begin));
}
break;
-
+
default:
break;
}
case TokenType.OP_LE: return BinaryOperator.LESS_THAN_OR_EQUAL;
case TokenType.OP_GE: return BinaryOperator.GREATER_THAN_OR_EQUAL;
case TokenType.OP_EQ: return BinaryOperator.EQUALITY;
- case TokenType.IS:
+ case TokenType.IS:
next();
if (current () == TokenType.OP_NEG) {
prev ();
param.direction = direction;
return param;
}
-
+
Expression parse_lambda_expression () throws ParseError {
var begin = get_location ();
List<Parameter> params = new ArrayList<Parameter> ();
-
+
expect (TokenType.DEF);
-
+
if (accept (TokenType.OPEN_PARENS)) {
if (current () != TokenType.CLOSE_PARENS) {
do {
var expr = parse_expression ();
lambda = new LambdaExpression (expr, get_src (begin));
expect_terminator ();
-
+
}
Statement get_for_statement_type () throws ParseError {
-
+
var begin = get_location ();
bool is_foreach = false;
-
+
while (current () != TokenType.EOL && current () != TokenType.DO) {
next ();
if (accept (TokenType.IN)) {
break;
}
}
-
+
rollback (begin);
-
+
if (is_foreach) {
return parse_foreach_statement ();
} else {
comment = scanner.pop_comment ();
switch (current ()) {
- /* skip over requires and ensures as we handled them in method declaration */
+ /* skip over requires and ensures as we handled them in method declaration */
case TokenType.REQUIRES:
case TokenType.ENSURES:
- var begin = get_location ();
+ var begin = get_location ();
next ();
if (accept (TokenType.EOL) && accept (TokenType.INDENT)) {
expect (TokenType.EOL);
}
-
+
stmt = new EmptyStatement (get_src (begin));
- break;
+ break;
case TokenType.INDENT:
break;
case TokenType.PRINT:
case TokenType.ASSERT:
- stmt = parse_expression_statement ();
+ stmt = parse_expression_statement ();
break;
case TokenType.IF:
stmt = parse_if_statement ();
}
block.source_reference.end = get_current_src ().end;
-
+
return block;
}
expect (TokenType.INDENT);
while (current () != TokenType.DEDENT) {
var section = new SwitchSection (get_src (begin));
-
+
if (accept (TokenType.WHEN)) {
do {
section.add_label (new SwitchLabel (parse_expression (), get_src (begin)));
var condition = parse_expression ();
expect_terminator ();
-
+
return new DoStatement (body, condition, get_src (begin));
}
is_expr = false;
break;
default:
-
+
bool local_is_expr = is_expression ();
is_expr = local_is_expr;
break;
expect (TokenType.COLON);
variable_type = parse_type (true, true);
}
-
+
DataType type_copy = null;
if (variable_type != null) {
type_copy = variable_type.copy ();
block.add_statement (new DeclarationStatement (local, local.source_reference));
}
-
-
-
+
+
+
if (accept (TokenType.TO)) {
- /* create expression for condition and incrementing iterator */
+ /* create expression for condition and incrementing iterator */
var to_begin = get_location ();
var to_src = get_src (to_begin);
var left = new MemberAccess (null, id, to_src);
var right = parse_primary_expression ();
condition = new BinaryExpression (BinaryOperator.LESS_THAN_OR_EQUAL, left, right, to_src);
-
+
iterator = new PostfixExpression (left, true, to_src);
} else {
expect (TokenType.DOWNTO);
} else {
expect_terminator ();
}
- return new ReturnStatement (expr, get_src (begin));
+ return new ReturnStatement (expr, get_src (begin));
}
Statement parse_yield_statement () throws ParseError {
expect (TokenType.COLON);
type = parse_type (true, true);
expect (TokenType.EOL);
-
+
}
var block = parse_block ();
catch_clauses.add (new CatchClause (type, id, block, get_src (begin)));
expect (TokenType.CLOSE_BRACKET);
}
if (!parameter)
- expect (TokenType.EOL);
+ expect (TokenType.EOL);
return attrs;
}
comment = scanner.pop_comment ();
var attrs = parse_attributes (false);
var begin = get_location ();
-
+
switch (current ()) {
case TokenType.CONST:
- return parse_constant_declaration (attrs);
+ return parse_constant_declaration (attrs);
case TokenType.CONSTRUCT:
return parse_creation_method_declaration (attrs);
case TokenType.CLASS:
}
rollback (begin);
return parse_constructor_declaration (attrs);
- case TokenType.DELEGATE:
- return parse_delegate_declaration (attrs);
+ case TokenType.DELEGATE:
+ return parse_delegate_declaration (attrs);
case TokenType.DEF:
return parse_method_declaration (attrs);
case TokenType.ENUM:
return parse_errordomain_declaration (attrs);
case TokenType.FINAL:
return parse_destructor_declaration (attrs);
- case TokenType.INTERFACE:
- return parse_interface_declaration (attrs);
- case TokenType.NAMESPACE:
- return parse_namespace_declaration (attrs);
- case TokenType.PROP:
+ case TokenType.INTERFACE:
+ return parse_interface_declaration (attrs);
+ case TokenType.NAMESPACE:
+ return parse_namespace_declaration (attrs);
+ case TokenType.PROP:
return parse_property_declaration (attrs);
- case TokenType.EVENT:
+ case TokenType.EVENT:
return parse_signal_declaration (attrs);
- case TokenType.STRUCT:
+ case TokenType.STRUCT:
return parse_struct_declaration (attrs);
- default:
-
+ default:
+
while (current () != TokenType.EOL && current () != TokenType.SEMICOLON && current () != TokenType.EOF) {
if (current () == TokenType.COLON) {
rollback (begin);
}
}
rollback (begin);
-
- break;
+
+ break;
}
-
+
TokenType cur = current ();
TokenType pre = tokens[index-1].type;
set_attributes (ns, attrs);
expect (TokenType.EOL);
parse_declarations (ns);
-
+
Namespace result = ns;
while (sym.inner != null) {
sym = sym.inner;
var begin = get_location ();
var sym = parse_symbol_name ();
var ns_ref = new UsingDirective (sym, get_src (begin));
-
+
scanner.source_file.add_using_directive (ns_ref);
ns.add_using_directive (ns_ref);
}
while (current () != TokenType.DEDENT && current () != TokenType.EOF) {
add_uses_clause (ns);
- expect (TokenType.EOL);
+ expect (TokenType.EOL);
}
expect (TokenType.DEDENT);
} else {
do {
- add_uses_clause (ns);
+ add_uses_clause (ns);
} while (accept (TokenType.COMMA));
expect_terminator ();
}
}
-
+
}
Symbol parse_class_declaration (List<Attribute>? attrs) throws ParseError {
if (accept (TokenType.COLON)) {
var type1 = parse_type (true, false);
base_types.add (type1);
-
+
if (accept (TokenType.IMPLEMENTS)) {
do {
var type2 = parse_type (true, true);
var flags = parse_member_declaration_modifiers ();
string id = parse_identifier ();
-
+
expect (TokenType.COLON);
var type = parse_type (false, false);
type = parse_inline_array_type (type);
var c = new Constant (id, type, initializer, get_src (begin), comment);
c.access = get_access (id);
-
+
if (ModifierFlags.EXTERN in flags || scanner.source_file.file_type == SourceFileType.PACKAGE) {
c.external = true;
}
if (ModifierFlags.NEW in flags) {
c.hides = true;
}
-
+
set_attributes (c, attrs);
if (ModifierFlags.STATIC in flags) {
var flags = parse_member_declaration_modifiers ();
var type = parse_type (true, true);
-
+
type = parse_inline_array_type (type);
- var f = new Field (id, type, null, get_src (begin), comment);
+ var f = new Field (id, type, null, get_src (begin), comment);
if (ModifierFlags.ABSTRACT in flags || ModifierFlags.VIRTUAL in flags || ModifierFlags.OVERRIDE in flags) {
Report.error (f.source_reference, "abstract, virtual, and override modifiers are not applicable to fields");
}
return initializer;
}
-
-
-
+
+
+
Method parse_main_method_declaration (List<Attribute>? attrs) throws ParseError {
var id = "main";
var method = new Method (id, type, get_src (begin), comment);
method.access = SymbolAccessibility.PUBLIC;
-
+
set_attributes (method, attrs);
method.binding = MemberBinding.STATIC;
-
+
var sym = new UnresolvedSymbol (null, "string", get_src (begin));
type = new UnresolvedType.from_symbol (sym, get_src (begin));
type.value_owned = true;
type = new ArrayType (type, 1, get_src (begin));
type.nullable = false;
-
+
var param = new Parameter ("args", type, get_src (begin));
method.add_parameter (param);
-
-
+
+
expect (TokenType.EOL);
if (accept_block ()) {
method.body = parse_block ();
}
-
+
return method;
}
if (accept (TokenType.COLON)) {
type = parse_type (true, false);
}
-
+
var type_param_list = parse_type_parameter_list ();
- var method = new Method (id, type, get_src (begin), comment);
+ var method = new Method (id, type, get_src (begin), comment);
if (ModifierFlags.PRIVATE in flags) {
method.access = SymbolAccessibility.PRIVATE;
} else {
foreach (TypeParameter type_param in type_param_list) {
method.add_type_parameter (type_param);
}
-
+
foreach (Parameter param in params) {
method.add_parameter (param);
if (ModifierFlags.ASYNC in flags) {
method.coroutine = true;
}
-
+
if (ModifierFlags.NEW in flags) {
method.hides = true;
}
/* "requires" and "ensures" if present will be at start of the method body */
- if (accept (TokenType.INDENT)) {
+ if (accept (TokenType.INDENT)) {
if (accept (TokenType.REQUIRES)) {
-
+
if (accept (TokenType.EOL) && accept (TokenType.INDENT)) {
while (current() != TokenType.DEDENT) {
method.add_precondition (parse_expression ());
expect (TokenType.EOL);
}
-
+
expect (TokenType.DEDENT);
accept_terminator ();
} else {
-
+
method.add_precondition (parse_expression ());
expect_terminator ();
-
+
}
-
+
}
if (accept (TokenType.ENSURES)) {
}
set_attributes (prop, attrs);
-
+
if (ModifierFlags.STATIC in flags) {
prop.binding = MemberBinding.STATIC;
} else if (ModifierFlags.CLASS in flags) {
if (ModifierFlags.OVERRIDE in flags) {
prop.overrides = true;
}
-
+
if (ModifierFlags.NEW in flags) {
prop.hides = true;
}
if (ModifierFlags.EXTERN in flags || scanner.source_file.file_type == SourceFileType.PACKAGE) {
prop.external = true;
}
-
+
if (ModifierFlags.ASYNC in flags) {
Report.error (prop.source_reference, "async properties are not supported yet");
}
prop.set_accessor = new PropertyAccessor (false, true, false, value_type, null, get_src (begin));
prop.set_accessor.access = SymbolAccessibility.PUBLIC;
-
+
}
expect_terminator ();
var needs_var = (readonly && (prop.get_accessor != null && prop.get_accessor.body == null));
if (!needs_var) {
- needs_var = (prop.get_accessor != null && prop.get_accessor.body == null) || (prop.set_accessor != null && prop.set_accessor.body == null);
+ needs_var = (prop.get_accessor != null && prop.get_accessor.body == null) || (prop.set_accessor != null && prop.set_accessor.body == null);
}
if (needs_var) {
if (ModifierFlags.NEW in flags) {
sig.hides = true;
}
-
+
if (ModifierFlags.STATIC in flags) {
throw new ParseError.SYNTAX ("`static' modifier not allowed on signals");
} else if (ModifierFlags.CLASS in flags) {
} else if (sym is Constant) {
st.add_constant ((Constant) sym);
} else if (sym is Property) {
- st.add_property ((Property) sym);
+ st.add_property ((Property) sym);
} else {
Report.error (sym.source_reference, "unexpected declaration in struct");
}
expect (TokenType.EOL);
-
+
parse_declarations (iface);
-
+
Symbol result = iface;
while (sym.inner != null) {
break;
}
var value_attrs = parse_attributes (false);
- var value_begin = get_location ();
+ var value_begin = get_location ();
string id = parse_identifier ();
comment = scanner.pop_comment ();
accept (TokenType.EOL);
}
} while (true);
-
+
expect (TokenType.DEDENT);
Symbol result = en;
ed.add_code (ec);
accept (TokenType.EOL);
} while (true);
-
-
+
+
expect (TokenType.DEDENT);
Symbol result = ed;
while (sym.inner != null) {
sym = sym.inner;
var ns = new Namespace (sym.name, ed.source_reference);
-
+
if (result is Namespace) {
ns.add_namespace ((Namespace) result);
} else {
case TokenType.ASYNC:
next ();
flags |= ModifierFlags.ASYNC;
- break;
+ break;
case TokenType.CLASS:
next ();
flags |= ModifierFlags.CLASS;
case TokenType.NEW:
next ();
flags |= ModifierFlags.NEW;
- break;
+ break;
case TokenType.OVERRIDE:
next ();
flags |= ModifierFlags.OVERRIDE;
case TokenType.SEALED:
next ();
flags |= ModifierFlags.SEALED;
- break;
+ break;
case TokenType.STATIC:
next ();
flags |= ModifierFlags.STATIC;
} else {
var sym = parse_symbol_name ();
if (sym.inner == null) {
-
+
if (sym.name != class_name) {
method = new CreationMethod (class_name, sym.name, get_src (begin), comment);
} else {
} else if (scanner.source_file.file_type == SourceFileType.PACKAGE) {
method.external = true;
}
-
+
return method;
}
var sym = parse_symbol_name ();
var type_param_list = parse_type_parameter_list ();
-
+
if (ModifierFlags.NEW in flags) {
throw new ParseError.SYNTAX ("`new' modifier not allowed on delegates");
}
if (accept (TokenType.COLON)) {
type = parse_type (true, false);
-
+
} else {
type = new VoidType ();
}
expect_terminator ();
-
+
if (ModifierFlags.PRIVATE in flags) {
d.access = SymbolAccessibility.PRIVATE;
} else {
}
}
-
+
// try to parse type argument list
List<DataType>? parse_type_argument_list (bool maybe_expression) throws ParseError {
var begin = get_location ();
if (accept (TokenType.OPEN_PARENS)) {
inParens = true;
}
-
+
do {
switch (current ()) {
case TokenType.VOID:
return null;
}
} while (accept (TokenType.COMMA));
-
+
if (inParens) {
expect (TokenType.CLOSE_PARENS);
}
char* begin;
char* current;
char* end;
-
+
int line;
int column;
int current_indent_level;
int indent_level;
int pending_dedents;
-
+
/* track open parens and braces for automatic line continuations */
int open_parens_count;
int open_brace_count;
bool parse_started;
Comment _comment;
-
+
Conditional[] conditional_stack;
struct Conditional {
TEMPLATE,
TEMPLATE_PART
}
-
+
public Scanner (SourceFile source_file) {
this.source_file = source_file;
current_indent_level = 0;
indent_level = 0;
pending_dedents = 0;
-
+
open_parens_count = 0;
open_brace_count = 0;
parse_started = false;
last_token = TokenType.NONE;
-
+
}
bool in_template () {
bool is_ident_char (char c) {
return (c.isalnum () || c == '_');
}
-
+
bool in_regex_literal () {
return (state_stack.length > 0 && state_stack[state_stack.length - 1] == State.REGEX_LITERAL);
}
return type;
}
-
+
public void seek (SourceLocation location) {
current = location.pos;
line = location.line;
break;
case 'o':
if (matches (begin, "of")) return TokenType.OF;
-
+
if (matches (begin, "or")) return TokenType.OP_OR;
break;
case 't':
break;
}
break;
-
+
case 'n':
if (matches (begin, "null")) return TokenType.NULL;
break;
return TokenType.IDENTIFIER;
}
-
+
public TokenType read_template_token (out SourceLocation token_begin, out SourceLocation token_end) {
TokenType type;
char* begin = current;
/* scrub whitespace (excluding newlines) and comments */
space ();
}
-
-
+
+
/* handle explicit line continuation (lines ending with "\") */
while (current < end && current[0] == '\\' && current[1] == '\n') {
current += 2;
line++;
skip_space_tabs ();
}
-
+
/* handle automatic line continuations (when inside parens or braces) */
while (current < end && current[0] == '\n' && (open_parens_count > 0 || open_brace_count > 0)) {
current++;
line++;
skip_space_tabs ();
}
-
+
/* handle non-consecutive new line once parsing is underway - EOL */
if (newline () && parse_started && last_token != TokenType.EOL && last_token != TokenType.SEMICOLON) {
int count_tabs ()
{
-
+
int tab_count = 0;
column++;
space_count++;
}
-
+
tab_count = space_count / _indent_spaces;
-
+
}
/* ignore comments and whitspace and other lines that contain no code */
bool whitespace () {
bool found = false;
while (current < end && current[0].isspace () && current[0] != '\n' ) {
-
+
found = true;
current++;
column++;
}
-
+
if ((column == 1) && (current < end) && (current[0] == '#')) {
pp_directive ();
return true;
}
-
+
return found;
}
if (current[1] == '/') {
// single-line comment
-
+
SourceReference source_reference = null;
if (file_comment) {
source_reference = get_source_reference (0);
}
-
+
current += 2;
// skip until end of line or end of file
column = 1;
current_indent_level = 0;
}
-
+
if (source_reference != null) {
push_comment (((string) begin).substring (0, (long) (current - begin)), source_reference, file_comment);
}
-
+
} else {
// delimited comment
SourceReference source_reference = null;
column++;
found = true;
}
-
+
return found;
}
void skip_space_tabs () {
while (whitespace () || skip_tabs () || comment () ) {
}
-
+
}
void space () {
public void parse_file_comments () {
while (whitespace () || comment (true)) {
}
-
+
}
void push_comment (string comment_item, SourceReference source_reference, bool file_comment) {
case NAMESPACE: return "`namespace'";
case NEW: return "`new'";
case NULL: return "`null'";
- case OF: return "`of'";
+ case OF: return "`of'";
case OUT: return "`out'";
case OP_AND: return "`and'";
case OP_DEC: return "`--'";
public Node (string? name) {
this.name = name;
}
-
+
public void add_member (Node node) {
var nodes = scope[node.name];
if (nodes == null) {
}
}
}
-
+
if (symbol is Class && girdata != null) {
var class_struct = girdata["glib:type-struct"];
if (class_struct != null) {
}
}
}
-
+
prop.get_accessor.value_type.value_owned = m.return_type.value_owned;
if (!m.is_abstract && !m.is_virtual && prop.is_abstract) {
var base_prop_node = parser.base_interface_property (this);
if (base_prop_node != null) {
base_prop_node.process (parser);
-
+
var base_property = (Property) base_prop_node.symbol;
if (base_property.get_attribute ("ConcreteAccessor") != null) {
prop.set_attribute ("NoAccessorMethod", false);
if (prop.set_accessor != null) {
prop.set_accessor.value_type.value_owned = base_property.set_accessor.value_type.value_owned;
}
-
+
}
}
}
}
return type_id;
}
-
+
void set_array_ccode (Symbol sym, ParameterInfo info) {
sym.set_attribute_double ("CCode", "array_length_pos", info.vala_idx);
if (sym is Parameter) {
base_node.process (this);
orig = (Delegate) base_node.symbol;
}
-
+
var deleg = new Delegate (alias.name, orig.return_type.copy (), alias.source_reference);
deleg.access = orig.access;
-
+
foreach (var param in orig.get_parameters ()) {
deleg.add_parameter (param.copy ());
}
-
+
foreach (var error_type in orig.get_error_types ()) {
deleg.add_error_type (error_type.copy ());
}
-
+
foreach (var attribute in orig.attributes) {
deleg.attributes.append (attribute);
}
-
+
deleg.external = true;
-
+
alias.symbol = deleg;
}
// processed in parse_alias
return;
}
-
+
var s = node.symbol;
List<ParameterInfo> parameters = node.parameters;
_condition.parent_node = this;
}
}
-
+
/**
* The statement to be evaluated if the condition holds.
*/
_true_statement.parent_node = this;
}
}
-
+
/**
* The optional statement to be evaluated if the condition doesn't hold.
*/
false_statement = false_stmt;
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_if_statement (this);
}
public override void accept_children (CodeVisitor visitor) {
condition.accept (visitor);
-
+
visitor.visit_end_full_expression (condition);
-
+
true_statement.accept (visitor);
if (false_statement != null) {
false_statement.accept (visitor);
*/
public class Vala.InitializerList : Expression {
private List<Expression> initializers = new ArrayList<Expression> ();
-
+
/**
- * Appends the specified expression to this initializer
+ * Appends the specified expression to this initializer
*
* @param expr an expression
*/
initializers.add (expr);
expr.parent_node = this;
}
-
+
/**
- * Returns a copy of the expression
+ * Returns a copy of the expression
*
* @return expression list
*/
}
/**
- * Returns the initializer count in this initializer
+ * Returns the initializer count in this initializer
*/
public int size {
get { return initializers.size; }
}
/**
- * Creates a new initializer
+ * Creates a new initializer
*
* @param source_reference reference to source code
* @return newly created initializer list
value = i;
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_integer_literal (this);
u = true;
value = value.substring (0, value.length - 1);
}
-
+
int64 n = int64.parse (value);
if (!u && (n > int.MAX || n < int.MIN)) {
// value doesn't fit into signed 32-bit
public List<DataType> get_prerequisites () {
return prerequisites;
}
-
+
/**
* Adds the specified method as a member to this interface.
*
public override void add_method (Method m) {
if (m is CreationMethod) {
Report.error (m.source_reference, "construction methods may only be declared within classes and structs");
-
+
m.error = true;
return;
}
prop.this_parameter = new Parameter ("this", new ObjectType (this));
prop.scope.add (prop.this_parameter.name, prop.this_parameter);
}
-
+
public virtual List<Symbol> get_virtuals () {
return virtuals;
}
foreach (Method m in get_methods ()) {
m.accept (visitor);
}
-
+
foreach (Field f in get_fields ()) {
f.accept (visitor);
}
foreach (Property prop in get_properties ()) {
prop.accept (visitor);
}
-
+
foreach (Signal sig in get_signals ()) {
sig.accept (visitor);
}
-
+
foreach (Class cl in get_classes ()) {
cl.accept (visitor);
}
-
+
foreach (Struct st in get_structs ()) {
st.accept (visitor);
}
public override bool is_reference_type () {
return true;
}
-
+
public override bool is_subtype_of (TypeSymbol t) {
if (this == t) {
return true;
return true;
}
}
-
+
return false;
}
-
+
public override void replace_type (DataType old_type, DataType new_type) {
for (int i = 0; i < prerequisites.size; i++) {
if (prerequisites[i] == old_type) {
result.nullable = nullable;
result.is_dynamic = is_dynamic;
result.floating_reference = floating_reference;
-
+
foreach (DataType arg in get_type_arguments ()) {
result.add_type_argument (arg.copy ());
}
-
+
return result;
}
}
* expression_body or statement_body may be set.
*/
public Expression expression_body { get; set; }
-
+
/**
* The statement body of this lambda expression. Only one of
* expression_body or statement_body may be set.
*/
public Block statement_body { get; set; }
-
+
/**
* The generated method.
*/
this.source_reference = source_reference;
this.expression_body = expression_body;
}
-
+
/**
* Creates a new lambda expression with statement body.
*
this.statement_body = statement_body;
this.source_reference = source_reference;
}
-
+
/**
* Appends implicitly typed parameter.
*
public void add_parameter (Parameter param) {
parameters.add (param);
}
-
+
/**
* Returns copy of parameter list.
*
public List<Parameter> get_parameters () {
return parameters;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_lambda_expression (this);
public LocalVariable (DataType? variable_type, string name, Expression? initializer = null, SourceReference? source_reference = null) {
base (variable_type, name, initializer, source_reference);
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_local_variable (this);
}
public override void accept_children (CodeVisitor visitor) {
if (initializer != null) {
initializer.accept (visitor);
-
+
visitor.visit_end_full_expression (initializer);
}
-
+
if (variable_type != null) {
variable_type.accept (visitor);
}
* Indicates a specific lockable object beeing actually locked somewhere.
*/
public abstract bool get_lock_used ();
-
+
/**
* Set this lockable object as beeing locked somewhere.
*/
* Expression representing the resource to be locked.
*/
public Expression resource { get; set; }
-
+
/**
* The statement during its execution the resource is locked.
*/
public Block? body { get; set; }
-
+
public LockStatement (Expression resource, Block? body, SourceReference? source_reference = null) {
this.body = body;
this.source_reference = source_reference;
this.resource = resource;
}
-
+
public override void accept (CodeVisitor visitor) {
resource.accept (visitor);
if (body != null) {
}
}
}
-
+
/**
* The name of the member.
*/
private Expression? _inner;
private List<DataType> type_argument_list = new ArrayList<DataType> ();
-
+
/**
* Creates a new member access expression.
*
type_argument_list.add (arg);
arg.parent_node = this;
}
-
+
/**
* Returns a copy of the list of generic type arguments.
*
if (inner != null) {
inner.accept (visitor);
}
-
+
foreach (DataType type_arg in type_argument_list) {
type_arg.accept (visitor);
}
if (inner != null) {
inner.check (context);
}
-
+
foreach (DataType type_arg in type_argument_list) {
type_arg.check (context);
}
this.source_reference = source_reference;
this.name = name;
}
-
+
public override void accept (CodeVisitor visitor) {
initializer.accept (visitor);
}
-
+
public override bool check (CodeContext context) {
return initializer.check (context);
}
* the contained type.
*/
public MemberBinding binding { get; set; default = MemberBinding.INSTANCE; }
-
+
/**
* Specifies whether this method is abstract. Abstract methods have no
* body, may only be specified within abstract classes, and must be
* overriden by derived non-abstract classes.
*/
public bool is_abstract { get; set; }
-
+
/**
* Specifies whether this method is virtual. Virtual methods may be
* overridden by derived classes.
*/
public bool is_virtual { get; set; }
-
+
/**
* Specifies whether this method overrides a virtual or abstract method
* of a base type.
*/
public bool overrides { get; set; }
-
+
/**
* Specifies whether this method should be inlined.
*/
/**
* Specifies the virtual or abstract method this method overrides.
- * Reference must be weak as virtual and abstract methods set
+ * Reference must be weak as virtual and abstract methods set
* base_method to themselves.
*/
public Method base_method {
parameters.add (param);
scope.add (param.name, param);
}
-
+
public List<Parameter> get_parameters () {
return parameters;
}
invalid_match = "Base method expected return type `%s', but `%s' was provided".printf (actual_base_type.to_prototype_string (), return_type.to_prototype_string ());
return false;
}
-
+
Iterator<Parameter> method_params_it = parameters.iterator ();
int param_index = 1;
foreach (Parameter base_param in base_method.parameters) {
}
param_index++;
}
-
+
/* this method may not expect more arguments */
if (method_params_it.next ()) {
invalid_match = "too many parameters";
continue;
}
}
-
+
string invalid_match = null;
if (!compatible (base_method, out invalid_match)) {
error = true;
Report.error (source_reference, "overriding method `%s' is incompatible with base method `%s': %s.".printf (get_full_name (), base_method_type.to_prototype_string (), invalid_match));
return;
}
-
+
_base_interface_method = base_method;
return;
}
}
// check that all errors that can be thrown in the method body are declared
- if (body != null) {
+ if (body != null) {
foreach (DataType body_error_type in body.get_error_types ()) {
bool can_propagate_error = false;
foreach (DataType method_error_type in get_error_types ()) {
return false;
}
}
-
+
if (binding == MemberBinding.INSTANCE) {
// method must be static
return false;
}
-
+
if (return_type is VoidType) {
} else if (return_type.data_type == context.analyzer.int_type.data_type) {
} else {
// return type must be void or int
return false;
}
-
+
var params = get_parameters ();
if (params.size == 0) {
// method may have no parameters
// method must not have more than one parameter
return false;
}
-
+
Iterator<Parameter> params_it = params.iterator ();
params_it.next ();
var param = params_it.get ();
// parameter must not be an out parameter
return false;
}
-
+
if (!(param.variable_type is ArrayType)) {
// parameter must be an array
return false;
}
-
+
var array_type = (ArrayType) param.variable_type;
if (array_type.element_type.data_type != context.analyzer.string_type.data_type) {
// parameter must be an array of strings
return false;
}
-
+
return true;
}
public bool is_chainup { get; private set; }
private Expression _call;
-
+
private List<Expression> argument_list = new ArrayList<Expression> ();
/**
this.source_reference = source_reference;
this.call = call;
}
-
+
/**
* Appends the specified expression to the list of arguments.
*
argument_list.add (arg);
arg.parent_node = this;
}
-
+
/**
* Returns a copy of the argument list.
*
if (call == old_node) {
call = new_node;
}
-
+
int index = argument_list.index_of (old_node);
if (index >= 0 && new_node.parent_node == null) {
argument_list[index] = new_node;
// method types incompatible to anything but delegates
return false;
}
-
+
return dt.delegate_symbol.matches_method (method_symbol, dt);
}
scope.add (ns.name, ns);
}
}
-
+
/**
* Returns a copy of the list of namespaces.
*
public List<Namespace> get_namespaces () {
return namespaces;
}
-
+
/**
* Adds the specified class to this namespace.
*
scope.add (iface.name, iface);
}
-
+
/**
* Adds the specified struct to this namespace.
*
structs.add (st);
scope.add (st.name, st);
}
-
+
/**
* Removes the specified struct from this namespace.
*
structs.remove (st);
scope.remove (st.name);
}
-
+
/**
* Adds the specified enum to this namespace.
*
public List<Class> get_classes () {
return classes;
}
-
+
/**
* Returns a copy of the list of interfaces.
*
public List<Interface> get_interfaces () {
return interfaces;
}
-
+
/**
* Returns a copy of the list of enums.
*
public List<Enum> get_enums () {
return enums;
}
-
+
/**
* Returns a copy of the list of error domains.
*
public List<ErrorDomain> get_error_domains () {
return error_domains;
}
-
+
/**
* Returns a copy of the list of fields.
*
public List<Field> get_fields () {
return fields;
}
-
+
/**
* Returns a copy of the list of constants.
*
public List<Constant> get_constants () {
return constants;
}
-
+
/**
* Returns a copy of the list of delegates.
*
public List<Delegate> get_delegates () {
return delegates;
}
-
+
/**
* Returns a copy of the list of methods.
*
public List<Method> get_methods () {
return methods;
}
-
+
/**
* Adds the specified constant to this namespace.
*
constants.add (constant);
scope.add (constant.name, constant);
}
-
+
/**
* Adds the specified field to this namespace.
*
fields.add (f);
scope.add (f.name, f);
}
-
+
/**
* Adds the specified method to this namespace.
*
public NullLiteral (SourceReference? source = null) {
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_null_literal (this);
this.source_reference = source_reference;
this.member_name = member_name;
}
-
+
/**
* Appends the specified expression to the list of arguments.
*
if (member_name != null) {
member_name.accept (visitor);
}
-
+
foreach (Expression arg in argument_list) {
arg.accept (visitor);
}
if (member_name != null) {
member_name.check (context);
}
-
+
foreach (Expression arg in argument_list) {
arg.check (context);
}
result.nullable = nullable;
result.is_dynamic = is_dynamic;
result.floating_reference = floating_reference;
-
+
foreach (DataType arg in get_type_arguments ()) {
result.add_type_argument (arg.copy ());
}
-
+
return result;
}
if (value_owned != target_type.value_owned) {
return false;
}
-
+
if (nullable && !target_type.nullable) {
return false;
}
/**
* Represents a runtime data type for objects and interfaces. This data type may
- * be defined in Vala source code or imported from an external library with a
+ * be defined in Vala source code or imported from an external library with a
* Vala API file.
*/
public abstract class Vala.ObjectTypeSymbol : TypeSymbol {
* parameters.
*/
public bool ellipsis { get; set; }
-
+
/**
* Specifies whether the methods accepts an indefinite number of
* parameters.
*/
public bool params_array { get; set; }
-
+
public bool captured { get; set; }
public bool format_arg {
access = SymbolAccessibility.PUBLIC;
}
-
+
/**
* Creates a new ellipsis parameter representing an indefinite number of
* parameters.
public override void accept_children (CodeVisitor visitor) {
if (!ellipsis) {
variable_type.accept (visitor);
-
+
if (initializer != null) {
initializer.accept (visitor);
}
if (!ellipsis) {
variable_type.check (context);
-
+
if (params_array && !(variable_type is ArrayType)) {
error = true;
Report.error (source_reference, "parameter array expected");
index = -1;
size = 0;
-
+
next ();
} catch (ParseError e) {
report_parse_error (e);
}
-
+
scanner = null;
if (!has_global_context) {
context = null;
}
accept (TokenType.INTERR);
}
-
+
while (accept (TokenType.OPEN_BRACKET)) {
do {
// required for decision between expression and declaration statement
bool is_inner_array_type () {
var begin = get_location ();
-
+
var result = accept (TokenType.OPEN_PARENS) && accept (TokenType.UNOWNED) && current() != TokenType.CLOSE_PARENS;
rollback (begin);
return result;
}
-
+
DataType parse_type (bool owned_by_default, bool can_weak_ref, bool require_unowned = false) throws ParseError {
var begin = get_location ();
if (accept (TokenType.OPEN_PARENS)) {
type = parse_type (false, false, true);
expect (TokenType.CLOSE_PARENS);
-
+
inner_type_owned = false;
expect (TokenType.OPEN_BRACKET);
} else {
var sym = parse_symbol_name ();
List<DataType> type_arg_list = parse_type_argument_list (false);
-
+
type = new UnresolvedType.from_symbol (sym, get_src (begin));
if (type_arg_list != null) {
foreach (DataType type_arg in type_arg_list) {
}
}
}
-
+
while (accept (TokenType.STAR)) {
type = new PointerType (type, get_src (begin));
}
type.nullable = accept (TokenType.INTERR);
}
}
-
+
// array brackets in types are read from right to left,
// this is more logical, especially when nullable arrays
// or pointers are involved
expect (TokenType.OPEN_PARENS);
expect (TokenType.UNOWNED);
}
-
+
var member = parse_member_name ();
DataType element_type = UnresolvedType.new_from_expression (member);
bool is_pointer_type = false;
element_type.nullable = true;
}
}
-
+
if (inner_array_type) {
expect (TokenType.CLOSE_PARENS);
element_type.value_owned = false;
} else {
element_type.value_owned = true;
}
-
+
expect (TokenType.OPEN_BRACKET);
bool size_specified = false;
if (current () == TokenType.OPEN_PARENS) {
return !is_inner_array_type ();
}
-
+
var begin = get_location ();
// decide between declaration and expression statement
void parse_declaration (Symbol parent, bool root = false) throws ParseError {
comment = scanner.pop_comment ();
var attrs = parse_attributes ();
-
+
var begin = get_location ();
-
+
TokenType last_keyword = current ();
-
+
while (is_declaration_keyword (current ())) {
last_keyword = current ();
next ();
}
-
- switch (current ()) {
+
+ switch (current ()) {
case TokenType.CONSTRUCT:
rollback (begin);
parse_constructor_declaration (parent, attrs);
_inner.parent_node = this;
}
}
-
+
private Expression _inner;
/**
this.source_reference = source_reference;
this.inner = inner;
}
-
+
public override void accept (CodeVisitor visitor) {
inner.accept (visitor);
_inner.parent_node = this;
}
}
-
+
/**
* Specifies whether value should be incremented or decremented.
*/
increment = inc;
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_postfix_expression (this);
}
}
}
-
+
/**
* The get accessor of this property if available.
*/
}
}
}
-
+
/**
* The set/construct accessor of this property if available.
*/
}
}
}
-
+
/**
* Represents the generated `this` parameter in this property.
*/
* disabled.
*/
public bool interface_only { get; set; }
-
+
/**
* Specifies whether this property is abstract. Abstract properties have
* no accessor bodies, may only be specified within abstract classes and
* interfaces, and must be overriden by derived non-abstract classes.
*/
public bool is_abstract { get; set; }
-
+
/**
* Specifies whether this property is virtual. Virtual properties may be
* overridden by derived classes.
*/
public bool is_virtual { get; set; }
-
+
/**
* Specifies whether this property overrides a virtual or abstract
* property of a base type.
return _base_property;
}
}
-
+
/**
* Specifies the abstract interface property this property implements.
*/
public override void accept_children (CodeVisitor visitor) {
property_type.accept (visitor);
-
+
if (get_accessor != null) {
get_accessor.accept (visitor);
}
public bool get_lock_used () {
return lock_used;
}
-
+
public void set_lock_used (bool used) {
lock_used = used;
}
-
+
/**
* Checks whether the accessors of this property are compatible
* with the specified base property.
* Specifies whether this accessor may be used to get the property.
*/
public bool readable { get; private set; }
-
+
/**
* Specifies whether this accessor may be used to set the property.
*/
public bool writable { get; private set; }
-
+
/**
* Specifies whether this accessor may be used to construct the
* property.
public Parameter value_parameter { get; private set; }
private DataType _value_type;
-
+
/**
* Creates a new property accessor.
*
value = r;
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_real_literal (this);
visitor.visit_expression (this);
}
-
+
/**
* Returns the type name of the value this literal represents.
*
if (value.has_suffix ("f") || value.has_suffix ("F")) {
return "float";
}
-
+
return "double";
}
_inner.parent_node = this;
}
}
-
+
private Expression _inner;
/**
this.inner = inner;
this.source_reference = source_reference;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_reference_transfer_expression (this);
visitor.visit_expression (this);
}
-
+
public override void accept_children (CodeVisitor visitor) {
inner.accept (visitor);
}
private delegate int AttyFunc (int fd);
private bool is_atty (int fd) {
- Module module = Module.open (null, ModuleFlags.BIND_LAZY);
+ Module module = Module.open (null, ModuleFlags.BIND_LAZY);
if (module == null) {
return false;
}
public override void accept_children (CodeVisitor visitor) {
if (return_expression != null) {
return_expression.accept (visitor);
-
+
visitor.visit_end_full_expression (return_expression);
}
}
} else {
temp_access.target_type = target_type != null ? target_type.copy () : null;
}
-
+
return temp_access;
}
-
+
public void visit_member_initializer (MemberInitializer init, DataType type) {
init.symbol_reference = symbol_lookup_inherited (type.data_type, init.name);
if (!(init.symbol_reference is Field || init.symbol_reference is Property)) {
base (name, source_reference, comment);
this.return_type = return_type;
}
-
+
/**
* Appends parameter to signal handler.
*
return generated_delegate;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_signal (this);
}
public override void accept_children (CodeVisitor visitor) {
return_type.accept (visitor);
-
+
foreach (Parameter param in parameters) {
param.accept (visitor);
}
public bool get_lock_used () {
return lock_used;
}
-
+
public void set_lock_used (bool used) {
lock_used = used;
}
checked = true;
return_type.check (context);
-
+
foreach (Parameter param in parameters) {
if (param.ellipsis) {
Report.error (param.source_reference, "Signals with variable argument lists are not supported");
type_reference = type;
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_sizeof_expression (this);
* The name of this source file.
*/
public string filename { get; set; }
-
+
public string? relative_filename {
set {
this._relative_filename = value;
return mapped_file.get_contents ();
}
-
+
public size_t get_mapped_length () {
if (content != null) {
return content.length;
this.end = end;
using_directives = file.current_using_directives;
}
-
+
/**
* Returns a string representation of this source reference.
*
* Evaluates the literal string value.
*
* @return the unescaped string
- */
+ */
public string? eval () {
if (value == null) {
return null;
}
-
+
/* remove quotes */
var noquotes = value.substring (1, (uint) (value.length - 2));
/* unescape string */
return noquotes.compress ();
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_string_literal (this);
type_parameters.add (p);
scope.add (p.name, p);
}
-
+
/**
* Returns a copy of the type parameter list.
*
constants.add (c);
scope.add (c.name, c);
}
-
+
/**
* Adds the specified field as a member to this struct.
*
fields.add (f);
scope.add (f.name, f);
}
-
+
/**
* Returns a copy of the list of fields.
*
*/
public override void add_method (Method m) {
return_if_fail (m != null);
-
+
if (m.binding == MemberBinding.INSTANCE || m is CreationMethod) {
m.this_parameter = new Parameter ("this", SemanticAnalyzer.get_data_type_for_symbol (this));
m.scope.add (m.this_parameter.name, m.this_parameter);
methods.add (m);
scope.add (m.name, m);
}
-
+
/**
* Returns a copy of the list of methods.
*
foreach (TypeParameter p in type_parameters) {
p.accept (visitor);
}
-
+
foreach (Field f in fields) {
f.accept (visitor);
}
-
+
foreach (Constant c in constants) {
c.accept (visitor);
}
-
+
foreach (Method m in methods) {
m.accept (visitor);
}
}
return integer_type;
}
-
+
/**
* Returns whether this is a floating point type.
*
public override int get_type_parameter_index (string name) {
int i = 0;
-
+
foreach (TypeParameter p in type_parameters) {
if (p.name == name) {
return (i);
}
i++;
}
-
+
return -1;
}
public SwitchLabel.with_default (SourceReference? source = null) {
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_switch_label (this);
}
-
+
public override void accept_children (CodeVisitor visitor) {
if (expression != null) {
expression.accept (visitor);
-
+
visitor.visit_end_full_expression (expression);
}
}
-
+
public override bool check (CodeContext context) {
if (expression != null) {
var switch_statement = (SwitchStatement) section.parent_node;
public SwitchSection (SourceReference? source_reference) {
base (source_reference);
}
-
+
/**
* Appends the specified label to the list of switch labels.
*
labels.add (label);
label.section = this;
}
-
+
/**
* Returns a copy of the list of switch labels.
*
public List<SwitchLabel> get_labels () {
return labels;
}
-
+
public bool has_default_label () {
foreach (SwitchLabel label in labels) {
if (label.expression == null) {
return true;
}
}
-
+
return false;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_switch_section (this);
}
this.source_reference = source_reference;
this.expression = expression;
}
-
+
/**
* Appends the specified section to the list of switch sections.
*
section.parent_node = this;
sections.add (section);
}
-
+
/**
* Returns a copy of the list of switch sections.
*
expression.accept (visitor);
visitor.visit_end_full_expression (expression);
-
+
foreach (SwitchSection section in sections) {
section.accept (visitor);
}
expression = new_node;
}
}
-
+
public override bool check (CodeContext context) {
if (checked) {
return !error;
public bool hides { get; set; }
/**
- * Check if this symbol is just internal API (and therefore doesn't need
+ * Check if this symbol is just internal API (and therefore doesn't need
* to be listed in header files for instance) by traversing parent symbols
* and checking their accessibility.
*/
if (parent_symbol == null) {
return name;
}
-
+
if (name == null) {
return parent_symbol.get_full_name ();
}
return "%s.%s".printf (parent_symbol.get_full_name (), name);
}
}
-
+
/**
* Converts a string from CamelCase to lower_case.
*
}
}
}
-
+
result_builder.append_unichar (c.tolower ());
-
+
first = false;
i = i.next_char ();
}
-
+
return result_builder.str;
}
} else {
result_builder.append_unichar (c);
}
-
+
i = i.next_char ();
}
CodeContext context;
Symbol root_symbol;
Scope current_scope;
-
+
/**
* Resolve symbol names in the specified code context.
*
root_symbol = null;
this.context = null;
}
-
+
public override void visit_namespace (Namespace ns) {
var old_scope = current_scope;
current_scope = ns.scope;
current_scope = old_scope;
}
-
+
public override void visit_class (Class cl) {
current_scope = cl.scope;
_expression.parent_node = this;
}
}
-
+
/**
* The type to be matched against.
*/
* @param type a data type
* @param source reference to source code
* @return newly created type check expression
- */
+ */
public TypeCheck (Expression expr, DataType type, SourceReference source) {
expression = expr;
type_reference = type;
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_type_check (this);
checked = true;
expression.check (context);
-
+
type_reference.check (context);
if (expression.value_type == null) {
type_reference = type;
source_reference = source;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_typeof_expression (this);
public virtual bool is_subtype_of (TypeSymbol t) {
return (this == t);
}
-
+
/**
* Return the index of the specified type parameter name.
*/
_inner.parent_node = this;
}
}
-
+
private Expression _inner;
/**
result.nullable = nullable;
result.is_dynamic = is_dynamic;
result.unresolved_symbol = unresolved_symbol.copy ();
-
+
foreach (DataType arg in get_type_arguments ()) {
result.add_type_argument (arg.copy ());
}
-
+
return result;
}
"Version", "since", "replacement", "deprecated", "deprecated_since", "experimental", "experimental_until", "",
"Signal", "detailed", "run", "no_recurse", "action", "no_hooks", "",
"Description", "nick", "blurb", "",
-
+
"IntegerType", "rank", "min", "max", "signed", "width", "",
"FloatingType", "rank", "decimal", "width", "",
"BooleanType", "",
"GIR", "fullname", "name", ""
};
-
+
public UsedAttr () {
// mark default valac attrs
var curattr = "";
}
}
}
-
+
/**
* Mark the attribute or attribute argument as used by the compiler
*/
set.add (argument);
}
}
-
+
/**
* Traverse the code tree and warn about unused attributes.
*
}
}
}
-
+
public override void visit_namespace (Namespace ns) {
check_unused_attr (ns);
ns.accept_children (this);
}
-
+
public override void visit_class (Class cl) {
check_unused_attr (cl);
cl.accept_children (this);
this.namespace_symbol = namespace_symbol;
this.source_reference = source_reference;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_using_directive (this);
}
}
}
}
-
+
/**
* The variable type.
*/
_condition.parent_node = this;
}
}
-
+
/**
* Specifies the loop body.
*/
this.source_reference = source_reference;
this.condition = condition;
}
-
+
public override void accept (CodeVisitor visitor) {
visitor.visit_while_statement (this);
}
public override void accept_children (CodeVisitor visitor) {
condition.accept (visitor);
-
+
visitor.visit_end_full_expression (condition);
body.accept (visitor);
public override void visit_comment (Content.Comment c) {
c.accept_children (this);
}
-
+
public override void visit_embedded (Embedded em) {
current_builder.append ("<figure>");
if (em.caption != null) {
hl.accept_children (this);
current_builder.append ("\n");
}
-
+
public override void visit_wiki_link (WikiLink link) {
// wiki pages are not supported right now
if (link.content.size > 0) {
list.accept_children (this);
current_builder.append_printf ("</%s>", tag);
}
-
+
public override void visit_list_item (ListItem item) {
current_builder.append ("<listitem>");
item.accept_children (this);
current_builder.append ("</listitem>");
}
-
+
public override void visit_paragraph (Paragraph para) {
if (!in_brief_comment) {
current_builder.append ("<para>");
public override void visit_page (Page page) {
page.accept_children (this);
}
-
+
public override void visit_run (Run run) {
string? tag = null;
switch (run.style) {
current_builder.append_printf ("</%s>", tag);
}
}
-
+
public override void visit_source_code (SourceCode code) {
current_builder.append ("\n|[\n");
current_builder.append (Markup.escape_text (code.code));
current_builder.append ("\n]|\n");
}
-
+
public override void visit_table (Table t) {
current_builder.append ("<table>");
t.accept_children (this);
current_builder.append ("</table>");
}
-
+
public override void visit_table_row (TableRow row) {
current_builder.append ("<tr>");
row.accept_children (this);
cell.accept_children (this);
current_builder.append ("</td>");
}
-
+
public override void visit_taglet (Taglet t) {
var old_builder = (owned)current_builder;
current_builder = new StringBuilder ();
}
current_builder = (owned)old_builder;
}
-
+
public override void visit_text (Text t) {
current_builder.append (Markup.escape_text (t.content));
t.accept_children (this);
en.accept_all_children (this);
var gcomment = add_symbol (en.get_filename(), en.get_cname(), en.documentation);
-
+
// Handle attributes for things like deprecation.
process_attributes (en, gcomment);
// field not in class/struct/interface
var gcomment = add_symbol (f.get_filename(), f.get_cname(), f.documentation);
f.accept_all_children (this);
-
+
// Handle attributes for things like deprecation.
process_attributes (f, gcomment);
} else {
*/
}
}
-
+
// Handle attributes for things like deprecation.
process_attributes (d, gcomment);
public void close () {
stream = null;
}
-
+
public void write_line (string line) {
stream.puts (line);
stream.putc ('\n');
}
resolve_type_reference (item.property_type);
-
+
item.accept_all_children (this, false);
}
Api.NodeType.TYPE_PARAMETER
};
- Vala.List<Api.Node> nodes = en.get_children_by_types (forbidden, false);
+ Vala.List<Api.Node> nodes = en.get_children_by_types (forbidden, false);
assert (nodes.size == 0);
}
Api.NodeType.TYPE_PARAMETER
};
- Vala.List<Api.Node> nodes = err.get_children_by_types (forbidden, false);
+ Vala.List<Api.Node> nodes = err.get_children_by_types (forbidden, false);
assert (nodes.size == 0);
}
case "field2":
// (.Field check)
- assert (field.get_cname () == "field2");
+ assert (field.get_cname () == "field2");
assert (field.is_static == false);
assert (field.is_volatile == false);
// (.Symbol check)
Api.NodeType.TYPE_PARAMETER
};
- Vala.List<Api.Node> nodes = cl.get_children_by_types (forbidden, false);
+ Vala.List<Api.Node> nodes = cl.get_children_by_types (forbidden, false);
assert (nodes.size == 0);
}
Api.NodeType.TYPE_PARAMETER
};
- Vala.List<Api.Node> nodes = iface.get_children_by_types (forbidden, false);
+ Vala.List<Api.Node> nodes = iface.get_children_by_types (forbidden, false);
assert (nodes.size == 0);
}
case "field2":
// (.Field check)
- assert (field.get_cname () == "field2");
+ assert (field.get_cname () == "field2");
assert (field.is_static == false);
assert (field.is_volatile == false);
// (.Symbol check)
Api.NodeType.TYPE_PARAMETER
};
- Vala.List<Api.Node> nodes = stru.get_children_by_types (forbidden, false);
+ Vala.List<Api.Node> nodes = stru.get_children_by_types (forbidden, false);
assert (nodes.size == 0);
}
Api.NodeType.TYPE_PARAMETER
};
- Vala.List<Api.Node> nodes = m.get_children_by_types (forbidden, false);
+ Vala.List<Api.Node> nodes = m.get_children_by_types (forbidden, false);
assert (nodes.size == 0);
Vala.List<Api.Node> params = m.get_children_by_type (Api.NodeType.FORMAL_PARAMETER, false);
Api.NodeType.TYPE_PARAMETER
};
- Vala.List<Api.Node> nodes = ns.get_children_by_types (forbidden, false);
+ Vala.List<Api.Node> nodes = ns.get_children_by_types (forbidden, false);
assert (nodes.size == 0);
}
Api.NodeType.TYPE_PARAMETER
};
- Vala.List<Api.Node> nodes = m.get_children_by_types (forbidden, false);
+ Vala.List<Api.Node> nodes = m.get_children_by_types (forbidden, false);
assert (nodes.size == 0);
Api.TypeReference? ret = m.return_type;
Api.Field field = fields.get (0) as Api.Field;
assert (field != null);
// (.Field check)
- assert (field.get_cname () == "test_field_global");
+ assert (field.get_cname () == "test_field_global");
assert (field.is_static == false);
assert (field.is_volatile == false);
// (.Symbol check)
Api.Constant constant = constants.get (0) as Api.Constant;
assert (constant != null);
// (.Constant check)
- assert (constant.get_cname () == "test_const_global");
+ assert (constant.get_cname () == "test_const_global");
// (.Symbol check)
assert (constant.is_deprecated == false);
assert (constant.accessibility == Api.SymbolAccessibility.PUBLIC);
assert (token.type == Gtkdoc.TokenType.WORD);
assert (token.content == "myword");
assert (token.attributes == null);
-
+
token = scanner.next ();
assert (token.type == Gtkdoc.TokenType.SPACE);
public static void positive_1 () {
var reporter = new ErrorReporter ();
- string content =
+ string content =
"""<?xml version="1.0" ?>
<root-element>
<subelement level="1" nested="true">my text</subelement>
parent.add_child (node);
process_children (node, element);
- }
+ }
//
projects / thirdparty / vala.git / commitdiff
