vala/valaarray.vala

   1 /* valaarray.vala
   2  *
   3  * Copyright (C) 2006-2007  Raffaele Sandrini, 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  *      Raffaele Sandrini <rasa@gmx.ch>
  21  *      Jürg Billeter <j@bitron.ch>
  22  */
  23
  24 using GLib;
  25
  26 /**
  27  * Represents an array type i.e. everything with direct accessable elements.
  28  */
  29 public class Vala.Array : DataType {
  30
  31         /**
  32          * DataType of which this is an array of.
  33          */
  34         public DataType element_type { get; set construct; }
  35
  36         /**
  37          * TypeParameter of which this is an array of.
  38          */
  39         public TypeParameter element_type_parameter { get; set construct; }
  40
  41         /**
  42          * The rank of this array.
  43          */
  44         public int rank { get; set construct; }
  45
  46         private string cname;
  47
  48         private ArrayLengthField length_field;
  49
  50         private ArrayResizeMethod resize_method;
  51
  52         public Array (DataType! _element_type, int _rank, SourceReference! _source_reference) {
  53                 rank = _rank;
  54                 element_type = _element_type;
  55                 source_reference = _source_reference;
  56         }
  57
  58         public Array.with_type_parameter (TypeParameter! _element_type_parameter, int _rank, SourceReference! _source_reference) {
  59                 rank = _rank;
  60                 element_type_parameter = _element_type_parameter;
  61                 source_reference = _source_reference;
  62         }
  63
  64         construct {
  65                 /* FIXME: this implementation reveals compiler bugs
  66                 string commas = "";
  67                 int i = rank - 1;
  68
  69                 while (i > 0) {
  70                         string += ",";
  71                         i--;
  72                 }
  73
  74                 name = "%s[%s]".printf (element_type.name, commas); */
  75
  76                 if (rank < 1) {
  77                         Report.error (null, "internal: attempt to create an array with rank smaller than 1");
  78                 }
  79
  80                 int i = rank - 1;
  81                 if (element_type != null) {
  82                         name = "%s[".printf (element_type.name);
  83                 } else {
  84                         name = "%s[".printf (element_type_parameter.name);
  85                 }
  86                 while (i > 0) {
  87                         name = "%s,".printf (name);
  88                         i--;
  89                 }
  90                 name = "%s]".printf (name);
  91
  92                 length_field = new ArrayLengthField (source_reference);
  93                 length_field.symbol = new Symbol (length_field);
  94
  95                 resize_method = new ArrayResizeMethod (source_reference);
  96                 resize_method.symbol = new Symbol (resize_method);
  97         }
  98
  99         /**
 100          * Returns the name of this data type as it is used in C code.
 101          *
 102          * @return the name to be used in C code
 103          */
 104         public override string get_cname (bool const_type = false) {
 105                 if (cname == null) {
 106                         if (element_type != null) {
 107                                 if (element_type.is_reference_type ()) {
 108                                         cname = "%s*".printf (element_type.get_cname ());
 109                                 } else {
 110                                         cname = element_type.get_cname ();
 111                                 }
 112                         } else {
 113                                 cname = "gpointer";
 114                         }
 115                 }
 116
 117                 return cname;
 118         }
 119
 120         /**
 121          * Checks whether this data type has value or reference type semantics.
 122          *
 123          * @return true if this data type has reference type semantics
 124          */
 125         public override bool is_reference_type () {
 126                 return true;
 127         }
 128
 129         /**
 130          * Returns the C name of this data type in upper case. Words are
 131          * separated by underscores. The upper case C name of the namespace is
 132          * prefix of the result.
 133          *
 134          * @param infix a string to be placed between namespace and data type
 135          *              name or null
 136          * @return      the upper case name to be used in C code
 137          */
 138         public override string get_upper_case_cname (string infix) {
 139                 return null;
 140         }
 141
 142         /**
 143          * Returns the C name of this data type in lower case. Words are
 144          * separated by underscores. The lower case C name of the namespace is
 145          * prefix of the result.
 146          *
 147          * @param infix a string to be placed between namespace and data type
 148          *              name or null
 149          * @return      the lower case name to be used in C code
 150          */
 151         public override string get_lower_case_cname (string infix) {
 152                 return null;
 153         }
 154
 155         /**
 156          * Returns the C function name that frees instances of this data type.
 157          * This is only valid for data types with reference type semantics that
 158          * do not support reference counting. The specified C function must
 159          * accept one argument pointing to the instance to be freed.
 160          *
 161          * @return the name of the C function or null if this data type is not a
 162          *         reference type or if it supports reference counting
 163          */
 164         public override string get_free_function () {
 165                 return "g_free";
 166         }
 167
 168         /**
 169          * Returns a list of C header filenames users of this data type must
 170          * include.
 171          *
 172          * @return list of C header filenames for this data type
 173          */
 174         public override List<string> get_cheader_filenames () {
 175                 if (element_type != null) {
 176                         return element_type.get_cheader_filenames ();
 177                 } else {
 178                         return null;
 179                 }
 180         }
 181
 182         public override string get_marshaller_type_name () {
 183                 return "POINTER";
 184         }
 185
 186         public override string get_get_value_function () {
 187                 return "g_value_get_pointer";
 188         }
 189
 190         public override string get_set_value_function () {
 191                 return "g_value_set_pointer";
 192         }
 193
 194         public ArrayLengthField get_length_field () {
 195                 return length_field;
 196         }
 197
 198         public ArrayResizeMethod get_resize_method () {
 199                 return resize_method;
 200         }
 201 }