vala/valafield.vala

   1 /* valafield.vala
   2  *
   3  * Copyright (C) 2006-2010  Jürg Billeter
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Jürg Billeter <j@bitron.ch>
  21  */
  22
  23 using GLib;
  24
  25 /**
  26  * Represents a type or namespace field.
  27  */
  28 public class Vala.Field : Variable, Lockable {
  29         /**
  30          * Specifies whether this field may only be accessed with an instance of
  31          * the contained type.
  32          */
  33         public MemberBinding binding { get; set; default = MemberBinding.INSTANCE; }
  34
  35         /**
  36          * Specifies whether the field is volatile. Volatile fields are
  37          * necessary to allow multi-threaded access.
  38          */
  39         public bool is_volatile { get; set; }
  40
  41         /**
  42          * Specifies whether an array length field should implicitly be created
  43          * if the field type is an array.
  44          */
  45         public bool no_array_length { get; set; }
  46
  47         /**
  48          * Specifies whether a delegate target field should implicitly be created
  49          * if the field type is a delegate.
  50          */
  51         public bool no_delegate_target { get; set; }
  52
  53         /**
  54          * Specifies whether the array is null terminated.
  55          */
  56         public bool array_null_terminated { get; set; }
  57
  58         /**
  59          * Specifies whether the array length field uses a custom name in C.
  60          */
  61         public bool has_array_length_cname {
  62                 get { return (array_length_cname != null); }
  63         }
  64
  65         /**
  66          * Specifies whether the array uses a custom C expression as length.
  67          */
  68         public bool has_array_length_cexpr {
  69                 get { return (array_length_cexpr != null); }
  70         }
  71
  72         /**
  73          * Specifies a custom type for the array length.
  74          */
  75         public string? array_length_type { get; set; default = null; }
  76
  77         private string? array_length_cname;
  78
  79         private string? array_length_cexpr;
  80
  81         private string cname;
  82
  83         private bool lock_used = false;
  84
  85         /**
  86          * Creates a new field.
  87          *
  88          * @param name   field name
  89          * @param type   field type
  90          * @param init   initializer expression
  91          * @param source reference to source code
  92          * @return       newly created field
  93          */
  94         public Field (string name, DataType variable_type, Expression? initializer, SourceReference? source_reference = null, Comment? comment = null) {
  95                 base (variable_type, name, initializer, source_reference, comment);
  96         }
  97
  98         public override void accept (CodeVisitor visitor) {
  99                 visitor.visit_field (this);
 100         }
 101
 102         public override void accept_children (CodeVisitor visitor) {
 103                 variable_type.accept (visitor);
 104
 105                 if (initializer != null) {
 106                         initializer.accept (visitor);
 107                 }
 108         }
 109
 110         /**
 111          * Returns the name of this field as it is used in C code.
 112          *
 113          * @return the name to be used in C code
 114          */
 115         public string get_cname () {
 116                 if (cname == null) {
 117                         cname = get_default_cname ();
 118                 }
 119                 return cname;
 120         }
 121
 122         /**
 123          * Sets the name of this field as it is used in C code.
 124          *
 125          * @param cname the name to be used in C code
 126          */
 127         public void set_cname (string cname) {
 128                 this.cname = cname;
 129         }
 130
 131         /**
 132          * Returns the default name of this field as it is used in C code.
 133          *
 134          * @return the name to be used in C code by default
 135          */
 136         public string get_default_cname () {
 137                 if (binding == MemberBinding.STATIC) {
 138                         return parent_symbol.get_lower_case_cprefix () + name;
 139                 } else {
 140                         return name;
 141                 }
 142         }
 143
 144         /**
 145          * Returns the name of the array length field as it is used in C code
 146          *
 147          * @return the name of the array length field to be used in C code
 148          */
 149         public string? get_array_length_cname () {
 150                 return this.array_length_cname;
 151         }
 152
 153         /**
 154          * Sets the name of the array length field as it is used in C code
 155          *
 156          * @param array_length_cname the name of the array length field to be
 157          * used in C code
 158          */
 159         public void set_array_length_cname (string? array_length_cname) {
 160                 this.array_length_cname = array_length_cname;
 161         }
 162
 163         /**
 164          * Returns the array length expression as it is used in C code
 165          *
 166          * @return the array length expression to be used in C code
 167          */
 168         public string? get_array_length_cexpr () {
 169                 return this.array_length_cexpr;
 170         }
 171
 172
 173         /**
 174          * Sets the array length expression as it is used in C code
 175          *
 176          * @param array_length_cexpr the array length expression to be used in C
 177          * code
 178          */
 179         public void set_array_length_cexpr (string? array_length_cexpr) {
 180                 this.array_length_cexpr = array_length_cexpr;
 181         }
 182
 183         private void process_ccode_attribute (Attribute a) {
 184                 if (a.has_argument ("cname")) {
 185                         set_cname (a.get_string ("cname"));
 186                 }
 187                 if (a.has_argument ("cheader_filename")) {
 188                         var val = a.get_string ("cheader_filename");
 189                         foreach (string filename in val.split (",")) {
 190                                 add_cheader_filename (filename);
 191                         }
 192                 }
 193                 if (a.has_argument ("array_length")) {
 194                         no_array_length = !a.get_bool ("array_length");
 195                 }
 196                 if (a.has_argument ("array_null_terminated")) {
 197                         array_null_terminated = a.get_bool ("array_null_terminated");
 198                 }
 199                 if (a.has_argument ("array_length_cname")) {
 200                         set_array_length_cname (a.get_string ("array_length_cname"));
 201                 }
 202                 if (a.has_argument ("array_length_cexpr")) {
 203                         set_array_length_cexpr (a.get_string ("array_length_cexpr"));
 204                 }
 205                 if (a.has_argument ("array_length_type")) {
 206                         array_length_type = a.get_string ("array_length_type");
 207                 }
 208                 if (a.has_argument ("delegate_target")) {
 209                         no_delegate_target = !a.get_bool ("delegate_target");
 210                 }
 211         }
 212
 213         /**
 214          * Process all associated attributes.
 215          */
 216         public void process_attributes () {
 217                 foreach (Attribute a in attributes) {
 218                         if (a.name == "CCode") {
 219                                 process_ccode_attribute (a);
 220                         } else if (a.name == "Deprecated") {
 221                                 process_deprecated_attribute (a);
 222                         }
 223                 }
 224         }
 225
 226         public bool get_lock_used () {
 227                 return lock_used;
 228         }
 229
 230         public void set_lock_used (bool used) {
 231                 lock_used = used;
 232         }
 233
 234         public override void replace_expression (Expression old_node, Expression new_node) {
 235                 if (initializer == old_node) {
 236                         initializer = new_node;
 237                 }
 238         }
 239
 240         public override void replace_type (DataType old_type, DataType new_type) {
 241                 if (variable_type == old_type) {
 242                         variable_type = new_type;
 243                 }
 244         }
 245
 246         public string? get_ctype () {
 247                 var attr = get_attribute ("CCode");
 248                 if (attr == null) {
 249                         return null;
 250                 }
 251                 return attr.get_string ("type");
 252         }
 253
 254         public void set_ctype (string ctype) {
 255                 var attr = get_attribute ("CCode");
 256                 if (attr == null) {
 257                         attr = new Attribute ("CCode");
 258                         attributes.append (attr);
 259                 }
 260                 attr.add_argument ("type", new StringLiteral ("\"%s\"".printf (ctype)));
 261         }
 262
 263         public override bool check (SemanticAnalyzer analyzer) {
 264                 if (checked) {
 265                         return !error;
 266                 }
 267
 268                 checked = true;
 269
 270                 var old_source_file = analyzer.current_source_file;
 271                 var old_symbol = analyzer.current_symbol;
 272
 273                 if (source_reference != null) {
 274                         analyzer.current_source_file = source_reference.file;
 275                 }
 276                 analyzer.current_symbol = this;
 277
 278                 variable_type.check (analyzer);
 279
 280                 // check whether field type is at least as accessible as the field
 281                 if (!analyzer.is_type_accessible (this, variable_type)) {
 282                         error = true;
 283                         Report.error (source_reference, "field type `%s` is less accessible than field `%s`".printf (variable_type.to_string (), get_full_name ()));
 284                         return false;
 285                 }
 286
 287                 process_attributes ();
 288
 289                 if (initializer != null) {
 290                         initializer.target_type = variable_type;
 291
 292                         if (!initializer.check (analyzer)) {
 293                                 error = true;
 294                                 return false;
 295                         }
 296
 297                         if (initializer.value_type == null) {
 298                                 error = true;
 299                                 Report.error (source_reference, "expression type not allowed as initializer");
 300                                 return false;
 301                         }
 302
 303                         if (!initializer.value_type.compatible (variable_type)) {
 304                                 error = true;
 305                                 Report.error (source_reference, "Cannot convert from `%s' to `%s'".printf (initializer.value_type.to_string (), variable_type.to_string ()));
 306                                 return false;
 307                         }
 308
 309                         if (external) {
 310                                 error = true;
 311                                 Report.error (source_reference, "External fields cannot use initializers");
 312                         }
 313                 }
 314
 315                 if (binding == MemberBinding.INSTANCE && parent_symbol is Interface) {
 316                         error = true;
 317                         Report.error (source_reference, "Interfaces may not have instance fields");
 318                         return false;
 319                 }
 320
 321                 bool field_in_header = !is_internal_symbol ();
 322                 if (parent_symbol is Class) {
 323                         var cl = (Class) parent_symbol;
 324                         if (cl.is_compact && !cl.is_internal_symbol ()) {
 325                                 // compact classes don't have priv structs
 326                                 field_in_header = true;
 327                         }
 328                 }
 329
 330                 if (!external_package && !hides && get_hidden_member () != null) {
 331                         Report.warning (source_reference, "%s hides inherited field `%s'. Use the `new' keyword if hiding was intentional".printf (get_full_name (), get_hidden_member ().get_full_name ()));
 332                 }
 333
 334                 analyzer.current_source_file = old_source_file;
 335                 analyzer.current_symbol = old_symbol;
 336
 337                 return !error;
 338         }
 339 }