src/ir.c

   1 /*!@file
   2   \brief   IR Memory Implementation
   3   \details Intermediary memory management
   4   \author  Jordan Lavatai
   5   \date    Aug 2016
   6   ----------------------------------------------------------------------------*/
   7 /* Standard */
   8 #include <stdlib.h> //exit, malloc
   9 #include <stdio.h>  //print
  10 #include <stdarg.h> //va_args
  11 #include <stdint.h> //uint64_t
  12 #include <string.h> //memset, str*
  13 /* Unicode */
  14 #include <unistd.h>   //u8_* functions
  15 #include <unitypes.h> //uint8_t as a char
  16 #include <unistr.h>   //u32_cpy
  17 /* Local */
  18 #include "apc.h"
  19 #include "ir.h"
  20 /* Public */
  21 int      ir_init(void);
  22 void     ir_quit(void);
  23 int      ir_linker(void);
  24 int      ir_condenser(void);
  25 /* Memory allocation structures */
  26 enum dtype { FSDAT, MSDAT, ADAT, LDAT, FBDAT };
  27 struct pagenode_t;
  28 struct pagenode_header_t {
  29   struct pagenode_t* next;
  30   char*              head;
  31 };
  32 struct pagenode_t {
  33   struct pagenode_header_t header;
  34   char                     root[];
  35 };
  36 struct pagelist_t {
  37   struct pagenode_t* root, * head;
  38   size_t             pagesize;
  39 };
  40 struct ir_namelist_t;
  41 struct ir_namelist_t
  42 { struct ir_namelist_t* nextsib;
  43   uint8_t*              name;
  44 };
  45 struct ir_classld_t
  46 { struct ir_class_t*    root_class;
  47   struct ir_namelist_t* namelist, * namelist_head;
  48 };
  49 struct ir_setld_t
  50 { struct ir_classld_t*  classld;
  51   long long             ref;
  52   struct ir_namelist_t* namelist, * namelist_head;
  53 };
  54 /* Set data mem */
  55 struct ir_setdata_header_t
  56 { enum dtype          type;
  57   uint8_t*            src_filename, * data_name;
  58   union ir_setdata_t* nextsib;
  59 };
  60 struct ir_frameinfo_t
  61 { int facing, w, h; };
  62 struct ir_framedata_t
  63 { struct ir_setdata_header_t header;
  64   struct ir_frameinfo_t      frameinfo;
  65 };
  66 struct ir_framebox_t
  67 { struct ir_setdata_header_t header;
  68   struct ir_framedata_t      framesheets[FACING_MAX];
  69   struct ir_framedata_t      mapsheets[FACING_MAX];
  70 };
  71 struct ir_simplex_t { struct ir_setdata_header_t header; };
  72 struct ir_link_t
  73 { struct ir_setdata_header_t header;
  74   struct ir_classld_t*       classld;
  75   struct ir_setld_t*         setld;
  76   enum ltype                 type;
  77 };
  78 union ir_setdata_t
  79 { struct ir_setdata_header_t  header;
  80   struct ir_framebox_t        framebox;
  81   struct ir_framedata_t       framesheet;
  82   struct ir_framedata_t       mapsheet;
  83   struct ir_simplex_t         audio;
  84   struct ir_link_t            link;
  85 };
  86 struct ir_class_t
  87 { struct ir_class_t* nextchild, * nextsib;
  88   struct ir_set_t*   root_set;
  89   uint8_t*           name;
  90 };
  91 struct ir_set_t
  92 { struct ir_set_t*      nextchild, * nextsib;
  93   struct ir_class_t*    class;
  94   long long             ref;
  95   uint8_t*              name;
  96   struct ir_framebox_t* frameboxes;
  97   struct ir_simplex_t*  audio;
  98   struct ir_link_t*     links;
  99 };
 100 /* Functions */
 101 static inline
 102 int                   init_pagelist(struct pagelist_t*,size_t);
 103 static inline
 104 struct ir_framebox_t* ir_set_add_framebox(struct ir_set_t*,const uint8_t*);
 105 static
 106 void                  ir_free_pagenodes(struct pagenode_t*);
 107 static inline
 108 int                   bytes_identical(const uint8_t*,const uint8_t*);
 109 static
 110 void*                 stack_alloc(size_t);
 111 static
 112 uint8_t*              name_alloc(const uint8_t*);
 113 static inline
 114 union ir_setdata_t*   ir_framedata (enum dtype,const uint8_t*,apc_facing,int,int);
 115 /* Function-Like Macros */
 116 #define do_warn() do {                          \
 117   } while (0)
 118 #define wprint(str) do {                        \
 119     fprintf(stderr, str);                       \
 120     do_warn();                                  \
 121   } while (0)
 122 #define wprintf(fmt,...) do {                   \
 123     fprintf(stderr, fmt, __VA_ARGS__);          \
 124     do_warn();                                  \
 125   } while (0)
 126 #define do_error() do {                         \
 127     exit(-1);                                   \
 128   } while (0)
 129 #define eprint(str) do {                        \
 130     fprintf(stderr, str);                       \
 131     do_error();                                 \
 132   } while (0)
 133 #define eprintf(fmt,...) do {                   \
 134     fprintf(stderr, fmt, __VA_ARGS__);          \
 135     do_error();                                 \
 136   } while (0)
 137 #define struct_alloc(_T) ((struct _T*) stack_alloc(sizeof(struct _T)))
 138 #define DATA_PAGESIZE   (sys_pagesize)
 139 #define NAME_PAGESIZE   (APC_NAME_MAX * 1024)
 140 #define PL_HEADERSIZE   (sizeof(struct pagenode_header_t))
 141 #define PL_HEADSIZE(_PL) (_PL.head->header.head - _PL.head->root)
 142 #define PL_HEADMEM(_PL)  (_PL.pagesize - PL_HEADERSIZE - PL_HEADSIZE(_PL))
 143 /* Memory */
 144 extern //apc.c
 145 long sys_pagesize;
 146 static
 147 struct pagelist_t datapages, namepages;
 148 static
 149 struct ir_class_t root_class = { .name = (uint8_t*)"." };
 150
 151 /* Init */
 152 int ir_init
 153 ( void )
 154 { if (init_pagelist(&datapages, (size_t)DATA_PAGESIZE))
 155     eprint("Memory allocation error\n");
 156   if (init_pagelist(&namepages, (size_t)NAME_PAGESIZE))
 157     eprint("Memory allocation error\n");
 158   return 0;
 159 }
 160
 161 static inline
 162 int init_pagelist
 163 ( struct pagelist_t* pl,
 164   size_t size
 165 )
 166 { pl->pagesize = size;
 167   pl->root = (struct pagenode_t*) calloc(size,1);
 168   if (pl->root == NULL)
 169     return -1;
 170   pl->root->header.head = pl->root->root;
 171   pl->head = pl->root;
 172   return 0;
 173 }
 174
 175 /* Quit/Cleanup
 176    Recursively clean pagenode linked list
 177 */
 178 void ir_quit
 179 ( void )
 180 { ir_free_pagenodes(datapages.root);
 181   ir_free_pagenodes(namepages.root);
 182 }
 183
 184 static
 185 void ir_free_pagenodes
 186 ( struct pagenode_t* pagenode )
 187 { if (pagenode->header.next != NULL)
 188     ir_free_pagenodes(pagenode->header.next);
 189   free(pagenode);
 190 }
 191
 192 /* Link
 193 */
 194 int ir_linker
 195 ( void )
 196 { return 0; }
 197
 198 /* Condense
 199 */
 200 int ir_condenser
 201 ( void )
 202 { return 0; }
 203
 204 /* Return a pointer to the root class */
 205 struct ir_class_t* ir_class_root
 206 ( void )
 207 { return &root_class; }
 208
 209 /* Add a subclass to a class
 210    Attempts to create a new subclass in the provided class, returning
 211    the class if it already exists
 212 */
 213 struct ir_class_t* ir_class_addchild
 214 ( struct ir_class_t* class,
 215   const uint8_t*     name
 216 )
 217 { struct ir_class_t* iter;
 218   if (class->nextchild == NULL)
 219     return class->nextchild = struct_alloc(ir_class_t);
 220   iter = class->nextchild;
 221  check:
 222   if (bytes_identical(iter->name, name))
 223     return iter;
 224   if (iter->nextsib != NULL)
 225     { iter = iter->nextsib;
 226       goto check;
 227     }
 228   iter = struct_alloc(ir_class_t);
 229   iter->nextsib = class->nextchild;
 230   iter->name = name_alloc(name);
 231   return class->nextchild = iter;
 232 }
 233
 234 /* Add a set to a class
 235    Attempts to create a new root set in the specified class, returning
 236    the set if it already exists
 237 */
 238 struct ir_set_t* ir_class_addset
 239 ( struct ir_class_t* class,
 240   const uint8_t*     name
 241 )
 242 { struct ir_set_t* iter;
 243   if (class->root_set == NULL)
 244     return class->root_set = struct_alloc(ir_set_t);
 245   iter = class->root_set;
 246  check:
 247   if (bytes_identical(iter->name, name))
 248     return iter;
 249   if (iter->nextsib != NULL)
 250     { iter = iter->nextsib;
 251       goto check;
 252     }
 253   iter = struct_alloc(ir_set_t);
 254   iter->nextsib = class->root_set;
 255   iter->name = name_alloc(name);
 256   return class->root_set = iter;
 257 }
 258
 259 /* Add a set to a set
 260    Attempts to create a new subset of the specified set, returning the
 261    child if it already exists
 262 */
 263 struct ir_set_t* ir_set_addchild
 264 ( struct ir_set_t* set,
 265   const uint8_t*   name
 266 )
 267 { struct ir_set_t* iter;
 268   if (set->nextchild == NULL)
 269     return set->nextchild = struct_alloc(ir_set_t);
 270   iter = set->nextchild;
 271  check:
 272   if (bytes_identical(iter->name, name))
 273     return iter;
 274   if (iter->nextsib != NULL)
 275     { iter = iter->nextsib;
 276       goto check;
 277     }
 278   iter = struct_alloc(ir_set_t);
 279   iter->nextsib = set->nextchild;
 280   iter->name = name_alloc(name);
 281   return set->nextchild = iter;
 282 }
 283
 284 /* Add a framebox to a set
 285    Attempts to create a new framebox of the specified set, returning
 286    the framebox if it already exists
 287 */
 288 static inline
 289 struct ir_framebox_t* ir_set_add_framebox
 290 ( struct ir_set_t* set,
 291   const uint8_t*   name
 292 )
 293 { struct ir_framebox_t* iter;
 294   if (set->frameboxes == NULL)
 295     return set->frameboxes = struct_alloc(ir_framebox_t);
 296   iter = set->frameboxes;
 297  check:
 298   if (bytes_identical(iter->header.data_name, name))
 299     return iter;
 300   if (iter->header.nextsib != NULL)
 301     { iter = (struct ir_framebox_t*) iter->header.nextsib;
 302       goto check;
 303     }
 304   iter = struct_alloc(ir_framebox_t);
 305   iter->header.nextsib = (union ir_setdata_t*) set->frameboxes;
 306   iter->header.data_name = name_alloc(name);
 307   return set->frameboxes = iter;
 308 }
 309
 310 /* Match two null-terminated bytestrings
 311    Return 1 if the two bytestrings are identical, else 0
 312 */
 313 static inline
 314 int bytes_identical
 315 ( const uint8_t* stra,
 316   const uint8_t* strb
 317 )
 318 { int ca, cb;
 319   do {
 320     ca = *stra++;
 321     cb = *strb++;
 322   } while (ca && ca != '_' && ca == cb);
 323   return (ca == cb);
 324 }
 325
 326 /* Assign Setdata to Set
 327
 328  */
 329 void ir_set_assign_data
 330 ( struct ir_set_t*      set,
 331   union  ir_setdata_t*  setdata
 332 )
 333 { struct ir_framebox_t* framebox;
 334   struct ir_simplex_t*  simplex;
 335   switch (setdata->header.type)
 336     { case FSDAT:
 337         framebox = ir_set_add_framebox(set, setdata->header.data_name);
 338         if (framebox->framesheets[setdata->framesheet.frameinfo.facing].header.data_name != NULL)
 339           wprintf("Duplicate framesheet [%i] %s\n",
 340                   setdata->framesheet.frameinfo.facing, setdata->header.data_name);
 341         framebox->framesheets[setdata->framesheet.frameinfo.facing] = setdata->framesheet;
 342         break;
 343       case MSDAT:
 344         framebox = ir_set_add_framebox(set, setdata->header.data_name);
 345         if (framebox->mapsheets[setdata->mapsheet.frameinfo.facing].header.data_name != NULL)
 346           wprintf("Duplicate mapsheet [%i] %s\n",
 347                   setdata->mapsheet.frameinfo.facing, setdata->header.data_name);
 348         framebox->mapsheets[setdata->mapsheet.frameinfo.facing] = setdata->mapsheet;
 349         break;
 350       case ADAT:
 351         if (set->audio == NULL)
 352           { set->audio = (struct ir_simplex_t*) setdata;
 353             return;
 354           }
 355         simplex = set->audio;
 356         while (simplex->header.nextsib != NULL)
 357           if (bytes_identical(simplex->header.data_name, setdata->header.data_name))
 358             { wprintf("Duplicate audio %s\n", setdata->header.data_name);
 359               *simplex = setdata->audio;
 360               //setdata is now a pointer to redundant, unused memory.
 361               return;
 362             }
 363           else
 364             simplex = (struct ir_simplex_t*) simplex->header.nextsib;
 365         setdata->audio.header.nextsib = (union ir_setdata_t*) set->audio;
 366         set->audio = (struct ir_simplex_t*) setdata;
 367         break;
 368       case LDAT:
 369         setdata->link.header.nextsib = (union ir_setdata_t*) set->links;
 370         set->links = (struct ir_link_t*) setdata;
 371         break;
 372       default:
 373         fprintf(stderr, "Unknown setdata type %x\n", setdata->header.type);
 374         exit(-1);
 375     }
 376 }
 377
 378 void ir_set_assign_ref
 379 ( struct ir_set_t* set,
 380   long long        ref
 381 )
 382 { if (set->ref != 0)
 383     wprintf("Ref override: 0x%lx -> 0x%lx for set %s\n",
 384             (long unsigned) set->ref, (long unsigned) ref, set->name);
 385   set->ref = ref;
 386   //TODO: reflist_add(set);
 387 }
 388
 389 void ir_data_assign_path
 390 ( union ir_setdata_t* setdata,
 391   const uint8_t*      path
 392 )
 393 { if (setdata->header.src_filename != NULL)
 394     wprintf("Path override: %s -> %s for setdata %s\n",
 395             setdata->header.src_filename, path, setdata->header.data_name);
 396   setdata->header.src_filename = name_alloc(path);
 397 }
 398
 399 union ir_setdata_t* ir_framesheet
 400 ( const uint8_t* name,
 401   apc_facing     d,
 402   int            width,
 403   int            height
 404 )
 405 { return ir_framedata(FSDAT, name, d, width, height); }
 406
 407 union ir_setdata_t* ir_mapsheet
 408 ( const uint8_t* name,
 409   apc_facing     d,
 410   int            width,
 411   int            height
 412 )
 413 { return ir_framedata(MSDAT, name, d, width, height); }
 414
 415 static inline
 416 union ir_setdata_t* ir_framedata
 417 ( enum dtype     type,
 418   const uint8_t* name,
 419   apc_facing     d,
 420   int            width,
 421   int            height
 422 )
 423 { struct ir_framedata_t* framedata = struct_alloc(ir_framedata_t);
 424   framedata->header.type = type;
 425   framedata->header.data_name = name_alloc(name);
 426   framedata->frameinfo.facing = d;
 427   framedata->frameinfo.w = width;
 428   framedata->frameinfo.h = height;
 429   return (union ir_setdata_t*) framedata;
 430 }
 431
 432 union ir_setdata_t* ir_audio
 433 ( const uint8_t* name )
 434 { struct ir_simplex_t* audio = struct_alloc(ir_simplex_t);
 435   audio->header.type = ADAT;
 436   audio->header.data_name = name_alloc(name);
 437   return (union ir_setdata_t*) audio;
 438 }
 439
 440
 441 /* Create classld that points to a class */
 442 struct ir_classld_t* ir_classld_from_class
 443 ( struct ir_class_t* class )
 444 { struct ir_classld_t* classld;
 445   classld = struct_alloc(ir_classld_t);
 446   classld->root_class = class;
 447   return classld;
 448 }
 449
 450 struct ir_setld_t* ir_setld_from_ref
 451 ( long long ref )
 452 { struct ir_setld_t* setld;
 453   setld = struct_alloc(ir_setld_t);
 454   setld->ref = ref;
 455   return setld;
 456 }
 457
 458 struct ir_setld_t* ir_setld_from_classld
 459 ( struct ir_classld_t* classld,
 460   const uint8_t*       name
 461 )
 462 { struct ir_setld_t* setld;
 463   setld = struct_alloc(ir_setld_t);
 464   setld->namelist = struct_alloc(ir_namelist_t);
 465   setld->namelist_head = setld->namelist;
 466   setld->namelist_head->name = name_alloc(name);
 467   setld->classld = classld;
 468   return setld;
 469 }
 470
 471 struct ir_setld_t* ir_setld_addchild
 472 ( struct ir_setld_t* setld,
 473   const uint8_t*     name
 474 )
 475 { if (setld->namelist == NULL)
 476     { setld->namelist = struct_alloc(ir_namelist_t);
 477       setld->namelist_head = setld->namelist;
 478     }
 479   else
 480     { setld->namelist_head->nextsib = struct_alloc(ir_namelist_t);
 481       setld->namelist_head = setld->namelist_head->nextsib;
 482     }
 483   setld->namelist_head->name = name_alloc(name);
 484   return setld;
 485 }
 486
 487 union ir_setdata_t* ir_link
 488 ( enum ltype         link_type,
 489   struct ir_setld_t* setld,
 490   const uint8_t*     name
 491 )
 492 { struct ir_link_t* link;
 493   link = struct_alloc(ir_link_t);
 494   link->header.type = LDAT;
 495   link->type = link_type;
 496   link->classld = setld->classld;
 497   link->setld = setld;
 498   if (link_type != OLINK && name != NULL)
 499     link->header.data_name = name_alloc(name);
 500   return (union ir_setdata_t*) link;
 501 }
 502
 503
 504 static
 505 void* stack_alloc
 506 ( size_t bytes )
 507 { if (!bytes) //valid behavior to attain current head
 508     return datapages.head->header.head;
 509   if (PL_HEADMEM(datapages) < bytes)
 510     { datapages.head->header.next = (struct pagenode_t*) calloc(datapages.pagesize,1);
 511       if (datapages.head->header.next == NULL)
 512         eprint("Memory allocation error \n");
 513       datapages.head = datapages.head->header.next;
 514       datapages.head->header.head = datapages.head->root;
 515     }
 516   datapages.head->header.head += bytes;
 517   return (void*) datapages.head->header.head - bytes;
 518 }
 519
 520 static
 521 uint8_t* name_alloc
 522 ( const uint8_t* name_src )
 523 { const uint8_t* iter;
 524   uint8_t*       name;
 525   int            head_mem;
 526  copy:
 527   name = (uint8_t*)namepages.head->header.head;
 528   iter = name_src;
 529   for (head_mem = PL_HEADMEM(namepages); *iter && *iter != '_' && head_mem; head_mem--)
 530     *(namepages.head->header.head)++ = *iter++;
 531   if (head_mem == 0) //not enough room
 532     { namepages.head->header.next = (struct pagenode_t*) calloc(namepages.pagesize,1);
 533       if (namepages.head->header.next == NULL)
 534         eprint("Memory allocation error\n");
 535       namepages.head = namepages.head->header.next;
 536       namepages.head->header.head = namepages.head->root;
 537       goto copy;
 538     }
 539   *(namepages.head->header.head)++ = '\0';
 540   return name;
 541 }