libs/loaders/GP_MetaData.c

   1 /*****************************************************************************
   2  * This file is part of gfxprim library.                                     *
   3  *                                                                           *
   4  * Gfxprim is free software; you can redistribute it and/or                  *
   5  * modify it under the terms of the GNU Lesser General Public                *
   6  * License as published by the Free Software Foundation; either              *
   7  * version 2.1 of the License, or (at your option) any later version.        *
   8  *                                                                           *
   9  * Gfxprim is distributed in the hope that it will be useful,                *
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  12  * Lesser General Public License for more details.                           *
  13  *                                                                           *
  14  * You should have received a copy of the GNU Lesser General Public          *
  15  * License along with gfxprim; if not, write to the Free Software            *
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor,                        *
  17  * Boston, MA  02110-1301  USA                                               *
  18  *                                                                           *
  19  * Copyright (C) 2009-2012 Cyril Hrubis <metan@ucw.cz>                       *
  20  *                                                                           *
  21  *****************************************************************************/
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include "core/GP_Debug.h"
  27
  28 #include "GP_MetaData.h"
  29
  30 struct GP_MetaData {
  31         struct GP_MetaRecord *root;
  32         struct GP_MetaRecord *last;
  33         unsigned int rec_count;
  34         size_t size;
  35         size_t free;
  36         char buf[];
  37 };
  38
  39 static unsigned int do_hash(const char *id)
  40 {
  41         unsigned int hash = 0;
  42
  43         while (*id != '\0') {
  44                 hash += *id * 1217;
  45                 hash %= 46309;
  46                 id += 1;
  47         }
  48
  49         return hash;
  50 }
  51
  52 GP_MetaData *GP_MetaDataCreate(unsigned int expected_records)
  53 {
  54         GP_MetaData *data;
  55         size_t size = expected_records * sizeof(struct GP_MetaRecord);
  56
  57         GP_DEBUG(1, "Creating MetaData for %u records", expected_records);
  58
  59         data = malloc(sizeof(struct GP_MetaData) + size);
  60
  61         if (data == NULL) {
  62                 GP_DEBUG(1, "Malloc failed :(");
  63                 return NULL;
  64         }
  65
  66         data->root = NULL;
  67         data->last = NULL;
  68         data->rec_count = 0;
  69         data->size = size;
  70         data->free = size;
  71
  72         return data;
  73 }
  74
  75 void GP_MetaDataClear(GP_MetaData *self)
  76 {
  77         GP_DEBUG(1, "Clearing MetaData %p with %u records",
  78                  self, self->rec_count);
  79
  80         self->root = NULL;
  81         self->last = NULL;
  82         self->rec_count = 0;
  83         self->free = self->size;
  84 }
  85
  86 void GP_MetaDataDestroy(GP_MetaData *self)
  87 {
  88         GP_DEBUG(1, "Destroying MetaData %p", self);
  89         free(self);
  90 }
  91
  92 void GP_MetaDataPrint(GP_MetaData *self)
  93 {
  94         GP_MetaRecord *rec;
  95
  96         printf("MetaData %u record(s)\n", self->rec_count);
  97
  98         for (rec = self->root; rec != NULL; rec = rec->next) {
  99                 printf("%-32s: ", rec->id);
 100
 101                 switch (rec->type) {
 102                 case GP_META_INT:
 103                         printf("%i\n", rec->val.i);
 104                 break;
 105                 case GP_META_RATIONAL:
 106                         printf("%i/%i (%.4f)\n", rec->val.r.num, rec->val.r.den,
 107                                (float)rec->val.r.num / rec->val.r.den);
 108                 break;
 109                 case GP_META_STRING:
 110                         printf("'%s'\n", rec->val.str);
 111                 break;
 112                 case GP_META_DOUBLE:
 113                         printf("%lf\n", rec->val.d);
 114                 break;
 115                 }
 116         }
 117 }
 118
 119 static GP_MetaRecord *record_lookup(GP_MetaData *self, const char *id,
 120                                     unsigned int hash)
 121 {
 122         GP_MetaRecord *rec;
 123
 124         for (rec = self->root; rec != NULL; rec = rec->next)
 125                 if (rec->hash == hash && !strcmp(rec->id, id))
 126                         return rec;
 127
 128         return NULL;
 129 }
 130
 131 static void *do_alloc(struct GP_MetaData *self, size_t size)
 132 {
 133         if (self->free < size) {
 134                 GP_DEBUG(0, "TODO: storage full");
 135                 return NULL;
 136         }
 137
 138         void *ret = ((char*)self) + sizeof(struct GP_MetaData) + (self->size - self->free);
 139
 140         self->free -= size;
 141
 142         return ret;
 143 }
 144
 145 static GP_MetaRecord *record_create(GP_MetaData *self, const char *id,
 146                                     unsigned int hash)
 147 {
 148         GP_MetaRecord *rec;
 149
 150         if (strlen(id) + 1 > GP_META_RECORD_ID_MAX) {
 151                 GP_DEBUG(0, "Can't create id '%s' longer than %i chars",
 152                          id, GP_META_RECORD_ID_MAX - 1);
 153                 return NULL;
 154         }
 155
 156         rec = do_alloc(self, sizeof(struct GP_MetaRecord));
 157
 158         if (rec == NULL)
 159                 return NULL;
 160
 161         strcpy(rec->id, id);
 162         rec->hash = hash;
 163         rec->next = NULL;
 164
 165         if (self->root == NULL) {
 166                 self->root = rec;
 167                 self->last = rec;
 168         } else {
 169                 self->last->next = rec;
 170                 self->last = rec;
 171         }
 172
 173         self->rec_count++;
 174
 175         return rec;
 176 }
 177
 178 GP_MetaRecord *GP_MetaDataCreateRecord(GP_MetaData *self, const char *id)
 179 {
 180         unsigned int hash = do_hash(id);
 181
 182         if (record_lookup(self, id, hash)) {
 183                 GP_DEBUG(1, "Trying to create duplicate record id '%s'", id);
 184                 return NULL;
 185         }
 186
 187         return record_create(self, id, hash);
 188 }
 189
 190 int GP_MetaDataGetInt(GP_MetaData *self, const char *id, int *res)
 191 {
 192         GP_MetaRecord *rec;
 193
 194         GP_DEBUG(2, "Looking for GP_META_INT id '%s'", id);
 195
 196         rec = record_lookup(self, id, do_hash(id));
 197
 198         if (rec == NULL) {
 199                 GP_DEBUG(3, "Record id '%s' not found", id);
 200                 return 1;
 201         }
 202
 203         if (rec->type != GP_META_INT) {
 204                 GP_DEBUG(3, "Record id '%s' has wrong type", id);
 205                 return 1;
 206         }
 207
 208         *res = rec->val.i;
 209
 210         GP_DEBUG(3, "Found GP_META_INT id '%s' = %i", id, *res);
 211
 212         return 0;
 213 }
 214
 215 int GP_MetaDataGetDouble(GP_MetaData *self, const char *id, double *res)
 216 {
 217         GP_MetaRecord *rec;
 218
 219         GP_DEBUG(2, "Looking for GP_META_DOUBLE id '%s'", id);
 220
 221         rec = record_lookup(self, id, do_hash(id));
 222
 223         if (rec == NULL) {
 224                 GP_DEBUG(3, "Record id '%s' not found", id);
 225                 return 1;
 226         }
 227
 228         if (rec->type != GP_META_DOUBLE) {
 229                 GP_DEBUG(3, "Record id '%s' has wrong type", id);
 230                 return 1;
 231         }
 232
 233         *res = rec->val.d;
 234
 235         GP_DEBUG(3, "Found GP_META_DOUBLE id '%s' = %lf", id, *res);
 236
 237         return 0;
 238 }
 239
 240 const char *GP_MetaDataGetString(GP_MetaData *self, const char *id)
 241 {
 242         GP_MetaRecord *rec;
 243
 244         GP_DEBUG(2, "Looking for GP_META_STRING id '%s'", id);
 245
 246         rec = record_lookup(self, id, do_hash(id));
 247
 248         if (rec == NULL) {
 249                 GP_DEBUG(3, "Record id '%s' not found", id);
 250                 return NULL;
 251         }
 252
 253         if (rec->type != GP_META_STRING) {
 254                 GP_DEBUG(3, "Record id '%s' has wrong type", id);
 255                 return NULL;
 256         }
 257
 258         GP_DEBUG(3, "Found GP_META_STRING id '%s' = '%s'", id, rec->val.str);
 259
 260         return rec->val.str;
 261 }
 262
 263 GP_MetaRecord *GP_MetaDataCreateInt(GP_MetaData *self, const char *id, int val)
 264 {
 265         GP_MetaRecord *rec;
 266
 267         GP_DEBUG(2, "Creating GP_META_INT id '%s' = %i", id, val);
 268
 269         rec = GP_MetaDataCreateRecord(self, id);
 270
 271         if (rec == NULL)
 272                 return NULL;
 273
 274         rec->type = GP_META_INT;
 275         rec->val.i = val;
 276
 277         return rec;
 278 }
 279
 280 GP_MetaRecord *GP_MetaDataCreateRat(GP_MetaData *self, const char *id,
 281                                     int num, int den)
 282 {
 283         GP_MetaRecord *rec;
 284
 285         GP_DEBUG(2, "Creating GP_META_RATIONAL id '%s' = %i/%i", id, num, den);
 286
 287         if (den == 0) {
 288                 GP_DEBUG(1, "Would not create '%s' with denominator == 0", id);
 289                 return NULL;
 290         }
 291
 292         rec = GP_MetaDataCreateRecord(self, id);
 293
 294         if (rec == NULL)
 295                 return NULL;
 296
 297         rec->type = GP_META_RATIONAL;
 298         rec->val.r.num = num;
 299         rec->val.r.den = den;
 300
 301         return rec;
 302 }
 303
 304 GP_MetaRecord *GP_MetaDataCreateDouble(GP_MetaData *self, const char *id,
 305                                        double val)
 306 {
 307         GP_MetaRecord *rec;
 308
 309         GP_DEBUG(2, "Creating GP_META_DOUBLE id '%s' = %lf", id, val);
 310
 311         rec = GP_MetaDataCreateRecord(self, id);
 312
 313         if (rec == NULL)
 314                 return NULL;
 315
 316         rec->type = GP_META_DOUBLE;
 317         rec->val.d = val;
 318
 319         return rec;
 320 }
 321
 322 GP_MetaRecord *GP_MetaDataCreateString(GP_MetaData *self, const char *id,
 323                                        const char *str, int len, int dup)
 324 {
 325         GP_MetaRecord *rec;
 326
 327         GP_DEBUG(2, "Creating GP_META_STRING id '%s' = '%s'", id, str);
 328
 329         rec = GP_MetaDataCreateRecord(self, id);
 330
 331         if (rec == NULL)
 332                 return NULL;
 333
 334         if (dup) {
 335                 size_t size;
 336                 char *s;
 337
 338                 if (len == 0)
 339                         len = strlen(str);
 340
 341                 size = len + 1;
 342
 343                 /* Play safe with aligment */
 344                 if (size % 8)
 345                         size += 8 - size % 8;
 346
 347                 //TODO: allocation error
 348                 s = do_alloc(self, size);
 349                 memcpy(s, str, len);
 350                 s[len] = '\0';
 351                 str = s;
 352         }
 353
 354         rec->type = GP_META_STRING;
 355         rec->val.str = str;
 356
 357         return rec;
 358 }