vala/valaclass.vala

   1 /* valaclass.vala
   2  *
   3  * Copyright (C) 2006-2007  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 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 class declaration in the source code.
  27  */
  28 public class Vala.Class : DataType {
  29         /**
  30          * Specifies the base class.
  31          */
  32         public Class base_class { get; set; }
  33
  34         /**
  35          * Specifies whether this class is abstract. Abstract classes may not be
  36          * instantiated.
  37          */
  38         public bool is_abstract { get; set; }
  39
  40         /**
  41          * Specifies whether this class is static. Static classes may not be
  42          * instantiated and may only contain static members.
  43          */
  44         public bool is_static { get; set; }
  45
  46         /**
  47          * Specifies whether this class has private fields.
  48          */
  49         public bool has_private_fields {
  50                 get {
  51                         return _has_private_fields;
  52                 }
  53         }
  54
  55         private string cname;
  56         private string lower_case_csuffix;
  57         private string type_id;
  58
  59         private bool _has_private_fields;
  60
  61         private List<TypeParameter> type_parameters;
  62
  63         private List<TypeReference> base_types;
  64
  65         private List<Constant> constants;
  66         private List<Field> fields;
  67         private List<Method> methods;
  68         private List<Property> properties;
  69         private List<Signal> signals;
  70
  71         /**
  72          * Specifies the default construction method.
  73          */
  74         public Method default_construction_method { get; set; }
  75
  76         /**
  77          * Specifies the instance constructor.
  78          */
  79         public Constructor constructor { get; set; }
  80
  81         /**
  82          * Specifies the instance destructor.
  83          */
  84         public Destructor destructor { get; set; }
  85
  86         /**
  87          * Creates a new class.
  88          *
  89          * @param name   type name
  90          * @param source reference to source code
  91          * @return       newly created class
  92          */
  93         public Class (string! _name, SourceReference source = null) {
  94                 name = _name;
  95                 source_reference = source;
  96         }
  97
  98         /**
  99          * Adds the specified class or interface to the list of base types of
 100          * this class.
 101          *
 102          * @param type a class or interface reference
 103          */
 104         public void add_base_type (TypeReference! type) {
 105                 base_types.append (type);
 106         }
 107
 108         /**
 109          * Returns a copy of the base type list.
 110          *
 111          * @return list of base types
 112          */
 113         public List<weak TypeReference> get_base_types () {
 114                 return base_types.copy ();
 115         }
 116
 117         /**
 118          * Appends the specified parameter to the list of type parameters.
 119          *
 120          * @param p a type parameter
 121          */
 122         public void add_type_parameter (TypeParameter! p) {
 123                 type_parameters.append (p);
 124                 p.type = this;
 125         }
 126
 127         /**
 128          * Returns a copy of the type parameter list.
 129          *
 130          * @return list of type parameters
 131          */
 132         public List<weak TypeParameter> get_type_parameters () {
 133                 return type_parameters.copy ();
 134         }
 135
 136         /**
 137          * Adds the specified constant as a member to this class.
 138          *
 139          * @param c a constant
 140          */
 141         public void add_constant (Constant! c) {
 142                 constants.append (c);
 143         }
 144
 145         /**
 146          * Adds the specified field as a member to this class.
 147          *
 148          * @param f a field
 149          */
 150         public void add_field (Field! f) {
 151                 // non_null fields not yet supported due to initialization issues
 152                 f.type_reference.non_null = false;
 153                 fields.append (f);
 154                 if (f.access == MemberAccessibility.PRIVATE && f.instance) {
 155                         _has_private_fields = true;
 156                 }
 157         }
 158
 159         /**
 160          * Returns a copy of the list of fields.
 161          *
 162          * @return list of fields
 163          */
 164         public List<weak Field> get_fields () {
 165                 return fields.copy ();
 166         }
 167
 168         /**
 169          * Adds the specified method as a member to this class.
 170          *
 171          * @param m a method
 172          */
 173         public void add_method (Method! m) {
 174                 methods.append (m);
 175         }
 176
 177         /**
 178          * Returns a copy of the list of methods.
 179          *
 180          * @return list of methods
 181          */
 182         public List<weak Method> get_methods () {
 183                 return methods.copy ();
 184         }
 185
 186         /**
 187          * Adds the specified property as a member to this class.
 188          *
 189          * @param prop a property
 190          */
 191         public void add_property (Property! prop, bool no_field = false) {
 192                 properties.append (prop);
 193
 194                 if (!no_field && prop.set_accessor != null && prop.set_accessor.body == null &&
 195                     source_reference != null && !source_reference.file.pkg) {
 196                         /* automatic property accessor body generation */
 197                         var field_type = prop.type_reference.copy ();
 198                         // non_null fields not yet supported due to initialization issues
 199                         field_type.non_null = false;
 200                         var f = new Field ("_%s".printf (prop.name), field_type, null, prop.source_reference);
 201                         f.access = MemberAccessibility.PRIVATE;
 202                         add_field (f);
 203                 }
 204         }
 205
 206         /**
 207          * Returns a copy of the list of properties.
 208          *
 209          * @return list of properties
 210          */
 211         public List<weak Property> get_properties () {
 212                 return properties.copy ();
 213         }
 214
 215         /**
 216          * Adds the specified signal as a member to this class.
 217          *
 218          * @param sig a signal
 219          */
 220         public void add_signal (Signal! sig) {
 221                 signals.append (sig);
 222         }
 223
 224         /**
 225          * Returns a copy of the list of signals.
 226          *
 227          * @return list of signals
 228          */
 229         public List<weak Signal> get_signals () {
 230                 return signals.copy ();
 231         }
 232
 233         public override void accept (CodeVisitor! visitor) {
 234                 visitor.visit_class (this);
 235         }
 236
 237         public override void accept_children (CodeVisitor! visitor) {
 238                 foreach (TypeReference type in base_types) {
 239                         type.accept (visitor);
 240                 }
 241
 242                 foreach (TypeParameter p in type_parameters) {
 243                         p.accept (visitor);
 244                 }
 245
 246                 foreach (Field f in fields) {
 247                         f.accept (visitor);
 248                 }
 249
 250                 foreach (Constant c in constants) {
 251                         c.accept (visitor);
 252                 }
 253
 254                 foreach (Method m in methods) {
 255                         m.accept (visitor);
 256                 }
 257
 258                 foreach (Property prop in properties) {
 259                         prop.accept (visitor);
 260                 }
 261
 262                 foreach (Signal sig in signals) {
 263                         sig.accept (visitor);
 264                 }
 265
 266                 if (constructor != null) {
 267                         constructor.accept (visitor);
 268                 }
 269
 270                 if (destructor != null) {
 271                         destructor.accept (visitor);
 272                 }
 273         }
 274
 275         public override string get_cname (bool const_type = false) {
 276                 if (cname == null) {
 277                         cname = "%s%s".printf (@namespace.get_cprefix (), name);
 278                 }
 279                 return cname;
 280         }
 281
 282         /**
 283          * Sets the name of this class as it is used in C code.
 284          *
 285          * @param cname the name to be used in C code
 286          */
 287         public void set_cname (string! cname) {
 288                 this.cname = cname;
 289         }
 290
 291         private string get_lower_case_csuffix () {
 292                 if (lower_case_csuffix == null) {
 293                         lower_case_csuffix = Namespace.camel_case_to_lower_case (name);
 294                 }
 295                 return lower_case_csuffix;
 296         }
 297
 298         public override string get_lower_case_cname (string infix) {
 299                 if (infix == null) {
 300                         infix = "";
 301                 }
 302                 return "%s%s%s".printf (@namespace.get_lower_case_cprefix (), infix, get_lower_case_csuffix ());
 303         }
 304
 305         public override string get_lower_case_cprefix () {
 306                 return "%s_".printf (get_lower_case_cname (null));
 307         }
 308
 309         public override string get_upper_case_cname (string infix) {
 310                 return get_lower_case_cname (infix).up ();
 311         }
 312
 313         public override bool is_reference_type () {
 314                 return true;
 315         }
 316
 317         private void process_ccode_attribute (Attribute! a) {
 318                 if (a.has_argument ("cname")) {
 319                         set_cname (a.get_string ("cname"));
 320                 }
 321                 if (a.has_argument ("cheader_filename")) {
 322                         var val = a.get_string ("cheader_filename");
 323                         foreach (string filename in val.split (",")) {
 324                                 add_cheader_filename (filename);
 325                         }
 326                 }
 327         }
 328
 329         /**
 330          * Process all associated attributes.
 331          */
 332         public void process_attributes () {
 333                 foreach (Attribute a in attributes) {
 334                         if (a.name == "CCode") {
 335                                 process_ccode_attribute (a);
 336                         }
 337                 }
 338         }
 339
 340         public override string get_type_id () {
 341                 if (type_id == null) {
 342                         type_id = get_upper_case_cname ("TYPE_");
 343                 }
 344
 345                 return type_id;
 346         }
 347
 348         public override string get_marshaller_type_name () {
 349                 return "OBJECT";
 350         }
 351
 352         public override string get_get_value_function () {
 353                 return "g_value_get_object";
 354         }
 355
 356         public override string get_set_value_function () {
 357                 return "g_value_set_object";
 358         }
 359
 360         public override bool is_reference_counting () {
 361                 return true;
 362         }
 363
 364         public override string get_ref_function () {
 365                 return "g_object_ref";
 366         }
 367
 368         public override string get_unref_function () {
 369                 return "g_object_unref";
 370         }
 371
 372         public override bool is_subtype_of (DataType! t) {
 373                 foreach (TypeReference base_type in base_types) {
 374                         if (base_type.data_type == t ||
 375                             base_type.data_type.is_subtype_of (t)) {
 376                                 return true;
 377                         }
 378                 }
 379
 380                 return false;
 381         }
 382
 383         public override int get_type_parameter_index (string! name) {
 384                 int i = 0;
 385                 foreach (TypeParameter parameter in type_parameters) {
 386                         if (parameter.name == name) {
 387                                 return i;
 388                         }
 389                         i++;
 390                 }
 391                 return -1;
 392         }
 393 }
 394