src/gras/DataDesc/datadesc.c

   1 /* $Id$ */
   2
   3 /* datadesc - data description in order to send/recv it in GRAS             */
   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(DataDesc,GRAS);
  14 gras_set_t *gras_datadesc_set_local=NULL;
  15
  16 /**
  17  * gras_datadesc_init:
  18  *
  19  * Initialize the datadesc module
  20  **/
  21 void
  22 gras_datadesc_init(void) {
  23   gras_error_t errcode;
  24
  25   VERB0("Initializing DataDesc");
  26   errcode = gras_set_new(&gras_datadesc_set_local);
  27   gras_assert0(errcode==no_error,
  28                "Impossible to create the data set containg locally known types");
  29 }
  30
  31 /**
  32  * gras_datadesc_exit:
  33  *
  34  * Finalize the datadesc module
  35  **/
  36 void
  37 gras_datadesc_exit(void) {
  38   VERB0("Exiting DataDesc");
  39   gras_set_free(&gras_datadesc_set_local);
  40 }
  41
  42 /***
  43  *** CREATION FUNCTIONS: private to this file
  44  ***/
  45 static gras_error_t
  46 gras_ddt_new(const char            *name,
  47              gras_datadesc_type_t **dst) {
  48
  49   gras_datadesc_type_t *res=malloc(sizeof(gras_datadesc_type_t));
  50   if (!res)
  51     RAISE_MALLOC;
  52
  53   memset(res, 0, sizeof(res));
  54   res->name = strdup(name);
  55
  56   *dst=res;
  57   return no_error;
  58 }
  59
  60 /**
  61  * gras_ddt_new_scalar:
  62  *
  63  * Create a new scalar and give a pointer to it
  64  */
  65 gras_error_t
  66 gras_ddt_new_scalar(const char                       *name,
  67                     long int                         size,
  68                     enum e_gras_dd_scalar_encoding   encoding,
  69                     gras_datadesc_type_cb_void_t     cb,
  70                     gras_datadesc_type_t           **dst) {
  71
  72   gras_error_t errcode;
  73   gras_datadesc_type_t *res;
  74
  75   TRY(gras_ddt_new(name,dst));
  76   res=*dst;
  77
  78   res->size = size>0 ? size : 0;
  79
  80   if (size>0) { /* Black magic from Oli FIXME: documentation ;)*/
  81     long int sz   = size;
  82     long int mask = sz;
  83
  84     while ((sz >>= 1)) {
  85       mask |= sz;
  86     }
  87
  88     if (size & (mask >> 1)) {
  89       res->alignment = (size & ~(mask >> 1)) << 1;
  90       gras_assert0(res->alignment != 0,
  91                    "scalar type too large");
  92
  93       res->aligned_size    = aligned(size, res->alignment);
  94       gras_assert0 (res->aligned_size >= 0,
  95                     "scalar type too large");
  96
  97     } else {
  98       res->alignment       = size & ~(mask >> 1);;
  99       res->aligned_size    = aligned(size, res->alignment);
 100     }
 101
 102   } else {
 103     res->alignment    = 0;
 104     res->aligned_size = 0;
 105   }
 106
 107   res->category_code                 = e_gras_datadesc_type_cat_scalar;
 108   res->category.scalar_data.encoding = encoding;
 109
 110   res->pre = cb;
 111   return no_error;
 112 }
 113
 114
 115 /**
 116  * gras_dd_cat_field_free:
 117  *
 118  * Frees one struct or union field
 119  */
 120 void gras_dd_cat_field_free(void *f) {
 121   gras_dd_cat_field_t *field = (gras_dd_cat_field_t *)f;
 122   if (field) {
 123     if (field->name)
 124       free(field->name);
 125     free(field);
 126   }
 127 }
 128
 129 /**
 130  * gras_ddt_new_struct:
 131  *
 132  * Create a new struct and give a pointer to it
 133  */
 134 gras_error_t
 135 gras_ddt_new_struct(const char                      *name,
 136                     gras_datadesc_type_cb_void_t     pre,
 137                     gras_datadesc_type_cb_void_t     post,
 138                     gras_datadesc_type_t           **dst) {
 139
 140   gras_error_t errcode;
 141   gras_datadesc_type_t *res;
 142
 143   TRY(gras_ddt_new(name,dst));
 144   res=*dst;
 145
 146   res->size                     = 0;
 147   res->alignment                = 0;
 148   res->aligned_size             = 0;
 149   res->category_code            = e_gras_datadesc_type_cat_struct;
 150   TRY(gras_dynar_new(&(res->category.struct_data.fields),
 151                      sizeof(gras_dd_cat_field_t*),
 152                      &gras_dd_cat_field_free));
 153   res->pre                      = pre;
 154   res->post                     = post;
 155
 156   return no_error;
 157 }
 158
 159 /**
 160  * gras_ddt_new_struct_append:
 161  *
 162  * Append a field to the struct
 163  */
 164 gras_error_t
 165 gras_ddt_new_struct_append(gras_datadesc_type_t            *struct_type,
 166                            const char                      *name,
 167                            gras_datadesc_type_t            *field_type,
 168                            gras_datadesc_type_cb_void_t     pre,
 169                            gras_datadesc_type_cb_void_t     post) {
 170
 171   gras_error_t errcode;
 172   gras_dd_cat_field_t *field;
 173
 174   gras_assert0(field_type->size >= 0,
 175                "Cannot add a dynamically sized field in a structure");
 176
 177   field=malloc(sizeof(gras_dd_cat_field_t));
 178   if (!field)
 179     RAISE_MALLOC;
 180
 181   field->name   = strdup(name);
 182   field->offset = aligned(struct_type->size, field_type->alignment);
 183   field->code   = field_type->code;
 184   field->pre    = pre;
 185   field->post   = post;
 186
 187   TRY(gras_dynar_push(struct_type->category.struct_data.fields, field));
 188
 189   struct_type->size             = field->offset + field_type->size;
 190   struct_type->alignment        = max(struct_type->alignment, field_type->alignment);
 191   struct_type->aligned_size     = aligned(struct_type->size, struct_type->alignment);
 192
 193   return no_error;
 194 }
 195
 196 /**
 197  * gras_ddt_new_union:
 198  *
 199  * Create a new union and give a pointer to it
 200  */
 201 gras_error_t
 202 gras_ddt_new_union(const char                      *name,
 203                    gras_datadesc_type_cb_int_t      field_count,
 204                    gras_datadesc_type_cb_void_t     post,
 205                    gras_datadesc_type_t           **dst) {
 206
 207   gras_error_t errcode;
 208   gras_datadesc_type_t *res;
 209
 210   gras_assert0(field_count,
 211                "Attempt to creat an union without field_count function");
 212
 213   TRY(gras_ddt_new(name,dst));
 214   res=*dst;
 215
 216   res->size                     = 0;
 217   res->alignment                = 0;
 218   res->aligned_size             = 0;
 219   res->category_code            = e_gras_datadesc_type_cat_union;
 220   TRY(gras_dynar_new(&(res->category.union_data.fields),
 221                      sizeof(gras_dd_cat_field_t*),
 222                      &gras_dd_cat_field_free));
 223   res->category.union_data.field_count = field_count;
 224   res->pre                      = NULL;
 225   res->post                     = post;
 226
 227   return no_error;
 228 }
 229
 230 /**
 231  * gras_ddt_new_union_append:
 232  *
 233  * Append a field to the union
 234  */
 235 gras_error_t
 236 gras_ddt_new_union_append(gras_datadesc_type_t            *union_type,
 237                           const char                      *name,
 238                           gras_datadesc_type_t            *field_type,
 239                           gras_datadesc_type_cb_void_t     pre,
 240                           gras_datadesc_type_cb_void_t     post) {
 241
 242   gras_error_t errcode;
 243   gras_dd_cat_field_t *field;
 244
 245   gras_assert0(field_type->size >= 0,
 246                "Cannot add a dynamically sized field in an union");
 247
 248   field=malloc(sizeof(gras_dd_cat_field_t));
 249   if (!field)
 250     RAISE_MALLOC;
 251
 252   field->name   = strdup(name);
 253   field->offset = 0; /* that's the purpose of union ;) */
 254   field->code   = field_type->code;
 255   field->pre    = pre;
 256   field->post   = post;
 257
 258   TRY(gras_dynar_push(union_type->category.union_data.fields, field));
 259
 260   union_type->size         = max(union_type->size, field_type->size);
 261   union_type->alignment    = max(union_type->alignment, field_type->alignment);
 262   union_type->aligned_size = aligned(union_type->size, union_type->alignment);
 263
 264   return no_error;
 265 }
 266
 267 /**
 268  * gras_ddt_new_ref:
 269  *
 270  * Create a new ref and give a pointer to it
 271  */
 272 gras_error_t
 273 gras_ddt_new_ref(const char                      *name,
 274                  gras_datadesc_type_t            *referenced_type,
 275                  gras_datadesc_type_cb_int_t      discriminant,
 276                  gras_datadesc_type_cb_void_t     post,
 277                  gras_datadesc_type_t           **dst) {
 278
 279   gras_error_t errcode;
 280   gras_datadesc_type_t *res;
 281
 282   gras_assert0(discriminant || referenced_type,
 283                "Attempt to create a generic reference without discriminant");
 284
 285   TRY(gras_ddt_new(name,dst));
 286   res=*dst;
 287
 288   /* FIXME: Size from bootstraping */
 289   res->size                     = 0;
 290   res->alignment                = 0;
 291   res->aligned_size             = 0;
 292   res->category_code            = e_gras_datadesc_type_cat_ref;
 293
 294   res->category.ref_data.code         = referenced_type ? referenced_type->code : -1;
 295   res->category.ref_data.discriminant = discriminant;
 296   res->pre                      = NULL;
 297   res->post                     = post;
 298
 299   return no_error;
 300 }
 301
 302 /**
 303  * gras_ddt_new_array:
 304  *
 305  * Create a new array and give a pointer to it
 306  */
 307 gras_error_t
 308 gras_ddt_new_array(const char                      *name,
 309                    gras_datadesc_type_t            *element_type,
 310                    long int                         fixed_size,
 311                    gras_datadesc_type_cb_int_t      dynamic_size,
 312                    gras_datadesc_type_cb_void_t     post,
 313                    gras_datadesc_type_t           **dst) {
 314
 315   gras_error_t errcode;
 316   gras_datadesc_type_t *res;
 317
 318   gras_assert0(dynamic_size || fixed_size>0,
 319                "Attempt to create a dynamic array without size discriminant");
 320
 321   TRY(gras_ddt_new(name,dst));
 322   res=*dst;
 323
 324   if (fixed_size <= 0) {
 325     res->size = fixed_size;
 326   } else {
 327     res->size = fixed_size * element_type->aligned_size;
 328   }
 329   res->alignment                = element_type->alignment;
 330   res->aligned_size             = fixed_size; /*FIXME: That was so in GS, but looks stupid*/
 331   res->category_code            = e_gras_datadesc_type_cat_array;
 332
 333   res->category.array_data.code         = element_type->code;
 334   res->category.array_data.fixed_size   = fixed_size;
 335   res->category.array_data.dynamic_size = dynamic_size;
 336
 337   res->pre                      = NULL;
 338   res->post                     = post;
 339
 340   return no_error;
 341 }
 342
 343 /***
 344  *** BOOTSTRAPING FUNCTIONS: known within GRAS only
 345  ***/
 346
 347 /***
 348  *** DECLARATION FUNCTIONS: public functions
 349  ***/
 350 gras_error_t
 351 gras_datadesc_declare_struct_cb(const char                   *name,
 352                                 gras_datadesc_type_cb_void_t  pre,
 353                                 gras_datadesc_type_cb_void_t  post,
 354                                 long int                     *code) {
 355   gras_error_t errcode;
 356   gras_datadesc_type_t *type;
 357   TRY(gras_ddt_new_struct(name, pre, post, &type));
 358   TRY(gras_ddt_register(gras_datadesc_set_local, type));
 359   *code = type->code;
 360   return no_error;
 361 }
 362
 363 gras_error_t
 364 gras_datadesc_declare_struct_add_name_cb(long int    struct_code,
 365                                          const char *field_name,
 366                                          const char *field_type_name,
 367                                          gras_datadesc_type_cb_void_t     pre_cb,
 368                                          gras_datadesc_type_cb_void_t     post_cb) {
 369
 370   gras_error_t errcode;
 371   gras_datadesc_type_t *struct_type;
 372   gras_datadesc_type_t *field_type;
 373
 374   TRY(gras_set_get_by_id(gras_datadesc_set_local,struct_code,
 375                          (gras_set_elm_t**)struct_type));
 376   TRY(gras_set_get_by_name(gras_datadesc_set_local,field_type_name,
 377                          (gras_set_elm_t**)field_type));
 378
 379   TRY(gras_ddt_new_struct_append(struct_type,
 380                                  field_name,  field_type,
 381                                  pre_cb,      post_cb));
 382
 383   return no_error;
 384 }
 385 gras_error_t
 386 gras_datadesc_declare_struct_add_code_cb(long int    struct_code,
 387                                          const char *field_name,
 388                                          long int    field_code,
 389                                          gras_datadesc_type_cb_void_t     pre_cb,
 390                                          gras_datadesc_type_cb_void_t     post_cb) {
 391   gras_error_t errcode;
 392   gras_datadesc_type_t *struct_type;
 393   gras_datadesc_type_t *field_type;
 394
 395   TRY(gras_set_get_by_id(gras_datadesc_set_local,struct_code,
 396                          (gras_set_elm_t**)struct_type));
 397   TRY(gras_set_get_by_id(gras_datadesc_set_local,field_code,
 398                          (gras_set_elm_t**)field_type));
 399
 400   TRY(gras_ddt_new_struct_append(struct_type,
 401                                  field_name,  field_type,
 402                                  pre_cb,      post_cb));
 403
 404   return no_error;
 405 }
 406
 407 gras_error_t
 408 gras_datadesc_declare_union_cb(const char                   *name,
 409                                gras_datadesc_type_cb_int_t   field_count,
 410                                gras_datadesc_type_cb_void_t  post,
 411                                long int                     *code) {
 412   gras_error_t errcode;
 413   gras_datadesc_type_t *type;
 414   TRY(gras_ddt_new_union(name, field_count, post, &type));
 415   TRY(gras_ddt_register(gras_datadesc_set_local, type));
 416   *code = type->code;
 417   return no_error;
 418 }
 419
 420 gras_error_t
 421 gras_datadesc_declare_union_add_name_cb(long int                      union_code,
 422                                         const char                   *field_name,
 423                                         const char                   *field_type_name,
 424                                         gras_datadesc_type_cb_void_t  pre_cb,
 425                                         gras_datadesc_type_cb_void_t  post_cb) {
 426   gras_error_t errcode;
 427   gras_datadesc_type_t *union_type;
 428   gras_datadesc_type_t *field_type;
 429
 430   TRY(gras_set_get_by_id(gras_datadesc_set_local,union_code,
 431                          (gras_set_elm_t**)union_type));
 432   TRY(gras_set_get_by_name(gras_datadesc_set_local,field_type_name,
 433                          (gras_set_elm_t**)field_type));
 434
 435   TRY(gras_ddt_new_union_append(union_type,
 436                                 field_name,  field_type,
 437                                 pre_cb,      post_cb));
 438
 439   return no_error;
 440 }
 441 gras_error_t
 442 gras_datadesc_declare_union_add_code_cb(long int                      union_code,
 443                                         const char                   *field_name,
 444                                         long int                      field_code,
 445                                         gras_datadesc_type_cb_void_t  pre_cb,
 446                                         gras_datadesc_type_cb_void_t  post_cb) {
 447   gras_error_t errcode;
 448   gras_datadesc_type_t *union_type;
 449   gras_datadesc_type_t *field_type;
 450
 451   TRY(gras_set_get_by_id(gras_datadesc_set_local,union_code,
 452                          (gras_set_elm_t**)union_type));
 453   TRY(gras_set_get_by_id(gras_datadesc_set_local,field_code,
 454                          (gras_set_elm_t**)field_type));
 455
 456   TRY(gras_ddt_new_union_append(union_type,
 457                                 field_name,  field_type,
 458                                 pre_cb,      post_cb));
 459
 460   return no_error;
 461 }
 462
 463 gras_error_t
 464 gras_datadesc_declare_ref_cb(const char                      *name,
 465                              gras_datadesc_type_t            *referenced_type,
 466                              gras_datadesc_type_cb_int_t      discriminant,
 467                              gras_datadesc_type_cb_void_t     post,
 468                              long int                        *code){
 469   gras_error_t errcode;
 470   gras_datadesc_type_t *type;
 471   TRY(gras_ddt_new_ref(name, referenced_type,discriminant,post, &type));
 472   TRY(gras_ddt_register(gras_datadesc_set_local, type));
 473   *code = type->code;
 474   return no_error;
 475 }
 476
 477 gras_error_t
 478 gras_datadesc_declare_array_cb(const char                      *name,
 479                                gras_datadesc_type_t            *element_type,
 480                                long int                         fixed_size,
 481                                gras_datadesc_type_cb_int_t      dynamic_size,
 482                                gras_datadesc_type_cb_void_t     post,
 483                                long int                        *code){
 484   gras_error_t errcode;
 485   gras_datadesc_type_t *type;
 486   TRY(gras_ddt_new_array(name, element_type, fixed_size, dynamic_size, post, &type));
 487   TRY(gras_ddt_register(gras_datadesc_set_local, type));
 488   *code = type->code;
 489   return no_error;
 490 }