src/pmc/fixedfloatarray.pmc

   1 /*
   2 Copyright (C) 2001-2008, The Perl Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/fixedfloatarray.pmc - fixed size array for floating point numbers only
   8
   9 =head1 DESCRIPTION
  10
  11 This class, FixedFloatArray, implements an array of fixed size which
  12 stored FLOATVALs.  It uses Float PMCs to do all necessary conversions.
  13
  14 =head2 Functions
  15
  16 =over 4
  17
  18 =cut
  19
  20 */
  21
  22 #include "parrot/parrot.h"
  23
  24 pmclass FixedFloatArray need_ext provides array {
  25
  26 /*
  27
  28 =back
  29
  30 =head2 Methods
  31
  32 =over 4
  33
  34 =item C<void init()>
  35
  36 Initializes the array.
  37
  38 =cut
  39
  40 */
  41
  42     VTABLE void init() {
  43         PMC_int_val(SELF) = 0;
  44         PMC_data(SELF)    = NULL;
  45     }
  46
  47 /*
  48
  49 =item C<void destroy()>
  50
  51 Destroys the array.
  52
  53 =cut
  54
  55 */
  56
  57     VTABLE void destroy() {
  58         if (PMC_data(SELF))
  59             mem_sys_free(PMC_data(SELF));
  60
  61         PMC_data(SELF)    = NULL;
  62         PMC_int_val(SELF) = 0;
  63     }
  64
  65 /*
  66
  67 =item C<PMC *clone()>
  68
  69 Creates and returns a copy of the array.
  70
  71 =cut
  72
  73 */
  74
  75     VTABLE PMC *clone() {
  76         INTVAL size;
  77         size_t mem_size;
  78         PMC   * const dest = pmc_new(INTERP, SELF->vtable->base_type);
  79
  80         if (!PMC_data(SELF))
  81             return dest;
  82
  83         size              = PMC_int_val(SELF);
  84         PMC_int_val(dest) = size;
  85         mem_size          = size * sizeof (FLOATVAL);
  86
  87         PMC_data(dest)    = mem_sys_allocate(mem_size);
  88         mem_sys_memcopy(PMC_data(dest), PMC_data(SELF), mem_size);
  89         PObj_active_destroy_SET(dest);
  90
  91         return dest;
  92     }
  93
  94 /*
  95
  96 =item C<INTVAL get_bool()>
  97
  98 Returns whether the array has any elements (meaning been initialized, for a
  99 fixed sized array).
 100
 101 =cut
 102
 103 */
 104     VTABLE INTVAL get_bool() {
 105         const INTVAL size = SELF.elements();
 106         return (INTVAL)(size != 0);
 107     }
 108
 109 /*
 110
 111 =item C<INTVAL elements()>
 112
 113 =cut
 114
 115 */
 116
 117     VTABLE INTVAL elements() {
 118         return PMC_int_val(SELF);
 119     }
 120
 121 /*
 122
 123 =item C<INTVAL get_integer()>
 124
 125 Returns the number of elements in the array.
 126
 127 =cut
 128
 129 */
 130
 131     VTABLE INTVAL get_integer() {
 132         return SELF.elements();
 133     }
 134
 135
 136 /*
 137
 138 =item C<INTVAL get_integer_keyed_int(INTVAL key)>
 139
 140 Returns the integer value of the element at index C<key>.
 141
 142 =cut
 143
 144 */
 145
 146     VTABLE INTVAL get_integer_keyed_int(INTVAL key) {
 147         const FLOATVAL f = SELF.get_number_keyed_int(key);
 148         return (INTVAL)f;
 149     }
 150
 151 /*
 152
 153 =item C<INTVAL get_integer_keyed(PMC *key)>
 154
 155 Returns the integer value of the element at index C<*key>.
 156
 157 =cut
 158
 159 */
 160
 161     VTABLE INTVAL get_integer_keyed(PMC *key) {
 162         /* simple int keys only */
 163         const INTVAL k = key_integer(INTERP, key);
 164         return SELF.get_integer_keyed_int(k);
 165     }
 166
 167
 168 /*
 169
 170 =item C<FLOATVAL get_number_keyed_int(INTVAL key)>
 171
 172 Returns the floating-point value of the element at index C<key>.
 173
 174 =cut
 175
 176 */
 177
 178     VTABLE FLOATVAL get_number_keyed_int(INTVAL key) {
 179         FLOATVAL *data;
 180
 181         if (key < 0 || key >= PMC_int_val(SELF))
 182             real_exception(INTERP, NULL, E_IndexError,
 183                 "FixedFloatArray: index out of bounds!");
 184
 185         data = (FLOATVAL *)PMC_data(SELF);
 186         return data[key];
 187     }
 188
 189 /*
 190
 191 =item C<FLOATVAL get_number_keyed(PMC *key)>
 192
 193 Returns the floating-point value of the element at index C<*key>.
 194
 195 =cut
 196
 197 */
 198
 199     VTABLE FLOATVAL get_number_keyed(PMC *key) {
 200         const INTVAL k = key_integer(INTERP, key);
 201         return SELF.get_number_keyed_int(k);
 202     }
 203
 204 /*
 205
 206 =item C<STRING *get_string_keyed_int(INTVAL key)>
 207
 208 Returns the Parrot string value of the element at index C<key>.
 209
 210 =cut
 211
 212 */
 213
 214     VTABLE STRING *get_string_keyed_int(INTVAL key) {
 215         PMC * const e = SELF.get_pmc_keyed_int(key);
 216         return VTABLE_get_string(INTERP, e);
 217     }
 218
 219 /*
 220
 221 =item C<STRING *get_string_keyed(PMC *key)>
 222
 223 Returns the Parrot string value of the element at index C<*key>.
 224
 225 =cut
 226
 227 */
 228
 229     VTABLE STRING *get_string_keyed(PMC *key) {
 230         const INTVAL k = key_integer(INTERP, key);
 231         return SELF.get_string_keyed_int(k);
 232     }
 233
 234
 235 /*
 236
 237 =item C<PMC *get_pmc_keyed_int(INTVAL key)>
 238
 239 Returns the PMC value of the element at index C<key>.
 240
 241 =cut
 242
 243 */
 244
 245     VTABLE PMC *get_pmc_keyed_int(INTVAL key) {
 246         PMC    * const ret = pmc_new(INTERP, enum_class_Float);
 247         const FLOATVAL val = SELF.get_number_keyed_int(key);
 248
 249         VTABLE_set_number_native(INTERP, ret, val);
 250         return ret;
 251     }
 252
 253 /*
 254
 255 =item C<PMC *get_pmc_keyed(PMC *key)>
 256
 257 Returns the PMC value of the element at index C<*key>.
 258
 259 =cut
 260
 261 */
 262
 263     VTABLE PMC *get_pmc_keyed(PMC *key) {
 264         const INTVAL k = key_integer(INTERP, key);
 265         return SELF.get_pmc_keyed_int(k);
 266     }
 267
 268 /*
 269
 270 =item C<void set_integer_native(INTVAL size)>
 271
 272 Resizes the array to C<size> elements.
 273
 274 =cut
 275
 276 */
 277
 278     VTABLE void set_integer_native(INTVAL size) {
 279         if (PMC_int_val(SELF) || size < 1)
 280             real_exception(INTERP, NULL, E_IndexError,
 281                     "FixedFloatArray: Can't resize!");
 282
 283         PMC_int_val(SELF) = size;
 284         PMC_data(SELF)    = mem_sys_allocate(size * sizeof (FLOATVAL));
 285         PObj_active_destroy_SET(SELF);
 286     }
 287
 288 /*
 289
 290 =item C<void set_integer_keyed_int(INTVAL key, INTVAL value)>
 291
 292 Sets the integer value of the element at index C<key> to C<value>.
 293
 294 =cut
 295
 296 */
 297
 298     VTABLE void set_integer_keyed_int(INTVAL key, INTVAL value) {
 299         SELF.set_number_keyed_int(key, (FLOATVAL)value);
 300     }
 301
 302 /*
 303
 304 =item C<void set_integer_keyed(PMC *key, INTVAL value)>
 305
 306 Sets the integer value of the element at index C<key> to C<value>.
 307
 308 =cut
 309
 310 */
 311
 312     VTABLE void set_integer_keyed(PMC *key, INTVAL value) {
 313         const INTVAL k = key_integer(INTERP, key);
 314         SELF.set_integer_keyed_int(k, value);
 315     }
 316
 317 /*
 318
 319 =item C<void set_number_keyed_int(INTVAL key, FLOATVAL value)>
 320
 321 Sets the floating-point value of the element at index C<key> to
 322 C<value>.
 323
 324 =cut
 325
 326 */
 327
 328     VTABLE void set_number_keyed_int(INTVAL key, FLOATVAL value) {
 329         FLOATVAL *data;
 330         if (key < 0 || key >= PMC_int_val(SELF))
 331             real_exception(INTERP, NULL, E_IndexError,
 332                 "FixedFloatArray: index out of bounds!");
 333
 334         data      = (FLOATVAL *)PMC_data(SELF);
 335         data[key] = value;
 336     }
 337
 338 /*
 339
 340 =item C<void set_number_keyed(PMC *key, FLOATVAL value)>
 341
 342 Sets the floating-point value of the element at index C<key> to
 343 C<value>.
 344
 345 =cut
 346
 347 */
 348
 349     VTABLE void set_number_keyed(PMC *key, FLOATVAL value) {
 350         const INTVAL k = key_integer(INTERP, key);
 351         SELF.set_number_keyed_int(k, value);
 352     }
 353
 354 /*
 355
 356 =item C<void set_string_keyed_int(INTVAL key, STRING *value)>
 357
 358 Sets the Parrot string value of the element at index C<key> to C<value>.
 359
 360 =cut
 361
 362 */
 363
 364     VTABLE void set_string_keyed_int(INTVAL key, STRING *value) {
 365         FLOATVAL tempNum;
 366         PMC * const tempPMC = pmc_new(INTERP, enum_class_Float);
 367
 368         VTABLE_set_string_native(INTERP, tempPMC, value);
 369         tempNum = VTABLE_get_number(INTERP, tempPMC);
 370         SELF.set_number_keyed_int(key, tempNum);
 371     }
 372
 373 /*
 374
 375 =item C<void set_string_keyed(PMC *key, STRING *value)>
 376
 377 Sets the string value of the element at index C<key> to
 378 C<value>.
 379
 380 =cut
 381
 382 */
 383
 384     VTABLE void set_string_keyed(PMC *key, STRING *value) {
 385         const INTVAL k = key_integer(INTERP, key);
 386         SELF.set_string_keyed_int(k, value);
 387     }
 388
 389 /*
 390
 391 =item C<void set_pmc_keyed_int(INTVAL key, PMC *src)>
 392
 393 Sets the PMC value of the element at index C<key> to C<*src>.
 394
 395 =cut
 396
 397 */
 398
 399     VTABLE void set_pmc_keyed_int(INTVAL key, PMC *src) {
 400         const FLOATVAL tempNum = VTABLE_get_number(INTERP, src);
 401         SELF.set_number_keyed_int(key, tempNum);
 402     }
 403
 404 /*
 405
 406 =item C<void set_pmc_keyed(PMC *key, PMC *value)>
 407
 408 Sets the string value of the element at index C<key> to
 409 C<value>.
 410
 411 =cut
 412
 413 */
 414
 415     VTABLE void set_pmc_keyed(PMC *key, PMC *value) {
 416         const INTVAL k = key_integer(INTERP, key);
 417         SELF.set_pmc_keyed_int(k, value);
 418     }
 419
 420 }
 421
 422 /*
 423
 424 =back
 425
 426 =head1 SEE ALSO
 427
 428 F<docs/pdds/pdd17_basic_types.pod>.
 429
 430 =cut
 431
 432 */
 433
 434 /*
 435  * Local variables:
 436  *   c-file-style: "parrot"
 437  * End:
 438  * vim: expandtab shiftwidth=4:
 439  */