+2007-07-27 Jürg Billeter <j@bitron.ch>
+
+ * Makefile.am, README, configure.ac, gee/Makefile.am,
+ gee/arraylist.vala, gee/collection.vala, gee/hashmap.vala,
+ gee/hashset.vala, gee/iterable.vala, gee/iterator.vala, gee/list.vala,
+ gee/map.vala, gee/readonlycollection.vala, gee/readonlylist.vala,
+ gee/readonlymap.vala, gee/readonlyset.vala, gee/set.vala,
+ vala/Makefile.am, vala/parser.y, vala/valaarray.vala,
+ vala/valaarraycreationexpression.vala, vala/valaattribute.vala,
+ vala/valablock.vala, vala/valacallback.vala, vala/valaclass.vala,
+ vala/valacodecontext.vala, vala/valacodenode.vala,
+ vala/valadatatype.vala, vala/valaelementaccess.vala,
+ vala/valaenum.vala, vala/valaexpression.vala, vala/valafield.vala,
+ vala/valaformalparameter.vala, vala/valaforstatement.vala,
+ vala/valainitializerlist.vala, vala/valainstancecast.vala,
+ vala/valainterface.vala, vala/valainterfacewriter.vala,
+ vala/valainvocationexpression.vala, vala/valainvokable.vala,
+ vala/valalambdaexpression.vala,
+ vala/valalocalvariabledeclaration.vala, vala/valamember.vala,
+ vala/valamemberaccess.vala, vala/valamemorymanager.vala,
+ vala/valamethod.vala, vala/valanamespace.vala,
+ vala/valaobjectcreationexpression.vala, vala/valapointer.vala,
+ vala/valascope.vala, vala/valasemanticanalyzer.vala,
+ vala/valasignal.vala, vala/valasourcefile.vala,
+ vala/valasourcefilecycle.vala, vala/valastruct.vala,
+ vala/valaswitchsection.vala, vala/valaswitchstatement.vala,
+ vala/valasymbol.vala, vala/valasymbolresolver.vala,
+ vala/valatrystatement.vala, vala/valatypeparameter.vala,
+ vala/valatypereference.vala, vala/valavariabledeclarator.vala,
+ ccode/Makefile.am, ccode/valaccodeblock.vala,
+ ccode/valaccodecasestatement.vala,
+ ccode/valaccodecommaexpression.vala, ccode/valaccodedeclaration.vala,
+ ccode/valaccodeenum.vala, ccode/valaccodeforstatement.vala,
+ ccode/valaccodefragment.vala, ccode/valaccodefunction.vala,
+ ccode/valaccodefunctioncall.vala,
+ ccode/valaccodefunctiondeclarator.vala,
+ ccode/valaccodeinitializerlist.vala, ccode/valaccodestruct.vala,
+ ccode/valaccodeswitchstatement.vala, gobject/Makefile.am,
+ gobject/valaclassregisterfunction.vala,
+ gobject/valacodegenerator.vala,
+ gobject/valacodegeneratorassignment.vala,
+ gobject/valacodegeneratorclass.vala,
+ gobject/valacodegeneratorinterface.vala,
+ gobject/valacodegeneratorinvocationexpression.vala,
+ gobject/valacodegeneratormemberaccess.vala,
+ gobject/valacodegeneratormethod.vala,
+ gobject/valacodegeneratorsignal.vala,
+ gobject/valacodegeneratorsourcefile.vala,
+ gobject/valainterfaceregisterfunction.vala, compiler/Makefile.am,
+ vapi/gio-standalone.vala, vapi/gstreamer-0.10.vala,
+ vapi/gtk+-2.0.vala, vapigen/Makefile.am, vapigen/valagidlparser.vala:
+ add internal copy of libgee and use Gee.ArrayList, Gee.HashMap, and
+ Gee.HashSet instead of GLib.List and GLib.HashTable
+
2007-07-27 Jürg Billeter <j@bitron.ch>
* vala/Makefile.am, vala/valaarray.vala, vala/valaarraymovemethod.vala,
endif
SUBDIRS = \
+ gee \
ccode \
vala \
gobject \
$(NULL)
DIST_SUBDIRS = \
+ gee \
ccode \
vala \
gobject \
More information about Vala is available at
- http://www.paldo.org/vala/
+ http://live.gnome.org/Vala/
$(NULL)
ccode.vala ccode.vala.stamp: $(filter %.vala,$(libvalaccode_la_SOURCES))
- $(VALAC) --vapidir $(srcdir)/../vapi --library ccode $^
+ $(VALAC) --vapidir $(srcdir)/../vapi --vapidir ../gee --pkg gee --library ccode $^
touch $@
libvalaccode_la_LIBADD = \
*/
using GLib;
+using Gee;
/**
* Represents a C code block.
*/
public bool suppress_newline { get; set; }
- List<CCodeNode> statements;
+ private Gee.List<CCodeNode> statements = new ArrayList<CCodeNode> ();
/**
* Prepend the specified statement to the list of statements.
*/
public void prepend_statement (CCodeNode! statement) {
- statements.prepend (statement);
+ statements.insert (0, statement);
}
/**
*/
public void add_statement (CCodeNode! statement) {
/* allow generic nodes to include comments */
- statements.append (statement);
+ statements.add (statement);
}
public override void write (CCodeWriter! writer) {
*/
using GLib;
+using Gee;
/**
* Represents a case block in a switch statement in C code.
/**
* The case expression.
*/
- public CCodeExpression! expression { get; set construct; }
+ public CCodeExpression! expression { get; set; }
- private List<CCodeStatement> statements;
+ private Gee.List<CCodeStatement> statements = new ArrayList<CCodeStatement> ();
- public CCodeCaseStatement (CCodeExpression! expr) {
- expression = expr;
+ public CCodeCaseStatement (construct CCodeExpression! expression) {
}
/**
* @param stmt a statement
*/
public void add_statement (CCodeStatement! stmt) {
- statements.append (stmt);
+ statements.add (stmt);
}
public override void write (CCodeWriter! writer) {
/* valaccodecommaexpression.vala
*
- * Copyright (C) 2006 Jürg Billeter
+ * Copyright (C) 2006-2007 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
*/
using GLib;
+using Gee;
/**
* Represents a comma separated expression list in the C code.
*/
public class Vala.CCodeCommaExpression : CCodeExpression {
- private List<CCodeExpression> inner;
+ private Gee.List<CCodeExpression> inner = new ArrayList<CCodeExpression> ();
/**
* Appends the specified expression to the expression list.
* @param expr a C code expression
*/
public void append_expression (CCodeExpression! expr) {
- inner.append (expr);
+ inner.add (expr);
}
public override void write (CCodeWriter! writer) {
*/
using GLib;
+using Gee;
/**
* Represents a local variable declaration in the C code.
/**
* The type of the local variable.
*/
- public string! type_name { get; set construct; }
+ public string! type_name { get; set; }
/**
* The declaration modifier.
*/
public CCodeModifiers modifiers { get; set; }
- private List<CCodeDeclarator> declarators;
+ private Gee.List<CCodeDeclarator> declarators = new ArrayList<CCodeDeclarator> ();
- public CCodeDeclaration (string! _type_name) {
- type_name = _type_name;
+ public CCodeDeclaration (construct string! type_name) {
}
/**
* @param decl a declarator
*/
public void add_declarator (CCodeDeclarator! decl) {
- declarators.append (decl);
+ declarators.add (decl);
}
public override void write (CCodeWriter! writer) {
*/
using GLib;
+using Gee;
/**
* Represents an enum in the C code.
*/
public string name { get; set; }
- private List<string> values;
+ private Gee.List<string> values = new ArrayList<string> ();
- public CCodeEnum (string n = null) {
- name = n;
+ public CCodeEnum (construct string name = null) {
}
/**
*/
public void add_value (string! name, string value = null) {
if (value == null) {
- values.append (name);
+ values.add (name);
} else {
- values.append ("%s = %s".printf (name, value));
+ values.add ("%s = %s".printf (name, value));
}
}
/* valaccodeforstatement.vala
*
- * Copyright (C) 2006 Jürg Billeter
+ * Copyright (C) 2006-2007 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
*/
using GLib;
+using Gee;
/**
* Represents a for iteration statement in the C code.
/**
* The loop condition.
*/
- public CCodeExpression! condition { get; set construct; }
+ public CCodeExpression! condition { get; set; }
/**
* The loop body.
*/
public CCodeStatement body { get; set; }
- private List<CCodeExpression> initializer;
- private List<CCodeExpression> iterator;
+ private Gee.List<CCodeExpression> initializer = new ArrayList<CCodeExpression> ();
+ private Gee.List<CCodeExpression> iterator = new ArrayList<CCodeExpression> ();
- public CCodeForStatement (CCodeExpression! cond, CCodeStatement stmt = null) {
- condition = cond;
- body = stmt;
+ public CCodeForStatement (construct CCodeExpression! condition, construct CCodeStatement body = null) {
}
/**
* @param expr an initializer expression
*/
public void add_initializer (CCodeExpression! expr) {
- initializer.append (expr);
+ initializer.add (expr);
}
/**
* @param expr an iterator expression
*/
public void add_iterator (CCodeExpression! expr) {
- iterator.append (expr);
+ iterator.add (expr);
}
public override void write (CCodeWriter! writer) {
*/
using GLib;
+using Gee;
/**
* Represents a container for C code nodes.
*/
public class Vala.CCodeFragment : CCodeNode {
- private List<CCodeNode> children;
+ private Gee.List<CCodeNode> children = new ArrayList<CCodeNode> ();
/**
* Appends the specified code node to this code fragment.
* @param node a C code node
*/
public void append (CCodeNode! node) {
- children.append (node);
+ children.add (node);
}
/**
*
* @return children list
*/
- public List<weak CCodeNode> get_children () {
- return children.copy ();
+ public Collection<CCodeNode> get_children () {
+ return new ReadOnlyCollection<CCodeNode> (children);
}
public override void write (CCodeWriter! writer) {
*/
using GLib;
+using Gee;
/**
* Represents a function declaration in the C code.
/**
* The name of this function.
*/
- public string! name { get; set construct; }
+ public string! name { get; set; }
/**
* The function modifiers.
/**
* The function return type.
*/
- public string! return_type { get; set construct; }
+ public string! return_type { get; set; }
/**
* The function body.
*/
public CCodeBlock block { get; set; }
- private List<CCodeFormalParameter> parameters;
+ private Gee.List<CCodeFormalParameter> parameters = new ArrayList<CCodeFormalParameter> ();
- public CCodeFunction (string! _name, string! _return_type) {
- name = _name;
- return_type = _return_type;
+ public CCodeFunction (construct string! name, construct string! return_type) {
}
/**
* @param param a formal parameter
*/
public void add_parameter (CCodeFormalParameter! param) {
- parameters.append (param);
+ parameters.add (param);
}
/**
* func.parameters = parameters.copy ();
*/
foreach (CCodeFormalParameter param in parameters) {
- func.parameters.append (param);
+ func.parameters.add (param);
}
func.block = block;
*/
using GLib;
+using Gee;
/**
* Represents a function call in the C code.
*/
public CCodeExpression call { get; set; }
- private List<CCodeExpression> arguments;
+ private Gee.List<CCodeExpression> arguments = new ArrayList<CCodeExpression> ();
public CCodeFunctionCall (construct CCodeExpression call = null) {
}
* @param expr a C code expression
*/
public void add_argument (CCodeExpression! expr) {
- arguments.append (expr);
+ arguments.add (expr);
}
/**
*
* @return list of arguments
*/
- public List<weak CCodeExpression> get_arguments () {
- return arguments.copy ();
+ public Gee.List<CCodeExpression> get_arguments () {
+ return new ReadOnlyList<CCodeExpression> (arguments);
}
public override void write (CCodeWriter! writer) {
*/
using GLib;
+using Gee;
/**
* Represents a function pointer declarator in the C code.
/**
* The declarator name.
*/
- public string! name { get; set construct; }
+ public string! name { get; set; }
- private List<CCodeFormalParameter> parameters;
+ private Gee.List<CCodeFormalParameter> parameters = new ArrayList<CCodeFormalParameter> ();
- public CCodeFunctionDeclarator (string! n) {
- name = n;
+ public CCodeFunctionDeclarator (construct string! name) {
}
/**
* @param param a formal parameter
*/
public void add_parameter (CCodeFormalParameter! param) {
- parameters.append (param);
+ parameters.add (param);
}
public override void write (CCodeWriter! writer) {
/* valaccodeinitializerlist.vala
*
- * Copyright (C) 2006 Jürg Billeter
+ * Copyright (C) 2006-2007 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
*/
using GLib;
+using Gee;
/**
* Represents a struct or array initializer list in the C code.
*/
public class Vala.CCodeInitializerList : CCodeExpression {
- private List<CCodeExpression> initializers;
+ private Gee.List<CCodeExpression> initializers = new ArrayList<CCodeExpression> ();
/**
* Appends the specified expression to this initializer list.
* @param expr an expression
*/
public void append (CCodeExpression! expr) {
- initializers.append (expr);
+ initializers.add (expr);
}
public override void write (CCodeWriter! writer) {
*/
using GLib;
+using Gee;
/**
* Represents a struct declaration in the C code.
/**
* The struct name.
*/
- public string! name { get; set construct; }
+ public string! name { get; set; }
- private List<CCodeDeclaration> declarations;
+ private Gee.List<CCodeDeclaration> declarations = new ArrayList<CCodeDeclaration> ();
- public CCodeStruct (string! n) {
- name = n;
+ public CCodeStruct (construct string! name) {
}
/**
* @param decl a variable declaration
*/
public void add_declaration (CCodeDeclaration! decl) {
- declarations.append (decl);
+ declarations.add (decl);
}
/**
/* valaccodeswitchstatement.vala
*
- * Copyright (C) 2006 Jürg Billeter
+ * Copyright (C) 2006-2007 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
*/
using GLib;
+using Gee;
/**
* Represents a switch selection statement in the C code.
/**
* The switch expression.
*/
- public CCodeExpression! expression { get; set construct; }
+ public CCodeExpression! expression { get; set; }
- private List<CCodeCaseStatement> case_statements;
+ private Gee.List<CCodeCaseStatement> case_statements = new ArrayList<CCodeCaseStatement> ();
- public CCodeSwitchStatement (CCodeExpression! expr) {
- expression = expr;
+ public CCodeSwitchStatement (construct CCodeExpression! expression) {
}
/**
* @param case_stmt a case statement
*/
public void add_case (CCodeCaseStatement! case_stmt) {
- case_statements.append (case_stmt);
+ case_statements.add (case_stmt);
}
public override void write (CCodeWriter! writer) {
$(NULL)
valac.vala.stamp: $(filter %.vala,$(valac_SOURCES))
- $(VALAC) --vapidir $(srcdir)/../vapi --vapidir ../ccode --pkg ccode --vapidir ../vala --pkg vala --vapidir ../gobject --pkg gobject --pkg config $^
+ $(VALAC) --vapidir $(srcdir)/../vapi --vapidir ../gee --pkg gee --vapidir ../ccode --pkg ccode --vapidir ../vala --pkg vala --vapidir ../gobject --pkg gobject --pkg config $^
touch $@
valac_CPPFLAGS = \
AC_CONFIG_FILES([Makefile
vala-1.0.pc
+ gee/Makefile
ccode/Makefile
vala/Makefile
gobject/Makefile
--- /dev/null
+NULL =
+
+INCLUDES = \
+ $(GLIB_CFLAGS) \
+ $(NULL)
+
+BUILT_SOURCES = gee.vala.stamp
+
+noinst_LTLIBRARIES = \
+ libgee.la
+ $(NULL)
+
+libgee_la_SOURCES = \
+ gee.vala.stamp \
+ arraylist.c \
+ arraylist.h \
+ arraylist.vala \
+ collection.c \
+ collection.h \
+ collection.vala \
+ hashmap.c \
+ hashmap.h \
+ hashmap.vala \
+ hashset.c \
+ hashset.h \
+ hashset.vala \
+ iterable.c \
+ iterable.h \
+ iterable.vala \
+ iterator.c \
+ iterator.h \
+ iterator.vala \
+ list.c \
+ list.h \
+ list.vala \
+ map.c \
+ map.h \
+ map.vala \
+ readonlycollection.c \
+ readonlycollection.h \
+ readonlycollection.vala \
+ readonlylist.c \
+ readonlylist.h \
+ readonlylist.vala \
+ readonlymap.c \
+ readonlymap.h \
+ readonlymap.vala \
+ readonlyset.c \
+ readonlyset.h \
+ readonlyset.vala \
+ set.c \
+ set.h \
+ set.vala \
+ $(NULL)
+
+geeincludedir = $(includedir)/vala-1.0/gee
+
+geeinclude_HEADERS = \
+ arraylist.h \
+ collection.h \
+ hashmap.h \
+ hashset.h \
+ iterable.h \
+ iterator.h \
+ list.h \
+ map.h \
+ readonlycollection.h \
+ readonlylist.h \
+ readonlymap.h \
+ readonlyset.h \
+ set.h \
+ $(NULL)
+
+gee.vala gee.vala.stamp: $(filter %.vala,$(libgee_la_SOURCES))
+ $(VALAC) --vapidir $(srcdir)/../vapi --library gee $^
+ touch $@
+
+libgee_la_LIBADD = \
+ $(GLIB_LIBS) \
+ $(NULL)
+
+EXTRA_DIST = gee.vala gee.vala.stamp
--- /dev/null
+/* arraylist.vala
+ *
+ * Copyright (C) 2004-2005 Novell, Inc
+ * Copyright (C) 2005 David Waite
+ * Copyright (C) 2007 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j@bitron.ch>
+ */
+
+using GLib;
+
+/**
+ * Arrays of arbitrary elements which grow automatically as elements are added.
+ */
+public class Gee.ArrayList<G> : Iterable<G>, Collection<G>, List<G> {
+ public int size {
+ get { return _size; }
+ }
+
+ public EqualFunc equal_func {
+ set { _equal_func = value; }
+ }
+
+ private G[] _items = new G[4];
+ private int _size;
+ private EqualFunc _equal_func;
+
+ // concurrent modification protection
+ private int _stamp = 0;
+
+ public ArrayList (construct EqualFunc equal_func = GLib.direct_equal) {
+ }
+
+ public Gee.Iterator<G> iterator () {
+ return new Iterator<G> (this);
+ }
+
+ public bool contains (G item) {
+ return (index_of (item) != -1);
+ }
+
+ public int index_of (G item) {
+ for (int index = 0; index < _size; index++) {
+ if (_equal_func (_items[index], item)) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ public G get (int index) {
+ assert (index >= 0 && index < _size);
+
+ return _items[index];
+ }
+
+ public void set (int index, G item) {
+ assert (index >= 0 && index < _size);
+
+ _items[index] = item;
+ }
+
+ public bool add (G item) {
+ if (_size == _items.length) {
+ grow_if_needed (1);
+ }
+ _items[_size++] = item;
+ _stamp++;
+ return true;
+ }
+
+ public void insert (int index, G item) {
+ assert (index >= 0 && index <= _size);
+
+ if (_size == _items.length) {
+ grow_if_needed (1);
+ }
+ shift (index, 1);
+ _items[index] = item;
+ _stamp++;
+ }
+
+ public bool remove (G item) {
+ for (int index = 0; index < _size; index++) {
+ if (_equal_func (_items[index], item)) {
+ remove_at (index);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public void remove_at (int index) {
+ assert (index >= 0 && index < _size);
+
+ _items[index] = null;
+
+ shift (index + 1, -1);
+
+ _stamp++;
+ }
+
+ public void clear () {
+ for (int index = 0; index < _size; index++) {
+ _items[index] = null;
+ }
+ _size = 0;
+ _stamp++;
+ }
+
+ private void shift (int start, int delta) {
+ assert (start >= 0 && start <= _size && start >= -delta);
+
+ _items.move (start, start + delta, _size - start);
+
+ _size += delta;
+ }
+
+ private void grow_if_needed (int new_count) {
+ assert (new_count >= 0);
+
+ int minimum_size = _size + new_count;
+ if (minimum_size > _items.length) {
+ // double the capacity unless we add even more items at this time
+ set_capacity (new_count > _items.length ? minimum_size : 2 * _items.length);
+ }
+ }
+
+ private void set_capacity (int value) {
+ assert (value >= _size);
+
+ _items.resize (value);
+ }
+
+ private class Iterator<G> : Gee.Iterator<G> {
+ public ArrayList<G> list {
+ set {
+ _list = value;
+ _stamp = _list._stamp;
+ }
+ }
+
+ private ArrayList<G> _list;
+ private int _index = -1;
+
+ // concurrent modification protection
+ public int _stamp = 0;
+
+ public Iterator (construct ArrayList! list) {
+ }
+
+ public bool next () {
+ assert (_stamp == _list._stamp);
+ if (_index < _list._size) {
+ _index++;
+ }
+ return (_index < _list._size);
+ }
+
+ public G get () {
+ assert (_stamp == _list._stamp);
+
+ if (_index < 0 || _index >= _list._size) {
+ return null;
+ }
+
+ return _list.get (_index);
+ }
+ }
+}
+
--- /dev/null
+/* collection.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j@bitron.ch>
+ */
+
+/**
+ * Serves as the base interface for implementing collection classes. Defines
+ * size, iteration, and modification methods.
+ */
+public interface Gee.Collection<G> : Iterable<G> {
+ /**
+ * The number of items in this collection.
+ */
+ public abstract int size { get; }
+
+ /**
+ * Determines whether this collection contains the specified item.
+ *
+ * @param item the item to locate in the collection
+ *
+ * @return true if item is found, false otherwise
+ */
+ public abstract bool contains (G item);
+
+ /**
+ * Adds an item to this collection. Must not be called on read-only
+ * collections.
+ *
+ * @param item the item to add to the collection
+ *
+ * @return true if the collection has been changed, false otherwise
+ */
+ public abstract bool add (G item);
+
+ /**
+ * Removes the first occurence of an item from this collection. Must not
+ * be called on read-only collections.
+ *
+ * @param item the item to remove from the collection
+ *
+ * @return true if the collection has been changed, false otherwise
+ */
+ public abstract bool remove (G item);
+
+ /**
+ * Removes all items from this collection. Must not be called on
+ * read-only collections.
+ */
+ public abstract void clear ();
+}
+
--- /dev/null
+/* hashmap.vala
+ *
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ * Copyright (C) 1997-2000 GLib Team and others
+ * Copyright (C) 2007 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j@bitron.ch>
+ */
+
+using GLib;
+
+/**
+ * Hashtable implementation of the Map interface.
+ */
+public class Gee.HashMap<K,V> : Map<K,V> {
+ public int size {
+ get { return _nnodes; }
+ }
+
+ public HashFunc key_hash_func {
+ set { _key_hash_func = value; }
+ }
+
+ public EqualFunc key_equal_func {
+ set { _key_equal_func = value; }
+ }
+
+ public EqualFunc value_equal_func {
+ set { _value_equal_func = value; }
+ }
+
+ private int _array_size;
+ private int _nnodes;
+ private Node<K,V>[] _nodes;
+
+ // concurrent modification protection
+ private int _stamp = 0;
+
+ private HashFunc _key_hash_func;
+ private EqualFunc _key_equal_func;
+ private EqualFunc _value_equal_func;
+
+ private const int MIN_SIZE = 11;
+ private const int MAX_SIZE = 13845163;
+
+ public HashMap (construct HashFunc key_hash_func = GLib.direct_hash, construct EqualFunc key_equal_func = GLib.direct_equal, construct EqualFunc value_equal_func = GLib.direct_equal) {
+ }
+
+ construct {
+ _array_size = MIN_SIZE;
+ _nodes = new Node<K,V>[_array_size];
+ }
+
+ public Set<K> get_keys () {
+ return new KeySet<K,V> (this);
+ }
+
+ public Collection<V> get_values () {
+ return new ValueCollection<K,V> (this);
+ }
+
+ private Node<K,V>* lookup_node (K key) {
+ uint hash_value = _key_hash_func (key);
+ Node<K,V>* node = &_nodes[hash_value % _array_size];
+ while ((*node) != null && (hash_value != (*node).key_hash || !_key_equal_func ((*node).key, key))) {
+ node = &((*node).next);
+ }
+ return node;
+ }
+
+ public bool contains (K key) {
+ Node<K,V>* node = lookup_node (key);
+ return (*node != null);
+ }
+
+ public V get (K key) {
+ weak Node<K,V> node = *lookup_node (key);
+ if (node != null) {
+ return node.value;
+ } else {
+ return null;
+ }
+ }
+
+ public void set (K key, V value) {
+ Node<K,V>* node = lookup_node (key);
+ if (*node != null) {
+ (*node).value = value;
+ } else {
+ uint hash_value = _key_hash_func (key);
+ *node = new Node<K,V> (key, value, hash_value);
+ _nnodes++;
+ resize ();
+ }
+ _stamp++;
+ }
+
+ public bool remove (K key) {
+ Node<K,V>* node = lookup_node (key);
+ if (*node != null) {
+ (*node).key = null;
+ (*node).value = null;
+ *node = (*node).next;
+ _nnodes--;
+ resize ();
+ _stamp++;
+ return true;
+ }
+ return false;
+ }
+
+ public void clear () {
+ for (int i = 0; i < _array_size; i++) {
+ Node<K,V> node = #_nodes[i];
+ while (node != null) {
+ Node next = #node.next;
+ node.key = null;
+ node.value = null;
+ node = #next;
+ }
+ }
+ _nnodes = 0;
+ resize ();
+ }
+
+ private void resize () {
+ if ((_array_size >= 3 * _nnodes && _array_size >= MIN_SIZE) ||
+ (3 * _array_size <= _nnodes && _array_size < MAX_SIZE)) {
+ int new_array_size = SpacedPrimes.closest (_nnodes);
+ new_array_size = new_array_size.clamp (MIN_SIZE, MAX_SIZE);
+
+ Node<K,V>[] new_nodes = new Node<K,V>[new_array_size];
+
+ for (int i = 0; i < _array_size; i++) {
+ Node<K,V> node;
+ Node<K,V> next;
+ for (node = #_nodes[i]; node != null; node = #next) {
+ next = #node.next;
+ uint hash_val = node.key_hash % new_array_size;
+ node.next = #new_nodes[hash_val];
+ new_nodes[hash_val] = #node;
+ }
+ }
+ _nodes = #new_nodes;
+ _array_size = new_array_size;
+ }
+ }
+
+ ~HashSet () {
+ clear ();
+ }
+
+ [ReferenceType]
+ private struct Node<K,V> {
+ public K key;
+ public V value;
+ public Node<K,V> next;
+ public uint key_hash;
+
+ public Node (K# k, V# v, uint hash) {
+ key = #k;
+ value = #v;
+ key_hash = hash;
+ }
+ }
+
+ private class KeySet<K,V> : Iterable<K>, Collection<K>, Set<K> {
+ public HashMap<K,V> map {
+ set { _map = value; }
+ }
+
+ private HashMap<K,V> _map;
+
+ public KeySet (construct HashMap! map) {
+ }
+
+ public Iterator<K> iterator () {
+ return new KeyIterator<K,V> (_map);
+ }
+
+ public int size {
+ get { return _map.size; }
+ }
+
+ public bool add (K key) {
+ assert_not_reached ();
+ return false;
+ }
+
+ public void clear () {
+ assert_not_reached ();
+ }
+
+ public bool remove (K key) {
+ assert_not_reached ();
+ return false;
+ }
+
+ public bool contains (K key) {
+ return _map.contains (key);
+ }
+ }
+
+ private class KeyIterator<K,V> : Iterator<K> {
+ public HashMap<K,V> map {
+ set {
+ _map = value;
+ _stamp = _map._stamp;
+ }
+ }
+
+ private HashMap<K,V> _map;
+ private int _index = -1;
+ private weak Node<K,V> _node;
+
+ // concurrent modification protection
+ private int _stamp;
+
+ public KeyIterator (construct HashMap! map) {
+ }
+
+ public bool next () {
+ if (_node != null) {
+ _node = _node.next;
+ }
+ while (_node == null && _index + 1 < _map._array_size) {
+ _index++;
+ _node = _map._nodes[_index];
+ }
+ return (_node != null);
+ }
+
+ public K get () {
+ assert (_stamp == _map._stamp);
+ assert (_node != null);
+ return _node.key;
+ }
+ }
+
+ private class ValueCollection<K,V> : Iterable<V>, Collection<V> {
+ public HashMap<K,V> map {
+ set { _map = value; }
+ }
+
+ private HashMap<K,V> _map;
+
+ public ValueCollection (construct HashMap! map) {
+ }
+
+ public Iterator<V> iterator () {
+ return new ValueIterator<K,V> (_map);
+ }
+
+ public int size {
+ get { return _map.size; }
+ }
+
+ public bool add (V value) {
+ assert_not_reached ();
+ }
+
+ public void clear () {
+ assert_not_reached ();
+ }
+
+ public bool remove (V value) {
+ assert_not_reached ();
+ }
+
+ public bool contains (V value) {
+ Iterator<V> it = iterator ();
+ while (it.next ()) {
+ if (_map._value_equal_func (it.get (), value)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+
+ private class ValueIterator<K,V> : Iterator<V> {
+ public HashMap<K,V> map {
+ set {
+ _map = value;
+ _stamp = _map._stamp;
+ }
+ }
+
+ private HashMap<V,K> _map;
+ private int _index = -1;
+ private weak Node<K,V> _node;
+
+ // concurrent modification protection
+ private int _stamp;
+
+ public ValueIterator (construct HashMap! map) {
+ }
+
+ public bool next () {
+ if (_node != null) {
+ _node = _node.next;
+ }
+ while (_node == null && _index + 1 < _map._array_size) {
+ _index++;
+ _node = _map._nodes[_index];
+ }
+ return (_node != null);
+ }
+
+ public V get () {
+ assert (_stamp == _map._stamp);
+ assert (_node != null);
+ return _node.value;
+ }
+ }
+}
+
--- /dev/null
+/* hashset.vala
+ *
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ * Copyright (C) 1997-2000 GLib Team and others
+ * Copyright (C) 2007 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j@bitron.ch>
+ */
+
+using GLib;
+
+/**
+ * Hashtable implementation of the Set interface.
+ */
+public class Gee.HashSet<G> : Iterable<G>, Collection<G>, Set<G> {
+ public int size {
+ get { return _nnodes; }
+ }
+
+ public HashFunc hash_func {
+ set { _hash_func = value; }
+ }
+
+ public EqualFunc equal_func {
+ set { _equal_func = value; }
+ }
+
+ private int _array_size;
+ private int _nnodes;
+ private Node<G>[] _nodes;
+
+ // concurrent modification protection
+ private int _stamp = 0;
+
+ private HashFunc _hash_func;
+ private EqualFunc _equal_func;
+
+ private const int MIN_SIZE = 11;
+ private const int MAX_SIZE = 13845163;
+
+ public HashSet (construct HashFunc hash_func = GLib.direct_hash, construct EqualFunc equal_func = GLib.direct_equal) {
+ }
+
+ construct {
+ _array_size = MIN_SIZE;
+ _nodes = new Node<G>[_array_size];
+ }
+
+ private Node<G>* lookup_node (G key) {
+ uint hash_value = _hash_func (key);
+ Node<G>* node = &_nodes[hash_value % _array_size];
+ while ((*node) != null && (hash_value != (*node).key_hash || !_equal_func ((*node).key, key))) {
+ node = &((*node).next);
+ }
+ return node;
+ }
+
+ public bool contains (G key) {
+ Node<G>* node = lookup_node (key);
+ return (*node != null);
+ }
+
+ public Gee.Iterator<G> iterator () {
+ return new Iterator<G> (this);
+ }
+
+ public bool add (G key) {
+ Node<G>* node = lookup_node (key);
+ if (*node != null) {
+ return false;
+ } else {
+ uint hash_value = _hash_func (key);
+ *node = new Node<G> (key, hash_value);
+ _nnodes++;
+ resize ();
+ _stamp++;
+ return true;
+ }
+ }
+
+ public bool remove (G key) {
+ Node<G>* node = lookup_node (key);
+ if (*node != null) {
+ (*node).key = null;
+ *node = (*node).next;
+ _nnodes--;
+ resize ();
+ _stamp++;
+ return true;
+ }
+ return false;
+ }
+
+ public void clear () {
+ for (int i = 0; i < _array_size; i++) {
+ Node<G> node = #_nodes[i];
+ while (node != null) {
+ Node next = #node.next;
+ node.key = null;
+ node = #next;
+ }
+ }
+ _nnodes = 0;
+ resize ();
+ }
+
+ private void resize () {
+ if ((_array_size >= 3 * _nnodes && _array_size >= MIN_SIZE) ||
+ (3 * _array_size <= _nnodes && _array_size < MAX_SIZE)) {
+ int new_array_size = SpacedPrimes.closest (_nnodes);
+ new_array_size = new_array_size.clamp (MIN_SIZE, MAX_SIZE);
+
+ Node<G>[] new_nodes = new Node<G>[new_array_size];
+
+ for (int i = 0; i < _array_size; i++) {
+ Node<G> node;
+ Node<G> next;
+ for (node = #_nodes[i]; node != null; node = #next) {
+ next = #node.next;
+ uint hash_val = node.key_hash % new_array_size;
+ node.next = #new_nodes[hash_val];
+ new_nodes[hash_val] = #node;
+ }
+ }
+ _nodes = #new_nodes;
+ _array_size = new_array_size;
+ }
+ }
+
+ ~HashSet () {
+ clear ();
+ }
+
+ [ReferenceType]
+ private struct Node<G> {
+ public G key;
+ public Node<G> next;
+ public uint key_hash;
+
+ public Node (G# k, uint hash) {
+ key = #k;
+ key_hash = hash;
+ }
+ }
+
+ private class Iterator<G> : Gee.Iterator<G> {
+ public HashSet<G> set {
+ set {
+ _set = value;
+ _stamp = _set._stamp;
+ // find first node
+ while (_node == null && _index + 1 < _set._array_size) {
+ _index++;
+ _node = _set._nodes[_index];
+ }
+ }
+ }
+
+ private HashSet<G> _set;
+ private int _index = -1;
+ private weak Node<G> _node;
+
+ // concurrent modification protection
+ private int _stamp = 0;
+
+ public Iterator (construct HashSet! set) {
+ }
+
+ public bool next () {
+ if (_node != null) {
+ _node = _node.next;
+ }
+ while (_node == null && _index + 1 < _set._array_size) {
+ _index++;
+ _node = _set._nodes[_index];
+ }
+ return (_node != null);
+ }
+
+ public G get () {
+ assert (_stamp == _set._stamp);
+ assert (_node != null);
+ return _node.key;
+ }
+ }
+}
+
--- /dev/null
+/* iterable.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j@bitron.ch>
+ */
+
+/**
+ * Implemented by classes that support a simple iteration over instances of the
+ * collection.
+ */
+public interface Gee.Iterable<G> {
+ /**
+ * Returns a Iterator that can be used for simple iteration over a
+ * collection.
+ *
+ * @return a Iterator that can be used for simple iteration over a
+ * collection
+ */
+ public abstract Iterator<G> iterator ();
+}
+
--- /dev/null
+/* iterator.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j@bitron.ch>
+ */
+
+/**
+ * Implemented by classes that support a simple iteration over instances of the
+ * collection.
+ */
+public interface Gee.Iterator<G> {
+ /**
+ * Advances to the next element in the iteration.
+ *
+ * @return true if the iterator has a next element
+ */
+ public abstract bool next ();
+
+ /**
+ * Returns the current element in the iteration.
+ *
+ * @return the current element in the iteration
+ */
+ public abstract G get ();
+}
+
--- /dev/null
+/* list.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j@bitron.ch>
+ */
+
+/**
+ * Represents a collection of items in a well-defined order.
+ */
+public interface Gee.List<G> : GLib.Object, Collection<G> {
+ /**
+ * Returns the item at the specified index in this list.
+ *
+ * @param index zero-based index of the item to be returned
+ *
+ * @return the item at the specified index in the list
+ */
+ public abstract G get (int index);
+
+ /**
+ * Sets the item at the specified index in this list.
+ *
+ * @param index zero-based index of the item to be set
+ */
+ public abstract void set (int index, G item);
+
+ /**
+ * Returns the index of the first occurence of the specified item in
+ * this list.
+ *
+ * @return the index of the first occurence of the specified item, or
+ * -1 if the item could not be found
+ */
+ public abstract int index_of (G item);
+
+ /**
+ * Inserts an item into this list at the specified position.
+ *
+ * @param index zero-based index at which item is inserted
+ * @param item item to insert into the list
+ */
+ public abstract void insert (int index, G item);
+
+ /**
+ * Removes the item at the specified index of this list.
+ *
+ * @param index zero-based index of the item to be removed
+ */
+ public abstract void remove_at (int index);
+}
+
--- /dev/null
+/* map.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j@bitron.ch>
+ */
+
+/**
+ * A map is a generic collection of key/value pairs.
+ */
+public interface Gee.Map<K,V> {
+ /**
+ * The number of items in this map.
+ */
+ public abstract int size { get; }
+
+ /**
+ * Returns the keys of this map as a read-only set.
+ *
+ * @return the keys of the map
+ */
+ public abstract Set<K> get_keys ();
+
+ /**
+ * Returns the values of this map as a read-only collection.
+ *
+ * @return the values of the map
+ */
+ public abstract Collection<V> get_values ();
+
+ /**
+ * Determines whether this map contains the specified key.
+ *
+ * @param key the key to locate in the map
+ *
+ * @return true if key is found, false otherwise
+ */
+ public abstract bool contains (K key);
+
+ /**
+ * Returns the value of the specified key in this map.
+ *
+ * @param key the key whose value is to be retrieved
+ *
+ * @return the value associated with the key, or null if the key
+ * couldn't be found
+ */
+ public abstract V get (K key);
+
+ /**
+ * Inserts a new key and value into this map.
+ *
+ * @param key the key to insert
+ * @param value the value to associate with the key
+ */
+ public abstract void set (K key, V value);
+
+ /**
+ * Removes the specified key from this map.
+ *
+ * @param key the key to remove from the map
+ *
+ * @return true if the map has been changed, false otherwise
+ */
+ public abstract bool remove (K key);
+
+ /**
+ * Removes all items from this collection. Must not be called on
+ * read-only collections.
+ */
+ public abstract void clear ();
+}
+
--- /dev/null
+/* readonlycollection.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j@bitron.ch>
+ */
+
+using GLib;
+
+/**
+ * Represents a read-only collection of items.
+ */
+public class Gee.ReadOnlyCollection<G> : Iterable<G>, Collection<G> {
+ public int size {
+ get { return _collection.size; }
+ }
+
+ public Collection<G> collection {
+ set { _collection = value; }
+ }
+
+ private Collection<G> _collection;
+
+ public ReadOnlyCollection (construct Collection<G> collection = null) {
+ }
+
+ public Gee.Iterator<G> iterator () {
+ if (_collection == null) {
+ return new Iterator<G> ();
+ }
+
+ return _collection.iterator ();
+ }
+
+ public bool contains (G item) {
+ if (_collection == null) {
+ return false;
+ }
+
+ return _collection.contains (item);
+ }
+
+ public bool add (G item) {
+ assert_not_reached ();
+ return false;
+ }
+
+ public bool remove (G item) {
+ assert_not_reached ();
+ return false;
+ }
+
+ public void clear () {
+ assert_not_reached ();
+ }
+
+ private class Iterator<G> : Gee.Iterator<G> {
+ public bool next () {
+ return false;
+ }
+
+ public G get () {
+ return null;
+ }
+ }
+}
+
--- /dev/null
+/* readonlylist.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j@bitron.ch>
+ */
+
+using GLib;
+
+/**
+ * Represents a read-only collection of items in a well-defined order.
+ */
+public class Gee.ReadOnlyList<G> : Iterable<G>, Collection<G>, List<G> {
+ public int size {
+ get { return _list.size; }
+ }
+
+ public List<G> list {
+ set { _list = value; }
+ }
+
+ private List<G> _list;
+
+ public ReadOnlyList (construct List<G> list = null) {
+ }
+
+ public Gee.Iterator<G> iterator () {
+ if (_list == null) {
+ return new Iterator<G> ();
+ }
+
+ return _list.iterator ();
+ }
+
+ public bool contains (G item) {
+ if (_list == null) {
+ return false;
+ }
+
+ return _list.contains (item);
+ }
+
+ public int index_of (G item) {
+ if (_list == null) {
+ return -1;
+ }
+
+ return _list.index_of (item);
+ }
+
+ public bool add (G item) {
+ assert_not_reached ();
+ return false;
+ }
+
+ public bool remove (G item) {
+ assert_not_reached ();
+ return false;
+ }
+
+ public void insert (int index, G item) {
+ assert_not_reached ();
+ }
+
+ public void remove_at (int index) {
+ assert_not_reached ();
+ }
+
+ public G get (int index) {
+ if (_list == null) {
+ return null;
+ }
+
+ return _list.get (index);
+ }
+
+ public void set (int index, G o) {
+ assert_not_reached ();
+ }
+
+ public void clear () {
+ assert_not_reached ();
+ }
+
+ class Iterator<G> : Gee.Iterator<G> {
+ public bool next () {
+ return false;
+ }
+
+ public G get () {
+ return null;
+ }
+ }
+}
+
--- /dev/null
+/* readonlymap.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j@bitron.ch>
+ */
+
+using GLib;
+
+/**
+ * Represents a read-only collection of key/value pairs.
+ */
+public class Gee.ReadOnlyMap<K,V> : Map<K,V> {
+ public int size {
+ get { return _map.size; }
+ }
+
+ public Map<K,V> map {
+ set { _map = value; }
+ }
+
+ private Map<K,V> _map;
+
+ public ReadOnlyMap (construct Map<K,V> map = null) {
+ }
+
+ public Set<K> get_keys () {
+ if (_map == null) {
+ return new ReadOnlySet<K> ();
+ }
+
+ return _map.get_keys ();
+ }
+
+ public Collection<V> get_values () {
+ if (_map == null) {
+ return new ReadOnlyCollection<V> ();
+ }
+
+ return _map.get_values ();
+ }
+
+ public bool contains (K key) {
+ if (_map == null) {
+ return false;
+ }
+
+ return _map.contains (key);
+ }
+
+ public V get (K key) {
+ if (_map == null) {
+ return null;
+ }
+
+ return _map.get (key);
+ }
+
+ public void set (K key, V value) {
+ assert_not_reached ();
+ }
+
+ public bool remove (K key) {
+ assert_not_reached ();
+ return false;
+ }
+
+ public void clear () {
+ assert_not_reached ();
+ }
+}
+
--- /dev/null
+/* readonlyset.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j@bitron.ch>
+ */
+
+using GLib;
+
+/**
+ * Represents a read-only collection of items without duplicates.
+ */
+public class Gee.ReadOnlySet<G> : Iterable<G>, Collection<G>, Set<G> {
+ public int size {
+ get { return _set.size; }
+ }
+
+ public Set<G> set {
+ set { _set = value; }
+ }
+
+ private Set<G> _set;
+
+ public ReadOnlySet (construct Set<G> set = null) {
+ }
+
+ public Gee.Iterator<G> iterator () {
+ if (_set == null) {
+ return new Iterator<G> ();
+ }
+
+ return _set.iterator ();
+ }
+
+ public bool contains (G item) {
+ if (_set == null) {
+ return false;
+ }
+
+ return _set.contains (item);
+ }
+
+ public bool add (G item) {
+ assert_not_reached ();
+ return false;
+ }
+
+ public bool remove (G item) {
+ assert_not_reached ();
+ return false;
+ }
+
+ public void clear () {
+ assert_not_reached ();
+ }
+
+ private class Iterator<G> : Gee.Iterator<G> {
+ public bool next () {
+ return false;
+ }
+
+ public G get () {
+ return null;
+ }
+ }
+}
+
--- /dev/null
+/* set.vala
+ *
+ * Copyright (C) 2007 Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author:
+ * Jürg Billeter <j@bitron.ch>
+ */
+
+/**
+ * A set is a collection without duplicates.
+ */
+public interface Gee.Set<G> : Collection<G> {
+}
+
$(NULL)
gobject.vala gobject.vala.stamp: $(filter %.vala,$(libvala_la_SOURCES))
- $(VALAC) --vapidir $(srcdir)/../vapi --vapidir ../ccode --pkg ccode --vapidir ../vala --pkg vala --library gobject $^
+ $(VALAC) --vapidir $(srcdir)/../vapi --vapidir ../gee --pkg gee --vapidir ../ccode --pkg ccode --vapidir ../vala --pkg vala --library gobject $^
touch $@
libvala_la_LIBADD = \
/**
* Specifies the class to be registered.
*/
- public Class! class_reference { get; set construct; }
+ public weak Class! class_reference { get; set; }
/**
* Creates a new C function to register the specified class at runtime.
*/
using GLib;
+using Gee;
/**
* Code visitor generating C Code.
CCodeBlock block;
/* all temporary variables */
- List<VariableDeclarator> temp_vars;
+ ArrayList<VariableDeclarator> temp_vars = new ArrayList<VariableDeclarator> ();
/* temporary variables that own their content */
- List<VariableDeclarator> temp_ref_vars;
+ ArrayList<VariableDeclarator> temp_ref_vars = new ArrayList<VariableDeclarator> ();
/* cache to check whether a certain marshaller has been created yet */
- HashTable<string,bool> user_marshal_list;
+ Gee.Set<string> user_marshal_set;
/* (constant) hash table with all predefined marshallers */
- HashTable<string,bool> predefined_marshal_list;
+ Gee.Set<string> predefined_marshal_set;
/* (constant) hash table with all C keywords */
- HashTable<string,bool> c_keywords;
+ Gee.Set<string> c_keywords;
private int next_temp_var_id = 0;
private int current_try_id = 0;
}
construct {
- predefined_marshal_list = new HashTable (str_hash, str_equal);
- predefined_marshal_list.insert ("VOID:VOID", true);
- predefined_marshal_list.insert ("VOID:BOOLEAN", true);
- predefined_marshal_list.insert ("VOID:CHAR", true);
- predefined_marshal_list.insert ("VOID:UCHAR", true);
- predefined_marshal_list.insert ("VOID:INT", true);
- predefined_marshal_list.insert ("VOID:UINT", true);
- predefined_marshal_list.insert ("VOID:LONG", true);
- predefined_marshal_list.insert ("VOID:ULONG", true);
- predefined_marshal_list.insert ("VOID:ENUM", true);
- predefined_marshal_list.insert ("VOID:FLAGS", true);
- predefined_marshal_list.insert ("VOID:FLOAT", true);
- predefined_marshal_list.insert ("VOID:DOUBLE", true);
- predefined_marshal_list.insert ("VOID:STRING", true);
- predefined_marshal_list.insert ("VOID:POINTER", true);
- predefined_marshal_list.insert ("VOID:OBJECT", true);
- predefined_marshal_list.insert ("STRING:OBJECT,POINTER", true);
- predefined_marshal_list.insert ("VOID:UINT,POINTER", true);
- predefined_marshal_list.insert ("BOOLEAN:FLAGS", true);
-
- c_keywords = new HashTable (str_hash, str_equal);
+ predefined_marshal_set = new HashSet<string> (str_hash, str_equal);
+ predefined_marshal_set.add ("VOID:VOID");
+ predefined_marshal_set.add ("VOID:BOOLEAN");
+ predefined_marshal_set.add ("VOID:CHAR");
+ predefined_marshal_set.add ("VOID:UCHAR");
+ predefined_marshal_set.add ("VOID:INT");
+ predefined_marshal_set.add ("VOID:UINT");
+ predefined_marshal_set.add ("VOID:LONG");
+ predefined_marshal_set.add ("VOID:ULONG");
+ predefined_marshal_set.add ("VOID:ENUM");
+ predefined_marshal_set.add ("VOID:FLAGS");
+ predefined_marshal_set.add ("VOID:FLOAT");
+ predefined_marshal_set.add ("VOID:DOUBLE");
+ predefined_marshal_set.add ("VOID:STRING");
+ predefined_marshal_set.add ("VOID:POINTER");
+ predefined_marshal_set.add ("VOID:OBJECT");
+ predefined_marshal_set.add ("STRING:OBJECT,POINTER");
+ predefined_marshal_set.add ("VOID:UINT,POINTER");
+ predefined_marshal_set.add ("BOOLEAN:FLAGS");
+
+ c_keywords = new HashSet<string> (str_hash, str_equal);
// C99 keywords
- c_keywords.insert ("_Bool", true);
- c_keywords.insert ("_Complex", true);
- c_keywords.insert ("_Imaginary", true);
- c_keywords.insert ("auto", true);
- c_keywords.insert ("break", true);
- c_keywords.insert ("case", true);
- c_keywords.insert ("char", true);
- c_keywords.insert ("const", true);
- c_keywords.insert ("continue", true);
- c_keywords.insert ("default", true);
- c_keywords.insert ("do", true);
- c_keywords.insert ("double", true);
- c_keywords.insert ("else", true);
- c_keywords.insert ("enum", true);
- c_keywords.insert ("extern", true);
- c_keywords.insert ("float", true);
- c_keywords.insert ("for", true);
- c_keywords.insert ("goto", true);
- c_keywords.insert ("if", true);
- c_keywords.insert ("inline", true);
- c_keywords.insert ("int", true);
- c_keywords.insert ("long", true);
- c_keywords.insert ("register", true);
- c_keywords.insert ("restrict", true);
- c_keywords.insert ("return", true);
- c_keywords.insert ("short", true);
- c_keywords.insert ("signed", true);
- c_keywords.insert ("sizeof", true);
- c_keywords.insert ("static", true);
- c_keywords.insert ("struct", true);
- c_keywords.insert ("switch", true);
- c_keywords.insert ("typedef", true);
- c_keywords.insert ("union", true);
- c_keywords.insert ("unsigned", true);
- c_keywords.insert ("void", true);
- c_keywords.insert ("volatile", true);
- c_keywords.insert ("while", true);
+ c_keywords.add ("_Bool");
+ c_keywords.add ("_Complex");
+ c_keywords.add ("_Imaginary");
+ c_keywords.add ("auto");
+ c_keywords.add ("break");
+ c_keywords.add ("case");
+ c_keywords.add ("char");
+ c_keywords.add ("const");
+ c_keywords.add ("continue");
+ c_keywords.add ("default");
+ c_keywords.add ("do");
+ c_keywords.add ("double");
+ c_keywords.add ("else");
+ c_keywords.add ("enum");
+ c_keywords.add ("extern");
+ c_keywords.add ("float");
+ c_keywords.add ("for");
+ c_keywords.add ("goto");
+ c_keywords.add ("if");
+ c_keywords.add ("inline");
+ c_keywords.add ("int");
+ c_keywords.add ("long");
+ c_keywords.add ("register");
+ c_keywords.add ("restrict");
+ c_keywords.add ("return");
+ c_keywords.add ("short");
+ c_keywords.add ("signed");
+ c_keywords.add ("sizeof");
+ c_keywords.add ("static");
+ c_keywords.add ("struct");
+ c_keywords.add ("switch");
+ c_keywords.add ("typedef");
+ c_keywords.add ("union");
+ c_keywords.add ("unsigned");
+ c_keywords.add ("void");
+ c_keywords.add ("volatile");
+ c_keywords.add ("while");
// MSVC keywords
- c_keywords.insert ("cdecl", true);
+ c_keywords.add ("cdecl");
}
/**
ma.symbol_reference = f;
var array_len_lhs = get_array_length_cexpression (ma, 1);
- var sizes = ((ArrayCreationExpression) f.initializer).get_sizes ();
- var size = (Expression) sizes.data;
+ Gee.List<Expression> sizes = ((ArrayCreationExpression) f.initializer).get_sizes ();
+ var size = sizes[0];
instance_init_fragment.append (new CCodeExpressionStatement (new CCodeAssignment (array_len_lhs, (CCodeExpression) size.ccodenode)));
}
}
}
create_temp_decl (stmt, temp_vars);
- temp_vars = null;
+ temp_vars.clear ();
}
private string! get_variable_cname (string! name) {
- if (c_keywords.lookup (name)) {
+ if (c_keywords.contains (name)) {
return name + "_";
} else {
return name;
len_decl.type_reference = new TypeReference ();
len_decl.type_reference.data_type = int_type.data_type;
- temp_vars.prepend (len_decl);
+ temp_vars.insert (0, len_decl);
}
}
var ccomma = new CCodeCommaExpression ();
var temp_decl = get_temp_variable_declarator (decl.type_reference);
- temp_vars.prepend (temp_decl);
+ temp_vars.insert (0, temp_decl);
ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_decl.name), rhs));
for (int dim = 1; dim <= arr.rank; dim++) {
public override void visit_end_full_expression (Expression! expr) {
if (!memory_management) {
- temp_vars = null;
- temp_ref_vars = null;
+ temp_vars.clear ();
+ temp_ref_vars.clear ();
return;
}
* expr.temp_vars = temp_vars;
* when deep list copying works
*/
- expr.temp_vars = null;
+ expr.temp_vars.clear ();
foreach (VariableDeclarator decl1 in temp_vars) {
- expr.temp_vars.append (decl1);
+ expr.temp_vars.add (decl1);
}
- temp_vars = null;
+ temp_vars.clear ();
- if (temp_ref_vars == null) {
+ if (((Gee.List<VariableDeclarator>) temp_ref_vars).size == 0) {
/* nothing to do without temporary variables */
return;
}
var full_expr_decl = get_temp_variable_declarator (expr.static_type);
- expr.temp_vars.append (full_expr_decl);
+ expr.temp_vars.add (full_expr_decl);
var expr_list = new CCodeCommaExpression ();
expr_list.append_expression (new CCodeAssignment (new CCodeIdentifier (full_expr_decl.name), (CCodeExpression) expr.ccodenode));
expr.ccodenode = expr_list;
- temp_ref_vars = null;
+ temp_ref_vars.clear ();
}
- private void append_temp_decl (CCodeFragment! cfrag, List<VariableDeclarator> temp_vars) {
+ private void append_temp_decl (CCodeFragment! cfrag, Collection<VariableDeclarator> temp_vars) {
foreach (VariableDeclarator decl in temp_vars) {
var cdecl = new CCodeDeclaration (decl.type_reference.get_cname (true, !decl.type_reference.takes_ownership));
var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, new CCodeIdentifier ("inner_error"), new CCodeConstant ("NULL"));
cfrag.append (new CCodeIfStatement (ccond, cerror_block));
- } else if (current_method != null && current_method.get_error_domains ().length () > 0) {
+ } else if (current_method != null && current_method.get_error_domains ().size > 0) {
// current method can fail, propagate error
// TODO ensure one of the error domains matches
/* free temporary objects */
if (!memory_management) {
- temp_vars = null;
- temp_ref_vars = null;
+ temp_vars.clear ();
+ temp_ref_vars.clear ();
return;
}
- if (temp_vars == null) {
+ if (((Gee.List<VariableDeclarator>) temp_vars).size == 0) {
/* nothing to do without temporary variables */
return;
}
stmt.ccodenode = cfrag;
- temp_vars = null;
- temp_ref_vars = null;
+ temp_vars.clear ();
+ temp_ref_vars.clear ();
}
- private void create_temp_decl (Statement! stmt, List<VariableDeclarator> temp_vars) {
+ private void create_temp_decl (Statement! stmt, Collection<VariableDeclarator> temp_vars) {
/* declare temporary variables */
- if (temp_vars == null) {
+ if (temp_vars.size == 0) {
/* nothing to do without temporary variables */
return;
}
public override void visit_switch_statement (SwitchStatement! stmt) {
// we need a temporary variable to save the property value
var temp_decl = get_temp_variable_declarator (stmt.expression.static_type);
- stmt.expression.temp_vars.prepend (temp_decl);
+ stmt.expression.temp_vars.insert (0, temp_decl);
var ctemp = new CCodeIdentifier (temp_decl.name);
create_temp_decl (stmt, stmt.expression.temp_vars);
- List<weak Statement> default_statements = null;
+ Collection<Statement> default_statements = null;
// generate nested if statements
CCodeStatement ctopstmt = null;
var cfrag = new CCodeFragment ();
append_temp_decl (cfrag, temp_vars);
cbody.add_statement (cfrag);
- temp_vars = null;
+ temp_vars.clear ();
}
var cdecl = new CCodeDeclaration (stmt.type_reference.get_cname ());
var cfrag = new CCodeFragment ();
append_temp_decl (cfrag, temp_vars);
cbody.add_statement (cfrag);
- temp_vars = null;
+ temp_vars.clear ();
}
var cdecl = new CCodeDeclaration (stmt.type_reference.get_cname ());
var cfrag = new CCodeFragment ();
append_temp_decl (cfrag, temp_vars);
cbody.add_statement (cfrag);
- temp_vars = null;
+ temp_vars.clear ();
}
var cdecl = new CCodeDeclaration (stmt.type_reference.get_cname ());
element_expr = convert_from_generic_pointer (element_expr, stmt.type_reference);
- List<weak TypeReference> type_arg_list = it_method.return_type.get_type_arguments ();
- var it_type = SemanticAnalyzer.get_actual_type (stmt.collection.static_type, it_method, (TypeReference) type_arg_list.data, stmt);
+ Iterator<TypeReference> type_arg_it = it_method.return_type.get_type_arguments ().iterator ();
+ type_arg_it.next ();
+ var it_type = SemanticAnalyzer.get_actual_type (stmt.collection.static_type, it_method, type_arg_it.get (), stmt);
if (stmt.type_reference.takes_ownership && !it_type.takes_ownership) {
var ma = new MemberAccess.simple (stmt.variable_name);
var cfrag = new CCodeFragment ();
append_temp_decl (cfrag, temp_vars);
cbody.add_statement (cfrag);
- temp_vars = null;
+ temp_vars.clear ();
}
var cdecl = new CCodeDeclaration (stmt.type_reference.get_cname ());
ccomma.append_expression (new CCodeIdentifier (return_expr_decl.name));
expr.ccodenode = ccomma;
- expr.temp_vars.append (return_expr_decl);
+ expr.temp_vars.add (return_expr_decl);
}
public override void visit_begin_return_statement (ReturnStatement! stmt) {
ccomma.append_expression (new CCodeIdentifier (return_expr_decl.name));
stmt.return_expression.ccodenode = ccomma;
- stmt.return_expression.temp_vars.append (return_expr_decl);
+ stmt.return_expression.temp_vars.add (return_expr_decl);
}
create_local_free_expr (stmt.return_expression);
var name_cnode = new CCodeIdentifier (temp_var.name);
int i = 0;
- temp_vars.prepend (temp_var);
+ temp_vars.insert (0, temp_var);
ce.append_expression (new CCodeAssignment (name_cnode, gnew));
}
if (array_expr is ArrayCreationExpression) {
- List<weak Expression> size = ((ArrayCreationExpression) array_expr).get_sizes ();
- var length_expr = size.nth_data (dim - 1);
+ Gee.List<Expression> size = ((ArrayCreationExpression) array_expr).get_sizes ();
+ var length_expr = size[dim - 1];
return (CCodeExpression) length_expr.ccodenode;
} else if (array_expr is InvocationExpression) {
var invocation_expr = (InvocationExpression) array_expr;
- List<weak CCodeExpression> size = invocation_expr.get_array_sizes ();
- return size.nth_data (dim - 1);
+ Gee.List<CCodeExpression> size = invocation_expr.get_array_sizes ();
+ return size[dim - 1];
} else if (array_expr.symbol_reference != null) {
if (array_expr.symbol_reference is FormalParameter) {
var param = (FormalParameter) array_expr.symbol_reference;
public override void visit_element_access (ElementAccess! expr)
{
- List<weak Expression> indices = expr.get_indices ();
- int rank = indices.length ();
+ Gee.List<Expression> indices = expr.get_indices ();
+ int rank = indices.size;
var container_type = expr.container.static_type.data_type;
var ccontainer = (CCodeExpression) expr.container.ccodenode;
- var cindex = (CCodeExpression) indices.nth_data (0).ccodenode;
+ var cindex = (CCodeExpression) indices[0].ccodenode;
if (container_type == string_type.data_type) {
// access to unichar in a string
var coffsetcall = new CCodeFunctionCall (new CCodeIdentifier ("g_utf8_offset_to_pointer"));
(container_type == list_type || container_type.is_subtype_of (list_type) ||
container_type == map_type || container_type.is_subtype_of (map_type))) {
var get_method = (Method) container_type.scope.lookup ("get");
- List<weak FormalParameter> get_params = get_method.get_parameters ();
- var get_param = (FormalParameter) get_params.data;
+ Collection<FormalParameter> get_params = get_method.get_parameters ();
+ Iterator<FormalParameter> get_params_it = get_params.iterator ();
+ get_params_it.next ();
+ var get_param = get_params_it.get ();
if (get_param.type_reference.type_parameter != null) {
var index_type = SemanticAnalyzer.get_actual_type (expr.container.static_type, get_method, get_param.type_reference, expr);
// access to element in an array
for (int i = 1; i < rank; i++) {
var cmul = new CCodeBinaryExpression (CCodeBinaryOperator.MUL, cindex, get_array_length_cexpression (expr.container, i + 1));
- cindex = new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, cmul, (CCodeExpression) indices.nth_data (i).ccodenode);
+ cindex = new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, cmul, (CCodeExpression) indices[i].ccodenode);
}
expr.ccodenode = new CCodeElementAccess (ccontainer, cindex);
}
// assign current value to temp variable
var temp_decl = get_temp_variable_declarator (prop.type_reference);
- temp_vars.prepend (temp_decl);
+ temp_vars.insert (0, temp_decl);
ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_decl.name), (CCodeExpression) expr.inner.ccodenode));
// increment/decrement property
return ccall;
} else {
var decl = get_temp_variable_declarator (expr.static_type, false);
- temp_vars.prepend (decl);
+ temp_vars.insert (0, decl);
var ctemp = new CCodeIdentifier (decl.name);
if (expr.ref_leaked) {
var decl = get_temp_variable_declarator (expr.static_type);
- temp_vars.prepend (decl);
- temp_ref_vars.prepend (decl);
+ temp_vars.insert (0, decl);
+ temp_ref_vars.insert (0, decl);
expr.ccodenode = new CCodeParenthesizedExpression (new CCodeAssignment (new CCodeIdentifier (get_variable_cname (decl.name)), (CCodeExpression) expr.ccodenode));
} else if (expr.ref_missing) {
expr.ccodenode = get_ref_expression (expr);
bool ellipsis = false;
int i = 1;
- weak List<weak FormalParameter> params_it = params;
+ Iterator<FormalParameter> params_it = params.iterator ();
foreach (Expression arg in expr.get_argument_list ()) {
CCodeExpression cexpr = (CCodeExpression) arg.ccodenode;
- if (params_it != null) {
- var param = (FormalParameter) params_it.data;
+ if (params_it.next ()) {
+ var param = params_it.get ();
ellipsis = param.ellipsis;
if (!param.ellipsis
&& param.type_reference.data_type != null
ccall.add_argument (cexpr);
i++;
-
- if (params_it != null) {
- params_it = params_it.next;
- }
}
- while (params_it != null) {
- var param = (FormalParameter) params_it.data;
+ while (params_it.next ()) {
+ var param = params_it.get ();
if (param.ellipsis) {
ellipsis = true;
ccall.add_argument ((CCodeExpression) param.default_expression.ccodenode);
i++;
-
- params_it = params_it.next;
}
if (expr.can_fail) {
/* (tmp = var, var = null, tmp) */
var ccomma = new CCodeCommaExpression ();
var temp_decl = get_temp_variable_declarator (expr.static_type);
- temp_vars.prepend (temp_decl);
+ temp_vars.insert (0, temp_decl);
var cvar = new CCodeIdentifier (temp_decl.name);
ccomma.append_expression (new CCodeAssignment (cvar, (CCodeExpression) expr.inner.ccodenode));
*/
using GLib;
+using Gee;
public class Vala.CodeGenerator {
public override void visit_end_assignment (Assignment! a) {
// get signal id
var ccomma = new CCodeCommaExpression ();
var temp_decl = get_temp_variable_declarator (uint_type);
- temp_vars.prepend (temp_decl);
+ temp_vars.insert (0, temp_decl);
var parse_call = new CCodeFunctionCall (new CCodeIdentifier ("g_signal_parse_name"));
parse_call.add_argument (sig.get_canonical_cconstant ());
var decl_type = (DataType) sig.parent_symbol;
var expr = (ElementAccess) a.left;
var container_type = expr.container.static_type.data_type;
- List<weak Expression> indices = expr.get_indices ();
+ Collection<Expression> indices = expr.get_indices ();
+ Iterator<Expression> indices_it = indices.iterator ();
+ indices_it.next ();
var ccontainer = (CCodeExpression) expr.container.ccodenode;
- var cindex = (CCodeExpression) indices.nth_data (0).ccodenode;
+ var cindex = (CCodeExpression) indices_it.get ().ccodenode;
if (container_type != null && list_type != null && map_type != null &&
(container_type == list_type || container_type.is_subtype_of (list_type) ||
container_type == map_type || container_type.is_subtype_of (map_type))) {
var set_method = (Method) container_type.scope.lookup ("set");
- List<weak FormalParameter> set_params = set_method.get_parameters ();
- var set_param = (FormalParameter) set_params.data;
+ Collection<FormalParameter> set_params = set_method.get_parameters ();
+ Iterator<FormalParameter> set_params_it = set_params.iterator ();
+ set_params_it.next ();
+ var set_param = set_params_it.get ();
if (set_param.type_reference.type_parameter != null) {
var index_type = SemanticAnalyzer.get_actual_type (expr.container.static_type, set_method, set_param.type_reference, a);
var ccomma = new CCodeCommaExpression ();
var temp_decl = get_temp_variable_declarator (a.left.static_type);
- temp_vars.prepend (temp_decl);
+ temp_vars.insert (0, temp_decl);
ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_decl.name), rhs));
if (unref_old) {
/* unref old value */
var cea = (CCodeElementAccess) a.left.ccodenode;
if (!(cea.index is CCodeConstant || cea.index is CCodeIdentifier)) {
var index_temp_decl = get_temp_variable_declarator (int_type);
- temp_vars.prepend (index_temp_decl);
+ temp_vars.insert (0, index_temp_decl);
var ccomma = new CCodeCommaExpression ();
ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (index_temp_decl.name), cea.index));
}
add_instance_init_function (cl);
- if ((memory_management && cl.get_fields () != null) || cl.destructor != null) {
+ if ((memory_management && cl.get_fields ().size > 0) || cl.destructor != null) {
add_dispose_function (cl);
}
}
/* set dispose function */
- if (memory_management && cl.get_fields () != null) {
+ if (memory_management && cl.get_fields ().size > 0) {
var ccast = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_CLASS"));
ccast.add_argument (new CCodeIdentifier ("klass"));
init_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (ccast, "dispose"), new CCodeIdentifier ("%s_dispose".printf (cl.get_lower_case_cname (null))))));
}
/* connect overridden methods */
- var methods = cl.get_methods ();
- foreach (Method m in methods) {
+ foreach (Method m in cl.get_methods ()) {
if (m.base_method == null) {
continue;
}
var parent_assignment = new CCodeAssignment (new CCodeIdentifier (parent_iface_var), ccall);
init_block.add_statement (new CCodeExpressionStatement (parent_assignment));
- var methods = cl.get_methods ();
- foreach (Method m in methods) {
+ foreach (Method m in cl.get_methods ()) {
if (m.base_interface_method == null) {
continue;
}
csignew.add_argument (marshal_arg);
var params = sig.get_parameters ();
- var params_len = params.length ();
+ var params_len = params.size;
if (sig.return_type.type_parameter != null) {
csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER"));
} else if (sig.return_type.data_type == null) {
*/
using GLib;
+using Gee;
public class Vala.CodeGenerator {
public override void visit_end_invocation_expression (InvocationExpression! expr) {
var ccall = new CCodeFunctionCall ((CCodeExpression) expr.call.ccodenode);
Method m = null;
- List<weak FormalParameter> params;
+ Collection<FormalParameter> params;
if (!(expr.call is MemberAccess)) {
expr.error = true;
bool ellipsis = false;
var i = 1;
- weak List<weak FormalParameter> params_it = params;
+ Iterator<FormalParameter> params_it = params.iterator ();
foreach (Expression arg in expr.get_argument_list ()) {
/* explicitly use strong reference as ccall gets
* unrefed at end of inner block
*/
CCodeExpression cexpr = (CCodeExpression) arg.ccodenode;
- if (params_it != null) {
- var param = (FormalParameter) params_it.data;
+ if (params_it.next ()) {
+ var param = params_it.get ();
ellipsis = param.ellipsis;
if (!ellipsis) {
if (param.type_reference.data_type != null
ccall.add_argument (cexpr);
i++;
-
- if (params_it != null) {
- params_it = params_it.next;
- }
}
- while (params_it != null) {
- var param = (FormalParameter) params_it.data;
+ while (params_it.next ()) {
+ var param = params_it.get ();
if (param.ellipsis) {
ellipsis = true;
ccall.add_argument ((CCodeExpression) param.default_expression.ccodenode);
i++;
-
- params_it = params_it.next;
}
/* add length argument for methods returning arrays */
var temp_decl = get_temp_variable_declarator (int_type);
var temp_ref = new CCodeIdentifier (temp_decl.name);
- temp_vars.prepend (temp_decl);
+ temp_vars.insert (0, temp_decl);
ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, temp_ref));
if (m is ArrayResizeMethod) {
// FIXME: size expression must not be evaluated twice at runtime (potential side effects)
- var new_size = (CCodeExpression) ((CodeNode) expr.get_argument_list ().data).ccodenode;
+ Iterator<Expression> arg_it = expr.get_argument_list ().iterator ();
+ arg_it.next ();
+ var new_size = (CCodeExpression) arg_it.get ().ccodenode;
var temp_decl = get_temp_variable_declarator (int_type);
var temp_ref = new CCodeIdentifier (temp_decl.name);
- temp_vars.prepend (temp_decl);
+ temp_vars.insert (0, temp_decl);
/* memset needs string.h */
string_h_needed = true;
var temp_decl = get_temp_variable_declarator (string_type);
var temp_ref = new CCodeIdentifier (temp_decl.name);
- temp_vars.prepend (temp_decl);
+ temp_vars.insert (0, temp_decl);
- List<weak CCodeExpression> args = ccall.get_arguments ();
+ Gee.List<CCodeExpression> args = ccall.get_arguments ();
var coffsetcall = new CCodeFunctionCall (new CCodeIdentifier ("g_utf8_offset_to_pointer"));
// full string
- coffsetcall.add_argument (args.nth_data (0));
+ coffsetcall.add_argument (args[0]);
// offset
- coffsetcall.add_argument (args.nth_data (1));
+ coffsetcall.add_argument (args[1]);
var coffsetcall2 = new CCodeFunctionCall (new CCodeIdentifier ("g_utf8_offset_to_pointer"));
coffsetcall2.add_argument (temp_ref);
// len
- coffsetcall2.add_argument (args.nth_data (2));
+ coffsetcall2.add_argument (args[2]);
var cndupcall = new CCodeFunctionCall (new CCodeIdentifier ("g_strndup"));
cndupcall.add_argument (temp_ref);
// we need a temporary variable to save the property value
var temp_decl = get_temp_variable_declarator (expr.static_type);
- temp_vars.prepend (temp_decl);
+ temp_vars.insert (0, temp_decl);
var ctemp = new CCodeIdentifier (temp_decl.name);
ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, ctemp));
*/
using GLib;
+using Gee;
public class Vala.CodeGenerator {
public override void visit_method (Method! m) {
function.add_parameter (instance_param);
}
- if (m.get_error_domains ().length () > 0) {
+ if (m.get_error_domains ().size > 0) {
var cparam = new CCodeFormalParameter ("error", "GError**");
function.add_parameter (cparam);
if (vdeclarator != null) {
}
var params = m.get_parameters ();
- if (params.length () == 0) {
+ if (params.size == 0) {
// method may have no parameters
args_parameter = false;
return true;
}
-
- if (params.length () > 1) {
+
+ if (params.size > 1) {
// method must not have more than one parameter
return false;
}
- var param = (FormalParameter) params.data;
+ Iterator<FormalParameter> params_it = params.iterator ();
+ params_it.next ();
+ var param = params_it.get ();
if (param.type_reference.is_out) {
// parameter must not be an out parameter
var params = sig.get_parameters ();
if (prefix == null) {
- // FIXME remove equality check with cast in next revision
- if (predefined_marshal_list.lookup (signature) != (bool) null) {
+ if (predefined_marshal_set.contains (signature)) {
prefix = "g_cclosure_marshal";
} else {
prefix = "g_cclosure_user_marshal";
/* check whether a signal with the same signature already exists for this source file (or predefined) */
signature = get_signal_signature (sig);
- // FIXME remove equality checks with cast in next revision
- if (predefined_marshal_list.lookup (signature) != (bool) null || user_marshal_list.lookup (signature) != (bool) null) {
+ if (predefined_marshal_set.contains (signature) || user_marshal_set.contains (signature)) {
return;
}
signal_marshaller.block = marshaller_body;
source_signal_marshaller_definition.append (signal_marshaller);
- user_marshal_list.insert (signature, true);
+ user_marshal_set.add (signature);
}
}
*/
using GLib;
+using Gee;
public class Vala.CodeGenerator {
private CCodeIncludeDirective get_internal_include (string! filename) {
source_signal_marshaller_definition = new CCodeFragment ();
source_signal_marshaller_declaration = new CCodeFragment ();
- user_marshal_list = new HashTable (str_hash, str_equal);
+ user_marshal_set = new HashSet<string> (str_hash, str_equal);
next_temp_var_id = 0;
header_begin.append (new CCodeIncludeDirective ("glib-object.h"));
source_include_directives.append (new CCodeIncludeDirective (source_file.get_cheader_filename (), true));
- List<string> used_includes = null;
- used_includes.append ("glib.h");
- used_includes.append ("glib-object.h");
- used_includes.append (source_file.get_cheader_filename ());
+ Gee.List<string> used_includes = new ArrayList<string> (str_equal);
+ used_includes.add ("glib.h");
+ used_includes.add ("glib-object.h");
+ used_includes.add (source_file.get_cheader_filename ());
- foreach (string filename1 in source_file.get_header_external_includes ()) {
- if (used_includes.find_custom (filename1, strcmp) == null) {
- header_begin.append (new CCodeIncludeDirective (filename1));
- used_includes.append (filename1);
+ foreach (string filename in source_file.get_header_external_includes ()) {
+ if (!used_includes.contains (filename)) {
+ header_begin.append (new CCodeIncludeDirective (filename));
+ used_includes.add (filename);
}
}
- foreach (string filename2 in source_file.get_header_internal_includes ()) {
- if (used_includes.find_custom (filename2, strcmp) == null) {
- header_begin.append (get_internal_include (filename2));
- used_includes.append (filename2);
+ foreach (string filename in source_file.get_header_internal_includes ()) {
+ if (!used_includes.contains (filename)) {
+ header_begin.append (get_internal_include (filename));
+ used_includes.add (filename);
}
}
- foreach (string filename3 in source_file.get_source_external_includes ()) {
- if (used_includes.find_custom (filename3, strcmp) == null) {
- source_include_directives.append (new CCodeIncludeDirective (filename3));
- used_includes.append (filename3);
+ foreach (string filename in source_file.get_source_external_includes ()) {
+ if (!used_includes.contains (filename)) {
+ source_include_directives.append (new CCodeIncludeDirective (filename));
+ used_includes.add (filename);
}
}
- foreach (string filename4 in source_file.get_source_internal_includes ()) {
- if (used_includes.find_custom (filename4, strcmp) == null) {
- source_include_directives.append (get_internal_include (filename4));
- used_includes.append (filename4);
+ foreach (string filename in source_file.get_source_internal_includes ()) {
+ if (!used_includes.contains (filename)) {
+ source_include_directives.append (get_internal_include (filename));
+ used_includes.add (filename);
}
}
if (source_file.is_cycle_head) {
/**
* Specifies the interface to be registered.
*/
- public Interface! interface_reference { get; set construct; }
+ public weak Interface! interface_reference { get; set; }
public InterfaceRegisterFunction (Interface! iface) {
interface_reference = iface;
$(NULL)
vala.vala vala.vala.stamp: $(filter %.vala,$(libvalacore_la_SOURCES))
- $(VALAC) --vapidir $(srcdir)/../vapi --vapidir ../ccode --pkg ccode --library vala $^
+ $(VALAC) --vapidir $(srcdir)/../vapi --vapidir ../gee --pkg gee --vapidir ../ccode --pkg ccode --library vala $^
touch $@
libvalacore_la_LIBADD = \
$(GLIB_LIBS) \
+ ../gee/libgee.la \
../ccode/libvalaccode.la \
$(NULL)
}
| FOR OPEN_PARENS local_variable_declaration SEMICOLON opt_expression SEMICOLON opt_statement_expression_list CLOSE_PARENS embedded_statement
{
- GList *l;
- GList *decls;
+ GeeCollection *decls;
+ GeeIterator *decls_it;
ValaDeclarationStatement *decl_statement;
decls = vala_local_variable_declaration_get_variable_declarators ($3);
- for (l = decls; l != NULL; l = l->next) {
- ValaVariableDeclarator *decl = l->data;
+ decls_it = gee_iterable_iterator (GEE_ITERABLE (decls));
+ g_object_unref (decls);
+ while (gee_iterator_next (decls_it)) {
+ ValaVariableDeclarator *decl = gee_iterator_get (decls_it);
ValaExpression *init = vala_variable_declarator_get_initializer (decl);
if (init != NULL) {
vala_variable_declarator_set_initializer (decl, NULL);
}
}
- g_list_free (decls);
+ g_object_unref (decls_it);
decl_statement = vala_declaration_statement_new ($3, src);
g_object_unref ($3);
g_object_unref (decl_statement);
if ($7 != NULL) {
+ GList *l;
for (l = $7; l != NULL; l = l->next) {
vala_for_statement_add_iterator (for_statement, l->data);
g_object_unref (l->data);
class_declaration
: comment opt_attributes opt_access_modifier opt_modifiers CLASS identifier opt_name_specifier opt_type_parameter_list opt_class_base
{
- GList *l;
ValaSourceReference *src;
char *name = $6;
if ($7 != NULL) {
ValaSourceReference *ns_src = src(@6);
+ g_object_unref (parent_symbol);
parent_symbol = vala_scope_lookup (parent_scope, $6);
if (parent_symbol != NULL) {
if (check_is_namespace (parent_symbol, src)) {
vala_class_set_is_static (VALA_CLASS (current_symbol), TRUE);
}
if ($8 != NULL) {
+ GList *l;
for (l = $8; l != NULL; l = l->next) {
vala_class_add_type_parameter (VALA_CLASS (current_symbol), l->data);
g_object_unref (l->data);
g_list_free ($8);
}
if ($9 != NULL) {
+ GList *l;
for (l = $9; l != NULL; l = l->next) {
vala_class_add_base_type (VALA_CLASS (current_symbol), l->data);
g_object_unref (l->data);
if ($6 != NULL) {
ValaSourceReference *ns_src = src(@5);
+ g_object_unref (parent_symbol);
parent_symbol = vala_scope_lookup (parent_scope, $5);
if (parent_symbol != NULL) {
if (check_is_namespace (parent_symbol, src)) {
}
g_list_free ($8);
}
+
+ g_object_unref (parent_symbol);
}
;
if ($7 != NULL) {
ValaSourceReference *ns_src = src(@6);
+ g_object_unref (parent_symbol);
parent_symbol = vala_scope_lookup (parent_scope, $6);
if (parent_symbol != NULL) {
if (check_is_namespace (parent_symbol, src)) {
if ($6 != NULL) {
ValaSourceReference *ns_src = src(@5);
+ g_object_unref (parent_symbol);
parent_symbol = vala_scope_lookup (parent_scope, $5);
if (parent_symbol != NULL) {
if (check_is_namespace (parent_symbol, src)) {
if ($8 != NULL) {
ValaSourceReference *ns_src = src(@7);
+ g_object_unref (parent_symbol);
parent_symbol = vala_scope_lookup (parent_scope, $7);
if (parent_symbol != NULL) {
if (check_is_namespace (parent_symbol, src)) {
*/
using GLib;
+using Gee;
/**
* Represents an array type i.e. everything with direct accessable elements.
/**
* DataType of which this is an array of.
*/
- public DataType element_type { get; set construct; }
+ public weak DataType element_type { get; set construct; }
/**
* TypeParameter of which this is an array of.
*/
- public TypeParameter element_type_parameter { get; set construct; }
+ public weak TypeParameter element_type_parameter { get; set construct; }
/**
* The rank of this array.
return "g_free";
}
- public override List<weak string> get_cheader_filenames () {
+ public override Collection<string> get_cheader_filenames () {
if (element_type != null) {
return element_type.get_cheader_filenames ();
} else {
- return null;
+ return base.get_cheader_filenames ();
}
}
*/
using GLib;
+using Gee;
/**
* Represents an array creation expression e.g. "new int[] {1,2,3}".
/**
* The size for each dimension ascending from left to right.
*/
- private List<Expression> sizes;
+ private Gee.List<Expression> sizes = new ArrayList<Expression> ();
/**
* The root array initializer list.
* Add a size expression.
*/
public void append_size (Expression! size) {
- sizes.append (size);
+ sizes.add (size);
}
/**
* Get the sizes for all dimensions ascending from left to right.
*/
- public List<weak Expression> get_sizes () {
- return sizes.copy ();
+ public Gee.List<Expression> get_sizes () {
+ return new ReadOnlyList<Expression> (sizes);
}
- public ArrayCreationExpression (TypeReference _element_type, int _rank, InitializerList _initializer, SourceReference source) {
- element_type = _element_type;
- rank = _rank;
- initializer_list = _initializer;
- source_reference = source;
+ public ArrayCreationExpression (construct TypeReference element_type, construct int rank, construct InitializerList initializer_list, construct SourceReference source_reference) {
}
public override void accept (CodeVisitor! visitor) {
*/
using GLib;
+using Gee;
/**
* Represents an attribute specified in the source code.
/**
* Contains all specified attribute arguments.
*/
- public List<NamedArgument> args;
+ public Gee.List<NamedArgument> args = new ArrayList<NamedArgument> ();
/**
* Creates a new attribute.
* @param arg named argument
*/
public void add_argument (NamedArgument! arg) {
- args.append (arg);
+ args.add (arg);
}
/**
*/
using GLib;
+using Gee;
/**
* Represents a source code block.
*/
public bool contains_jump_statement { get; set; }
- private List<Statement> statement_list;
- private List<VariableDeclarator> local_variables;
+ private Gee.List<Statement> statement_list = new ArrayList<Statement> ();
+ private Gee.List<VariableDeclarator> local_variables = new ArrayList<VariableDeclarator> ();
/**
* Creates a new block.
* @param stmt a statement
*/
public void add_statement (Statement! stmt) {
- statement_list.append (stmt);
+ statement_list.add (stmt);
}
/**
*
* @return statement list
*/
- public List<weak Statement> get_statements () {
- return statement_list.copy ();
+ public Collection<Statement> get_statements () {
+ return new ReadOnlyCollection<Statement> (statement_list);
}
/**
* @param decl a variable declarator
*/
public void add_local_variable (VariableDeclarator! decl) {
- local_variables.append (decl);
+ local_variables.add (decl);
}
/**
*
* @return variable declarator list
*/
- public List<weak VariableDeclarator> get_local_variables () {
- return local_variables.copy ();
+ public Collection<VariableDeclarator> get_local_variables () {
+ return new ReadOnlyCollection<VariableDeclarator> (local_variables);
}
public override void accept (CodeVisitor! visitor) {
*/
using GLib;
+using Gee;
/**
* Represents a function callback type.
*/
public bool instance { get; set; }
- private List<TypeParameter> type_parameters;
+ private Gee.List<TypeParameter> type_parameters = new ArrayList<TypeParameter> ();
- private List<FormalParameter> parameters;
+ private Gee.List<FormalParameter> parameters = new ArrayList<FormalParameter> ();
private string cname;
/**
* @param p a type parameter
*/
public void add_type_parameter (TypeParameter! p) {
- type_parameters.append (p);
+ type_parameters.add (p);
p.type = this;
scope.add (p.name, p);
}
* @param param a formal parameter
*/
public void add_parameter (FormalParameter! param) {
- parameters.append (param);
+ parameters.add (param);
scope.add (param.name, param);
}
*
* @return parameter list
*/
- public List<weak FormalParameter> get_parameters () {
- return parameters.copy ();
+ public Collection<FormalParameter> get_parameters () {
+ return new ReadOnlyCollection<FormalParameter> (parameters);
}
/**
}
var method_params = m.get_parameters ();
- weak List<weak FormalParameter> method_params_it = method_params;
+ Iterator<FormalParameter> method_params_it = method_params.iterator ();
bool first = true;
foreach (FormalParameter param in parameters) {
/* use first callback parameter as instance parameter if
}
/* method is allowed to accept less arguments */
- if (method_params_it == null) {
+ if (!method_params_it.next ()) {
break;
}
- var method_param = (FormalParameter) method_params_it.data;
+ var method_param = method_params_it.get ();
if (!param.type_reference.stricter (method_param.type_reference)) {
return false;
}
-
- method_params_it = method_params_it.next;
}
/* method may not expect more arguments */
- if (method_params_it != null) {
+ if (method_params_it.next ()) {
return false;
}
*/
using GLib;
+using Gee;
/**
* Represents a class declaration in the source code.
private bool _has_private_fields;
- private List<TypeParameter> type_parameters;
+ private Gee.List<TypeParameter> type_parameters = new ArrayList<TypeParameter> ();
- private List<TypeReference> base_types;
+ private Gee.List<TypeReference> base_types = new ArrayList<TypeReference> ();
- private List<Constant> constants;
- private List<Field> fields;
- private List<Method> methods;
- private List<Property> properties;
- private List<Signal> signals;
+ private Gee.List<Constant> constants = new ArrayList<Constant> ();
+ private Gee.List<Field> fields = new ArrayList<Field> ();
+ private Gee.List<Method> methods = new ArrayList<Method> ();
+ private Gee.List<Property> properties = new ArrayList<Property> ();
+ private Gee.List<Signal> signals = new ArrayList<Signal> ();
// inner types
- private List<Class> classes;
- private List<Struct> structs;
+ private Gee.List<Class> classes = new ArrayList<Class> ();
+ private Gee.List<Struct> structs = new ArrayList<Struct> ();
/**
* Specifies the default construction method.
* @param source reference to source code
* @return newly created class
*/
- public Class (string! _name, SourceReference source = null) {
- name = _name;
- source_reference = source;
+ public Class (construct string! name, construct SourceReference source_reference = null) {
}
/**
* @param type a class or interface reference
*/
public void add_base_type (TypeReference! type) {
- base_types.append (type);
+ base_types.add (type);
}
/**
*
* @return list of base types
*/
- public List<weak TypeReference> get_base_types () {
- return base_types.copy ();
+ public Collection<TypeReference> get_base_types () {
+ return new ReadOnlyCollection<TypeReference> (base_types);
}
/**
* @param p a type parameter
*/
public void add_type_parameter (TypeParameter! p) {
- type_parameters.append (p);
+ type_parameters.add (p);
p.type = this;
scope.add (p.name, p);
}
*
* @return list of type parameters
*/
- public List<weak TypeParameter> get_type_parameters () {
- return type_parameters.copy ();
+ public Collection<TypeParameter> get_type_parameters () {
+ return new ReadOnlyCollection<TypeParameter> (type_parameters);
}
/**
* @param c a constant
*/
public void add_constant (Constant! c) {
- constants.append (c);
+ constants.add (c);
scope.add (c.name, c);
}
public void add_field (Field! f) {
// non_null fields not yet supported due to initialization issues
f.type_reference.non_null = false;
- fields.append (f);
+ fields.add (f);
if (f.access == MemberAccessibility.PRIVATE && f.instance) {
_has_private_fields = true;
}
*
* @return list of fields
*/
- public List<weak Field> get_fields () {
- return fields.copy ();
+ public Collection<Field> get_fields () {
+ return new ReadOnlyCollection<Field> (fields);
}
/**
default_construction_method = m;
}
- methods.append (m);
+ methods.add (m);
scope.add (m.name, m);
}
*
* @return list of methods
*/
- public List<weak Method> get_methods () {
- return methods.copy ();
+ public Collection<Method> get_methods () {
+ return new ReadOnlyCollection<Method> (methods);
}
/**
* @param prop a property
*/
public void add_property (Property! prop, bool no_field = false) {
- properties.append (prop);
+ properties.add (prop);
scope.add (prop.name, prop);
prop.this_parameter = new FormalParameter ("this", new TypeReference ());
*
* @return list of properties
*/
- public List<weak Property> get_properties () {
- return properties.copy ();
+ public Collection<Property> get_properties () {
+ return new ReadOnlyCollection<Property> (properties);
}
/**
* @param sig a signal
*/
public void add_signal (Signal! sig) {
- signals.append (sig);
+ signals.add (sig);
scope.add (sig.name, sig);
}
*
* @return list of signals
*/
- public List<weak Signal> get_signals () {
- return signals.copy ();
+ public Collection<Signal> get_signals () {
+ return new ReadOnlyCollection<Signal> (signals);
}
/**
* @param cl a class
*/
public void add_class (Class! cl) {
- classes.append (cl);
+ classes.add (cl);
scope.add (cl.name, cl);
}
* @param st a struct
*/
public void add_struct (Struct! st) {
- structs.append (st);
+ structs.add (st);
scope.add (st.name, st);
}
*/
using GLib;
+using Gee;
/**
* The root of the code tree.
*/
public Method module_init_method { get; set; }
- List<SourceFile> source_files;
+ private Gee.List<SourceFile> source_files = new ArrayList<SourceFile> ();
private Namespace! _root = new Namespace (null);
- List<SourceFileCycle> cycles;
+ private Gee.List<SourceFileCycle> cycles = new ArrayList<SourceFileCycle> ();
- private List<string> packages;
+ private Gee.List<string> packages = new ArrayList<string> (str_equal);
/**
* The root namespace of the symbol tree.
*
* @return list of source files
*/
- public List<weak SourceFile> get_source_files () {
- return source_files.copy ();
+ public Collection<SourceFile> get_source_files () {
+ return new ReadOnlyCollection<SourceFile> (source_files);
}
/**
* @param file a source file
*/
public void add_source_file (SourceFile! file) {
- source_files.append (file);
+ source_files.add (file);
}
/**
*
* @return list of used packages
*/
- public List<weak string> get_packages () {
- return packages.copy ();
+ public Collection<string> get_packages () {
+ return new ReadOnlyCollection<string> (packages);
}
/**
* @return true if the specified package is being used
*/
public bool has_package (string! pkg) {
- return packages.find_custom (pkg, strcmp) != null;
+ return packages.contains (pkg);
}
/**
* @param pkg a package name
*/
public void add_package (string! pkg) {
- packages.append (pkg);
+ packages.add (pkg);
}
/**
}
if (file.mark == 0) {
- visit (file, null);
+ visit (file, new ArrayList<SourceFile> ());
}
}
* hard dependencies on other files in the cycle
*/
foreach (SourceFileCycle cycle in cycles) {
- cycle.head = find_cycle_head ((SourceFile) cycle.files.data);
+ cycle.head = find_cycle_head (cycle.files.get (0));
cycle.head.is_cycle_head = true;
}
return file;
}
- private void visit (SourceFile! file, List<SourceFile> chain) {
- /* no deep copy available yet
- * var l = chain.copy ();
- */
- List<weak SourceFile> l = null;
+ private void visit (SourceFile! file, Collection<SourceFile> chain) {
+ Gee.List<SourceFile> l = new ArrayList<SourceFile> ();
foreach (SourceFile chain_file in chain) {
- l.append (chain_file);
+ l.add (chain_file);
}
- l.append (file);
- /* end workaround */
+ l.add (file);
/* mark file as currently being visited */
file.mark = 1;
/* found cycle */
var cycle = new SourceFileCycle ();
- cycles.append (cycle);
+ cycles.add (cycle);
bool cycle_start_found = false;
foreach (SourceFile cycle_file in l) {
/* file is in an other cycle, merge the two cycles */
- /* broken memory management cycles.remove (cycle_file.cycle); */
- List<weak SourceFileCycle> newlist = null;
- foreach (SourceFileCycle oldcycle in cycles) {
- if (oldcycle != cycle_file.cycle) {
- newlist.append (oldcycle);
- }
- }
- cycles = null;
- foreach (SourceFileCycle newcycle in newlist) {
- cycles.append (newcycle);
- }
- newlist = null;
- /* end workaround for broken memory management */
+ cycles.remove (cycle_file.cycle);
foreach (SourceFile inner_cycle_file in cycle_file.cycle.files) {
if (inner_cycle_file.cycle != cycle) {
/* file in inner cycle not yet added to outer cycle */
- cycle.files.append (inner_cycle_file);
+ cycle.files.add (inner_cycle_file);
inner_cycle_file.cycle = cycle;
}
}
} else {
- cycle.files.append (cycle_file);
+ cycle.files.add (cycle_file);
cycle_file.cycle = cycle;
}
}
/**
* Parent of this code node.
*/
- public CodeNode parent_node { get; set; }
+ public weak CodeNode parent_node { get; set; }
/**
* References the location in the source file where this code node has
*/
using GLib;
+using Gee;
/**
* Represents a runtime data type. This data type may be defined in Vala source
*/
public MemberAccessibility access;
- private List<string> cheader_filenames;
+ private Gee.List<string> cheader_filenames = new ArrayList<string> ();
private Pointer pointer_type;
/* holds the array types of this type; each rank is a separate one */
- private HashTable<int,Array> array_types;
+ private Map<int,Array> array_types;
/**
* Returns the name of this data type as it is used in C code.
return null;
}
- public override List<weak string> get_cheader_filenames () {
- if (cheader_filenames == null) {
+ public override Collection<string> get_cheader_filenames () {
+ if (cheader_filenames.size == 0) {
/* default to header filenames of the namespace */
foreach (string filename in parent_symbol.get_cheader_filenames ()) {
add_cheader_filename (filename);
}
- if (cheader_filenames == null && source_reference != null && !source_reference.file.pkg) {
+ if (cheader_filenames.size == 0 && source_reference != null && !source_reference.file.pkg) {
// don't add default include directives for VAPI files
- cheader_filenames.append (source_reference.file.get_cinclude_filename ());
+ cheader_filenames.add (source_reference.file.get_cinclude_filename ());
}
}
- return cheader_filenames.copy ();
+ return new ReadOnlyCollection<string> (cheader_filenames);
}
/**
* @param filename a C header filename
*/
public void add_cheader_filename (string! filename) {
- cheader_filenames.append (filename);
+ cheader_filenames.add (filename);
}
/**
Array array_type = null;
if (array_types != null) {
- array_type = array_types.lookup (rank);
+ array_type = array_types[rank];
}
if (array_type == null) {
if (array_types == null) {
- array_types = new HashTable.full (direct_hash, direct_equal, null, g_object_unref);
+ array_types = new HashMap<int,Array> ();
}
var new_array_type = new Array (this, rank, source_reference);
/* link the array type to the same source as the container type */
new_array_type.source_reference = this.source_reference;
- array_types.insert (rank, new_array_type);
+ array_types[rank] = new_array_type;
array_type = new_array_type;
}
*/
using GLib;
+using Gee;
/**
* Represents an array access expression e.g. "a[1,2]".
/**
* Expressions representing the indices we want to access inside the container.
*/
- private List<Expression>! indices;
+ private Gee.List<Expression>! indices = new ArrayList<Expression> ();
public void append_index (Expression! index) {
- indices.append (index);
+ indices.add (index);
}
- public List<weak Expression> get_indices () {
- return indices.copy ();
+ public Gee.List<Expression> get_indices () {
+ return new ReadOnlyList<Expression> (indices);
}
- public ElementAccess (Expression _container, SourceReference source) {
- container = _container;
- source_reference = source;
+ public ElementAccess (construct Expression container, construct SourceReference source_reference) {
}
public override void accept (CodeVisitor! visitor) {
*/
using GLib;
+using Gee;
/**
* Represents an enum declaration in the source code.
*/
public bool error_domain { get; set; }
- private List<EnumValue> values;
- private List<Method> methods;
+ private Gee.List<EnumValue> values = new ArrayList<EnumValue> ();
+ private Gee.List<Method> methods = new ArrayList<Method> ();
private string cname;
private string cprefix;
private string lower_case_cprefix;
* @param value an enum value
*/
public void add_value (EnumValue! value) {
- values.append (value);
+ values.add (value);
scope.add (value.name, value);
}
m.scope.add (m.this_parameter.name, m.this_parameter);
}
- methods.append (m);
+ methods.add (m);
scope.add (m.name, m);
}
*
* @return list of methods
*/
- public List<weak Method> get_methods () {
- return methods.copy ();
+ public Collection<Method> get_methods () {
+ return new ReadOnlyCollection<Method> (methods);
}
public override void accept (CodeVisitor! visitor) {
*/
using GLib;
+using Gee;
/**
* Base class for all code nodes that might be used as an expression.
/**
* The symbol this expression refers to.
*/
- public Symbol symbol_reference { get; set; }
+ public weak Symbol symbol_reference { get; set; }
/**
* Specifies that this expression transfers ownership without a receiver
*
* The code generator sets and uses them for memory management.
*/
- public List<VariableDeclarator> temp_vars;
+ public ArrayList<VariableDeclarator> temp_vars = new ArrayList<VariableDeclarator> ();
}
*/
using GLib;
+using Gee;
/**
* Represents a type or namespace field.
}
}
- public List<weak FormalParameter> get_parameters () {
+ public Collection<FormalParameter> get_parameters () {
if (!is_invokable ()) {
return null;
}
*/
using GLib;
+using Gee;
/**
* Represents a formal parameter in method and callback signatures.
}
}
- public List<weak FormalParameter> get_parameters () {
+ public Collection<FormalParameter> get_parameters () {
if (!is_invokable ()) {
return null;
}
*/
using GLib;
+using Gee;
/**
* Represents a for iteration statement in the source code.
}
}
- private List<Expression> initializer;
- private List<Expression> iterator;
+ private Gee.List<Expression> initializer = new ArrayList<Expression> ();
+ private Gee.List<Expression> iterator = new ArrayList<Expression> ();
private Expression! _condition;
private Block _body;
/**
* Creates a new for statement.
*
- * @param cond loop condition
- * @param body loop body
- * @param source reference to source code
- * @return newly created for statement
+ * @param cond loop condition
+ * @param body loop body
+ * @param source_reference reference to source code
+ * @return newly created for statement
*/
public ForStatement (construct Expression condition, construct Block body, construct SourceReference source_reference = null) {
}
*/
public void add_initializer (Expression! init) {
init.parent_node = this;
- initializer.append (init);
+ initializer.add (init);
}
/**
*
* @return initializer list
*/
- public List<weak Expression> get_initializer () {
- return initializer.copy ();
+ public Collection<Expression> get_initializer () {
+ return new ReadOnlyCollection<Expression> (initializer);
}
/**
*/
public void add_iterator (Expression! iter) {
iter.parent_node = this;
- iterator.append (iter);
+ iterator.add (iter);
}
/**
*
* @return iterator
*/
- public List<weak Expression> get_iterator () {
- return iterator.copy ();
+ public Collection<Expression> get_iterator () {
+ return new ReadOnlyCollection<Expression> (iterator);
}
public override void accept (CodeVisitor! visitor) {
}
public override void replace (CodeNode! old_node, CodeNode! new_node) {
- weak List<Expression> iter;
-
if (condition == old_node) {
condition = (Expression) new_node;
return;
}
- for (iter = initializer; iter != null; iter = iter.next) {
- if (iter.data == old_node) {
- weak List<Expression> silbling = iter.next;
- initializer.delete_link (iter);
- initializer.insert_before (silbling, new_node);
+ for (int i = 0; i < initializer.size; i++) {
+ if (initializer[i] == old_node) {
+ initializer[i] = (Expression) new_node;
return;
}
}
-
- for (iter = iterator; iter != null; iter = iter.next) {
- if (iter.data == old_node) {
- weak List<Expression> silbling = iter.next;
- iterator.delete_link (iter);
- iterator.insert_before (silbling, new_node);
+ for (int i = 0; i < iterator.size; i++) {
+ if (iterator[i] == old_node) {
+ iterator[i] = (Expression) new_node;
return;
}
- }
+ }
}
}
*/
using GLib;
+using Gee;
/**
* Represents an array or struct initializer list in the source code.
*/
public class Vala.InitializerList : Expression {
- private List<Expression> initializers;
+ private Gee.List<Expression> initializers = new ArrayList<Expression> ();
/**
* Appends the specified expression to this initializer list.
* @param expr an expression
*/
public void append (Expression! expr) {
- initializers.append (expr);
+ initializers.add (expr);
}
/**
*
* @return expression list
*/
- public List<weak Expression> get_initializers () {
- return initializers.copy ();
+ public Collection<Expression> get_initializers () {
+ return new ReadOnlyCollection<Expression> (initializers);
}
/**
* Creates a new initializer list.
*
- * @param source reference to source code
- * @return newly created initializer list
+ * @param source_reference reference to source code
+ * @return newly created initializer list
*/
- public InitializerList (SourceReference source) {
- source_reference = source;
+ public InitializerList (construct SourceReference source_reference) {
}
public override void accept (CodeVisitor! visitor) {
/**
* The target type.
*/
- public DataType! type_reference { get; set construct; }
+ public weak DataType! type_reference { get; set construct; }
/**
* The expression to be cast.
*/
using GLib;
+using Gee;
/**
* Represents a class declaration in the source code.
*/
public bool is_static { get; set; }
- private List<TypeParameter> type_parameters;
+ private Gee.List<TypeParameter> type_parameters = new ArrayList<TypeParameter> ();
- private List<TypeReference> prerequisites;
+ private Gee.List<TypeReference> prerequisites = new ArrayList<TypeReference> ();
- private List<Method> methods;
- private List<Field> fields;
- private List<Property> properties;
- private List<Signal> signals;
+ private Gee.List<Method> methods = new ArrayList<Method> ();
+ private Gee.List<Field> fields = new ArrayList<Field> ();
+ private Gee.List<Property> properties = new ArrayList<Property> ();
+ private Gee.List<Signal> signals = new ArrayList<Signal> ();
private string cname;
private string lower_case_csuffix;
* @param p a type parameter
*/
public void add_type_parameter (TypeParameter! p) {
- type_parameters.append (p);
+ type_parameters.add (p);
p.type = this;
scope.add (p.name, p);
}
*
* @return list of type parameters
*/
- public List<weak TypeParameter> get_type_parameters () {
- return type_parameters.copy ();
+ public Collection<TypeParameter> get_type_parameters () {
+ return new ReadOnlyCollection<TypeParameter> (type_parameters);
}
/**
* @param type an interface or class reference
*/
public void add_prerequisite (TypeReference! type) {
- prerequisites.append (type);
+ prerequisites.add (type);
}
/**
* @param type an interface or class reference
*/
public void prepend_prerequisite (TypeReference! type) {
- prerequisites.prepend (type);
+ prerequisites.insert (0, type);
}
/**
*
* @return list of base types
*/
- public List<weak TypeReference> get_prerequisites () {
- return prerequisites.copy ();
+ public Collection<TypeReference> get_prerequisites () {
+ return new ReadOnlyCollection<TypeReference> (prerequisites);
}
/**
m.scope.add (m.this_parameter.name, m.this_parameter);
}
- methods.append (m);
+ methods.add (m);
scope.add (m.name, m);
}
*
* @return list of methods
*/
- public List<weak Method> get_methods () {
- return methods.copy ();
+ public Collection<Method> get_methods () {
+ return new ReadOnlyCollection<Method> (methods);
}
/**
public void add_field (Field! f) {
// non_null fields not yet supported due to initialization issues
f.type_reference.non_null = false;
- fields.append (f);
+ fields.add (f);
scope.add (f.name, f);
}
*
* @return list of fields
*/
- public List<weak Field> get_fields () {
- return fields.copy ();
+ public Collection<Field> get_fields () {
+ return new ReadOnlyCollection<Field> (fields);
}
/**
* @param prop a property
*/
public void add_property (Property! prop) {
- properties.append (prop);
+ properties.add (prop);
scope.add (prop.name, prop);
}
*
* @return list of properties
*/
- public List<weak Property> get_properties () {
- return properties.copy ();
+ public Collection<Property> get_properties () {
+ return new ReadOnlyCollection<Property> (properties);
}
/**
* @param sig a signal
*/
public void add_signal (Signal! sig) {
- signals.append (sig);
+ signals.add (sig);
scope.add (sig.name, sig);
}
*
* @return list of signals
*/
- public List<weak Signal> get_signals () {
- return signals.copy ();
+ public Collection<Signal> get_signals () {
+ return new ReadOnlyCollection<Signal> (signals);
}
public override string get_cname (bool const_type = false) {
*/
using GLib;
+using Gee;
/**
* Code visitor generating Vala API file for the public interface.
write_identifier (cl.name);
var type_params = cl.get_type_parameters ();
- if (type_params != null) {
+ if (type_params.size > 0) {
write_string ("<");
bool first = true;
foreach (TypeParameter type_param in type_params) {
}
var base_types = cl.get_base_types ();
- if (base_types != null) {
+ if (base_types.size > 0) {
write_string (" : ");
bool first = true;
write_identifier (iface.name);
var type_params = iface.get_type_parameters ();
- if (type_params != null) {
+ if (type_params.size > 0) {
write_string ("<");
bool first = true;
foreach (TypeParameter type_param in type_params) {
}
var prerequisites = iface.get_prerequisites ();
- if (prerequisites != null) {
+ if (prerequisites.size > 0) {
write_string (" : ");
bool first = true;
write_newline ();
}
- private void write_params (List<FormalParameter> params) {
+ private void write_params (Collection<FormalParameter> params) {
write_string ("(");
bool first = true;
if (type == null) {
write_string ("void");
} else {
- if (!cb.return_type.transfers_ownership) {
+ if (cb.return_type.transfers_ownership) {
+ } else if ((cb.return_type.data_type != null && cb.return_type.data_type.is_reference_type ()) || cb.return_type.type_parameter != null) {
write_string ("weak ");
}
if (type == null) {
write_string ("void");
} else {
- if (!sig.return_type.transfers_ownership) {
+ if (sig.return_type.transfers_ownership) {
+ } else if ((sig.return_type.data_type != null && sig.return_type.data_type.is_reference_type ()) || sig.return_type.type_parameter != null) {
write_string ("weak ");
}
}
var type_args = type.get_type_arguments ();
- if (!(type.data_type is Array) && type_args != null) {
+ if (!(type.data_type is Array) && type_args.size > 0) {
write_string ("<");
bool first = true;
foreach (TypeReference type_arg in type_args) {
*/
using GLib;
+using Gee;
/**
* Represents an invocation expression in the source code.
public Expression! _call;
- private List<Expression> argument_list;
- private List<CCodeExpression> array_sizes;
+ private Gee.List<Expression> argument_list = new ArrayList<Expression> ();
+ private Gee.List<CCodeExpression> array_sizes = new ArrayList<CCodeExpression> ();
/**
* Creates a new invocation expression.
*
- * @param call method to call
- * @param source reference to source code
- * @return newly created invocation expression
+ * @param call method to call
+ * @param source_reference reference to source code
+ * @return newly created invocation expression
*/
- public InvocationExpression (Expression! _call, SourceReference source = null) {
- call = _call;
- source_reference = source;
+ public InvocationExpression (construct Expression! call, construct SourceReference source_reference = null) {
}
/**
* @param arg an argument
*/
public void add_argument (Expression! arg) {
- argument_list.append (arg);
+ argument_list.add (arg);
arg.parent_node = this;
}
*
* @return argument list
*/
- public List<weak Expression> get_argument_list () {
- return argument_list.copy ();
+ public Collection<Expression> get_argument_list () {
+ return new ReadOnlyCollection<Expression> (argument_list);
}
/**
* Add an array size C code expression.
*/
public void append_array_size (CCodeExpression! size) {
- array_sizes.append (size);
+ array_sizes.add (size);
}
/**
* Get the C code expression for array sizes for all dimensions
* ascending from left to right.
*/
- public List<weak CCodeExpression> get_array_sizes () {
- return array_sizes.copy ();
+ public Gee.List<CCodeExpression> get_array_sizes () {
+ return new ReadOnlyList<CCodeExpression> (array_sizes);
}
public override void accept (CodeVisitor! visitor) {
visitor.visit_begin_invocation_expression (this);
- // iterate over list copy as list may change in loop body
- foreach (Expression expr in argument_list.copy ()) {
+ foreach (Expression expr in argument_list) {
expr.accept (visitor);
}
call = (Expression) new_node;
}
- weak List<Expression> l = argument_list.find (old_node);
- if (l != null) {
- if (new_node.parent_node != null) {
- return;
- }
-
- argument_list.insert_before (l, new_node);
- argument_list.remove_link (l);
+ int index = argument_list.index_of (old_node);
+ if (index >= 0 && new_node.parent_node == null) {
+ argument_list[index] = (Expression) new_node;
new_node.parent_node = this;
}
}
*/
using GLib;
+using Gee;
/**
* Represents a possibly invokable code object.
*
* @return parameter list
*/
- public abstract List<weak FormalParameter> get_parameters ();
+ public abstract Collection<FormalParameter> get_parameters ();
}
*/
using GLib;
+using Gee;
/**
* Represents a lambda expression in the source code. Lambda expressions are
*/
public Method method { get; set; }
- private List<string> parameters;
+ private Gee.List<string> parameters = new ArrayList<string> ();
/**
* Creates a new lambda expression.
*
- * @param body expression body
- * @param source reference to source code
- * @return newly created lambda expression
+ * @param expression_body expression body
+ * @param source_reference reference to source code
+ * @return newly created lambda expression
*/
- public LambdaExpression (Expression! body, SourceReference source) {
- expression_body = body;
- source_reference = source;
+ public LambdaExpression (construct Expression! expression_body, construct SourceReference source_reference) {
}
/**
* Creates a new lambda expression with statement body.
*
- * @param body statement body
- * @param source reference to source code
- * @return newly created lambda expression
+ * @param statement_body statement body
+ * @param source_reference reference to source code
+ * @return newly created lambda expression
*/
- public LambdaExpression.with_statement_body (Block! body, SourceReference source) {
- statement_body = body;
- source_reference = source;
+ public LambdaExpression.with_statement_body (construct Block! statement_body, construct SourceReference source_reference) {
}
/**
* @param param parameter name
*/
public void add_parameter (string! param) {
- parameters.append (param);
+ parameters.add (param);
}
/**
*
* @return parameter list
*/
- public List<weak string> get_parameters () {
- return parameters.copy ();
+ public Collection<string> get_parameters () {
+ return new ReadOnlyCollection<string> (parameters);
}
public override void accept (CodeVisitor! visitor) {
*/
using GLib;
+using Gee;
/**
* Represents a local variable declaration in the source code.
*/
public TypeReference type_reference { get; set; }
- private List<VariableDeclarator> variable_declarators;
+ private Gee.List<VariableDeclarator> variable_declarators = new ArrayList<VariableDeclarator> ();
/**
* Creates a new local variable declaration.
*
- * @param type type of the variable
- * @param source reference to source code
- * @return newly created local variable declaration
+ * @param type_reference type of the variable
+ * @param source_reference reference to source code
+ * @return newly created local variable declaration
*/
- public LocalVariableDeclaration (TypeReference type, SourceReference source) {
- type_reference = type;
- source_reference = source;
+ public LocalVariableDeclaration (construct TypeReference type_reference, construct SourceReference source_reference) {
}
/**
* of the variable is inferred from the expression used to initialize
* the variable.
*
- * @param source reference to source code
- * @return newly created local variable declaration
+ * @param source_reference reference to source code
+ * @return newly created local variable declaration
*/
- public LocalVariableDeclaration.var_type (SourceReference source) {
- source_reference = source;
+ public LocalVariableDeclaration.var_type (construct SourceReference source_reference) {
}
/**
* @param declarator a variable declarator
*/
public void add_declarator (VariableDeclarator! declarator) {
- variable_declarators.append (declarator);
+ variable_declarators.add (declarator);
}
/**
*
* @return variable declarator list
*/
- public List<weak VariableDeclarator> get_variable_declarators () {
- return variable_declarators.copy ();
+ public Collection<VariableDeclarator> get_variable_declarators () {
+ return new ReadOnlyCollection<VariableDeclarator> (variable_declarators);
}
public override void accept (CodeVisitor! visitor) {
*/
using GLib;
+using Gee;
/**
* Represents a general class member.
*/
public class Vala.Member : Symbol {
- private List<string> cheader_filenames;
+ private Gee.List<string> cheader_filenames = new ArrayList<string> ();
public override void accept (CodeVisitor! visitor) {
visitor.visit_member (this);
}
-
- public override List<weak string> get_cheader_filenames () {
- if (cheader_filenames == null) {
+
+ public override Collection<string> get_cheader_filenames () {
+ if (cheader_filenames.size == 0) {
/* default to header filenames of the namespace */
foreach (string filename in parent_symbol.get_cheader_filenames ()) {
add_cheader_filename (filename);
}
- if (cheader_filenames == null && source_reference != null && !source_reference.file.pkg) {
+ if (cheader_filenames.size == 0 && source_reference != null && !source_reference.file.pkg) {
// don't add default include directives for VAPI files
- cheader_filenames.append (source_reference.file.get_cinclude_filename ());
+ cheader_filenames.add (source_reference.file.get_cinclude_filename ());
}
}
- return cheader_filenames.copy ();
+ return new ReadOnlyCollection<string> (cheader_filenames);
}
+
/**
* Adds a filename to the list of C header filenames users of this data
* @param filename a C header filename
*/
public void add_cheader_filename (string! filename) {
- cheader_filenames.append (filename);
+ cheader_filenames.add (filename);
}
}
*/
using GLib;
+using Gee;
/**
* Represents an access to a type member in the source code.
/**
* The name of the member.
*/
- public string! member_name { get; set construct; }
+ public string! member_name { get; set; }
private Expression _inner;
- private List<TypeReference> type_argument_list;
+ private Gee.List<TypeReference> type_argument_list = new ArrayList<TypeReference> ();
/**
* Creates a new member access expression.
*
- * @param inner parent of the member
- * @param member member name
- * @param source reference to source code
- * @return newly created member access expression
+ * @param inner parent of the member
+ * @param member_name member name
+ * @param source_reference reference to source code
+ * @return newly created member access expression
*/
- public MemberAccess (Expression _inner, string! member, SourceReference source = null) {
- inner = _inner;
- member_name = member;
- source_reference = source;
+ public MemberAccess (construct Expression inner, construct string! member_name, construct SourceReference source_reference = null) {
}
- public MemberAccess.simple (string! member, SourceReference source = null) {
- member_name = member;
- source_reference = source;
+ public MemberAccess.simple (construct string! member_name, construct SourceReference source_reference = null) {
}
/**
* @param arg a type reference
*/
public void add_type_argument (TypeReference! arg) {
- type_argument_list.append (arg);
+ type_argument_list.add (arg);
}
/**
*
* @return type argument list
*/
- public List<weak TypeReference> get_type_arguments () {
- return type_argument_list.copy ();
+ public Collection<TypeReference> get_type_arguments () {
+ return new ReadOnlyCollection<TypeReference> (type_argument_list);
}
public override void accept (CodeVisitor! visitor) {
*/
using GLib;
+using Gee;
/**
* Code visitor analyzing memory usage. The memory manager finds leaked and
public override void visit_end_invocation_expression (InvocationExpression! expr) {
var msym = (Invokable) expr.call.symbol_reference;
- List<weak FormalParameter> params = msym.get_parameters ();
+ Collection<FormalParameter> params = msym.get_parameters ();
- weak List<weak FormalParameter> params_it = params;
+ Iterator<FormalParameter> params_it = params.iterator ();
foreach (Expression arg in expr.get_argument_list ()) {
- if (params_it != null) {
- var param = (FormalParameter) params_it.data;
+ if (params_it.next ()) {
+ var param = params_it.get ();
if (!param.ellipsis
&& ((param.type_reference.data_type != null
&& param.type_reference.data_type.is_reference_type ())
} else {
visit_possibly_leaked_expression (arg);
}
-
- params_it = params_it.next;
} else {
visit_possibly_leaked_expression (arg);
}
}
var msym = (Invokable) expr.symbol_reference;
- List<weak FormalParameter> params = msym.get_parameters ();
+ Collection<FormalParameter> params = msym.get_parameters ();
- weak List<weak FormalParameter> params_it = params;
+ Iterator<FormalParameter> params_it = params.iterator ();
foreach (Expression arg in expr.get_argument_list ()) {
- if (params_it != null) {
- var param = (FormalParameter) params_it.data;
+ if (params_it.next ()) {
+ var param = params_it.get ();
if (!param.ellipsis
&& ((param.type_reference.data_type != null
&& param.type_reference.data_type.is_reference_type ())
} else {
visit_possibly_leaked_expression (arg);
}
-
- params_it = params_it.next;
} else {
visit_possibly_leaked_expression (arg);
}
*/
using GLib;
+using Gee;
/**
* Represents a type or namespace method.
public bool printf_format { get; set; }
private bool _instance = true;
- private List<FormalParameter> parameters;
+ private Gee.List<FormalParameter> parameters = new ArrayList<FormalParameter> ();
private string cname;
private bool _no_array_length;
- private List<TypeReference> error_domains;
- private List<string> cheader_filenames;
-
+ private Gee.List<TypeReference> error_domains = new ArrayList<TypeReference> ();
+
/**
* Creates a new method.
*
param.no_array_length = true;
}
- parameters.append (param);
+ parameters.add (param);
if (!param.ellipsis) {
scope.add (param.name, param);
}
}
- public List<weak FormalParameter> get_parameters () {
- return parameters.copy ();
+ public Collection<FormalParameter> get_parameters () {
+ return new ReadOnlyCollection<FormalParameter> (parameters);
}
public TypeReference get_return_type () {
return false;
}
- var method_params = m2.get_parameters ();
- weak List<weak FormalParameter> method_params_it = method_params;
+ Iterator<FormalParameter> method_params_it = m2.get_parameters ().iterator ();
foreach (FormalParameter param in parameters) {
/* method may not expect less arguments */
- if (method_params_it == null) {
+ if (!method_params_it.next ()) {
return false;
}
- var method_param = (FormalParameter) method_params_it.data;
- if (!method_param.type_reference.equals (param.type_reference)) {
+ if (!method_params_it.get ().type_reference.equals (param.type_reference)) {
return false;
}
-
- method_params_it = method_params_it.next;
}
/* method may not expect more arguments */
- if (method_params_it != null) {
+ if (method_params_it.next ()) {
return false;
}
* @param error_domain an error domain
*/
public void add_error_domain (TypeReference! error_domain) {
- error_domains.append (error_domain);
+ error_domains.add (error_domain);
}
/**
*
* @return list of error domains
*/
- public List<weak TypeReference> get_error_domains () {
- return error_domains.copy ();
+ public Collection<TypeReference> get_error_domains () {
+ return new ReadOnlyCollection<TypeReference> (error_domains);
}
}
*/
using GLib;
+using Gee;
/**
* Represents a namespace declaration in the source code.
*/
public bool pkg { get; set; }
- private List<Class> classes;
- private List<Interface> interfaces;
- private List<Struct> structs;
- private List<Enum> enums;
- private List<Callback> callbacks;
- private List<Constant> constants;
- private List<Field> fields;
- private List<Method> methods;
+ private Gee.List<Class> classes = new ArrayList<Class> ();
+ private Gee.List<Interface> interfaces = new ArrayList<Interface> ();
+ private Gee.List<Struct> structs = new ArrayList<Struct> ();
+ private Gee.List<Enum> enums = new ArrayList<Enum> ();
+ private Gee.List<Callback> callbacks = new ArrayList<Callback> ();
+ private Gee.List<Constant> constants = new ArrayList<Constant> ();
+ private Gee.List<Field> fields = new ArrayList<Field> ();
+ private Gee.List<Method> methods = new ArrayList<Method> ();
private string cprefix;
private string lower_case_cprefix;
- private List<string> cheader_filenames;
+ private Gee.List<string> cheader_filenames = new ArrayList<string> ();
- private List<Namespace> namespaces;
+ private Gee.List<Namespace> namespaces = new ArrayList<Namespace> ();
/**
* Creates a new namespace.
*
- * @param name namespace name
- * @param source reference to source code
- * @return newly created namespace
+ * @param name namespace name
+ * @param source_reference reference to source code
+ * @return newly created namespace
*/
public Namespace (construct string name, construct SourceReference source_reference = null) {
}
* @param ns a namespace
*/
public void add_namespace (Namespace! ns) {
- namespaces.append (ns);
+ namespaces.add (ns);
scope.add (ns.name, ns);
}
*
* @return namespace list
*/
- public List<weak Namespace> get_namespaces () {
- return namespaces.copy ();
+ public Collection<Namespace> get_namespaces () {
+ return new ReadOnlyCollection<Namespace> (namespaces);
}
/**
* @param cl a class
*/
public void add_class (Class! cl) {
- classes.append (cl);
+ classes.add (cl);
scope.add (cl.name, cl);
}
* @param iface an interface
*/
public void add_interface (Interface! iface) {
- interfaces.append (iface);
+ interfaces.add (iface);
scope.add (iface.name, iface);
}
* @param st a struct
*/
public void add_struct (Struct! st) {
- structs.append (st);
+ structs.add (st);
scope.add (st.name, st);
}
* @param en an enum
*/
public void add_enum (Enum! en) {
- enums.append (en);
+ enums.add (en);
scope.add (en.name, en);
}
* @param cb a callback
*/
public void add_callback (Callback! cb) {
- callbacks.append (cb);
+ callbacks.add (cb);
scope.add (cb.name, cb);
}
*
* @return struct list
*/
- public List<weak Struct> get_structs () {
- return structs.copy ();
+ public Collection<Struct> get_structs () {
+ return new ReadOnlyCollection<Struct> (structs);
}
/**
*
* @return class list
*/
- public List<weak Class> get_classes () {
- return classes.copy ();
+ public Collection<Class> get_classes () {
+ return new ReadOnlyCollection<Class> (classes);
}
/**
*
* @return interface list
*/
- public List<weak Interface> get_interfaces () {
- return interfaces.copy ();
+ public Collection<Interface> get_interfaces () {
+ return new ReadOnlyCollection<Interface> (interfaces);
}
/**
* @param constant a constant
*/
public void add_constant (Constant! constant) {
- constants.append (constant);
+ constants.add (constant);
scope.add (constant.name, constant);
}
* @param f a field
*/
public void add_field (Field! f) {
- fields.append (f);
+ fields.add (f);
scope.add (f.name, f);
}
return;
}
- methods.append (m);
+ methods.add (m);
scope.add (m.name, m);
}
this.lower_case_cprefix = cprefix;
}
- public override List<weak string> get_cheader_filenames () {
- return cheader_filenames.copy ();
+ public override Collection<string> get_cheader_filenames () {
+ return new ReadOnlyCollection<string> (cheader_filenames);
}
/**
* @param cheader_filename header filename
*/
public void set_cheader_filename (string! cheader_filename) {
- cheader_filenames = null;
- cheader_filenames.append (cheader_filename);
+ cheader_filenames = new ArrayList<string> ();
+ cheader_filenames.add (cheader_filename);
}
private void process_ccode_attribute (Attribute! a) {
if (a.has_argument ("cheader_filename")) {
var val = a.get_string ("cheader_filename");
foreach (string filename in val.split (",")) {
- cheader_filenames.append (filename);
+ cheader_filenames.add (filename);
}
}
}
*/
using GLib;
+using Gee;
/**
* Represents an object creation expression in the source code.
*/
public MemberAccess member_name { get; set; }
- private List<Expression> argument_list;
+ private Gee.List<Expression> argument_list = new ArrayList<Expression> ();
/**
* Creates a new object creation expression.
*
- * @param type object type to create
- * @param source reference to source code
- * @return newly created object creation expression
+ * @param member_name object type to create
+ * @param source_reference reference to source code
+ * @return newly created object creation expression
*/
- public ObjectCreationExpression (MemberAccess! name, SourceReference source) {
- member_name = name;
- source_reference = source;
+ public ObjectCreationExpression (construct MemberAccess! member_name, construct SourceReference source_reference) {
}
/**
* @param arg an argument
*/
public void add_argument (Expression! arg) {
- argument_list.append (arg);
+ argument_list.add (arg);
arg.parent_node = this;
}
*
* @return argument list
*/
- public List<weak Expression> get_argument_list () {
- return argument_list.copy ();
+ public Collection<Expression> get_argument_list () {
+ return new ReadOnlyCollection<Expression> (argument_list);
}
public override void accept (CodeVisitor! visitor) {
visitor.visit_begin_object_creation_expression (this);
- // iterate over list copy as list may change in loop body
- foreach (Expression arg in argument_list.copy ()) {
+ foreach (Expression arg in argument_list) {
arg.accept (visitor);
}
}
public override void replace (CodeNode! old_node, CodeNode! new_node) {
- weak List<Expression> l = argument_list.find (old_node);
- if (l != null) {
- if (new_node.parent_node != null) {
- return;
- }
-
- argument_list.insert_before (l, new_node);
- argument_list.remove_link (l);
+ int index = argument_list.index_of (old_node);
+ if (index >= 0 && new_node.parent_node == null) {
+ argument_list[index] = (Expression) new_node;
new_node.parent_node = this;
}
}
*/
using GLib;
+using Gee;
/**
* Represents a pointer-type.
/**
* The type to which this pointer type points.
*/
- public DataType! referent_type { get; set construct; }
+ public weak DataType! referent_type { get; set construct; }
private string cname;
return null;
}
- public override List<weak string> get_cheader_filenames () {
+ public override Collection<string> get_cheader_filenames () {
return referent_type.get_cheader_filenames ();
}
*/
using GLib;
+using Gee;
/**
* Represents a part of the symbol tree.
*/
public weak Scope parent_scope { get; set; }
- private HashTable<string,Symbol> symbol_table;
+ private Map<string,Symbol> symbol_table;
/**
* Creates a new scope.
public void add (string name, Symbol! sym) {
if (name != null) {
if (symbol_table == null) {
- symbol_table = new HashTable.full (str_hash, str_equal, g_free, g_object_unref);
+ symbol_table = new HashMap<string,Symbol> (str_hash, str_equal);
} else if (lookup (name) != null) {
owner.error = true;
Report.error (owner.source_reference, "`%s' already contains a definition for `%s'".printf (owner.get_full_name (), name));
return;
}
- symbol_table.insert (name, sym);
+ symbol_table[name] = sym;
}
sym.owner = this;
}
if (symbol_table == null) {
return null;
}
- Symbol sym = symbol_table.lookup (name);
+ Symbol sym = symbol_table[name];
if (sym != null && !sym.active) {
sym = null;
}
*/
using GLib;
+using Gee;
/**
* Code visitor analyzing and checking code.
Class current_class;
Struct current_struct;
- List<weak NamespaceReference> current_using_directives;
+ Collection<NamespaceReference> current_using_directives;
TypeReference bool_type;
TypeReference string_type;
cl.accept_children (this);
/* gather all prerequisites */
- List<DataType> prerequisites = null;
+ Gee.List<DataType> prerequisites = new ArrayList<DataType> ();
foreach (TypeReference base_type in cl.get_base_types ()) {
if (base_type.data_type is Interface) {
- prerequisites.concat (get_all_prerequisites ((Interface) base_type.data_type));
+ get_all_prerequisites ((Interface) base_type.data_type, prerequisites);
}
}
/* check whether all prerequisites are met */
- List<string> missing_prereqs = null;
+ Gee.List<string> missing_prereqs = new ArrayList<string> ();
foreach (DataType prereq in prerequisites) {
if (!class_is_a (cl, prereq)) {
- missing_prereqs.prepend (prereq.get_full_name ());
+ missing_prereqs.insert (0, prereq.get_full_name ());
}
}
/* report any missing prerequisites */
- if (missing_prereqs != null) {
+ if (missing_prereqs.size > 0) {
cl.error = true;
string error_string = "%s: some prerequisites (".printf (cl.get_full_name ());
current_class = null;
}
- private List<DataType> get_all_prerequisites (Interface! iface) {
- List<DataType> ret = null;
-
+ private void get_all_prerequisites (Interface! iface, Collection<DataType> list) {
foreach (TypeReference prereq in iface.get_prerequisites ()) {
DataType type = prereq.data_type;
/* skip on previous errors */
continue;
}
- ret.prepend (type);
+ list.add (type);
if (type is Interface) {
- ret.concat (get_all_prerequisites ((Interface) type));
+ get_all_prerequisites ((Interface) type, list);
}
}
-
- ret.reverse ();
- return #ret;
}
private bool class_is_a (Class! cl, DataType! t) {
* @param expr an array creation expression
*/
public override void visit_end_array_creation_expression (ArrayCreationExpression! expr) {
- int i;
- List<weak Expression> size = expr.get_sizes ();
+ Collection<Expression> size = expr.get_sizes ();
/* check for errors in the size list */
if (size != null) {
expr.static_type.floating_reference = false;
}
- private DataType find_parent_type (Symbol sym) {
- while (sym != null) {
- if (sym is DataType) {
- return (DataType) sym;
- }
- sym = sym.parent_symbol;
- }
- return null;
- }
-
public override void visit_member_access (MemberAccess! expr) {
Symbol base_symbol = null;
return;
}
- List<weak FormalParameter> params;
+ Collection<FormalParameter> params;
if (msym is Invokable) {
var m = (Invokable) msym;
}
var args = expr.get_argument_list ();
- weak List<weak Expression> arg_it = args;
+ Iterator<Expression> arg_it = args.iterator ();
foreach (FormalParameter param in params) {
if (param.ellipsis) {
break;
}
- if (arg_it != null) {
- var arg = (Expression) arg_it.data;
+ if (arg_it.next ()) {
+ Expression arg = arg_it.get ();
/* store expected type for callback parameters */
arg.expected_type = param.type_reference;
-
- arg_it = arg_it.next;
}
}
}
- private bool check_arguments (Expression! expr, Symbol! msym, List<FormalParameter> params, List<Expression> args) {
- weak List<weak Expression> prev_arg_it = null;
- weak List<weak Expression> arg_it = args;
+ private bool check_arguments (Expression! expr, Symbol! msym, Collection<FormalParameter> params, Collection<Expression> args) {
+ Expression prev_arg = null;
+ Iterator<Expression> arg_it = args.iterator ();
bool diag = (msym.get_attribute ("Diagnostics") != null);
current_source_file.add_symbol_dependency (param.type_reference.data_type, SourceFileDependencyType.SOURCE);
}
- if (arg_it == null) {
+ if (!arg_it.next ()) {
if (param.default_expression == null) {
expr.error = true;
- Report.error (expr.source_reference, "Too few arguments, method `%s' does not take %d arguments".printf (msym.get_full_name (), args.length ()));
+ Report.error (expr.source_reference, "Too few arguments, method `%s' does not take %d arguments".printf (msym.get_full_name (), args.size));
return false;
}
} else {
- var arg = (Expression) arg_it.data;
+ var arg = arg_it.get ();
if (arg.static_type == null) {
// disallow untyped arguments except for type inference of callbacks
if (!(param.type_reference.data_type is Callback)) {
return false;
}
- prev_arg_it = arg_it;
- arg_it = arg_it.next;
+ prev_arg = arg;
i++;
}
}
- if (!ellipsis && arg_it != null) {
+ if (!ellipsis && arg_it.next ()) {
expr.error = true;
- Report.error (expr.source_reference, "Too many arguments, method `%s' does not take %d arguments".printf (msym.get_full_name (), args.length ()));
+ Report.error (expr.source_reference, "Too many arguments, method `%s' does not take %d arguments".printf (msym.get_full_name (), args.size));
return false;
}
- if (diag && prev_arg_it != null) {
- var format_arg = (Expression) prev_arg_it.data;
+ if (diag && prev_arg != null) {
+ var format_arg = prev_arg;
if (format_arg is LiteralExpression) {
var format_lit = (StringLiteral) ((LiteralExpression) format_arg).literal;
format_lit.value = "\"%s:%d: %s".printf (expr.source_reference.file.filename, expr.source_reference.first_line, format_lit.value.offset (1));
var msym = expr.call.symbol_reference;
TypeReference ret_type;
- List<weak FormalParameter> params;
+ Collection<FormalParameter> params;
if (msym is Invokable) {
var m = (Invokable) msym;
if (msym is Method) {
var m = (Method) msym;
- expr.tree_can_fail = expr.can_fail = (m.get_error_domains ().length () > 0);
+ expr.tree_can_fail = expr.can_fail = (m.get_error_domains ().size > 0);
}
expr.static_type = ret_type;
TypeReference instance_type = derived_instance_type;
// trace type arguments back to the datatype where the method has been declared
while (instance_type.data_type != generic_member.parent_symbol) {
- List<weak TypeReference> base_types = null;
+ Collection<TypeReference> base_types = null;
if (instance_type.data_type is Class) {
var cl = (Class) instance_type.data_type;
base_types = cl.get_base_types ();
node_reference.error = true;
return null;
}
- type_arg = instance_type.get_type_arguments ().nth_data (param_index);
+ type_arg = instance_type.get_type_arguments ().get (param_index);
}
instance_base_type.add_type_argument (type_arg);
}
node_reference.error = true;
return null;
}
- var actual_type = (TypeReference) instance_type.get_type_arguments ().nth_data (param_index);
+ var actual_type = (TypeReference) instance_type.get_type_arguments ().get (param_index);
if (actual_type == null) {
Report.error (node_reference.source_reference, "internal error: no actual argument found for type parameter %s".printf (generic_type.type_parameter.name));
node_reference.error = true;
if (container_type is Array) {
var args = expr.container.static_type.get_type_arguments ();
- if (args.length () != 1) {
+ if (args.size != 1) {
expr.error = true;
- Report.error (expr.source_reference, "internal error: array reference with %d type arguments, expected 1".printf (args.length ()));
+ Report.error (expr.source_reference, "internal error: array reference with %d type arguments, expected 1".printf (args.size));
return;
}
- expr.static_type = (TypeReference) args.data;
+ expr.static_type = args.get (0);
} else if (container_type == string_type.data_type) {
- if (expr.get_indices ().length () != 1) {
+ if (expr.get_indices ().size != 1) {
expr.error = true;
Report.error (expr.source_reference, "Element access with more than one dimension is not supported for strings");
return;
} else if (container_type != null && list_type != null && map_type != null &&
(container_type == list_type || container_type.is_subtype_of (list_type) ||
container_type == map_type || container_type.is_subtype_of (map_type))) {
- List<weak Expression> indices = expr.get_indices ();
- if (indices.length () != 1) {
+ Collection<Expression> indices = expr.get_indices ();
+ if (indices.size != 1) {
expr.error = true;
Report.error (expr.source_reference, "Element access with more than one dimension is not supported for the specified type");
return;
}
- var index = (Expression) indices.data;
+ Iterator<Expression> indices_it = indices.iterator ();
+ indices_it.next ();
+ var index = indices_it.get ();
index_int_type_check = false;
var get_sym = container_type.scope.lookup ("get");
return;
}
var get_method = (Method) get_sym;
- List<weak FormalParameter> get_params = get_method.get_parameters ();
- var get_param = (FormalParameter) get_params.data;
+ Collection<FormalParameter> get_params = get_method.get_parameters ();
+ Iterator<FormalParameter> get_params_it = get_params.iterator ();
+ get_params_it.next ();
+ var get_param = get_params_it.get ();
var index_type = get_param.type_reference;
if (index_type.type_parameter != null) {
expr.error = true;
Report.error (expr.source_reference, "Base access invalid outside of class and struct");
return;
- } else if (current_struct.get_base_types ().length () != 1) {
+ } else if (current_struct.get_base_types ().size != 1) {
expr.error = true;
- Report.error (expr.source_reference, "Base access invalid without base type %d".printf (current_struct.get_base_types ().length ()));
+ Report.error (expr.source_reference, "Base access invalid without base type %d".printf (current_struct.get_base_types ().size));
return;
}
- expr.static_type = current_struct.get_base_types ().first ().data;
+ Iterator<TypeReference> base_type_it = current_struct.get_base_types ().iterator ();
+ base_type_it.next ();
+ expr.static_type = base_type_it.get ();
} else {
expr.static_type = new TypeReference ();
expr.static_type.data_type = current_class.base_class;
}
}
- if (expr.symbol_reference == null && expr.get_argument_list ().length () != 0) {
+ if (expr.symbol_reference == null && expr.get_argument_list ().size != 0) {
expr.static_type = null;
expr.error = true;
Report.error (expr.source_reference, "No arguments allowed when constructing type `%s'".printf (type.get_full_name ()));
var m = (Method) expr.symbol_reference;
check_arguments (expr, m, m.get_parameters (), expr.get_argument_list ());
- expr.tree_can_fail = expr.can_fail = (m.get_error_domains ().length () > 0);
+ expr.tree_can_fail = expr.can_fail = (m.get_error_domains ().size > 0);
} else if (type is Enum) {
- if (expr.get_argument_list ().length () == 0) {
+ if (expr.get_argument_list ().size == 0) {
expr.error = true;
Report.error (expr.source_reference, "Too few arguments, errors need at least 1 argument");
} else {
- var ex = (Expression) expr.get_argument_list ().data;
+ Iterator<Expression> arg_it = expr.get_argument_list ().iterator ();
+ arg_it.next ();
+ var ex = arg_it.get ();
if (ex.static_type == null || !is_type_compatible (ex.static_type, string_type)) {
expr.error = true;
Report.error (expr.source_reference, "Invalid type for argument 1");
expr.static_type = bool_type;
}
- private TypeReference compute_common_base_type (List<TypeReference> types) {
+ private TypeReference compute_common_base_type (Collection<TypeReference> types) {
bool null_found = false;
bool class_or_iface_found = false;
bool type_param_found = false;
}
/* FIXME: support memory management */
- List<TypeReference> types;
- types.append (expr.true_expression.static_type);
- types.append (expr.false_expression.static_type);
+ Gee.List<TypeReference> types = new ArrayList<TypeReference> ();
+ types.add (expr.true_expression.static_type);
+ types.add (expr.false_expression.static_type);
expr.static_type = compute_common_base_type (types);
}
l.method.owner = current_symbol.scope;
var lambda_params = l.get_parameters ();
- weak List<weak FormalParameter> lambda_param_it = lambda_params;
+ Iterator<string> lambda_param_it = lambda_params.iterator ();
foreach (FormalParameter cb_param in cb.get_parameters ()) {
- if (lambda_param_it == null) {
+ if (!lambda_param_it.next ()) {
/* lambda expressions are allowed to have less parameters */
break;
}
- var lambda_param = (string) lambda_param_it.data;
+ string lambda_param = lambda_param_it.get ();
var param = new FormalParameter (lambda_param, cb_param.type_reference);
l.method.add_parameter (param);
-
- lambda_param_it = lambda_param_it.next;
}
- if (lambda_param_it != null) {
+ if (lambda_param_it.next ()) {
/* lambda expressions may not expect more parameters */
l.error = true;
Report.error (l.source_reference, "lambda expression: too many parameters");
/* rhs transfers ownership of the expression */
var args = ea.container.static_type.get_type_arguments ();
- if (args.length () != 1) {
+ if (args.size != 1) {
a.error = true;
Report.error (ea.source_reference, "internal error: array reference without type arguments");
return;
}
- var element_type = (TypeReference) args.data;
+ var element_type = args.get (0);
if (!element_type.takes_ownership) {
/* lhs doesn't own the value */
*/
using GLib;
+using Gee;
/**
* Represents an object signal. Signals enable objects to provide notifications.
*/
public bool has_emitter { get; set; }
- private List<FormalParameter> parameters;
+ private Gee.List<FormalParameter> parameters = new ArrayList<FormalParameter> ();
private Callback generated_callback;
private string cname;
* @param param a formal parameter
*/
public void add_parameter (FormalParameter! param) {
- parameters.append (param);
+ parameters.add (param);
scope.add (param.name, param);
}
- public List<weak FormalParameter> get_parameters () {
- return parameters.copy ();
+ public Collection<FormalParameter> get_parameters () {
+ return new ReadOnlyCollection<FormalParameter> (parameters);
}
public TypeReference get_return_type () {
*/
using GLib;
+using Gee;
/**
* Represents a Vala source or VAPI package file.
*/
public weak CodeContext context { get; set; }
- private List<NamespaceReference> using_directives;
+ private Gee.List<NamespaceReference> using_directives = new ArrayList<NamespaceReference> ();
- private List<CodeNode> nodes;
+ private Gee.List<CodeNode> nodes = new ArrayList<CodeNode> ();
private string cheader_filename = null;
private string csource_filename = null;
private string cinclude_filename = null;
- private List<string> header_external_includes;
- private List<string> header_internal_includes;
- private List<string> source_external_includes;
- private List<string> source_internal_includes;
+ private Gee.List<string> header_external_includes = new ArrayList<string> ();
+ private Gee.List<string> header_internal_includes = new ArrayList<string> ();
+ private Gee.List<string> source_external_includes = new ArrayList<string> ();
+ private Gee.List<string> source_internal_includes = new ArrayList<string> ();
- private List<weak SourceFile> header_internal_full_dependencies;
- private List<weak SourceFile> header_internal_dependencies;
+ private Gee.List<weak SourceFile> header_internal_full_dependencies = new ArrayList<weak SourceFile> ();
+ private Gee.List<weak SourceFile> header_internal_dependencies = new ArrayList<weak SourceFile> ();
/**
* Creates a new source file.
* @param ns reference to namespace
*/
public void add_using_directive (NamespaceReference! ns) {
- using_directives.append (ns);
+ using_directives.add (ns);
}
/**
*
* @return using directive list
*/
- public List<weak NamespaceReference> get_using_directives () {
- return using_directives.copy ();
+ public Collection<NamespaceReference> get_using_directives () {
+ return new ReadOnlyCollection<NamespaceReference> (using_directives);
}
/**
* @param node a code node
*/
public void add_node (CodeNode! node) {
- nodes.append (node);
- }
-
- /**
- * Removes the specified code node from this source file.
- *
- * @param node a code node
- */
- public void remove_node (CodeNode! node) {
- nodes.remove (node);
+ nodes.add (node);
}
/**
*
* @return code node list
*/
- public List<weak CodeNode> get_nodes () {
- return nodes.copy ();
+ public Collection<CodeNode> get_nodes () {
+ return new ReadOnlyCollection<CodeNode> (nodes);
}
public void accept (CodeVisitor! visitor) {
* @param dep_type type of dependency
*/
public void add_symbol_dependency (Symbol! sym, SourceFileDependencyType dep_type) {
+ if (pkg) {
+ return;
+ }
+
Symbol s;
if (sym is DataType ||
if (dep_type == SourceFileDependencyType.SOURCE) {
if (s.source_reference.file.pkg) {
foreach (string fn in s.get_cheader_filenames ()) {
- source_external_includes.append (fn);
+ source_external_includes.add (fn);
}
} else {
foreach (string fn in s.get_cheader_filenames ()) {
- source_internal_includes.append (fn);
+ source_internal_includes.add (fn);
}
}
return;
if (s.source_reference.file.pkg) {
/* external package */
foreach (string fn in s.get_cheader_filenames ()) {
- header_external_includes.append (fn);
+ header_external_includes.add (fn);
}
return;
}
if (dep_type == SourceFileDependencyType.HEADER_FULL || (s is DataType && !((DataType)s).is_reference_type ())) {
foreach (string fn in s.get_cheader_filenames ()) {
- header_internal_includes.append (fn);
+ header_internal_includes.add (fn);
}
- header_internal_full_dependencies.append (s.source_reference.file);
+ header_internal_full_dependencies.add (s.source_reference.file);
}
- header_internal_dependencies.append (s.source_reference.file);
+ header_internal_dependencies.add (s.source_reference.file);
}
/**
*
* @return external include list for C header file
*/
- public weak List<string> get_header_external_includes () {
- return header_external_includes;
+ public Collection<string> get_header_external_includes () {
+ return new ReadOnlyCollection<string> (header_external_includes);
}
/**
public void add_header_internal_include (string! include) {
/* skip includes to self */
if (include != get_cinclude_filename ()) {
- header_internal_includes.append (include);
+ header_internal_includes.add (include);
}
}
*
* @return internal include list for C header file
*/
- public weak List<string> get_header_internal_includes () {
- return header_internal_includes;
+ public Collection<string> get_header_internal_includes () {
+ return new ReadOnlyCollection<string> (header_internal_includes);
}
/**
*
* @return include list for C source file
*/
- public weak List<string> get_source_external_includes () {
- return source_external_includes;
+ public Collection<string> get_source_external_includes () {
+ return new ReadOnlyCollection<string> (source_external_includes);
}
/**
*
* @return include list for C source file
*/
- public weak List<string> get_source_internal_includes () {
- return source_internal_includes;
+ public Collection<string> get_source_internal_includes () {
+ return new ReadOnlyCollection<string> (source_internal_includes);
}
/**
*
* @return definite source file dependencies
*/
- public weak List<SourceFile> get_header_internal_full_dependencies () {
- return header_internal_full_dependencies;
+ public Collection<weak SourceFile> get_header_internal_full_dependencies () {
+ return new ReadOnlyCollection<weak SourceFile> (header_internal_full_dependencies);
}
/**
*
* @return loose source file dependencies
*/
- public weak List<SourceFile> get_header_internal_dependencies () {
- return header_internal_dependencies;
+ public Collection<weak SourceFile> get_header_internal_dependencies () {
+ return new ReadOnlyCollection<weak SourceFile> (header_internal_dependencies);
}
}
/* valasourcefilecycle.vala
*
- * Copyright (C) 2006 Jürg Billeter
+ * Copyright (C) 2006-2007 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
*/
using GLib;
+using Gee;
/**
* Represents a dependency cycle of source files.
/**
* The members of this source file cycle.
*/
- public List<weak SourceFile> files;
+ public Gee.List<weak SourceFile> files = new ArrayList<weak SourceFile> ();
/**
* The head of this source file cycle.
*/
using GLib;
+using Gee;
/**
* Represents a struct declaration in the source code.
*/
public class Vala.Struct : DataType {
- private List<TypeParameter> type_parameters;
- private List<Constant> constants;
- private List<Field> fields;
- private List<Method> methods;
+ private Gee.List<TypeParameter> type_parameters = new ArrayList<TypeParameter> ();
+ private Gee.List<Constant> constants = new ArrayList<Constant> ();
+ private Gee.List<Field> fields = new ArrayList<Field> ();
+ private Gee.List<Method> methods = new ArrayList<Method> ();
- private List<TypeReference> base_types;
+ private Gee.List<TypeReference> base_types = new ArrayList<TypeReference> ();
private string cname;
private string const_cname;
/**
* Creates a new struct.
*
- * @param name type name
- * @param source reference to source code
- * @return newly created struct
+ * @param name type name
+ * @param source_reference reference to source code
+ * @return newly created struct
*/
- public Struct (string! _name, SourceReference source = null) {
- name = _name;
- source_reference = source;
+ public Struct (construct string! name, construct SourceReference source_reference = null) {
}
/**
* @param p a type parameter
*/
public void add_type_parameter (TypeParameter! p) {
- type_parameters.append (p);
+ type_parameters.add (p);
p.type = this;
scope.add (p.name, p);
}
* @param c a constant
*/
public void add_constant (Constant! c) {
- constants.append (c);
+ constants.add (c);
scope.add (c.name, c);
}
* @param f a field
*/
public void add_field (Field! f) {
- fields.append (f);
+ fields.add (f);
scope.add (f.name, f);
}
*
* @return list of fields
*/
- public List<weak Field> get_fields () {
- return fields.copy ();
+ public Collection<Field> get_fields () {
+ return new ReadOnlyCollection<Field> (fields);
}
/**
default_construction_method = m;
}
- methods.append (m);
+ methods.add (m);
scope.add (m.name, m);
}
*
* @return list of methods
*/
- public List<weak Method> get_methods () {
- return methods.copy ();
+ public Collection<Method> get_methods () {
+ return new ReadOnlyCollection<Method> (methods);
}
public override void accept (CodeVisitor! visitor) {
* @param type a class or interface reference
*/
public void add_base_type (TypeReference! type) {
- base_types.append (type);
+ base_types.add (type);
}
/**
*
* @return list of base types
*/
- public List<weak TypeReference> get_base_types () {
- return base_types.copy ();
+ public Collection<TypeReference> get_base_types () {
+ return new ReadOnlyCollection<TypeReference> (base_types);
}
public override int get_type_parameter_index (string! name) {
*/
using GLib;
+using Gee;
/**
* Represents a switch section in the source code.
*/
public class Vala.SwitchSection : CodeNode {
- private List<SwitchLabel> labels;
- private List<Statement> statement_list;
+ private Gee.List<SwitchLabel> labels = new ArrayList<SwitchLabel> ();
+ private Gee.List<Statement> statement_list = new ArrayList<Statement> ();
/**
* Creates a new switch section.
*
- * @param source reference to source code
- * @return newly created switch section
+ * @param source_reference reference to source code
+ * @return newly created switch section
*/
- public SwitchSection (SourceReference source) {
- source_reference = source;
+ public SwitchSection (construct SourceReference source_reference) {
}
/**
* @param label a switch label
*/
public void add_label (SwitchLabel! label) {
- labels.append (label);
+ labels.add (label);
}
/**
*
* @return switch label list
*/
- public List<weak SwitchLabel> get_labels () {
- return labels.copy ();
+ public Collection<SwitchLabel> get_labels () {
+ return new ReadOnlyCollection<SwitchLabel> (labels);
}
public bool has_default_label () {
* @param stmt a statement
*/
public void add_statement (Statement! stmt) {
- statement_list.append (stmt);
+ statement_list.add (stmt);
}
/**
*
* @return statement list
*/
- public List<weak Statement> get_statements () {
- return statement_list.copy ();
+ public Collection<Statement> get_statements () {
+ return new ReadOnlyCollection<Statement> (statement_list);
}
public override void accept (CodeVisitor! visitor) {
*/
using GLib;
+using Gee;
/**
* Represents a switch selection statement in the source code.
}
private Expression! _expression;
- private List<SwitchSection> sections;
+ private Gee.List<SwitchSection> sections = new ArrayList<SwitchSection> ();
/**
* Creates a new switch statement.
*
- * @param expr switch expression
- * @param source reference to source code
- * @return newly created switch statement
+ * @param expression switch expression
+ * @param source_reference reference to source code
+ * @return newly created switch statement
*/
- public SwitchStatement (Expression! expr, SourceReference source) {
- expression = expr;
- source_reference = source;
+ public SwitchStatement (construct Expression! expression, construct SourceReference source_reference) {
}
/**
* @param section a switch section
*/
public void add_section (SwitchSection! section) {
- sections.append (section);
+ sections.add (section);
}
/**
*
* @return section list
*/
- public List<weak SwitchSection> get_sections () {
- return sections.copy ();
+ public Collection<SwitchSection> get_sections () {
+ return new ReadOnlyCollection<SwitchSection> (sections);
}
public override void accept (CodeVisitor! visitor) {
*/
using GLib;
+using Gee;
/**
* Represents a node in the symbol tree.
get { return _scope; }
}
- private Scope _owner;
+ private weak Scope _owner;
private Scope _scope;
construct {
*
* @return list of C header filenames for this symbol
*/
- public virtual List<weak string> get_cheader_filenames () {
- return null;
+ public virtual Collection<string> get_cheader_filenames () {
+ return new ReadOnlyCollection<string> ();
}
/**
*/
using GLib;
+using Gee;
/**
* Code visitor resolving symbol names.
public class Vala.SymbolResolver : CodeVisitor {
Symbol root_symbol;
Scope current_scope;
- List<weak NamespaceReference> current_using_directives;
+ Collection<NamespaceReference> current_using_directives;
Class object_class;
*/
using GLib;
+using Gee;
/**
* Represents a try statement in the source code.
/**
* Specifies the body of the try statement.
*/
- public Block! body { get; set construct; }
+ public Block! body { get; set; }
/**
* Specifies the body of the optional finally clause.
*/
public Block finally_body { get; set; }
- private List<CatchClause> catch_clauses;
+ private Gee.List<CatchClause> catch_clauses = new ArrayList<CatchClause> ();
/**
* Creates a new try statement.
* @param clause a catch clause
*/
public void add_catch_clause (CatchClause! clause) {
- catch_clauses.append (clause);
+ catch_clauses.add (clause);
}
/**
*
* @return list of catch clauses
*/
- public List<weak CatchClause> get_catch_clauses () {
- return catch_clauses.copy ();
+ public Collection<CatchClause> get_catch_clauses () {
+ return new ReadOnlyCollection<CatchClause> (catch_clauses);
}
public override void accept (CodeVisitor! visitor) {
*/
using GLib;
+using Gee;
/**
* Represents a generic type parameter in the source code.
public weak DataType type;
/* holds the array types of this type; each rank is a separate one */
- /* FIXME: uses string because int does not work as key yet */
- private HashTable<string,Array> array_types = new HashTable.full (str_hash, str_equal, g_free, g_object_unref);
+ private Map<int,Array> array_types;
/**
* Creates a new generic type parameter.
* @return array type for this type parameter
*/
public Array! get_array (int rank) {
- Array array_type = (Array) array_types.lookup (rank.to_string ());
-
+ Array array_type = null;
+
+ if (array_types != null) {
+ array_type = array_types[rank];
+ }
+
if (array_type == null) {
+ if (array_types == null) {
+ array_types = new HashMap<int,Array> ();
+ }
+
var new_array_type = new Array.with_type_parameter (this, rank, source_reference);
parent_symbol.scope.add (new_array_type.name, new_array_type);
/* link the array type to the same source as the container type */
new_array_type.source_reference = this.source_reference;
- array_types.insert (rank.to_string (), new_array_type);
+ array_types[rank] = new_array_type;
array_type = new_array_type;
}
*/
using GLib;
+using Gee;
/**
* A reference to a data type. This is used to specify static types of
*/
public bool is_weak { get; set; }
- private List<TypeReference> type_argument_list;
+ private ArrayList<TypeReference> type_argument_list = new ArrayList<TypeReference> ();
public TypeReference () {
}
* @param arg a type reference
*/
public void add_type_argument (TypeReference! arg) {
- type_argument_list.append (arg);
+ type_argument_list.add (arg);
}
/**
*
* @return type argument list
*/
- public List<weak TypeReference> get_type_arguments () {
- return type_argument_list.copy ();
+ public Gee.List<TypeReference> get_type_arguments () {
+ return new ReadOnlyList<TypeReference> (type_argument_list);
}
/**
* Removes all generic type arguments.
*/
public void remove_all_type_arguments () {
- type_argument_list = null;
+ type_argument_list.clear ();
}
public override void accept (CodeVisitor! visitor) {
- foreach (TypeReference type_arg in type_argument_list) {
- type_arg.accept (visitor);
+ if (((Gee.List<TypeReference>) type_argument_list).size > 0) {
+ foreach (TypeReference type_arg in type_argument_list) {
+ type_arg.accept (visitor);
+ }
}
visitor.visit_type_reference (this);
result.is_weak = is_weak;
foreach (TypeReference arg in type_argument_list) {
- result.type_argument_list.append (arg.copy ());
+ result.type_argument_list.add (arg.copy ());
}
return result;
*/
using GLib;
+using Gee;
/**
* Represents a variable declarator in the source code.
visitor.visit_variable_declarator (this);
}
- public List<weak FormalParameter> get_parameters () {
+ public Collection<FormalParameter> get_parameters () {
if (!is_invokable ()) {
return null;
}
[CCode (cprefix = "G", lower_case_cprefix = "g_")]
namespace GLib {
- [CCode (cprefix = "G_DIRECTORY_MONITOR_EVENT_", cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cprefix = "G_DIRECTORY_MONITOR_EVENT_", cheader_filename = "gio/gvfs.h,glib.h")]
public enum DirectoryMonitorEvent {
CHANGED,
DELETED,
ATTRIBUTE_CHANGED,
UNMOUNTED,
}
- [CCode (cprefix = "G_FILE_ATTRIBUTE_TYPE_", cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cprefix = "G_FILE_ATTRIBUTE_TYPE_", cheader_filename = "gio/gvfs.h,glib.h")]
public enum FileAttributeType {
INVALID,
STRING,
UINT64,
INT64,
}
- [CCode (cprefix = "G_FILE_COPY_", cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cprefix = "G_FILE_COPY_", cheader_filename = "gio/gvfs.h,glib.h")]
public enum FileCopyFlags {
OVERWRITE,
BACKUP,
}
- [CCode (cprefix = "G_FILE_FLAG_", cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cprefix = "G_FILE_FLAG_", cheader_filename = "gio/gvfs.h,glib.h")]
public enum FileFlags {
HIDDEN,
SYMLINK,
LOCAL,
VIRTUAL,
}
- [CCode (cprefix = "G_FILE_GET_INFO_NOFOLLOW_", cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cprefix = "G_FILE_GET_INFO_NOFOLLOW_", cheader_filename = "gio/gvfs.h,glib.h")]
public enum FileGetInfoFlags {
SYMLINKS,
}
- [CCode (cprefix = "G_FILE_MONITOR_EVENT_", cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cprefix = "G_FILE_MONITOR_EVENT_", cheader_filename = "gio/gvfs.h,glib.h")]
public enum FileMonitorEvent {
CHANGED,
DELETED,
ATTRIBUTE_CHANGED,
UNMOUNTED,
}
- [CCode (cprefix = "G_FILE_TYPE_", cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cprefix = "G_FILE_TYPE_", cheader_filename = "gio/gvfs.h,glib.h")]
public enum FileType {
UNKNOWN,
REGULAR,
SHORTCUT,
MOUNTABLE,
}
- [CCode (cprefix = "G_IO_ERROR_", cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cprefix = "G_IO_ERROR_", cheader_filename = "gio/gvfs.h,glib.h")]
public enum IOErrorEnum {
FAILED,
NOT_FOUND,
WRONG_MTIME,
TIMED_OUT,
}
- [CCode (cprefix = "G_PASSWORD_FLAGS_", cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cprefix = "G_PASSWORD_FLAGS_", cheader_filename = "gio/gvfs.h,glib.h")]
public enum PasswordFlags {
NEED_PASSWORD,
NEED_USERNAME,
SAVING_SUPPORTED,
ANON_SUPPORTED,
}
- [CCode (cprefix = "G_PASSWORD_SAVE_", cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cprefix = "G_PASSWORD_SAVE_", cheader_filename = "gio/gvfs.h,glib.h")]
public enum PasswordSave {
NEVER,
FOR_SESSION,
PERMANENTLY,
}
- [CCode (cprefix = "G_UNIX_MOUNT_TYPE_", cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cprefix = "G_UNIX_MOUNT_TYPE_", cheader_filename = "gio/gvfs.h,glib.h")]
public enum UnixMountType {
UNKNOWN,
FLOPPY,
CAMERA,
HD,
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class BufferedInputStream : GLib.FilterInputStream {
public static GLib.Type get_type ();
public BufferedInputStream (GLib.InputStream base_stream);
[NoAccessorMethod]
public weak uint buffer_size { get; construct; }
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class BufferedOutputStream : GLib.FilterOutputStream {
public static GLib.Type get_type ();
public BufferedOutputStream (GLib.OutputStream base_stream);
[NoAccessorMethod]
public weak uint buffer_size { get; construct; }
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class Cancellable : GLib.Object {
public void cancel ();
public int get_fd ();
public void reset ();
public signal void cancelled ();
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class DesktopAppInfo : GLib.Object, GLib.AppInfo {
public static GLib.Type get_type ();
public DesktopAppInfo (string desktop_id);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class DirectoryMonitor : GLib.Object {
public virtual bool cancel ();
public void emit_event (GLib.File child, GLib.File other_file, GLib.DirectoryMonitorEvent event_type);
public void set_rate_limit (int limit_msecs);
public signal void changed (GLib.File child, GLib.File other_file, GLib.DirectoryMonitorEvent event_type);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class FileEnumerator : GLib.Object {
public static GLib.Type get_type ();
public bool has_pending ();
public virtual bool stop (GLib.Cancellable cancellable, GLib.Error error);
public virtual void stop_async (int io_priority, GLib.AsyncStopEnumeratingCallback callback, pointer user_data, GLib.Cancellable cancellable);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class FileIcon : GLib.Object, GLib.Icon, GLib.LoadableIcon {
public weak GLib.File get_file ();
public static GLib.Type get_type ();
public FileIcon (GLib.File file);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class FileInfo : GLib.Object {
public weak GLib.FileInfo copy ();
public weak string get_attribute_as_string (string attribute);
public void set_size (int64 size);
public void set_symlink_target (string symlink_target);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class FileInputStream : GLib.InputStream, GLib.Seekable {
public virtual weak GLib.FileInfo get_file_info (string attributes, GLib.Cancellable cancellable, GLib.Error error);
public static GLib.Type get_type ();
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class FileMonitor : GLib.Object {
public virtual bool cancel ();
public static weak GLib.DirectoryMonitor directory (GLib.File file);
public void set_rate_limit (int limit_msecs);
public signal void changed (GLib.File file, GLib.File other_file, GLib.FileMonitorEvent event_type);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class FileOutputStream : GLib.OutputStream {
public virtual weak GLib.FileInfo get_file_info (string attributes, GLib.Cancellable cancellable, GLib.Error error);
public void get_final_mtime (GLib.TimeVal mtime);
public void set_final_mtime (GLib.TimeVal final_mtime);
public void set_should_get_final_mtime (bool get_final_mtime);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class FilterInputStream : GLib.InputStream {
public weak GLib.InputStream get_base_stream ();
public static GLib.Type get_type ();
[NoAccessorMethod]
public weak GLib.InputStream base_stream { get; construct; }
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class FilterOutputStream : GLib.OutputStream {
public weak GLib.OutputStream get_base_stream ();
public static GLib.Type get_type ();
[NoAccessorMethod]
public weak GLib.OutputStream base_stream { get; construct; }
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class InputStream : GLib.Object {
public virtual bool close (GLib.Cancellable cancellable, GLib.Error error);
public virtual void close_async (int io_priority, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
public virtual void skip_async (ulong count, int io_priority, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
public virtual long skip_finish (GLib.AsyncResult result, GLib.Error error);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class LocalDirectoryMonitor : GLib.DirectoryMonitor {
public static GLib.Type get_type ();
public static weak GLib.DirectoryMonitor start (string dirname);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class LocalFile : GLib.Object, GLib.File {
public static GLib.Type get_type ();
public static weak GLib.FileInfo info_get (string basename, string path, GLib.FileAttributeMatcher attribute_matcher, GLib.FileGetInfoFlags flags, GLib.LocalParentFileInfo parent_info, GLib.Error error);
public static void info_get_parent_info (string dir, GLib.FileAttributeMatcher attribute_matcher, GLib.LocalParentFileInfo parent_info);
public LocalFile (string filename);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class LocalFileEnumerator : GLib.FileEnumerator {
public static GLib.Type get_type ();
public LocalFileEnumerator (string filename, string attributes, GLib.FileGetInfoFlags flags, GLib.Cancellable cancellable, GLib.Error error);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class LocalFileInputStream : GLib.FileInputStream {
public static GLib.Type get_type ();
public LocalFileInputStream (int fd);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class LocalFileMonitor : GLib.FileMonitor {
public static GLib.Type get_type ();
public static weak GLib.FileMonitor start (string dirname);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class LocalFileOutputStream : GLib.FileOutputStream {
public static weak GLib.FileOutputStream append (string filename, GLib.Cancellable cancellable, GLib.Error error);
public static weak GLib.FileOutputStream create (string filename, GLib.Cancellable cancellable, GLib.Error error);
public static GLib.Type get_type ();
public static weak GLib.FileOutputStream replace (string filename, ulong mtime, bool make_backup, GLib.Cancellable cancellable, GLib.Error error);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class LocalVfs : GLib.Object, GLib.Vfs {
public static GLib.Type get_type ();
public LocalVfs ();
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class MemoryInputStream : GLib.InputStream, GLib.Seekable {
public static weak GLib.InputStream from_data (pointer data, ulong len);
public static GLib.Type get_type ();
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class MemoryOutputStream : GLib.OutputStream, GLib.Seekable {
public static GLib.Type get_type ();
public MemoryOutputStream (GLib.ByteArray data);
[NoAccessorMethod]
public weak uint size_limit { get; set; }
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class MountOperation : GLib.Object {
public bool get_anonymous ();
public int get_choice ();
[HasEmitter]
public signal void reply (bool abort);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class OutputStream : GLib.Object {
public virtual bool close (GLib.Cancellable cancellable, GLib.Error error);
public virtual void close_async (int io_priority, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
public virtual void write_async (pointer buffer, ulong count, int io_priority, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
public virtual long write_finish (GLib.AsyncResult result, GLib.Error error);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class SimpleAsyncResult : GLib.Object, GLib.AsyncResult {
public void complete ();
public void complete_in_idle ();
public void set_op_res_gpointer (pointer op_res, GLib.DestroyNotify destroy_op_res);
public void set_op_res_gssize (long op_res);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class SocketInputStream : GLib.InputStream {
public static GLib.Type get_type ();
public SocketInputStream (int fd, bool close_fd_at_close);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class SocketOutputStream : GLib.OutputStream {
public static GLib.Type get_type ();
public SocketOutputStream (int fd, bool close_fd_at_close);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class ThemedIcon : GLib.Object, GLib.Icon {
public weak string get_names ();
public static GLib.Type get_type ();
public ThemedIcon (string iconname);
public ThemedIcon.from_names (string iconnames);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class UnionDrive : GLib.Object, GLib.Drive {
public bool child_is_for_monitor (GLib.VolumeMonitor child_monitor);
public static GLib.Type get_type ();
public bool is_for_child_drive (GLib.Drive child_drive);
public UnionDrive (GLib.VolumeMonitor union_monitor, GLib.Drive child_drive, GLib.VolumeMonitor child_monitor);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class UnionVolume : GLib.Object, GLib.Volume {
public void add_volume (GLib.Volume volume, GLib.VolumeMonitor monitor);
public weak GLib.Volume get_child_for_monitor (GLib.VolumeMonitor child_monitor);
public UnionVolume (GLib.VolumeMonitor union_monitor, GLib.Volume volume, GLib.VolumeMonitor monitor);
public void remove_volume (GLib.Volume volume);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class UnionVolumeMonitor : GLib.VolumeMonitor {
public weak GLib.Drive convert_drive (GLib.Drive child_drive);
public weak GLib.List convert_volumes (GLib.List child_volumes);
public static GLib.Type get_type ();
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class UnixDrive : GLib.Object, GLib.Drive {
public void disconnected ();
public static GLib.Type get_type ();
public void set_volume (GLib.UnixVolume volume);
public void unset_volume (GLib.UnixVolume volume);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class UnixVolume : GLib.Object, GLib.Volume {
public static GLib.Type get_type ();
public bool has_mountpoint (string mountpoint);
public void unmounted ();
public void unset_drive (GLib.UnixDrive drive);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class UnixVolumeMonitor : GLib.VolumeMonitor {
public static GLib.Type get_type ();
public weak GLib.UnixDrive lookup_drive_for_mountpoint (string mountpoint);
public UnixVolumeMonitor ();
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class VolumeMonitor : GLib.Object {
public virtual weak GLib.List get_connected_drives ();
public virtual weak GLib.List get_mounted_volumes ();
public signal void drive_connected (GLib.Drive drive);
public signal void drive_disconnected (GLib.Drive drive);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public class Win32AppInfo : GLib.Object, GLib.AppInfo {
public static GLib.Type get_type ();
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public interface AppInfo {
public static weak GLib.AppInfo create_from_commandline (string commandline, string application_name, GLib.Error error);
public virtual weak GLib.AppInfo dup ();
public virtual bool supports_uris ();
public virtual bool supports_xdg_startup_notify ();
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public interface AsyncResult {
public virtual weak GLib.Object get_source_object ();
public static GLib.Type get_type ();
public virtual pointer get_user_data ();
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public interface Drive {
public virtual bool can_eject ();
public virtual bool can_mount ();
public virtual void unmount_mountable (GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
public virtual bool unmount_mountable_finish (GLib.AsyncResult result, GLib.Error error);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public interface Icon {
public virtual bool equal (GLib.Icon icon2);
public static GLib.Type get_type ();
public static uint hash (pointer icon);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public interface LoadableIcon {
public static GLib.Type get_type ();
public virtual weak GLib.InputStream load (int size, string type, GLib.Cancellable cancellable, GLib.Error error);
public virtual void load_async (int size, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
public virtual weak GLib.InputStream load_finish (GLib.AsyncResult res, string type, GLib.Error error);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public interface Seekable {
public virtual bool can_seek ();
public virtual bool can_truncate ();
public virtual int64 tell ();
public virtual bool truncate (int64 offset, GLib.Cancellable cancellable, GLib.Error err);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public interface Vfs {
public static weak GLib.Vfs get ();
public virtual weak GLib.File get_file_for_path (string path);
public static GLib.Type get_type ();
public virtual weak GLib.File parse_name (string parse_name);
}
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public interface Volume {
public virtual bool can_eject ();
public virtual bool can_unmount ();
public signal void changed ();
}
[ReferenceType]
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public struct AsyncResultData {
public pointer async_object;
public weak GLib.Error error;
public pointer user_data;
}
[ReferenceType]
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public struct FileAttributeMatcher {
public bool enumerate_namespace (string @namespace);
public weak string enumerate_next ();
public FileAttributeMatcher (string attributes);
}
[ReferenceType]
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public struct IOJob {
public void send_to_mainloop (GLib.IODataFunc func, pointer user_data, GLib.DestroyNotify notify, bool block);
}
[ReferenceType]
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public struct LocalParentFileInfo {
public bool writable;
public bool is_sticky;
public int owner;
}
[ReferenceType]
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public struct UnixMount {
public weak string mount_path;
public weak string device_path;
public bool is_read_only;
}
[ReferenceType]
- [CCode (cheader_filename = "gio/gvfs.h, glib.h")]
+ [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
public struct UnixMountPoint {
public weak string mount_path;
public weak string device_path;
public static delegate Gst.IteratorResult IteratorNextFunction (Gst.Iterator it, pointer result);
public static delegate void IteratorResyncFunction (Gst.Iterator it);
public static delegate void LogFunction (Gst.DebugCategory category, Gst.DebugLevel level, string file, string function, int line, GLib.Object object, Gst.DebugMessage message, pointer data);
- public static delegate Gst.MiniObject MiniObjectCopyFunction (Gst.MiniObject obj);
+ public static delegate weak Gst.MiniObject MiniObjectCopyFunction (Gst.MiniObject obj);
public static delegate void MiniObjectFinalizeFunction (Gst.MiniObject obj);
public static delegate bool PadAcceptCapsFunction (Gst.Pad pad, Gst.Caps caps);
public static delegate bool PadActivateFunction (Gst.Pad pad);
public static delegate bool PadDispatcherFunction (Gst.Pad pad, pointer data);
public static delegate bool PadEventFunction (Gst.Pad pad, Gst.Event event);
public static delegate void PadFixateCapsFunction (Gst.Pad pad, Gst.Caps caps);
- public static delegate Gst.Caps PadGetCapsFunction (Gst.Pad pad);
+ public static delegate weak Gst.Caps PadGetCapsFunction (Gst.Pad pad);
public static delegate Gst.FlowReturn PadGetRangeFunction (Gst.Pad pad, uint64 offset, uint length, Gst.Buffer buffer);
- public static delegate GLib.List PadIntLinkFunction (Gst.Pad pad);
+ public static delegate weak GLib.List PadIntLinkFunction (Gst.Pad pad);
public static delegate Gst.PadLinkReturn PadLinkFunction (Gst.Pad pad, Gst.Pad peer);
public static delegate bool PadQueryFunction (Gst.Pad pad, Gst.Query query);
public static delegate bool PadSetCapsFunction (Gst.Pad pad, Gst.Caps caps);
public static delegate int ValueCompareFunc (GLib.Value value1, GLib.Value value2);
public static delegate bool ValueDeserializeFunc (GLib.Value dest, string s);
public static delegate bool ValueIntersectFunc (GLib.Value dest, GLib.Value value1, GLib.Value value2);
- public static delegate string ValueSerializeFunc (GLib.Value value1);
+ public static delegate weak string ValueSerializeFunc (GLib.Value value1);
public static delegate bool ValueSubtractFunc (GLib.Value dest, GLib.Value minuend, GLib.Value subtrahend);
public static delegate bool ValueUnionFunc (GLib.Value dest, GLib.Value value1, GLib.Value value2);
public static void init (ref string[] args);
public signal void page_reordered (Gtk.Widget p0, uint p1);
public signal void page_removed (Gtk.Widget p0, uint p1);
public signal void page_added (Gtk.Widget p0, uint p1);
- public signal Gtk.Notebook create_window (Gtk.Widget page, int x, int y);
+ public signal weak Gtk.Notebook create_window (Gtk.Widget page, int x, int y);
}
[CCode (cheader_filename = "gtk/gtk.h")]
public class Object : GLib.InitiallyUnowned {
public signal void draw_page (Gtk.PrintContext context, int page_nr);
public signal void end_print (Gtk.PrintContext context);
public signal void status_changed ();
- public signal Gtk.Widget create_custom_widget ();
+ public signal weak Gtk.Widget create_custom_widget ();
public signal void custom_widget_apply (Gtk.Widget widget);
public signal bool preview (Gtk.PrintOperationPreview preview, Gtk.PrintContext context, Gtk.Window parent);
}
public weak int digits { get; set; }
public weak bool draw_value { get; set; }
public weak Gtk.PositionType value_pos { get; set; }
- public signal string format_value (double value);
+ public signal weak string format_value (double value);
}
[CCode (cheader_filename = "gtk/gtk.h")]
public class ScaleButton : Gtk.Button {
public static delegate void MnemonicHashForeach (uint keyval, GLib.SList targets, pointer data);
public static delegate void ModuleDisplayInitFunc (Gdk.Display display);
public static delegate void ModuleInitFunc (int argc, string argv);
- public static delegate Gtk.Notebook NotebookWindowCreationFunc (Gtk.Notebook source, Gtk.Widget page, int x, int y, pointer data);
+ public static delegate weak Gtk.Notebook NotebookWindowCreationFunc (Gtk.Notebook source, Gtk.Widget page, int x, int y, pointer data);
public static delegate void PageSetupDoneFunc (Gtk.PageSetup page_setup, pointer data);
public static delegate void PrintFunc (pointer func_data, string str);
public static delegate void PrintJobCompleteFunc (Gtk.PrintJob print_job, pointer user_data, GLib.Error error);
public static delegate uchar TextBufferSerializeFunc (Gtk.TextBuffer register_buffer, Gtk.TextBuffer content_buffer, out Gtk.TextIter start, out Gtk.TextIter end, ulong length, pointer user_data);
public static delegate bool TextCharPredicate (unichar ch, pointer user_data);
public static delegate void TextTagTableForeach (Gtk.TextTag tag, pointer data);
- public static delegate string TranslateFunc (string path, pointer func_data);
+ public static delegate weak string TranslateFunc (string path, pointer func_data);
public static delegate void TreeCellDataFunc (Gtk.TreeViewColumn tree_column, Gtk.CellRenderer cell, Gtk.TreeModel tree_model, out Gtk.TreeIter iter, pointer data);
public static delegate void TreeDestroyCountFunc (Gtk.TreeView tree_view, Gtk.TreePath path, int children, pointer user_data);
public static delegate int TreeIterCompareFunc (Gtk.TreeModel model, out Gtk.TreeIter a, out Gtk.TreeIter b, pointer user_data);
$(NULL)
vapigen.vala.stamp: $(filter %.vala,$(vapigen_SOURCES))
- $(VALAC) --vapidir $(srcdir)/../vapi --vapidir ../ccode --pkg ccode --vapidir ../vala --pkg vala --vapidir ../gobject-introspection --pkg gidl $^
+ $(VALAC) --vapidir $(srcdir)/../vapi --vapidir ../gee --pkg gee --vapidir ../ccode --pkg ccode --vapidir ../vala --pkg vala --vapidir ../gobject-introspection --pkg gidl $^
touch $@
vapigen_LDADD = \
*/
using GLib;
+using Gee;
/**
* Code visitor parsing all GIDL files.
private SourceReference current_source_reference;
private DataType current_data_type;
- private HashTable<string,string> codenode_attributes_map;
- private HashTable<string,string> current_type_symbol_map;
+ private Map<string,string> codenode_attributes_map;
+ private Gee.Set<string> current_type_symbol_set;
/**
* Parse all source files in the specified code context and build a
current_source_file = source_file;
- codenode_attributes_map = new HashTable.full (str_hash, str_equal, g_free, g_free);
+ codenode_attributes_map = new HashMap<string,string> (str_hash, str_equal);
if (FileUtils.test (metadata_filename, FileTest.EXISTS)) {
try {
continue;
}
- codenode_attributes_map.insert (line_parts[0], line_parts[1]);
+ codenode_attributes_map.set (line_parts[0], line_parts[1]);
}
} catch (FileError e) {
Report.error (null, "Unable to read metadata file: %s".printf (e.message));
current_data_type = cl;
- current_type_symbol_map = new HashTable<string,string>.full (str_hash, str_equal, g_free, g_free);
- var current_type_vfunc_map = new HashTable<string,string>.full (str_hash, str_equal, g_free, g_free);
+ current_type_symbol_set = new HashSet<string> (str_hash, str_equal);
+ var current_type_vfunc_map = new HashMap<string,string> (str_hash, str_equal);
foreach (weak IdlNode member in node.members) {
if (member.type == IdlNodeTypeId.VFUNC) {
- current_type_vfunc_map.insert (member.name, "1");
+ current_type_vfunc_map.set (member.name, "1");
}
}
foreach (weak IdlNode member in node.members) {
if (member.type == IdlNodeTypeId.FUNCTION) {
- bool is_virtual = current_type_vfunc_map.lookup (member.name) != null;
+ bool is_virtual = current_type_vfunc_map.get (member.name) != null;
var m = parse_function ((IdlNodeFunction) member, is_virtual);
if (m != null) {
foreach (weak IdlNode member in node.members) {
if (member.type == IdlNodeTypeId.FIELD) {
- if (current_type_symbol_map.lookup (member.name) == null) {
+ if (!current_type_symbol_set.contains (member.name)) {
var f = parse_field ((IdlNodeField) member);
if (f != null) {
cl.add_field (f);
foreach (Property prop in cl.get_properties ()) {
var getter = "get_%s".printf (prop.name);
- if (prop.get_accessor != null && current_type_symbol_map.lookup (getter) == null) {
+ if (prop.get_accessor != null && !current_type_symbol_set.contains (getter)) {
prop.no_accessor_method = true;
}
var setter = "set_%s".printf (prop.name);
- if (prop.set_accessor != null && current_type_symbol_map.lookup (setter) == null) {
+ if (prop.set_accessor != null && !current_type_symbol_set.contains (setter)) {
prop.no_accessor_method = true;
}
}
current_data_type = null;
- current_type_symbol_map = null;
+ current_type_symbol_set = null;
return cl;
}
current_data_type = iface;
- var current_type_vfunc_map = new HashTable<string,string>.full (str_hash, str_equal, g_free, g_free);
+ var current_type_vfunc_map = new HashMap<string,string> (str_hash, str_equal);
foreach (weak IdlNode member in node.members) {
if (member.type == IdlNodeTypeId.VFUNC) {
- current_type_vfunc_map.insert (member.name, "1");
+ current_type_vfunc_map.set (member.name, "1");
}
}
foreach (weak IdlNode member in node.members) {
if (member.type == IdlNodeTypeId.FUNCTION) {
- bool is_virtual = current_type_vfunc_map.lookup (member.name) != null;
+ bool is_virtual = current_type_vfunc_map.get (member.name) != null;
var m = parse_function ((IdlNodeFunction) member, is_virtual, true);
if (m != null) {
// GIDL generator can't provide array parameter information yet
m.no_array_length = true;
- if (current_type_symbol_map != null) {
- current_type_symbol_map.insert (node.name, "1");
+ if (current_type_symbol_set != null) {
+ current_type_symbol_set.add (node.name);
}
if (current_data_type != null) {
prop.access = MemberAccessibility.PUBLIC;
prop.interface_only = true;
- if (current_type_symbol_map != null) {
- current_type_symbol_map.insert (prop.name, "1");
+ if (current_type_symbol_set != null) {
+ current_type_symbol_set.add (prop.name);
}
return prop;
}
}
- if (current_type_symbol_map != null) {
- current_type_symbol_map.insert (node.name, "1");
+ if (current_type_symbol_set != null) {
+ current_type_symbol_set.add (node.name);
}
var field = new Field (node.name, type, null, current_source_reference);
[NoArrayLength]
private string[] get_attributes (string! codenode) {
- string attributes = codenode_attributes_map.lookup (codenode);
+ string attributes = codenode_attributes_map.get (codenode);
if (attributes == null) {
return null;
}
projects / thirdparty / vala.git / commitdiff
