src/gras/DataDesc/ddt_create.c

   1 /* $Id$ */
   2
   3 /* ddt_new - creation/deletion of datatypes structs (private to this module)*/
   4
   5 /* Authors: Olivier Aumage, Martin Quinson                                  */
   6 /* Copyright (C) 2003, 2004 the GRAS posse.                                 */
   7
   8 /* This program is free software; you can redistribute it and/or modify it
   9    under the terms of the license (GNU LGPL) which comes with this package. */
  10
  11 #include "DataDesc/datadesc_private.h"
  12
  13 GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(new,DataDesc);
  14
  15 static gras_error_t
  16 gras_ddt_new(const char            *name,
  17              gras_datadesc_type_t **dst) {
  18
  19   gras_datadesc_type_t *res=malloc(sizeof(gras_datadesc_type_t));
  20   if (!res)
  21     RAISE_MALLOC;
  22
  23   memset(res, 0, sizeof(res));
  24   res->name = strdup(name);
  25
  26   *dst=res;
  27   return no_error;
  28 }
  29
  30 /**
  31  * gras_ddt_new_scalar:
  32  *
  33  * Create a new scalar and give a pointer to it
  34  */
  35 gras_error_t
  36 gras_ddt_new_scalar(const char                       *name,
  37                     long int                         size,
  38                     enum e_gras_dd_scalar_encoding   encoding,
  39                     gras_datadesc_type_cb_void_t     cb,
  40                     gras_datadesc_type_t           **dst) {
  41
  42   gras_error_t errcode;
  43   gras_datadesc_type_t *res;
  44
  45   TRY(gras_ddt_new(name,dst));
  46   res=*dst;
  47
  48   res->size = size>0 ? size : 0;
  49
  50   if (size>0) { /* Black magic from Oli FIXME: documentation ;)*/
  51     long int sz   = size;
  52     long int mask = sz;
  53
  54     while ((sz >>= 1)) {
  55       mask |= sz;
  56     }
  57
  58     if (size & (mask >> 1)) {
  59       res->alignment = (size & ~(mask >> 1)) << 1;
  60       gras_assert0(res->alignment != 0,
  61                    "scalar type too large");
  62
  63       res->aligned_size    = aligned(size, res->alignment);
  64       gras_assert0 (res->aligned_size >= 0,
  65                     "scalar type too large");
  66
  67     } else {
  68       res->alignment       = size & ~(mask >> 1);;
  69       res->aligned_size    = aligned(size, res->alignment);
  70     }
  71
  72   } else {
  73     res->alignment    = 0;
  74     res->aligned_size = 0;
  75   }
  76
  77   res->category_code                 = e_gras_datadesc_type_cat_scalar;
  78   res->category.scalar_data.encoding = encoding;
  79
  80   res->pre = cb;
  81   return no_error;
  82 }
  83
  84
  85 /**
  86  * gras_dd_cat_field_free:
  87  *
  88  * Frees one struct or union field
  89  */
  90 void gras_dd_cat_field_free(void *f) {
  91   gras_dd_cat_field_t *field = (gras_dd_cat_field_t *)f;
  92   if (field) {
  93     if (field->name)
  94       free(field->name);
  95     free(field);
  96   }
  97 }
  98
  99 /**
 100  * gras_ddt_new_struct:
 101  *
 102  * Create a new struct and give a pointer to it
 103  */
 104 gras_error_t
 105 gras_ddt_new_struct(const char                      *name,
 106                     gras_datadesc_type_cb_void_t     pre,
 107                     gras_datadesc_type_cb_void_t     post,
 108                     gras_datadesc_type_t           **dst) {
 109
 110   gras_error_t errcode;
 111   gras_datadesc_type_t *res;
 112
 113   TRY(gras_ddt_new(name,dst));
 114   res=*dst;
 115
 116   res->size                     = 0;
 117   res->alignment                = 0;
 118   res->aligned_size             = 0;
 119   res->category_code            = e_gras_datadesc_type_cat_struct;
 120   TRY(gras_dynar_new(&(res->category.struct_data.fields),
 121                      sizeof(gras_dd_cat_field_t*),
 122                      &gras_dd_cat_field_free));
 123   res->pre                      = pre;
 124   res->post                     = post;
 125
 126   return no_error;
 127 }
 128
 129 /**
 130  * gras_ddt_new_struct_append:
 131  *
 132  * Append a field to the struct
 133  */
 134 gras_error_t
 135 gras_ddt_new_struct_append(gras_datadesc_type_t            *struct_type,
 136                            const char                      *name,
 137                            gras_datadesc_type_t            *field_type,
 138                            gras_datadesc_type_cb_void_t     pre,
 139                            gras_datadesc_type_cb_void_t     post) {
 140
 141   gras_error_t errcode;
 142   gras_dd_cat_field_t *field;
 143
 144   gras_assert0(field_type->size >= 0,
 145                "Cannot add a dynamically sized field in a structure");
 146
 147   field=malloc(sizeof(gras_dd_cat_field_t));
 148   if (!field)
 149     RAISE_MALLOC;
 150
 151   field->name   = strdup(name);
 152   field->offset = aligned(struct_type->size, field_type->alignment);
 153   field->code   = field_type->code;
 154   field->pre    = pre;
 155   field->post   = post;
 156
 157   TRY(gras_dynar_push(struct_type->category.struct_data.fields, field));
 158
 159   struct_type->size             = field->offset + field_type->size;
 160   struct_type->alignment        = max(struct_type->alignment, field_type->alignment);
 161   struct_type->aligned_size     = aligned(struct_type->size, struct_type->alignment);
 162
 163   return no_error;
 164 }
 165
 166 /**
 167  * gras_ddt_new_union:
 168  *
 169  * Create a new union and give a pointer to it
 170  */
 171 gras_error_t
 172 gras_ddt_new_union(const char                      *name,
 173                    gras_datadesc_type_cb_int_t      field_count,
 174                    gras_datadesc_type_cb_void_t     post,
 175                    gras_datadesc_type_t           **dst) {
 176
 177   gras_error_t errcode;
 178   gras_datadesc_type_t *res;
 179
 180   gras_assert0(field_count,
 181                "Attempt to creat an union without field_count function");
 182
 183   TRY(gras_ddt_new(name,dst));
 184   res=*dst;
 185
 186   res->size                     = 0;
 187   res->alignment                = 0;
 188   res->aligned_size             = 0;
 189   res->category_code            = e_gras_datadesc_type_cat_union;
 190   TRY(gras_dynar_new(&(res->category.union_data.fields),
 191                      sizeof(gras_dd_cat_field_t*),
 192                      &gras_dd_cat_field_free));
 193   res->category.union_data.field_count = field_count;
 194   res->pre                      = NULL;
 195   res->post                     = post;
 196
 197   return no_error;
 198 }
 199
 200 /**
 201  * gras_ddt_new_union_append:
 202  *
 203  * Append a field to the union
 204  */
 205 gras_error_t
 206 gras_ddt_new_union_append(gras_datadesc_type_t            *union_type,
 207                           const char                      *name,
 208                           gras_datadesc_type_t            *field_type,
 209                           gras_datadesc_type_cb_void_t     pre,
 210                           gras_datadesc_type_cb_void_t     post) {
 211
 212   gras_error_t errcode;
 213   gras_dd_cat_field_t *field;
 214
 215   gras_assert0(field_type->size >= 0,
 216                "Cannot add a dynamically sized field in an union");
 217
 218   field=malloc(sizeof(gras_dd_cat_field_t));
 219   if (!field)
 220     RAISE_MALLOC;
 221
 222   field->name   = strdup(name);
 223   field->offset = 0; /* that's the purpose of union ;) */
 224   field->code   = field_type->code;
 225   field->pre    = pre;
 226   field->post   = post;
 227
 228   TRY(gras_dynar_push(union_type->category.union_data.fields, field));
 229
 230   union_type->size         = max(union_type->size, field_type->size);
 231   union_type->alignment    = max(union_type->alignment, field_type->alignment);
 232   union_type->aligned_size = aligned(union_type->size, union_type->alignment);
 233
 234   return no_error;
 235 }
 236
 237 /**
 238  * gras_ddt_new_ref:
 239  *
 240  * Create a new ref and give a pointer to it
 241  */
 242 gras_error_t
 243 gras_ddt_new_ref(const char                      *name,
 244                  gras_datadesc_type_t            *referenced_type,
 245                  gras_datadesc_type_cb_int_t      discriminant,
 246                  gras_datadesc_type_cb_void_t     post,
 247                  gras_datadesc_type_t           **dst) {
 248
 249   gras_error_t errcode;
 250   gras_datadesc_type_t *res;
 251
 252   gras_assert0(discriminant || referenced_type,
 253                "Attempt to create a generic reference without discriminant");
 254
 255   TRY(gras_ddt_new(name,dst));
 256   res=*dst;
 257
 258   /* FIXME: Size from bootstraping */
 259   res->size                     = 0;
 260   res->alignment                = 0;
 261   res->aligned_size             = 0;
 262   res->category_code            = e_gras_datadesc_type_cat_ref;
 263
 264   res->category.ref_data.code         = referenced_type ? referenced_type->code : -1;
 265   res->category.ref_data.discriminant = discriminant;
 266   res->pre                      = NULL;
 267   res->post                     = post;
 268
 269   return no_error;
 270 }
 271
 272 /**
 273  * gras_ddt_new_array:
 274  *
 275  * Create a new array and give a pointer to it
 276  */
 277 gras_error_t
 278 gras_ddt_new_array(const char                      *name,
 279                    gras_datadesc_type_t            *element_type,
 280                    long int                         fixed_size,
 281                    gras_datadesc_type_cb_int_t      dynamic_size,
 282                    gras_datadesc_type_cb_void_t     post,
 283                    gras_datadesc_type_t           **dst) {
 284
 285   gras_error_t errcode;
 286   gras_datadesc_type_t *res;
 287
 288   gras_assert0(dynamic_size || fixed_size>0,
 289                "Attempt to create a dynamic array without size discriminant");
 290
 291   TRY(gras_ddt_new(name,dst));
 292   res=*dst;
 293
 294   if (fixed_size <= 0) {
 295     res->size = fixed_size;
 296   } else {
 297     res->size = fixed_size * element_type->aligned_size;
 298   }
 299   res->alignment                = element_type->alignment;
 300   res->aligned_size             = fixed_size; /*FIXME: That was so in GS, but looks stupid*/
 301   res->category_code            = e_gras_datadesc_type_cat_array;
 302
 303   res->category.array_data.code         = element_type->code;
 304   res->category.array_data.fixed_size   = fixed_size;
 305   res->category.array_data.dynamic_size = dynamic_size;
 306
 307   res->pre                      = NULL;
 308   res->post                     = post;
 309
 310   return no_error;
 311 }
 312
 313 /**
 314  * gras_ddt_new_ignored:
 315  *
 316  * Create a new ignored field and give a pointer to it.
 317  *
 318  * If you give a default value, it will be copied away so that you can free your copy.
 319  */
 320 gras_error_t
 321 gras_ddt_new_ignored(const char *name,
 322                      void *default_value,
 323                      void_f_pvoid_t   *free_func,
 324                      long int                       size,
 325                      long int                       alignment,
 326                      gras_datadesc_type_cb_void_t     post,
 327                      gras_datadesc_type_t           **dst) {
 328   gras_error_t errcode;
 329   gras_datadesc_type_t *res;
 330
 331   TRY(gras_ddt_new(name,dst));
 332   res=*dst;
 333
 334   res->size             = size > 0?size:0;
 335   res->alignment        = alignment;
 336
 337   if (size > 0) {
 338     res->aligned_size   = aligned(size, alignment);
 339   } else {
 340     res->aligned_size   = 0;
 341   }
 342
 343   if (default_value && res->size) {
 344     res->category.ignored_data.default_value = malloc((size_t)size);
 345     if (! (res->category.ignored_data.default_value) )
 346       RAISE_MALLOC;
 347     memcpy(res->category.ignored_data.default_value,
 348            default_value, (size_t)size);
 349   }
 350
 351   res->category_code = e_gras_datadesc_type_cat_ignored;
 352   res->category.ignored_data.free_func = free_func;
 353
 354   res->post = post;
 355
 356
 357   res->size = size;
 358
 359   return no_error;
 360 }
 361
 362 /**
 363  * gras_ddt_free:
 364  *
 365  * Frees a datadescription.
 366  */
 367 void gras_ddt_free(gras_datadesc_type_t **type) {
 368   gras_datadesc_type_t *t;
 369
 370   if (type && *type) {
 371     t=*type;
 372
 373     free(t->name);
 374     switch (t->category_code) {
 375     case e_gras_datadesc_type_cat_scalar:
 376     case e_gras_datadesc_type_cat_ref:
 377     case e_gras_datadesc_type_cat_array:
 378       /* nothing to free in there */
 379       break;
 380
 381     case e_gras_datadesc_type_cat_ignored:
 382       if (t->category.ignored_data.free_func) {
 383         t->category.ignored_data.free_func(t->category.ignored_data.default_value);
 384       }
 385       break;
 386
 387     case e_gras_datadesc_type_cat_struct:
 388       gras_dynar_free(t->category.struct_data.fields);
 389       break;
 390
 391     case e_gras_datadesc_type_cat_union:
 392       gras_dynar_free(t->category.union_data.fields);
 393       break;
 394
 395     default:
 396       /* datadesc was invalid. Killing it is like euthanasy, I guess */
 397       break;
 398     }
 399   }
 400 }