\author Jordan Lavatai\r
\date Aug 2016\r
----------------------------------------------------------------------------*/\r
-#include <stdlib.h>\r
-#include <stdio.h>\r
-#include <unitypes.h> //uint8_t as a char\r
-#include <unistr.h> //u32_cpy\r
+/* Standard */\r
+#include <stdlib.h> //exit, malloc\r
+#include <stdio.h> //print\r
+#include <stdarg.h> //va_args\r
#include <stdint.h> //uint64_t\r
-#include <string.h> //memset\r
-#include <unistd.h> //u8_* functions\r
+#include <string.h> //memset, str*\r
+/* Unicode */\r
+#include <unistd.h> //u8_* functions\r
+#include <unitypes.h> //uint8_t as a char\r
+#include <unistr.h> //u32_cpy\r
+/* Local */\r
#include "apc.h"\r
-\r
-\r
-extern\r
-int\r
-name_u8_cpy(struct name*, struct name*);\r
-\r
-extern\r
-int\r
-name_u8_cmp(struct name*, struct name*);\r
-\r
-extern\r
-int\r
-name_u8_set(struct name*, ucs4_t);\r
-\r
-int\r
-ir_init(void);\r
-struct cdat*\r
-alloc_cdat(void);\r
-struct odat*\r
-alloc_odat(void);\r
-void\r
-alloc_vdat(void);\r
-struct link*\r
-alloc_link(void);\r
-struct ref*\r
-alloc_ref(void);\r
-struct set*\r
-alloc_set(void);\r
-struct cdat*\r
-curr_cdat(void);\r
-struct odat*\r
-curr_odat(void);\r
-struct vdat*\r
-curr_vdat(void);\r
-struct map*\r
-curr_map(void);\r
-struct set*\r
-curr_cdat_set(void);\r
-struct set*\r
-curr_set(void);\r
-struct ref*\r
-curr_ref(void);\r
-struct model*\r
-curr_model(void);\r
-\r
-/* ir.c */\r
-void\r
-inc_posts(void);\r
-void\r
-push_cdat(struct name*);\r
-void\r
-pop_cdat(void);\r
-void\r
-insert_refid(int);\r
-void\r
-insert_link_name(struct name*);\r
-void\r
-insert_link_namelist(struct name*);\r
-void\r
-insert_ss_name(struct name*);\r
-void\r
-insert_ss_namelist(struct name*);\r
-void\r
-insert_mlink(struct name*, int);\r
-void\r
-insert_vlink(struct name*, int);\r
-void\r
-insert_ref(struct odat*, int);\r
-void\r
-alloc_vdat(void);\r
-void\r
-insert_vdat(void);\r
-void\r
-insert_map(struct name*, int, int, int, int, uint8_t*);\r
-void\r
-insert_framesheet(struct name*, int, int, int, int, uint8_t*);\r
-\r
-\r
-\r
-//type safety handled by macro expansion (do not call these directly from code, make dependent macros for access to these)\r
-#define CHUNKS_LEN(STACK) ((STACK).csp - (STACK).chunks)\r
-#define CURRENT_CHUNK(STACK) ((STACK).chunks[CHUNKS_LEN(STACK) - 1])\r
-#define CHUNKS_FULL(STACK) ( (STACK).csp >= \\r
- (STACK).chunks + MAX_CHUNKS * (STACK).chunk_size)\r
-#define CURRENT_DSP(STACK,TYPE) ((TYPE*) ((STACK).dsp[CHUNKS_LEN(STACK) - 1]))\r
-#define DATA_FULL(STACK,TYPE) ((void*) CURRENT_DSP(STACK,TYPE) >= \\r
- (CURRENT_CHUNK(STACK) + (STACK).chunk_size))\r
-#define CSP_PUSH(STACK) (*(++(STACK).csp) = malloc((STACK).chunk_size))\r
-#define CURRENT_DATP(STACK,TYPE) (((TYPE**)(STACK).dsp)[CHUNKS_LEN(STACK) - 1])\r
-#define PREVIOUS_DATP(STACK,TYPE) (((TYPE**)(STACK).dsp)[CHUNKS_LEN(STACK) - 2])\r
-#define ALLOC_DAT(STACK,TYPE) (++CURRENT_DATP(STACK,TYPE))\r
-#define INIT_STACK(STACK,TYPE) \\r
- { int i; \\r
- (STACK).chunk_size = PAGES_PER_CHUNK * pagesize; \\r
- (STACK).max_dats = (STACK).chunk_size / sizeof (TYPE); \\r
- CSP_PUSH(STACK); \\r
- for( i = 0; i < MAX_CHUNKS; i++){ \\r
- (STACK).dsp[i] += pagesize; \\r
- } \\r
- }\r
-//Stack-specific macros (called directly from code (safety enforcement)\r
-#define INIT_ODAT() (INIT_STACK(ocs, struct odat))\r
-#define CURRENT_ODAT() (CURRENT_DATP(ocs,struct odat))\r
-#define ODAT_FULL() (DATA_FULL(ocs,struct odat))\r
-#define ODAT_ALLOC() (ALLOC_DAT(ocs,struct odat))\r
-#define OCS_FULL() (CHUNKS_FULL(ocs))\r
-#define INIT_VDAT() (INIT_STACK(vcs, struct vdat))\r
-#define CURRENT_VDAT() (CURRENT_DATP(vcs,struct vdat))\r
-#define VDAT_FULL() (DATA_FULL(vcs,struct vdat))\r
-#define VDAT_ALLOC() (ALLOC_DAT(vcs,struct vdat))\r
-#define VCS_FULL() (CHUNKS_FULL(vcs))\r
-#define INIT_CDAT() (INIT_STACK(ccs, struct cdat))\r
-#define CURRENT_CDAT() (CURRENT_DATP(ccs,struct cdat))\r
-#define CDAT_FULL() (DATA_FULL(ccs, struct cdat))\r
-#define CDAT_ALLOC() (ALLOC_DAT(ccs, struct cdat))\r
-#define CCS_FULL() (CHUNKS_FULL(ccs))\r
-#define INIT_SET() (INIT_STACK(scs, struct set))\r
-#define CURRENT_SET() (CURRENT_DATP(scs, struct set))\r
-#define SET_FULL() (DATA_FULL(scs, struct set))\r
-#define SET_ALLOC() (ALLOC_DAT(scs, struct set))\r
-#define SCS_FULL() (CHUNKS_FULL(scs))\r
-#define INIT_LINK() (INIT_STACK(lcs, struct link))\r
-#define CURRENT_LINK() (CURRENT_DATP(lcs,struct link))\r
-#define LDAT_FULL() (DATA_FULL(lcs, struct link))\r
-#define LDAT_ALLOC() (ALLOC_DAT(lcs, struct link))\r
-#define LCS_FULL() (CHUNKS_FULL(lcs))\r
-#define INIT_POST() (INIT_STACK(rcs, struct ref))\r
-#define CURRENT_POST() (CURRENT_DATP(pcs,struct ref))\r
-#define POST_FULL() (DATA_FULL(pcs,struct ref))\r
-#define POST_ALLOC() (ALLOC_DAT(pcs,struct ref))\r
-#define PCS_FULL() (CHUNKS_FULL(pcs))\r
-#define INIT_REF() (INIT_STACK(rcs, struct ref))\r
-#define CURRENT_REF() (CURRENT_DATP(rcs,struct ref))\r
-#define PREVIOUS_REF() (PREVIOUS_DATP(rcs, struct ref))\r
-#define REF_FULL() (DATA_FULL(rcs,struct ref))\r
-#define REF_ALLOC() (ALLOC_DAT(rcs,struct ref))\r
-#define RCS_FULL() (CHUNKS_FULL(rcs))\r
-//Metadata\r
-#define CURRENT_MODEL() (CURRENT_VDAT()->model_list[CURRENT_VDAT()->num_models])\r
-\r
-\r
-\r
-\r
-/* Cdats: A cdat is a class data structure. Cdats serve as the central */\r
-/* data types of the IR. Cdats contain pointers to their subclasses so that the relationship between */\r
-/* classes can be determined, but the subclasses are not represented inside */\r
-/* of the cdat itself but rather in subsequent cdats in cdat_buf. We */\r
-/* can determine the number of subclasses (the last index into cdat_buf */\r
-/* that represents a subclass of some arbitrary cdat) each cdat has by */\r
-/* incrementing num_classes during parse time. */\r
-/* TODO: Should classes point to their parent class? */\r
-/* TODO: Talk more about cdat set structure */\r
-\r
-struct cdat {\r
- struct name name;\r
- int idx;\r
- int num_classes;\r
- int num_sets;\r
- struct cdat* class_list[MAX_CLASSES];\r
- struct set* set_list[MAX_SETS];\r
+#include "ir.h"\r
+/* Public */\r
+int ir_init(void);\r
+void ir_quit(void);\r
+int ir_linker(void);\r
+int ir_condenser(void);\r
+/* Private */\r
+struct pagenode_t;\r
+extern //apc.c\r
+long sys_pagesize;\r
+static inline\r
+struct ir_framebox_t* ir_set_add_framebox(struct ir_set_t*, uint8_t*);\r
+static\r
+void ir_free_pages(struct pagenode_t*);\r
+static inline\r
+int bytes_identical(uint8_t*,uint8_t*);\r
+static\r
+void* stack_alloc(size_t);\r
+/* Memory allocator */\r
+struct pagenode_t {\r
+ struct pagenode_t* next;\r
+ char* head;\r
+ char root[];\r
+}* pagenode_root, * pagenode_head;\r
+#define PN_ALLOCSIZE (sys_pagesize)\r
+#define PN_HEADERSIZE() (sizeof(struct pagenode_t*) + sizeof(char*))\r
+#define PN_MEMSIZE() (PN_ALLOCSIZE - PN_HEADERSIZE())\r
+#define PN_HEADSIZE() (pagenode_head->head - pagenode_head->root)\r
+#define PN_HEADSPACE() (PN_MEMSIZE() - PN_HEADSIZE())\r
+/* Enumerated types */\r
+enum dtype { FSDAT, MSDAT, ADAT, LDAT, FBDAT };\r
+enum ltype { OLINK, MLINK, VLINK, ALINK };\r
+/* Set data mem */\r
+struct ir_setdata_header_t\r
+{ enum dtype type;\r
+ uint8_t* src_filename, * data_name;\r
+ union ir_setdata_t* nextsib;\r
};\r
-\r
-\r
-struct set {\r
- int cdat_idx;\r
- int num_sets;\r
- struct set* set_list[MAX_SETS];\r
+struct ir_frameinfo_t\r
+{ int facing, w, h; };\r
+struct ir_framedata_t\r
+{ struct ir_setdata_header_t header;\r
+ struct ir_frameinfo_t frameinfo;\r
};\r
-\r
-struct ref {\r
- struct ref* nextref;\r
- struct ref* lastref;\r
- struct odat* odatp;\r
- int refid; //0xFFFFFF->digit\r
+struct ir_framebox_t\r
+{ struct ir_setdata_header_t header;\r
+ struct ir_framedata_t framesheets[FACING_MAX];\r
+ struct ir_framedata_t mapsheets[FACING_MAX];\r
};\r
-\r
-struct olink {\r
- int src_refid;\r
+struct ir_simplex_t\r
+{ struct ir_setdata_header_t header; };\r
+struct ir_link_t\r
+{ struct ir_setdata_header_t header;\r
+ struct ir_set_t* src, * trg;\r
+ enum ltype type;\r
};\r
- \r
-struct vlink {\r
- int src_refid;\r
- struct name src_animname;\r
- struct name src_namelist[MAX_DEPTH];\r
+union ir_setdata_t\r
+{ struct ir_setdata_header_t header;\r
+ struct ir_framebox_t framebox;\r
+ struct ir_framedata_t framesheet;\r
+ struct ir_framedata_t mapsheet;\r
+ struct ir_simplex_t audio;\r
+ struct ir_link_t link;\r
};\r
-\r
-struct mlink {\r
- int src_refid;\r
- struct name src_mapname;\r
- struct name src_namelist[MAX_DEPTH];\r
-\r
-};\r
-\r
-union link_t {\r
- struct vlink vlink;\r
- struct mlink mlink;\r
- struct olink olink;\r
-};\r
-\r
-\r
-/* Links are a mechanism for designers to indicate in the grammar that a odat, vdat, or map \r
- is defined elsewhere and that the link should be replaced with the specified odat/vdat/map */ \r
-struct link {\r
- int type; //1 = olink, 2 = vlink, 3 = mlink\r
- union link_t link_t;\r
- int dest_refid; //if it exists\r
- struct odat* dest_odatp;\r
-\r
-};\r
-\r
-struct map {\r
- struct name name;\r
- int height;\r
- int width;\r
- uint8_t filepath[FPATH_MAX];\r
-};\r
-\r
-/* Odats: Odats consist of the object data necessary for\r
- each object. Odats are sometimes referred to as archetypes\r
- at compile-time, in order to distinguish the difference from\r
- a runtime object and a compile-time object.\r
- TODO: Need more info about objects at runtime, to described\r
- the reasoning behind odat structure at compile-time*/\r
-struct odat {\r
- struct name name;\r
- int refid; \r
- int ismap;\r
- int vdat_idx;\r
- struct link* linkp; \r
- struct vdat* vdatp;\r
- struct odat* parent_odatp; /* null if parent is a cdat */\r
- struct ref* refp; /* pointer to it's ref on ref_list */\r
- struct map map; /* only valid if odat ismap */\r
-\r
-};\r
-\r
-/* A framesheet is a grouping of animation frames in a single direction (N,W,S,E, etc.). Framesheets\r
- also hold the framesheet dimensions and the filepath to the png of the framesheet so the file can be opened\r
- and the png data can be extracted. */\r
-struct framesheet {\r
- int width;\r
- int height;\r
- uint8_t filepath[FPATH_MAX];\r
- int num_frames;\r
-\r
+struct ir_class_t\r
+{ struct ir_class_t* nextchild, * nextsib;\r
+ struct ir_set_t* root_set;\r
+ uint8_t* name;\r
};\r
-\r
-/* A model is a collection of framesheets for every\r
- direction (N,W,S,E,NW,NE,SW,SE). Currently, users can only define\r
- framesheets in the APC grammar, which are inserted into the current model*/\r
-struct model {\r
- struct name name;\r
- struct framesheet spritesheet[8]; //one for each\r
-};\r
-\r
-/* Vdat: Vdats are the video data of each object. Vdats have a list of models for every\r
- animation that the vdats odat can do for that vdat. */\r
-struct vdat {\r
- struct odat* creator; //pointer to odat that made this vdat\r
- int num_models;\r
- struct model model_list[MAX_MODELS];\r
-};\r
-\r
-/* An entry on the set_stack that describes the namelist and relevant information for \r
- the current set that is being processed in the parser. For each set name,\r
- there is a corresponding set/odat that is created when set names are encountered. */\r
-\r
-struct set_frame\r
-{ struct name namelist[MAX_DEPTH];\r
- int num_names;\r
- struct set* setp;\r
- struct odat* odatp;\r
-} ;\r
-\r
-/* Stores the last defined set at every depth */\r
-struct set_stack\r
-{ struct set_frame set_frames[MAX_DEPTH];\r
- int curr_depth; //used to get most recently created set/odat + to check for undefined parents of namelists\r
+struct ir_set_t\r
+{ struct ir_set_t* nextchild, * nextsib;\r
+ struct ir_class_t* class;\r
+ long long ref;\r
+ uint8_t* name;\r
+ struct ir_framebox_t* frameboxes;\r
+ struct ir_simplex_t* audio;\r
+ struct ir_link_t* links;\r
};\r
-\r
-\r
-//"type free" chunk stacking\r
-struct chunk_stack\r
-{ void* chunks[MAX_CHUNKS];\r
- void* *csp; //chunk stack pointer\r
- void* dsp[MAX_CHUNKS]; //dat stack pointer (per chunk)\r
- int chunk_size; //size of a chunk (including its forfeited page)\r
- int max_dats; //number of dats per chunk for this stack\r
-} ocs, vcs, ccs, rcs, lcs, pcs, scs; //odat, vdat, cdat, ref, link, post stacks\r
-\r
-/* The cdat_stack is a stack pointers to cdat pointers, the top of which is\r
- the cdat that is currently being parsed. Whenever a new cdat is recognized\r
- by the grammar (CLOPEN), a cdat is pushed onto the cdat_stack, and we refer\r
- to this cdat through the macro CURR_CDAT. By keeping a cdat_stack, we have\r
- access to the current cdat so that the elements and sets can populate themselves\r
- in the cdat accordingly. */\r
-\r
-struct cdat* cdat_stack[MAX_CLASSES];\r
-struct cdat** cdat_stackp;\r
-\r
-\r
-\r
-struct set_stack ss;\r
-struct name set_namelist[MAX_DEPTH];\r
-int set_numnames = 0;\r
-\r
-struct name link_namelist[MAX_DEPTH];\r
-int link_numnames = 0;\r
-\r
-int num_cdats = 0;\r
-int num_odats = 0;\r
-int num_vdats = 0;\r
-int num_sets = 0;\r
-int num_refs = 0;\r
-int ss_refid = 0x0FFFFFFF; /* system space for refids */\r
-int num_posts = 0;\r
-int num_links = 0;\r
-int num_models = 0;\r
-long pagesize = 0;\r
-\r
-\r
-/* The initalization function of the IR. */\r
-int\r
-ir_init()\r
-{ struct name name;\r
-\r
-\r
- uint8_t root[4] = "root";\r
-\r
- u8_stpncpy(name.name, root, 4);\r
-\r
- pagesize = sysconf(_SC_PAGESIZE);\r
-\r
- INIT_CDAT();\r
- *cdat_stackp = CURRENT_CDAT();\r
- name_u8_cpy(&(*cdat_stackp)->name, &name);\r
-\r
- INIT_ODAT();\r
- INIT_VDAT();\r
- VDAT_ALLOC(); //NULL vdat\r
- VDAT_ALLOC(); //First vdat req. because alloc_vdat happens after vdat is reduced\r
- INIT_SET();\r
- INIT_LINK();\r
- INIT_REF();\r
- INIT_POST();\r
-\r
-\r
+/* Function-Like Macros */\r
+#define do_warn() do { \\r
+ } while (0)\r
+#define wprint(str) do { \\r
+ fprintf(stderr, str); \\r
+ do_warn(); \\r
+ } while (0)\r
+ #define wprintf(fmt,...) do { \\r
+ fprintf(stderr, fmt, __VA_ARGS__); \\r
+ do_warn(); \\r
+ } while (0)\r
+#define do_error() do { \\r
+ exit(-1); \\r
+ } while (0)\r
+#define eprint(str) do { \\r
+ fprintf(stderr, str); \\r
+ do_error(); \\r
+ } while (0)\r
+#define eprintf(fmt,...) do { \\r
+ fprintf(stderr, fmt, __VA_ARGS__); \\r
+ do_error(); \\r
+ } while (0)\r
+#define struct_alloc(_T) ((struct _T*) stack_alloc(sizeof(struct _T)))\r
+\r
+static\r
+struct ir_class_t root_class = { .name = (uint8_t*)"." };\r
+\r
+/* Init */\r
+int ir_init\r
+( void )\r
+{ pagenode_root = (struct pagenode_t*) calloc((size_t)PN_ALLOCSIZE,1);\r
+ if (pagenode_root == NULL)\r
+ return -1;\r
+ pagenode_root->head = pagenode_root->root;\r
+ pagenode_head = pagenode_root;\r
return 0;\r
-\r
-}\r
-\r
-void\r
-ir_quit()\r
-{\r
- int i;\r
-\r
- for(i = 0; i < CHUNKS_LEN(ccs) ; i++)\r
- {\r
- free(ccs.chunks[i]);\r
- }\r
- for(i = 0; i < CHUNKS_LEN(ocs); i++)\r
- {\r
- free(ocs.chunks[i]);\r
- }\r
- for(i = 0; i < CHUNKS_LEN(vcs) ; i++)\r
- {\r
- free(vcs.chunks[i]);\r
- }\r
- for(i = 0; i < CHUNKS_LEN(rcs); i++)\r
- {\r
- free(rcs.chunks[i]);\r
- }\r
- for(i = 0; i < CHUNKS_LEN(lcs); i++)\r
- {\r
- free(lcs.chunks[i]);\r
- }\r
- for(i = 0; i < CHUNKS_LEN(pcs); i++)\r
- {\r
- free(pcs.chunks[i]);\r
- }\r
-\r
-}\r
-\r
-struct cdat*\r
-alloc_cdat()\r
-{\r
- num_cdats++;\r
- if(CDAT_FULL())\r
- { if(CCS_FULL())\r
- { fprintf(stderr, "You have allocated to many (%d) cdats ", num_cdats);\r
- exit(EXIT_FAILURE);\r
- }\r
- else\r
- CSP_PUSH(ccs);\r
- }\r
- else\r
- CDAT_ALLOC();\r
-\r
- return CURRENT_CDAT();\r
-}\r
-\r
-//these should probably be inline\r
-struct odat*\r
-alloc_odat\r
-()\r
-{\r
- num_odats++;\r
- if(ODAT_FULL())\r
- { if(!OCS_FULL())\r
- { fprintf(stderr, "You have allocated to many (%d) odats ", num_odats);\r
- exit(EXIT_FAILURE);\r
- }\r
- else\r
- CSP_PUSH(ocs);\r
- }\r
- else\r
- ODAT_ALLOC();\r
-\r
- return CURRENT_ODAT();\r
-}\r
-\r
-void\r
-alloc_vdat\r
-()\r
-{ num_vdats++;\r
- if(VDAT_FULL())\r
- { if(!VCS_FULL())\r
- { fprintf(stderr, "You have allocated to many (%d) vdats ", num_vdats);\r
- exit(EXIT_FAILURE);\r
- }\r
- else\r
- CSP_PUSH(vcs);\r
- }\r
- else\r
- VDAT_ALLOC();\r
-\r
- \r
+} \r
+\r
+/* Quit/Cleanup\r
+ Recursively clean pagenode linked list\r
+*/\r
+void ir_quit\r
+( void )\r
+{ ir_free_pages(pagenode_root); }\r
+\r
+static\r
+void ir_free_pages\r
+( struct pagenode_t* pagenode )\r
+{ if (pagenode->next != NULL)\r
+ ir_free_pages(pagenode->next);\r
+ free(pagenode);\r
}\r
\r
-struct set* \r
-alloc_set\r
-()\r
-{ num_sets++;\r
- if(SET_FULL())\r
- { if(!SCS_FULL())\r
- { fprintf(stderr, "You have allocated to many (%d) sets ", num_sets);\r
- exit(EXIT_FAILURE);\r
- }\r
- else\r
- CSP_PUSH(scs);\r
+/* Link\r
+*/\r
+int ir_linker\r
+( void )\r
+{ return 0; }\r
+\r
+/* Condense\r
+*/\r
+int ir_condenser\r
+( void )\r
+{ return 0; }\r
+\r
+/* Return a pointer to the root class */\r
+struct ir_class_t* ir_class_root\r
+( void )\r
+{ return &root_class; }\r
+\r
+/* Add a subclass to a class\r
+ Attempts to create a new subclass in the provided class, returning\r
+ the class if it already exists\r
+*/\r
+struct ir_class_t* ir_class_addchild\r
+( struct ir_class_t* class,\r
+ uint8_t* name\r
+)\r
+{ struct ir_class_t* iter;\r
+ if (class->nextchild == NULL)\r
+ return class->nextchild = struct_alloc(ir_class_t);\r
+ iter = class->nextchild;\r
+ check:\r
+ if (bytes_identical(iter->name, name))\r
+ return iter;\r
+ if (iter->nextsib != NULL)\r
+ { iter = iter->nextsib;\r
+ goto check;\r
}\r
- else\r
- SET_ALLOC();\r
-\r
- return CURRENT_SET();\r
+ return iter->nextsib = struct_alloc(ir_class_t);\r
}\r
\r
-\r
-struct link*\r
-alloc_link\r
-()\r
-{ num_links++;\r
- if(LDAT_FULL())\r
- { if(!LCS_FULL())\r
- { fprintf(stderr, "You have allocated to many (%d) links ", num_links);\r
- exit(EXIT_FAILURE);\r
- }\r
- else\r
- CSP_PUSH(lcs);\r
+/* Add a set to a class\r
+ Attempts to create a new root set in the specified class, returning\r
+ the set if it already exists\r
+*/\r
+struct ir_set_t* ir_class_addset\r
+( struct ir_class_t* class,\r
+ uint8_t* name\r
+)\r
+{ struct ir_set_t* iter;\r
+ if (class->root_set == NULL)\r
+ return class->root_set = struct_alloc(ir_set_t);\r
+ iter = class->root_set;\r
+ check:\r
+ if (bytes_identical(iter->name, name))\r
+ return iter;\r
+ if (iter->nextsib != NULL)\r
+ { iter = iter->nextsib;\r
+ goto check;\r
}\r
- else\r
- LDAT_ALLOC();\r
-\r
- return CURRENT_LINK();\r
-\r
+ return iter->nextsib = struct_alloc(ir_set_t);\r
}\r
\r
-struct ref*\r
-alloc_ref\r
-()\r
-{ num_refs++;\r
- if(REF_FULL())\r
- { if(!RCS_FULL())\r
- { fprintf(stderr, "You have allocated to many (%d) refs ", num_refs);\r
- exit(EXIT_FAILURE);\r
- }\r
- else\r
- CSP_PUSH(rcs);\r
+/* Add a set to a set\r
+ Attempts to create a new subset of the specified set, returning the\r
+ child if it already exists\r
+*/\r
+struct ir_set_t* ir_set_addchild\r
+( struct ir_set_t* set,\r
+ uint8_t* name\r
+)\r
+{ struct ir_set_t* iter;\r
+ if (set->nextchild == NULL)\r
+ return set->nextchild = struct_alloc(ir_set_t);\r
+ iter = set->nextchild;\r
+ check:\r
+ if (bytes_identical(iter->name, name))\r
+ return iter;\r
+ if (iter->nextsib != NULL)\r
+ { iter = iter->nextsib;\r
+ goto check;\r
}\r
- else\r
- REF_ALLOC();\r
-\r
-\r
- if(num_refs % 16 == 0)\r
- { CURRENT_POST() = CURRENT_REF();\r
- inc_posts();\r
- }\r
-\r
- return CURRENT_REF();\r
+ return iter->nextsib = struct_alloc(ir_set_t);\r
}\r
\r
-void\r
-inc_posts()\r
-{ num_posts++;\r
- if(POST_FULL())\r
- { if(!PCS_FULL())\r
- { fprintf(stderr, "You have allocated to many (%d) refs ", num_posts);\r
- exit(EXIT_FAILURE);\r
- }\r
- else\r
- CSP_PUSH(pcs);\r
+/* Add a framebox to a set\r
+ Attempts to create a new framebox of the specified set, returning\r
+ the framebox if it already exists\r
+*/\r
+static inline\r
+struct ir_framebox_t* ir_set_add_framebox\r
+( struct ir_set_t* set,\r
+ uint8_t* name\r
+)\r
+{ struct ir_framebox_t* iter;\r
+ if (set->frameboxes == NULL)\r
+ return set->frameboxes = struct_alloc(ir_framebox_t);\r
+ iter = set->frameboxes;\r
+ check:\r
+ if (bytes_identical(iter->header.data_name, name))\r
+ return iter;\r
+ if (iter->header.nextsib != NULL)\r
+ { iter = (struct ir_framebox_t*) iter->header.nextsib;\r
+ goto check;\r
}\r
- else\r
- POST_ALLOC();\r
-\r
-}\r
-\r
-struct cdat*\r
-curr_cdat\r
-()\r
-{\r
- return (*cdat_stackp);\r
-}\r
-\r
-struct odat*\r
-curr_odat\r
-()\r
-{\r
- return CURRENT_ODAT();\r
+ iter->header.nextsib = (union ir_setdata_t*) struct_alloc(ir_framebox_t);\r
+ return (struct ir_framebox_t*) iter->header.nextsib;\r
}\r
\r
-struct vdat*\r
-curr_vdat\r
-()\r
-{\r
- return CURRENT_VDAT();\r
-}\r
-struct set*\r
-curr_cdat_set \r
-()\r
-{\r
- return CURRENT_SET();\r
-}\r
-\r
-struct ref*\r
-curr_ref\r
-()\r
-{\r
- return CURRENT_REF();\r
-}\r
-struct ref*\r
-prev_ref\r
-()\r
-{\r
- return PREVIOUS_REF();\r
-}\r
-struct model*\r
-curr_model\r
-()\r
-{\r
- return &CURRENT_MODEL();\r
+/* Match two null-terminated bytestrings\r
+ Return 1 if the two bytestrings are identical, else 0\r
+*/\r
+static inline\r
+int bytes_identical\r
+( uint8_t* stra,\r
+ uint8_t* strb\r
+)\r
+{ while (*stra && *strb)\r
+ if (*stra++ != *strb++)\r
+ return 0;\r
+ return *stra == *strb;\r
}\r
\r
-/* IR.C*/\r
-void\r
-push_cdat\r
-( struct name* name )\r
-{\r
- struct cdat* curr_cdatp;\r
-\r
- curr_cdatp = alloc_cdat();\r
-\r
- name_u8_cpy(&curr_cdatp->name, name);\r
- curr_cdatp->idx = num_cdats;\r
-\r
- /* Set the cdat as a subclass of the previous cdat */\r
- (*cdat_stackp)->class_list[(*cdat_stackp)->num_classes++] = curr_cdatp;\r
- /* Push the cdat onto the cdat_stack */\r
- *++cdat_stackp = curr_cdatp;\r
-\r
-}\r
-\r
-void\r
-pop_cdat\r
-()\r
-{\r
- cdat_stackp--;\r
-}\r
-\r
-\r
-\r
-void\r
-insert_set_name\r
-( struct name* name )\r
-{ \r
- //Push name onto current namelist, set the set_namelist.\r
- name_u8_cpy(&set_namelist[set_numnames++], name);\r
- \r
-}\r
-\r
-\r
-/* Called at the last name of a sets namelist. Inserts the set namelist \r
- onto the set_stack at the appropriate depth i.e. the number of names in\r
- the namelist. If each name in the namelist at every depth matches, nothing happens. For every\r
- name on the namelist that doesnt match what is currently on the set_stack,\r
- a new set/odat is created at the depth that it describes. E.g. a set name\r
- of A_B_C is a depth of 3 and is represented in the set_stack as A, A_B and A_B_C. \r
- If a new set namelist is defined, X_Y, the new set_stack will become X, X_Y. */\r
-\r
-void\r
-insert_set_namelist\r
-( struct name* name )\r
-{ int depth, nameidx, i;\r
-\r
- insert_set_name(name);\r
-\r
- \r
- for( depth = 0; depth < set_numnames ; depth++ )\r
- { for (nameidx = 0; nameidx <= depth; nameidx++)\r
- { if( name_u8_cmp(&set_namelist[nameidx], &ss.set_frames[depth].namelist[nameidx]) != 0 )\r
- { /* Populate the namelist of the set at the current depth */\r
- for(i = 0; i <= depth; i++)\r
- name_u8_cpy(&ss.set_frames[depth].namelist[i], &set_namelist[i]);\r
-\r
- /* Alloc set and odat */\r
- ss.set_frames[depth].odatp = alloc_odat();\r
- ss.set_frames[depth].setp = alloc_set();\r
-\r
- /* populate set/odat name and cdat_idx */\r
- name_u8_cpy(&ss.set_frames[depth].odatp->name, &set_namelist[depth]);\r
- ss.set_frames[depth].setp->cdat_idx = ( *cdat_stackp)->idx;\r
- \r
- /* Insert allocated set and odat into their respective trees if there is a depth \r
- (they have parents) */ \r
- if(depth)\r
- { ss.set_frames[depth].odatp->parent_odatp = ss.set_frames[depth-1].odatp;\r
- if(ss.set_frames[depth-1].setp->num_sets < MAX_SETS)\r
- ss.set_frames[depth-1].setp->set_list[ss.set_frames[depth-1].setp->num_sets++] = ss.set_frames[depth].setp;\r
- else\r
- { printf("you have allocated too many sets in insert_namelist()\n");\r
- //TODO: EXIT()\r
- }\r
- }\r
- else /* no parent set, so assign to cdat set_list */\r
- { ss.set_frames[depth].odatp->parent_odatp = NULL; //no parent odat = NULL.\r
- if(curr_cdat_set()->num_sets < MAX_SETS)\r
- curr_cdat_set()->set_list[curr_cdat_set()->num_sets++] = ss.set_frames[depth].setp;\r
- else\r
- { printf("you have allocated too many sets in insert_namelist()\n");\r
- //TODO: EXIT()\r
- }\r
- }\r
- \r
- \r
- ss.set_frames[depth].num_names = set_numnames;\r
- ss.curr_depth = depth;\r
-\r
- /* Every set has a vdat, but some won't be populated because the namelist that instantiated */\r
- /* the set might not have a SS statement that populates the models of the vdat. This is ok */\r
- /* because 1) IR is supposed to be bloated so that binary out isnt 2) this functionality */\r
- /* preserves the assumptions that insert_framesheet() makes when it calls curr_vdat() */\r
- alloc_vdat();\r
+/* Assign Setdata to Set\r
+\r
+ */\r
+void ir_set_assign_data\r
+( struct ir_set_t* set,\r
+ union ir_setdata_t* setdata\r
+)\r
+{ struct ir_framebox_t* framebox;\r
+ struct ir_simplex_t* simplex;\r
+ struct ir_link_t* link;\r
+ switch (setdata->header.type)\r
+ { case FSDAT:\r
+ framebox = ir_set_add_framebox(set, setdata->header.data_name);\r
+ if (framebox->framesheets[setdata->framesheet.frameinfo.facing].header.data_name != NULL)\r
+ wprintf("Duplicate framesheet [%i] %s\n",\r
+ setdata->framesheet.frameinfo.facing, setdata->header.data_name);\r
+ framebox->framesheets[setdata->framesheet.frameinfo.facing] = setdata->framesheet;\r
+ break;\r
+ case MSDAT:\r
+ framebox = ir_set_add_framebox(set, setdata->header.data_name);\r
+ if (framebox->mapsheets[setdata->mapsheet.frameinfo.facing].header.data_name != NULL)\r
+ wprintf("Duplicate mapsheet [%i] %s\n",\r
+ setdata->mapsheet.frameinfo.facing, setdata->header.data_name);\r
+ framebox->mapsheets[setdata->mapsheet.frameinfo.facing] = setdata->mapsheet;\r
+ break;\r
+ case ADAT:\r
+ if (set->audio == NULL)\r
+ { set->audio = (struct ir_simplex_t*) setdata;\r
+ return;\r
+ }\r
+ simplex = set->audio;\r
+ while (simplex->header.nextsib != NULL)\r
+ if (bytes_identical(simplex->header.data_name, setdata->header.data_name))\r
+ { wprintf("Duplicate audio %s\n", setdata->header.data_name);\r
+ *simplex = setdata->audio;\r
+ //setdata->audio is now a pointer to redundant, unused memory.\r
+ return;\r
}\r
- \r
- }\r
- \r
+ else\r
+ simplex = (struct ir_simplex_t*) simplex->header.nextsib;\r
+ simplex->header.nextsib = setdata;\r
+ break;\r
+ case LDAT:\r
+ if (set->links == NULL)\r
+ { set->links = (struct ir_link_t*) setdata;\r
+ return;\r
+ }\r
+ link = set->links;\r
+ while (link->header.nextsib != NULL)\r
+ link = (struct ir_link_t*) link->header.nextsib;\r
+ link->header.nextsib = setdata;\r
+ break;\r
+ default:\r
+ fprintf(stderr, "Unknown setdata type %x\n", setdata->header.type);\r
+ exit(-1);\r
}\r
-\r
- /* Set to 0 to reset for next set_namelist */\r
- set_numnames = 0;\r
}\r
\r
-\r
-/* We create new odats for each map variant that are children of the current odat/set\r
- set their name as the map name, and identify them by marking them as a map. This lets\r
- us distinguish between sibling odats that have the same name because the map of the parent\r
- odat had the same name as another, regular odat. */\r
-#define CURR_SS_FRAME() (ss.set_frames[ss.curr_depth])\r
-#define CURR_SS_SETP() (CURR_SS_FRAME().setp)\r
-#define CURR_SS_ODATP() (CURR_SS_FRAME().odatp)\r
-void\r
-insert_map\r
-( struct name* name, int direction, int height, int width, int refid, uint8_t* filepath )\r
-{ int i;\r
- struct odat* curr_map_odatp; //pointer to odat in odat_buf\r
- struct set* curr_map_setp; //pointer to set in set_buf\r
- struct link* linkp;\r
-\r
- curr_map_odatp = alloc_odat();\r
- curr_map_setp = alloc_set();\r
- /* Create a new odat, make its parent be the set. Make a set for mdat, its name should */\r
- /* be the name of the odat + name of model. That makes a conflict beween odats that are named */\r
- /* the same thing as the model of a sibling odat that was created from a map. They can have */\r
- /* same name if the map odat is marked. So mark the map odat. */\r
-\r
- /* insert parent odat */\r
- curr_map_odatp->parent_odatp = CURR_SS_ODATP(); \r
-\r
- /* insert into set_list */\r
- if(CURR_SS_SETP()->num_sets < MAX_SETS)\r
- CURR_SS_SETP()->set_list[CURR_SS_SETP()->num_sets++] = curr_map_setp;\r
- else\r
- { printf("You have allocated to many sets, error in insert_map()\n");\r
- //TODO: EXIT()\r
- }\r
- \r
- /* indicate that newly created odat is a map */\r
- curr_map_odatp->ismap = 1;\r
- /* set odat and set name */\r
- name_u8_cpy(&curr_map_odatp->name, name);\r
-\r
- /* set cdat idx values for both set and odat */\r
- curr_map_setp->cdat_idx = num_cdats;\r
-\r
- /* Insert map information into the odats map */\r
- curr_map_odatp->map.height = height;\r
- curr_map_odatp->map.width = width;\r
- u8_stpncpy(curr_map_odatp->map.filepath, filepath, FPATH_MAX);\r
-\r
-\r
- /* Generate refid if needed, put into ref_buf */\r
- if(!refid)\r
- refid = ss_refid++;\r
-\r
- insert_ref(curr_map_odatp, refid);\r
-\r
- /* If current odatp on stack has a link, then we need to make our own link. just set the vdat_idx */\r
- if(CURR_SS_ODATP()->vdat_idx == 0)\r
- { linkp = alloc_link();\r
- linkp->type = CURR_SS_ODATP()->linkp->type;\r
- linkp->dest_odatp = CURR_SS_ODATP();\r
- linkp->dest_refid = refid;\r
- linkp->link_t.mlink.src_refid = CURR_SS_ODATP()->linkp->link_t.mlink.src_refid;\r
-\r
- /* Copy the animation name of the vlink*/\r
- name_u8_cpy(&linkp->link_t.vlink.src_animname, &CURR_SS_ODATP()->linkp->link_t.vlink.src_animname);\r
- /* Copy the namelist of the vlink*/\r
- for(i = 0; i < MAX_DEPTH; i++)\r
- name_u8_cpy(&linkp->link_t.vlink.src_namelist[i], &CURR_SS_ODATP()->linkp->link_t.vlink.src_namelist[i]);\r
- }\r
- else\r
- curr_map_odatp->vdat_idx = CURR_SS_ODATP()->vdat_idx;\r
-\r
+void ir_set_assign_ref\r
+( struct ir_set_t* set,\r
+ long long ref\r
+)\r
+{ if (set->ref != 0)\r
+ wprintf("Ref override: 0x%lx -> 0x%lx for set %s\n",\r
+ (long unsigned) set->ref, (long unsigned) ref, set->name);\r
+ set->ref = ref;\r
+ //TODO: reflist_add(set);\r
}\r
- \r
-\r
-/* 11/22 Each vdat has a multiple models. Each model has 8 framesheets, one in each\r
- direction, that create a spritesheet. Inserting framesheets into the correct \r
- model is just a matter of checking whether or not the last models name matches\r
- the current one. We can never get a framesheet that is for the same model before \r
- AND after some other model, due to alphasorting of the files in each directory */\r
-void\r
-insert_framesheet\r
-( struct name* model_name, int direction, int height, int width, int refid, uint8_t* filepath )\r
-{ struct vdat* curr_vdatp;\r
- struct model* curr_modelp;\r
- static struct name last_model_name[32];\r
- \r
- curr_vdatp = curr_vdat();\r
-\r
- /* If the model name changed, that means there are no more\r
- framesheets for that model to be processed, a guaruntee we make\r
- b/c the filenames are alphabetically sorted */\r
- if(!name_u8_cmp(last_model_name, model_name))\r
- { if(curr_vdatp->num_models)\r
- curr_vdatp->num_models++;\r
- num_models++; // total number of models\r
- }\r
- \r
-\r
- if(CURR_SS_ODATP()->refid == 0)\r
- { if(!refid)\r
- refid = ss_refid++;\r
- insert_ref(CURR_SS_ODATP(), refid); /* given a odatp and a refid, insert the odatp into the ref_buf. */\r
- } \r
- else\r
- printf("error: redefining a previously set refid\n");\r
- \r
- curr_modelp = curr_model(); \r
-\r
- name_u8_cpy(&curr_modelp->name, model_name);\r
- curr_modelp->spritesheet[direction].height = height;\r
- curr_modelp->spritesheet[direction].width = width;\r
- u8_stpncpy(curr_modelp->spritesheet[direction].filepath, filepath, FPATH_MAX);\r
\r
- name_u8_cpy(last_model_name, model_name);\r
- \r
+void ir_data_assign_path\r
+( union ir_setdata_t* setdata,\r
+ uint8_t* path\r
+)\r
+{ setdata->header.src_filename = path;\r
+ //TODO: internal strdup, not assign (= path;)\r
}\r
\r
\r
-void\r
-insert_mlink\r
-( struct name* src_mapname, int src_refid)\r
-{ struct link* linkp;\r
- int i;\r
-\r
- linkp = alloc_link();\r
-\r
- /* set type */\r
- linkp->type = 3;\r
- /* set the name of the src map for the link, if a name exists */\r
- if(src_mapname)\r
- name_u8_cpy(&linkp->link_t.mlink.src_mapname, src_mapname);\r
- /* Set the source ref id of the link */\r
- linkp->link_t.mlink.src_refid = src_refid;\r
- \r
- /* Copy the entire namelist of the link, if it exists */\r
- for(i = 0; i < link_numnames; i--) \r
- { name_u8_cpy(&linkp->link_t.mlink.src_namelist[i], &link_namelist[i]);\r
- name_u8_set(&link_namelist[i], (ucs4_t) 0);\r
- }\r
- link_numnames = 0;\r
- \r
- linkp->dest_odatp = CURR_SS_ODATP();//current odat on set_stack\r
-\r
+//TODO: Macro ir_framsheet and mapsheet?\r
+union ir_setdata_t* ir_framesheet\r
+( uint8_t* name,\r
+ apc_facing d,\r
+ int width,\r
+ int height\r
+)\r
+{ struct ir_framedata_t* framesheet = struct_alloc(ir_framedata_t);\r
+ framesheet->header.type = FSDAT;\r
+ framesheet->header.data_name = name;\r
+ framesheet->frameinfo.facing = d;\r
+ framesheet->frameinfo.w = width;\r
+ framesheet->frameinfo.h = height;\r
+ return (union ir_setdata_t*) framesheet; \r
}\r
\r
-\r
-void\r
-insert_link_name\r
-( struct name* name )\r
-{ \r
- //Push name onto current namelist, set the set_namelist.\r
- name_u8_cpy(&link_namelist[link_numnames++], name);\r
- \r
+union ir_setdata_t* ir_mapsheet\r
+( uint8_t* name,\r
+ apc_facing d,\r
+ int width,\r
+ int height\r
+)\r
+{ struct ir_framedata_t* mapsheet = struct_alloc(ir_framedata_t);\r
+ mapsheet->header.type = MSDAT;\r
+ mapsheet->header.data_name = name;\r
+ mapsheet->frameinfo.facing = d;\r
+ mapsheet->frameinfo.w = width;\r
+ mapsheet->frameinfo.h = height;\r
+ return (union ir_setdata_t*) mapsheet;\r
}\r
\r
-\r
-/* Nearly identical to mlink */\r
-void\r
-insert_vlink\r
-( struct name* src_animname, int src_refid ) \r
-{ struct link* linkp;\r
- int i;\r
-\r
- linkp = alloc_link();\r
-\r
- /* set type */\r
- linkp->type = 2;\r
- \r
- /* set the name of the src animname for the link, if a name exists */\r
- if(src_animname)\r
- name_u8_cpy(&linkp->link_t.vlink.src_animname, src_animname);\r
- \r
- /* Set the source ref id of the link */\r
- linkp->link_t.mlink.src_refid = src_refid;\r
- \r
- /* Copy the entire namelist of the link, if it exists */\r
- for(i = 0; i < link_numnames; i++) \r
- { name_u8_cpy(&linkp->link_t.vlink.src_namelist[i], &link_namelist[i]);\r
- name_u8_set(&link_namelist[i], (ucs4_t) 0);//set to null for next link_namelist\r
- }\r
- link_numnames = 0;\r
- \r
- linkp->dest_odatp = CURR_SS_ODATP();//current odat on set_stack\r
-\r
+union ir_setdata_t* ir_audio\r
+( uint8_t* name )\r
+{ struct ir_simplex_t* audio = struct_alloc(ir_simplex_t);\r
+ audio->header.type = ADAT;\r
+ audio->header.data_name = name;\r
+ return (union ir_setdata_t*) audio;\r
}\r
\r
-\r
-/* TODO: Do we really need to store the prev/next pointer? iterating through the \r
- ref_buf could be achieved by iterating until the num_refs anyway. */\r
-void\r
-insert_ref\r
-( struct odat* odatp, int refid )\r
-{ struct ref* curr_refp;\r
- struct ref* prev_refp;\r
-\r
- curr_refp = alloc_ref();\r
- prev_refp = prev_ref();\r
-\r
- prev_refp->nextref = curr_refp;\r
- curr_refp->lastref = prev_refp;\r
-\r
- curr_refp->odatp = odatp;\r
- curr_refp->refid = refid;\r
-\r
- if(refid % 16)\r
- { POST_ALLOC();\r
- CURRENT_POST()->refid = refid;\r
- CURRENT_POST()->odatp = odatp;\r
+static\r
+void* stack_alloc(size_t bytes)\r
+{ if (!bytes)\r
+ { wprint("Attempting to allocate 0 bytes in stack_alloc");\r
+ return pagenode_head->head;\r
}\r
- \r
-}\r
-\r
-\r
-void\r
-insert_refid\r
-( int refid )\r
-{ CURR_SS_ODATP()->refid = refid;\r
+ if (PN_HEADSPACE() < bytes) \r
+ { pagenode_head->next = (struct pagenode_t*) calloc(PN_ALLOCSIZE,1);\r
+ pagenode_head = pagenode_head->next;\r
+ pagenode_head->head = pagenode_head->root;\r
+ }\r
+ pagenode_head->head += bytes;\r
+ return (void*) pagenode_head->head - bytes;\r
}\r
\r
-\r
-void\r
-insert_vdat\r
-()\r
-{ struct vdat* curr_vdatp;\r
-\r
- curr_vdatp = curr_vdat();\r
- \r
- curr_vdatp->creator = CURR_SS_ODATP();\r
- CURR_SS_ODATP()->vdat_idx = num_vdats;\r
- CURR_SS_ODATP()->vdatp = curr_vdatp;\r
- alloc_vdat();\r
-}\r
projects / henge / apc.git / blobdiff