vala/valafield.vala

   1 /* valafield.vala
   2  *
   3  * Copyright (C) 2006-2008  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 using Gee;
  25
  26 /**
  27  * Represents a type or namespace field.
  28  */
  29 public class Vala.Field : Member, Lockable {
  30         /**
  31          * The data type of this field.
  32          */
  33         public DataType field_type {
  34                 get { return _data_type; }
  35                 set {
  36                         _data_type = value;
  37                         _data_type.parent_node = this;
  38                 }
  39         }
  40
  41         /**
  42          * Specifies the expression to be used to initialize this field.
  43          */
  44         public Expression? initializer {
  45                 get { return _initializer; }
  46                 set {
  47                         _initializer = value;
  48                         if (_initializer != null) {
  49                                 _initializer.parent_node = this;
  50                         }
  51                 }
  52         }
  53
  54         /**
  55          * Specifies whether this field may only be accessed with an instance of
  56          * the contained type.
  57          */
  58         public MemberBinding binding { get; set; default = MemberBinding.INSTANCE; }
  59
  60         /**
  61          * Specifies whether the field is volatile. Volatile fields are
  62          * necessary to allow multi-threaded access.
  63          */
  64         public bool is_volatile { get; set; }
  65
  66         /**
  67          * Specifies whether an array length field should implicitly be created
  68          * if the field type is an array.
  69          */
  70         public bool no_array_length { get; set; }
  71
  72         private string cname;
  73
  74         private bool lock_used = false;
  75
  76         private Expression _initializer;
  77
  78         private DataType _data_type;
  79
  80         /**
  81          * Creates a new field.
  82          *
  83          * @param name   field name
  84          * @param type   field type
  85          * @param init   initializer expression
  86          * @param source reference to source code
  87          * @return       newly created field
  88          */
  89         public Field (string name, DataType field_type, Expression? initializer, SourceReference? source_reference = null) {
  90                 base (name, source_reference);
  91                 this.field_type = field_type;
  92                 this.initializer = initializer;
  93         }
  94
  95         public override void accept (CodeVisitor visitor) {
  96                 visitor.visit_member (this);
  97
  98                 visitor.visit_field (this);
  99         }
 100
 101         public override void accept_children (CodeVisitor visitor) {
 102                 field_type.accept (visitor);
 103
 104                 if (initializer != null) {
 105                         initializer.accept (visitor);
 106                 }
 107         }
 108
 109         /**
 110          * Returns the name of this field as it is used in C code.
 111          *
 112          * @return the name to be used in C code
 113          */
 114         public string get_cname () {
 115                 if (cname == null) {
 116                         cname = get_default_cname ();
 117                 }
 118                 return cname;
 119         }
 120
 121         /**
 122          * Sets the name of this field as it is used in C code.
 123          *
 124          * @param cname the name to be used in C code
 125          */
 126         public void set_cname (string cname) {
 127                 this.cname = cname;
 128         }
 129
 130         /**
 131          * Returns the default name of this field as it is used in C code.
 132          *
 133          * @return the name to be used in C code by default
 134          */
 135         public string get_default_cname () {
 136                 if (binding == MemberBinding.STATIC) {
 137                         return parent_symbol.get_lower_case_cprefix () + name;
 138                 } else {
 139                         return name;
 140                 }
 141         }
 142
 143         private void process_ccode_attribute (Attribute a) {
 144                 if (a.has_argument ("cname")) {
 145                         set_cname (a.get_string ("cname"));
 146                 }
 147                 if (a.has_argument ("cheader_filename")) {
 148                         var val = a.get_string ("cheader_filename");
 149                         foreach (string filename in val.split (",")) {
 150                                 add_cheader_filename (filename);
 151                         }
 152                 }
 153         }
 154
 155         /**
 156          * Process all associated attributes.
 157          */
 158         public void process_attributes () {
 159                 foreach (Attribute a in attributes) {
 160                         if (a.name == "CCode") {
 161                                 process_ccode_attribute (a);
 162                         } else if (a.name == "NoArrayLength") {
 163                                 no_array_length = true;
 164                         }
 165                 }
 166         }
 167
 168         public bool get_lock_used () {
 169                 return lock_used;
 170         }
 171
 172         public void set_lock_used (bool used) {
 173                 lock_used = used;
 174         }
 175
 176         public override void replace_type (DataType old_type, DataType new_type) {
 177                 if (field_type == old_type) {
 178                         field_type = new_type;
 179                 }
 180         }
 181
 182         public string? get_ctype () {
 183                 var attr = get_attribute ("CCode");
 184                 if (attr == null) {
 185                         return null;
 186                 }
 187                 return attr.get_string ("type");
 188         }
 189
 190         public void set_ctype (string ctype) {
 191                 var attr = get_attribute ("CCode");
 192                 if (attr == null) {
 193                         attr = new Attribute ("CCode");
 194                         attributes.append (attr);
 195                 }
 196                 attr.add_argument ("type", new StringLiteral ("\"%s\"".printf (ctype)));
 197         }
 198
 199         public override bool check (SemanticAnalyzer analyzer) {
 200                 if (checked) {
 201                         return !error;
 202                 }
 203
 204                 checked = true;
 205
 206                 var old_source_file = analyzer.current_source_file;
 207
 208                 if (source_reference != null) {
 209                         analyzer.current_source_file = source_reference.file;
 210                 }
 211
 212                 field_type.check (analyzer);
 213
 214                 process_attributes ();
 215
 216                 if (initializer != null) {
 217                         initializer.target_type = field_type;
 218                 }
 219
 220                 field_type.check (analyzer);
 221
 222                 if (initializer != null) {
 223                         initializer.check (analyzer);
 224                 }
 225
 226                 if (binding == MemberBinding.INSTANCE && parent_symbol is Interface) {
 227                         error = true;
 228                         Report.error (source_reference, "Interfaces may not have instance fields");
 229                         return false;
 230                 }
 231
 232                 bool field_in_header = !is_internal_symbol ();
 233                 if (parent_symbol is Class) {
 234                         var cl = (Class) parent_symbol;
 235                         if (cl.is_compact && !cl.is_internal_symbol ()) {
 236                                 // compact classes don't have priv structs
 237                                 field_in_header = true;
 238                         }
 239                 }
 240
 241                 if (field_in_header) {
 242                         if (field_type is ValueType) {
 243                                 analyzer.current_source_file.add_type_dependency (field_type, SourceFileDependencyType.HEADER_FULL);
 244                         } else {
 245                                 analyzer.current_source_file.add_type_dependency (field_type, SourceFileDependencyType.HEADER_SHALLOW);
 246                         }
 247                 } else {
 248                         if (parent_symbol is Namespace) {
 249                                 error = true;
 250                                 Report.error (source_reference, "Namespaces may not have private members");
 251                                 return false;
 252                         }
 253
 254                         analyzer.current_source_file.add_type_dependency (field_type, SourceFileDependencyType.SOURCE);
 255                 }
 256
 257                 analyzer.current_source_file = old_source_file;
 258
 259                 return !error;
 260         }
 261 }