+2007-08-30 Jürg Billeter <j@bitron.ch>
+
+ * vala/valasymbolresolver.vala, vala/valasemanticanalyzer.vala,
+ gobject/valacodegenerator.vala, gobject/valacodegeneratorclass.vala:
+ don't implicitly derive from GLib.Object in preparation for a more
+ consistent type system
+
+ * gee/arraylist.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,
+ vala/valabindingprovider.vala, vala/valacodecontext.vala,
+ vala/valacodenode.vala, vala/valacodevisitor.vala,
+ vala/valascope.vala, vala/valasourcefile.vala,
+ vala/valasourcefilecycle.vala, vala/valasourcereference.vala,
+ ccode/valaccodenode.vala, ccode/valaccodewriter.vala,
+ gobject/valaccodecompiler.vala, gobject/valadbusbindingprovider.vala,
+ gobject/valatyperegisterfunction.vala, compiler/valacompiler.vala,
+ tests/, vapigen/valavapigen.vala: derive all classes from GLib.Object
+
2007-08-30 Jürg Billeter <j@bitron.ch>
* vapi/libnotify.deps: add missing file
/**
* Represents a node in the C code tree.
*/
-public abstract class Vala.CCodeNode {
+public abstract class Vala.CCodeNode : Object {
/**
* The source file name and line number to be presumed for this code
* node.
/**
* Represents a writer to write C source files.
*/
-public class Vala.CCodeWriter {
+public class Vala.CCodeWriter : Object {
/**
* Specifies the file to be written.
*/
using GLib;
-class Vala.Compiler {
+class Vala.Compiler : Object {
static string directory;
static bool version;
[NoArrayLength ()]
/**
* Arrays of arbitrary elements which grow automatically as elements are added.
*/
-public class Gee.ArrayList<G> : Iterable<G>, Collection<G>, List<G> {
+public class Gee.ArrayList<G> : Object, Iterable<G>, Collection<G>, List<G> {
public int size {
get { return _size; }
}
_items.resize (value);
}
- private class Iterator<G> : Gee.Iterator<G> {
+ private class Iterator<G> : Object, Gee.Iterator<G> {
public ArrayList<G> list {
set {
_list = value;
/**
* Hashtable implementation of the Map interface.
*/
-public class Gee.HashMap<K,V> : Map<K,V> {
+public class Gee.HashMap<K,V> : Object, Map<K,V> {
public int size {
get { return _nnodes; }
}
}
}
- private class KeySet<K,V> : Iterable<K>, Collection<K>, Set<K> {
+ private class KeySet<K,V> : Object, Iterable<K>, Collection<K>, Set<K> {
public HashMap<K,V> map {
set { _map = value; }
}
}
}
- private class KeyIterator<K,V> : Iterator<K> {
+ private class KeyIterator<K,V> : Object, Iterator<K> {
public HashMap<K,V> map {
set {
_map = value;
}
}
- private class ValueCollection<K,V> : Iterable<V>, Collection<V> {
+ private class ValueCollection<K,V> : Object, Iterable<V>, Collection<V> {
public HashMap<K,V> map {
set { _map = value; }
}
}
}
- private class ValueIterator<K,V> : Iterator<V> {
+ private class ValueIterator<K,V> : Object, Iterator<V> {
public HashMap<K,V> map {
set {
_map = value;
/**
* Hashtable implementation of the Set interface.
*/
-public class Gee.HashSet<G> : Iterable<G>, Collection<G>, Set<G> {
+public class Gee.HashSet<G> : Object, Iterable<G>, Collection<G>, Set<G> {
public int size {
get { return _nnodes; }
}
}
}
- private class Iterator<G> : Gee.Iterator<G> {
+ private class Iterator<G> : Object, Gee.Iterator<G> {
public HashSet<G> set {
set {
_set = value;
* Implemented by classes that support a simple iteration over instances of the
* collection.
*/
-public interface Gee.Iterable<G> {
+public interface Gee.Iterable<G> : GLib.Object {
/**
* Returns a Iterator that can be used for simple iteration over a
* collection.
* Implemented by classes that support a simple iteration over instances of the
* collection.
*/
-public interface Gee.Iterator<G> {
+public interface Gee.Iterator<G> : GLib.Object {
/**
* Advances to the next element in the iteration.
*
/**
* Represents a collection of items in a well-defined order.
*/
-public interface Gee.List<G> : GLib.Object, Collection<G> {
+public interface Gee.List<G> : Collection<G> {
/**
* Returns the item at the specified index in this list.
*
/**
* A map is a generic collection of key/value pairs.
*/
-public interface Gee.Map<K,V> {
+public interface Gee.Map<K,V> : GLib.Object {
/**
* The number of items in this map.
*/
/**
* Represents a read-only collection of items.
*/
-public class Gee.ReadOnlyCollection<G> : Iterable<G>, Collection<G> {
+public class Gee.ReadOnlyCollection<G> : Object, Iterable<G>, Collection<G> {
public int size {
get { return _collection.size; }
}
assert_not_reached ();
}
- private class Iterator<G> : Gee.Iterator<G> {
+ private class Iterator<G> : Object, Gee.Iterator<G> {
public bool next () {
return false;
}
/**
* Represents a read-only collection of items in a well-defined order.
*/
-public class Gee.ReadOnlyList<G> : Iterable<G>, Collection<G>, List<G> {
+public class Gee.ReadOnlyList<G> : Object, Iterable<G>, Collection<G>, List<G> {
public int size {
get { return _list.size; }
}
assert_not_reached ();
}
- class Iterator<G> : Gee.Iterator<G> {
+ class Iterator<G> : Object, Gee.Iterator<G> {
public bool next () {
return false;
}
/**
* Represents a read-only collection of key/value pairs.
*/
-public class Gee.ReadOnlyMap<K,V> : Map<K,V> {
+public class Gee.ReadOnlyMap<K,V> : Object, Map<K,V> {
public int size {
get { return _map.size; }
}
/**
* Represents a read-only collection of items without duplicates.
*/
-public class Gee.ReadOnlySet<G> : Iterable<G>, Collection<G>, Set<G> {
+public class Gee.ReadOnlySet<G> : Object, Iterable<G>, Collection<G>, Set<G> {
public int size {
get { return _set.size; }
}
assert_not_reached ();
}
- private class Iterator<G> : Gee.Iterator<G> {
+ private class Iterator<G> : Object, Gee.Iterator<G> {
public bool next () {
return false;
}
/**
* Interface to the C compiler.
*/
-public class Vala.CCodeCompiler {
+public class Vala.CCodeCompiler : Object {
public CCodeCompiler () {
}
TypeReference string_type;
TypeReference float_type;
TypeReference double_type;
+ DataType gobject_type;
DataType gerror_type;
DataType glist_type;
DataType gslist_type;
var glib_ns = root_symbol.scope.lookup ("GLib");
+ gobject_type = (DataType) glib_ns.scope.lookup ("Object");
gerror_type = (DataType) glib_ns.scope.lookup ("Error");
glist_type = (DataType) glib_ns.scope.lookup ("List");
gslist_type = (DataType) glib_ns.scope.lookup ("SList");
decl_frag.append (new CCodeTypeDefinition ("struct %s".printf (type_struct.name), new CCodeVariableDeclarator ("%sClass".printf (cl.get_cname ()))));
}
decl_frag.append (new CCodeTypeDefinition ("struct %s".printf (instance_priv_struct.name), new CCodeVariableDeclarator ("%sPrivate".printf (cl.get_cname ()))));
-
- instance_struct.add_field (cl.base_class.get_cname (), "parent");
- instance_struct.add_field ("%sPrivate *".printf (cl.get_cname ()), "priv");
- type_struct.add_field ("%sClass".printf (cl.base_class.get_cname ()), "parent");
+
+ if (cl.is_subtype_of (gobject_type)) {
+ instance_struct.add_field (cl.base_class.get_cname (), "parent");
+ instance_struct.add_field ("%sPrivate *".printf (cl.get_cname ()), "priv");
+ type_struct.add_field ("%sClass".printf (cl.base_class.get_cname ()), "parent");
+ }
if (cl.source_reference.comment != null) {
def_frag.append (new CCodeComment (cl.source_reference.comment));
cl.accept_children (this);
- if (!cl.is_static) {
+ if (cl.is_subtype_of (gobject_type)) {
if (class_has_readable_properties (cl) || cl.get_type_parameters ().size > 0) {
add_get_property_function (cl);
}
/**
* Dynamic binding provider for DBus objects.
*/
-public class Vala.DBusBindingProvider : BindingProvider {
+public class Vala.DBusBindingProvider : Object, BindingProvider {
public CodeContext context {
set {
_context = value;
/**
* C function to register a type at runtime.
*/
-public abstract class Vala.TypeRegisterFunction {
+public abstract class Vala.TypeRegisterFunction : Object {
private CCodeFragment declaration_fragment = new CCodeFragment ();
private CCodeFragment definition_fragment = new CCodeFragment ();
using GLib;
namespace Maman {
- class Bar {
+ class Bar : Object {
static int main (string[] args) {
stdout.printf ("Class in Namespace Test\n");
return 0;
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
}
class Maman.SubBar : Bar {
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
public void do_action () {
stdout.printf (" 2");
}
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
public static void do_action () {
stdout.printf (" 2");
}
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
static int main (string[] args) {
stdout.printf ("For Test: 1");
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
public virtual void do_action () {
stdout.printf (" BAD");
}
using GLib;
-class Maman.Foo {
+class Maman.Foo : Object {
public int public_base_field = 2;
}
using GLib;
-class Maman.Foo {
+class Maman.Foo : Object {
private int _public_base_property = 2;
public int public_base_property {
get {
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
static int main (string[] args) {
stdout.printf ("Assignment Test: 1");
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
static int main (string[] args) {
stdout.printf ("Binary Expression Test: 1");
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
static int main (string[] args) {
stdout.printf ("Block Test: 1");
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
static int main (string[] args) {
stdout.printf ("Break Test: 1");
public static delegate int Maman.ActionCallback ();
-class Maman.Bar {
+class Maman.Bar : Object {
static int do_action () {
return 2;
}
static delegate int Maman.ActionCallback (int i);
-class Maman.Bar {
+class Maman.Bar : Object {
static int do_action (ActionCallback cb) {
return cb (1);
}
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
static int main (string[] args) {
stdout.printf ("Conditional Expression Test: 1");
using GLib;
-interface Maman.Ibaz {
+interface Maman.Ibaz : Object {
public abstract void do_action ();
}
-class Maman.Baz : Ibaz {
+class Maman.Baz : Object, Ibaz {
public void do_action () {
stdout.printf (" 2");
}
using GLib;
-class Maman.Foo {
+class Maman.Foo : Object {
public signal void activated (bool b);
public void do_action (bool b) {
}
}
-class Maman.Bar {
+class Maman.Bar : Object {
void activated (Foo foo, bool b) {
if (b) {
stdout.printf (" BAD");
using GLib;
-class Maman.Foo {
+class Maman.Foo : Object {
public void run () {
stdout.printf (" 2");
using GLib;
-class Maman.Foo {
+class Maman.Foo : Object {
public void run () {
stdout.printf (" 2");
using GLib;
-class Maman.Foo {
+class Maman.Foo : Object {
static int main (string[] args) {
stdout.printf ("String Test: 1");
using GLib;
-class Maman.Foo {
+class Maman.Foo : Object {
public Foo (construct string bar) {
}
using GLib;
-class Maman.Foo {
+class Maman.Foo : Object {
public void run () {
foreach (string s in create_list ()) {
stdout.printf (" %s", s);
using GLib;
-class Maman.Foo {
+class Maman.Foo : Object {
public signal void activated (int i1, int i2);
public void do_action () {
}
}
-class Maman.Bar {
+class Maman.Bar : Object {
public void run () {
stdout.printf (" 2");
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
public virtual void do_action () {
stdout.printf (" 3");
}
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
public void do_action () {
stdout.printf (" 3");
}
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
public int foo { get; set; }
public void run () {
VAL5 = 5
}
-class Maman.Bar {
+class Maman.Bar : Object {
public void run () {
stdout.printf (" %d", Foo.VAL2);
using GLib;
-class Maman.Foo {
+class Maman.Foo : Object {
public int p1 { get; set; }
public int p2 { get; set; }
using GLib;
-class Maman.Foo {
+class Maman.Foo : Object {
static void main (string[] args) {
stdout.printf (
"int8: %s...%s\n",
using GLib;
-class Maman.Foo {
+class Maman.Foo : Object {
const float[] FLOAT_TESTS = {
float.EPSILON, 0.0, 1.0,
-float.INFINITY,
using GLib;
-class Maman.Bar {
+class Maman.Bar : Object {
public int[] foo_numbers () {
return new int[3] { 2, 3, 4 };
}
LIST
}
-class Maman.Bar {
+class Maman.Bar : Object {
public void foo () throws BarError {
stdout.printf (" 6");
using GLib;
-class Maman.A {
+class Maman.A : Object {
}
class Maman.B : A {
}
-class Maman.C {
+class Maman.C : Object {
}
-class Maman.Bar {
+class Maman.Bar : Object {
static void main () {
var a = new A ();
var b = new B ();
using GLib;
-class SwitchTest {
+class SwitchTest : Object {
static void main () {
var foo = "Hello World";
var bar = 0;
using Enchant;
using GLib;
-class TestEnchant {
+class TestEnchant : Object {
static void info (string message) {
stdout.printf ("INFO: %s\n", message);
}
/**
* Interface for dynamic binding providers.
*/
-public interface Vala.BindingProvider {
+public interface Vala.BindingProvider : Object {
/**
* Return custom binding for the specified member access expression.
*
/**
* The root of the code tree.
*/
-public class Vala.CodeContext {
+public class Vala.CodeContext : Object {
/**
* Specifies the name of the library to be built.
*
* Code nodes get created by the parser and are used throughout the whole
* compilation process.
*/
-public abstract class Vala.CodeNode {
+public abstract class Vala.CodeNode : Object {
/**
* Parent of this code node.
*/
/**
* Abstract code node visitor for traversing source code tree.
*/
-public abstract class Vala.CodeVisitor {
+public abstract class Vala.CodeVisitor : Object {
/**
* Visit operation called for source files.
*
/**
* Represents a part of the symbol tree.
*/
-public class Vala.Scope {
+public class Vala.Scope : Object {
/**
* The symbol that owns this scope.
*/
}
}
- if (prereq_class == null) {
- /* default to GObject */
- var obj_type = new TypeReference ();
- obj_type.data_type = object_type;
- iface.prepend_prerequisite (obj_type);
- }
-
iface.accept_children (this);
current_symbol = current_symbol.parent_symbol;
/**
* Represents a Vala source or VAPI package file.
*/
-public class Vala.SourceFile {
+public class Vala.SourceFile : Object {
/**
* The name of this source file.
*/
/**
* Represents a dependency cycle of source files.
*/
-public class Vala.SourceFileCycle {
+public class Vala.SourceFileCycle : Object {
/**
* The members of this source file cycle.
*/
* Jürg Billeter <j@bitron.ch>
*/
+using GLib;
+
/**
* Represents a reference to a location in a source file.
*/
-public class Vala.SourceReference {
+public class Vala.SourceReference : Object {
/**
* The source file to be referenced.
*/
Scope current_scope;
Collection<NamespaceReference> current_using_directives;
- Class object_class;
-
/**
* Resolve symbol names in the specified code context.
*
public void resolve (CodeContext! context) {
root_symbol = context.root;
current_scope = root_symbol.scope;
-
- // TODO: don't require GLib namespace in symbol resolver
- var glib_ns = root_symbol.scope.lookup ("GLib");
- if (glib_ns != null) {
- object_class = (Class) glib_ns.scope.lookup ("Object");
- }
-
+
context.accept (this);
}
cl.base_class = (Class) type.data_type;
}
}
- if (cl.base_class == null && cl != object_class) {
- var object_type = new TypeReference ();
- object_type.data_type = object_class;
- cl.add_base_type (object_type);
- cl.base_class = object_class;
- }
-
+
current_scope = current_scope.parent_scope;
}
using GLib;
-class Vala.VAPIGen {
+class Vala.VAPIGen : Object {
static string directory;
static bool version;
[NoArrayLength ()]
projects / thirdparty / vala.git / commitdiff
