valapointertype.vala 4.19 KB
Newer Older
1 2
/* valapointertype.vala
 *
Jürg Billeter's avatar
Jürg Billeter committed
3
 * Copyright (C) 2007-2009  Jürg Billeter
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 *
 * 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.1 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;

/**
 * A pointer type.
 */
public class Vala.PointerType : DataType {
	/**
	 * The base type the pointer is referring to.
	 */
32 33 34
	public DataType base_type {
		get { return _base_type; }
		set {
35
			_base_type = value;
36 37 38
			_base_type.parent_node = this;
		}
	}
39

40 41 42
	private DataType _base_type;

	public PointerType (DataType base_type, SourceReference? source_reference = null) {
43
		this.base_type = base_type;
44
		nullable = true;
45
		this.source_reference = source_reference;
46
	}
47

48 49
	public override string to_qualified_string (Scope? scope) {
		return base_type.to_qualified_string (scope) + "*";
50 51
	}

52
	public override DataType copy () {
53
		return new PointerType (base_type.copy ());
54 55
	}

56
	public override bool compatible (DataType target_type) {
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
		if (target_type is PointerType) {
			var tt = target_type as PointerType;

			if (tt.base_type is VoidType || base_type is VoidType) {
				return true;
			}

			/* dereference only if both types are references or not */
			if (base_type.is_reference_type_or_type_parameter () != tt.base_type.is_reference_type_or_type_parameter ()) {
				return false;
			}

			return base_type.compatible (tt.base_type);
		}

		if ((target_type.data_type != null && target_type.data_type.get_attribute ("PointerType") != null)) {
73 74 75 76
			return true;
		}

		/* temporarily ignore type parameters */
77
		if (target_type is GenericType) {
78 79 80
			return true;
		}

81 82
		if (base_type.is_reference_type_or_type_parameter ()) {
			// Object* is compatible with Object if Object is a reference type
83
			return base_type.compatible (target_type);
84 85
		}

86
		if (CodeContext.get ().profile == Profile.GOBJECT && target_type.data_type != null && target_type.data_type.is_subtype_of (CodeContext.get ().analyzer.gvalue_type.data_type)) {
87 88 89 90
			// allow implicit conversion to GValue
			return true;
		}

91 92
		return false;
	}
93

94
	public override Symbol? get_member (string member_name) {
Jürg Billeter's avatar
Jürg Billeter committed
95
		return null;
96 97
	}

98
	public override Symbol? get_pointer_member (string member_name) {
99 100 101 102 103 104 105 106
		Symbol base_symbol = base_type.data_type;

		if (base_symbol == null) {
			return null;
		}

		return SemanticAnalyzer.symbol_lookup_inherited (base_symbol, member_name);
	}
107

108 109
	public override bool is_accessible (Symbol sym) {
		return base_type.is_accessible (sym);
110
	}
111

112 113 114 115 116 117 118 119 120
	public override void accept_children (CodeVisitor visitor) {
		base_type.accept (visitor);
	}

	public override void replace_type (DataType old_type, DataType new_type) {
		if (base_type == old_type) {
			base_type = new_type;
		}
	}
121 122 123 124

	public override bool is_disposable () {
		return false;
	}
Jürg Billeter's avatar
Jürg Billeter committed
125

126
	public override DataType get_actual_type (DataType? derived_instance_type, List<DataType>? method_type_arguments, CodeNode node_reference) {
127 128
		PointerType result = (PointerType) this.copy ();

129
		if (derived_instance_type == null && method_type_arguments == null) {
130
			return result;
131 132 133
		}

		if (base_type is GenericType || base_type.has_type_arguments ()) {
134
			result.base_type = result.base_type.get_actual_type (derived_instance_type, method_type_arguments, node_reference);
135 136 137 138 139
		}

		return result;
	}

140 141 142 143 144 145 146 147 148
	public override DataType? infer_type_argument (TypeParameter type_param, DataType value_type) {
		var pointer_type = value_type as PointerType;
		if (pointer_type != null) {
			return base_type.infer_type_argument (type_param, pointer_type.base_type);
		}

		return null;
	}

149 150
	public override bool check (CodeContext context) {
		error = !base_type.check (context);
Jürg Billeter's avatar
Jürg Billeter committed
151 152
		return !error;
	}
153
}