ccode.add_return (new CCodeIdentifier ("obj"));
} else if (is_in_destructor ()) {
// do not call return as member cleanup and chain up to base finalizer
- // stil need to be executed
+ // still need to be executed
ccode.add_goto ("_return");
} else if (is_in_coroutine ()) {
} else if (current_method is CreationMethod) {
public abstract void remove ();
/**
- * Determines wheather the call to {@link get} is legal. It is false at the
+ * Determines whether the call to {@link get} is legal. It is false at the
* beginning and after {@link remove} call and true otherwise.
*/
public abstract bool valid { get; }
}
}
- // search relative to the current directory / absoulte path
+ // search relative to the current directory / absolute path
if (!FileUtils.test (url, FileTest.EXISTS | FileTest.IS_REGULAR)) {
string base_name = Path.get_basename (url);
}
}
- // search relative to the current directory / absoulte path
+ // search relative to the current directory / absolute path
if (!FileUtils.test (path, FileTest.EXISTS | FileTest.IS_REGULAR)) {
string node_segment = (container is Api.Package)? "" : container.get_full_name () + ": ";
code = "File '%s' does not exist".printf (path);
}
public override void visit_paragraph (Paragraph element) {
- //FIXME: the extra-field is just a workarround for the current codegen ...
+ //FIXME: the extra-field is just a workaround for the current codegen ...
switch (element.horizontal_align) {
case HorizontalAlign.CENTER:
writer.start_tag ("p", {"style", "text-align: center;"});
}
/**
- * Writes text to a desination like a {@link GLib.StringBuilder} or a {@link GLib.FileStream}
+ * Writes text to a destination like a {@link GLib.StringBuilder} or a {@link GLib.FileStream}
*/
public delegate void WriteFunc (string text);
public void accept_token (Token token) throws ParserError {
#if HARD_DEBUG
- debug ("Incomming token: %s", token.to_pretty_string ());
+ debug ("Incoming token: %s", token.to_pretty_string ());
#endif
_current_token = token;
#if DEBUG
private void log_error (string message) {
- stderr.printf ("An error occured while parsing: %s\n", message);
+ stderr.printf ("An error occurred while parsing: %s\n", message);
stderr.printf ("\nDumping rule stack:\n");
for (int i = 0; i < rule_stack.size; i++) {
stderr.printf ("\t%2d: %s\n", i, rule_stack[i].to_string (rule_state_stack[i]));
} else {
if (initlist == null) {
error = true;
- /* this is an internal error because it is already handeld by the parser */
+ /* this is an internal error because it is already handled by the parser */
Report.error (source_reference, "internal error: initializer list expected");
} else {
foreach (Expression size in calc_sizes) {
/* relational operation */
if (context.profile == Profile.GOBJECT) {
- // Implicit cast for comparsion expression of GValue with other type
+ // Implicit cast for comparison expression of GValue with other type
var gvalue_type = context.analyzer.gvalue_type.type_symbol;
if ((left.target_type.type_symbol == gvalue_type && right.target_type.type_symbol != gvalue_type)
|| (left.target_type.type_symbol != gvalue_type && right.target_type.type_symbol == gvalue_type)) {
Report.error (source_reference, "SingleInstance class `%s' requires inheritance from `GLib.Object'".printf (get_full_name ()));
}
- /* singleton classes require an instance construtor */
+ /* singleton classes require an instance constructor */
if (is_singleton && constructor == null) {
var c = new Constructor (source_reference);
c.body = new Block (source_reference);
/**
* Visit operation called for catch clauses.
*
- * @param clause a catch cluase
+ * @param clause a catch clause
*/
public virtual void visit_catch_clause (CatchClause clause) {
}
}
/**
- * Visit operations called for expresions.
+ * Visit operations called for expressions.
*
* @param expr an expression
*/
}
/**
- * Visit operations called for array creation expresions.
+ * Visit operations called for array creation expressions.
*
* @param expr an array creation expression
*/
/**
* Allows overriding of a specific cheader in the output
- * @param original orignal cheader to override
+ * @param original original cheader to override
* @param replacement cheader to replace original with
*/
public void set_cheader_override (string original, string replacement)
return true;
}
- // Allow compatiblity of struct subtypes in both ways
+ // Allow compatibility of struct subtypes in both ways
if (expect_struct.is_subtype_of (expr_struct)) {
return true;
}
}
/**
- * Appends paramater to this callback function.
+ * Appends parameter to this callback function.
*
* @param param a formal parameter
*/
return true;
}
- /* otherwhise the error_domain has to be equal */
+ /* otherwise the error_domain has to be equal */
if (et.error_domain != error_domain) {
return false;
}
}
- /* ignore comments and whitspace and other lines that contain no code */
+ /* ignore comments and whitespace and other lines that contain no code */
space ();
alias.merged = true;
}
- // inherit atributes, like type_id
+ // inherit attributes, like type_id
if (type_sym is Class || (type_sym is Struct && !simple_type)) {
if (type_sym.has_attribute_argument ("CCode", "has_type_id")) {
alias.symbol.set_attribute_bool ("CCode", "has_type_id", type_sym.get_attribute_bool ("CCode", "has_type_id"));
}
/**
- * Returns the initalizer expression list
+ * Returns the initializer expression list
*
* @return expression list
*/
*/
public interface Vala.Lockable {
/**
- * Indicates a specific lockable object beeing actually locked somewhere.
+ * Indicates a specific lockable object being actually locked somewhere.
*/
public abstract bool lock_used { get; set; }
}
/**
* 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.
+ * overridden by derived non-abstract classes.
*/
public bool is_abstract { 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.
+ * interfaces, and must be overridden by derived non-abstract classes.
*/
public bool is_abstract { get; set; }
if (writable || construction) {
value_parameter = new Parameter ("value", value_type, source_reference);
- // Inherit important atttributes
+ // Inherit important attributes
value_parameter.copy_attribute_bool (prop, "CCode", "array_length");
value_parameter.copy_attribute_bool (prop, "CCode", "array_null_terminated");
value_parameter.copy_attribute_bool (prop, "CCode", "delegate_target");
public bool used { get; set; }
/**
- * Specifies whether this symbol is anonymous and has no public defintion.
+ * Specifies whether this symbol is anonymous and has no public definition.
*/
public bool anonymous { get; set; }
}
private bool add_package (Vala.CodeContext context, string pkg) {
- // ignore multiple occurences of the same package
+ // ignore multiple occurrences of the same package
if (context.has_package (pkg)) {
return true;
}
case IdlNodeTypeId.VALUE:
case IdlNodeTypeId.VFUNC:
- // Not appliable?
+ // Not applicable?
break;
default:
projects / thirdparty / vala.git / commitdiff
