src/st-array.c

   1 /*
   2  * st-array.c
   3  *
   4  * Copyright (c) 2008 Vincent Geddes
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  21  * THE SOFTWARE.
  22 */
  23
  24 #include "st-array.h"
  25 #include "st-universe.h"
  26 #include "st-utils.h"
  27 #include "st-descriptor.h"
  28 #include "st-behavior.h"
  29 #include <string.h>
  30
  31 static st_oop
  32 array_allocate_arrayed (st_oop    class,
  33                         st_smi    size)
  34 {
  35     st_oop  array;
  36     st_oop *elements;
  37
  38     st_assert (size >= 0);
  39
  40     array = st_memory_allocate (ST_SIZE_OOPS (struct st_array) + size);
  41     st_object_initialize_header (array, class);
  42
  43     ST_ARRAYED_OBJECT (array)->size = st_smi_new (size);
  44     elements = ST_ARRAY (array)->elements;
  45     for (st_smi i = 0; i < size; i++)
  46         elements[i] = st_nil;
  47
  48     return array;
  49 }
  50
  51 static st_uint
  52 array_size (st_oop object)
  53 {
  54     return ST_SIZE_OOPS (struct st_arrayed_object) + st_smi_value (st_arrayed_object_size (object));
  55 }
  56
  57 static void
  58 array_contents (st_oop object, st_oop **oops, st_uint *size)
  59 {
  60     *oops = st_array_elements (object);
  61     *size = st_smi_value (st_arrayed_object_size (object));
  62 }
  63
  64 st_descriptor *
  65 st_array_descriptor (void)
  66 {
  67     static st_descriptor __descriptor =
  68         { .allocate         = NULL,
  69           .allocate_arrayed = array_allocate_arrayed,
  70           .size             = array_size,
  71           .contents         = array_contents,
  72         };
  73
  74     return & __descriptor;
  75 }
  76
  77 /* ByteArray */
  78
  79 static st_oop
  80 byte_allocate_arrayed (st_oop    class,
  81                        st_smi    size)
  82 {
  83     st_uint size_oops;
  84     st_oop  array;
  85
  86     st_assert (size >= 0);
  87
  88     /* add 1 byte for NULL terminator. Allows toll-free bridging with C string function */
  89     size_oops = ST_ROUNDED_UP_OOPS (size + 1);
  90
  91     array = st_memory_allocate (ST_SIZE_OOPS (struct st_byte_array) + size_oops);
  92     st_object_initialize_header (array, class);
  93
  94     ST_ARRAYED_OBJECT (array)->size = st_smi_new (size);
  95     memset (st_byte_array_bytes (array), 0, ST_OOPS_TO_BYTES (size_oops));
  96
  97     return array;
  98 }
  99
 100 bool
 101 st_byte_array_equal (st_oop object, st_oop other)
 102 {
 103     st_smi size, size_other;
 104
 105     if (st_object_class (other) != st_byte_array_class &&
 106         st_object_class (other) != st_string_class &&
 107         st_object_class (other) != st_symbol_class)
 108         return false;
 109
 110     size = st_smi_value (ST_ARRAYED_OBJECT (object)->size);
 111     size_other = st_smi_value (ST_ARRAYED_OBJECT (other)->size);
 112
 113     if (size != size_other)
 114         return false;
 115
 116     return memcmp (st_byte_array_bytes (object), st_byte_array_bytes (other), size) == 0;
 117 }
 118
 119 st_uint
 120 st_byte_array_hash (st_oop object)
 121 {
 122     return st_string_hash ((char *) st_byte_array_bytes (object));
 123 }
 124
 125 static st_uint
 126 byte_array_size (st_oop object)
 127 {
 128     st_uint size;
 129
 130     size = st_smi_value (st_arrayed_object_size (object));
 131     return ST_SIZE_OOPS (struct st_arrayed_object) + ST_ROUNDED_UP_OOPS (size + 1);
 132 }
 133
 134 static void
 135 byte_array_contents (st_oop object, st_oop **oops, st_uint *size)
 136 {
 137     *oops = NULL;
 138     *size = 0;
 139 }
 140
 141 st_descriptor *
 142 st_byte_array_descriptor (void)
 143 {
 144     static st_descriptor __descriptor =
 145         { .allocate         = NULL,
 146           .allocate_arrayed = byte_allocate_arrayed,
 147           .size             = byte_array_size,
 148           .contents         = byte_array_contents,
 149         };
 150
 151     return & __descriptor;
 152 }
 153
 154 /* WordArray */
 155
 156 static st_oop
 157 word_allocate_arrayed (st_oop class, st_smi size)
 158 {
 159     st_oop   array;
 160     st_smi   size_oops;
 161     st_uint *elements;
 162
 163     st_assert (size >= 0);
 164
 165     size_oops = size / (sizeof (st_oop) / sizeof (st_uint));
 166
 167     array = st_memory_allocate (ST_SIZE_OOPS (struct st_word_array) + size_oops);
 168     st_object_initialize_header (array, class);
 169
 170     ST_ARRAYED_OBJECT (array)->size = st_smi_new (size);
 171     elements = st_word_array_elements (array);
 172     for (st_smi i = 0; i < size; i++)
 173         elements[i] = 0;
 174
 175     return array;
 176 }
 177
 178
 179 static st_uint
 180 word_array_size (st_oop object)
 181 {
 182     return ST_SIZE_OOPS (struct st_arrayed_object)
 183         + (st_smi_value (st_arrayed_object_size (object)) / (sizeof (st_oop) / sizeof (st_uint)));
 184 }
 185
 186 static void
 187 word_array_contents (st_oop object, st_oop **oops, st_uint *size)
 188 {
 189     *oops = NULL;
 190     *size = 0;
 191 }
 192
 193 st_descriptor *
 194 st_word_array_descriptor (void)
 195 {
 196     static st_descriptor __descriptor =
 197         { .allocate         = NULL,
 198           .allocate_arrayed = word_allocate_arrayed,
 199           .size             = word_array_size,
 200           .contents         = word_array_contents,
 201         };
 202     return & __descriptor;
 203 }
 204
 205
 206 /* FloatArray */
 207
 208 static st_oop
 209 float_allocate_arrayed (st_oop class, st_smi size)
 210 {
 211     st_oop  object;
 212     double *elements;
 213     st_smi  size_oops;
 214
 215     st_assert (size >= 0);
 216
 217     /* get actual size in oops (dependent on whether system is 64bit or 32bit) */
 218     size_oops = size * (sizeof (double) / sizeof (st_oop));
 219
 220     object = st_memory_allocate (ST_SIZE_OOPS (struct st_float_array) + size_oops);
 221     st_object_initialize_header (object, class);
 222
 223     ST_ARRAYED_OBJECT (object)->size = st_smi_new (size);
 224
 225     elements = ST_FLOAT_ARRAY (object)->elements;
 226     for (st_smi i = 0; i < size; i++)
 227         elements[i] = (double) 0;
 228
 229     return object;
 230 }
 231
 232 static st_uint
 233 float_array_size (st_oop object)
 234 {
 235     return ST_SIZE_OOPS (struct st_arrayed_object) + (st_smi_value (st_arrayed_object_size (object)) * ST_SIZE_OOPS (double));
 236 }
 237
 238 static void
 239 float_array_contents (st_oop object, st_oop **oops, st_uint *size)
 240 {
 241     *oops = NULL;
 242     *size = 0;
 243 }
 244
 245 st_descriptor *
 246 st_float_array_descriptor (void)
 247 {
 248     static st_descriptor __descriptor =
 249         { .allocate         = NULL,
 250           .allocate_arrayed = float_allocate_arrayed,
 251           .size             = float_array_size,
 252           .contents         = float_array_contents,
 253         };
 254
 255     return & __descriptor;
 256 }