\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(int);\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
-/* Dynamically allocate memory for a class data structure, */\r
-/* or cdat, after a class has been identified in a grammar. */\r
-/* We also create a stack of class pointers so that */\r
-/* we can access the cdat during processing of that */\r
-/* cdats sets and elements, a requirement because the */\r
-/* nature of recursive classes prevents us from accessing */\r
-/* the cdat based on the previous index into cdat_buf, */\r
-/* which is a list of all allocated cdats */\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
-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
-/* Sets: What is a set? \r
- Instantiation?\r
- Associations? \r
- Containment?\r
- Usage?\r
- The set is populated at parse time AFTER the elements are populated, due to\r
- the nature of bottom up parsing. */\r
-struct set {\r
- int cdat_idx;\r
- int num_sets;\r
- struct set* set_list[MAX_SETS];\r
-};\r
-\r
-/* Refs: Each set/ele has a reference to its object data (odat) through a refid.\r
- refids are unsigned 64 byte integers that map to the hex values RGBA. During\r
- the construction of the directory structure, users can choose a RGBA value for\r
- each object that any other object can refer to via links (see link). If a user\r
- does not choose an RGBA value, then the object is given one from the system space.\r
- We maintain a doubly linked list of refs in the ref_buf at parse time so that\r
- links can be resolved after the parsing of the directory structure is complete.\r
- For every 16th ref, we create a post so that we can reduce on the search time for\r
- a random access. */\r
-\r
-struct ref {\r
- int type; //TODO: Is this needed?\r
- struct ref* nextref;\r
- struct ref* lastref;\r
- struct odat* odatp;\r
- int refid; //0xFFFFFF->digit\r
-};\r
-\r
-/* Links: At parse time, a set/ele can include a link in their\r
- grammar representation instead of the actual data and this signifies\r
- to the APC that that set/ele wishes to use the data of another\r
- set/ele, either its video data (vdat) or object data (odat). The link\r
- itself contains the type of link it is, the refid OR name, and\r
- which set/ele created the link. During parse time, links can be made\r
- to o/vdats that have yet to be parsed. In order to accomodate for this,\r
- we resolve all links AFTER parse time by iterating through the link_buf,\r
- finding the refid that was stored for some object (if the refid exists),\r
- and creating a relative pointer from the original object to the data that\r
- was linked */\r
-\r
-/* TODO: Explain links more betta */\r
-\r
-struct olink {\r
- int src_refid;\r
-};\r
- \r
-struct vlink {\r
- int src_refid;\r
- struct name src_animname;\r
- struct name src_namelist[MAX_DEPTH];\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
-/* From: src odat ()To: dest odat (refid)*/\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
+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
-/* 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; // odat == set ? null : set refid\r
- struct ref* refp; /* pointer to it's ref on ref_list */\r
- struct map map; //only valid if odat ismap\r
-\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
-/* A framesheet is a grouping of animation frames in\r
- a single direction (N,W,S,E) */\r
-struct framesheet {\r
- int width;\r
- int height;\r
- int num_frames;\r
-\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
-/* A model is a collection of framesheets for every\r
- direction (N,W,S,E,NW,NE,SW,SE)*/\r
-/* NAMED spritesheet */\r
-struct model {\r
- struct name name;\r
- uint8_t filepath[PATH_MAX];\r
- struct framesheet spritesheet[8]; //one for each\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
-/* Vdat: Vdats are the video data of each object. They can not be\r
- created as a stand alone object (because they consist solely\r
- of animation information and not the map which the\r
- animation manipulates). 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
- uint8_t filename[FNAME_MAX];\r
- int height;\r
- int width;\r
- uint8_t filepath[FPATH_MAX];\r
- struct model model_list[MAX_MODELS];\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
-\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
-\r
-\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
-\r
-\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
-\r
-struct cdat* cdat_stack[MAX_CLASSES];\r
-struct cdat** cdat_stackp;\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
-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
- }\r
- else\r
- SET_ALLOC();\r
-\r
- return CURRENT_SET();\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
+} \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
+/* 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
- LDAT_ALLOC();\r
-\r
- return CURRENT_LINK();\r
-\r
+ return iter->nextsib = struct_alloc(ir_class_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
- }\r
- else\r
- REF_ALLOC();\r
-\r
-\r
- if(num_refs % 16 == 0)\r
- { CURRENT_POST() = CURRENT_REF();\r
- inc_posts();\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
-\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 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
- 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
-}\r
-\r
-struct vdat*\r
-curr_vdat\r
-()\r
-{\r
- return CURRENT_VDAT();\r
-}\r
-\r
-struct set*\r
-curr_cdat_set \r
-()\r
-{\r
- return CURRENT_SET();\r
+ return iter->nextsib = struct_alloc(ir_set_t);\r
}\r
\r
-struct set*\r
-curr_set\r
-(int depth)\r
-{ int i;\r
- struct set* setp;\r
-\r
- for(i = 0; i <= depth; i++)\r
- { if(!(setp = setp->set_list[setp->num_sets]))\r
- { printf("You are trying to access a set that does not exist irmem.c\n");\r
- return NULL;\r
- }\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
-\r
-\r
- return setp;\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
+ iter->header.nextsib = (union ir_setdata_t*) struct_alloc(ir_framebox_t);\r
+ return (struct ir_framebox_t*) iter->header.nextsib;\r
}\r
\r
-/* IR.C*/\r
-void\r
-push_cdat\r
-( name )\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
-void\r
-insert_set_name\r
-( 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
+/* 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
+/* Assign Setdata to Set\r
\r
-void\r
-insert_set_namelist\r
-( name )\r
- struct name* name;\r
-{ int depth, nameidx, i;\r
-\r
- insert_set_name(name);\r
-\r
- //Check if entire string matches first? Only possible if namelist is contiguous (uint8_t strings seperated by \0)\r
- //Create odats/sets for each name in namelist where nameidx > ns_depth\r
- //first check if any parts of namelist matches what is currently on namestack\r
- //we can gauruntee that from ns_depth + 1 -> set_numnames namelists dont match. x\r
- \r
-\r
- //if name_list doesnt match, from the first depth at which namelist doesnt match\r
- //remove the nameframes namelist (zero out ones below?) and replace with current namelist,\r
- //then allocate a new odat and set it to the current set_frame.\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
+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
\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 odatsthat 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
-( name, direction, height, width, refid, filepath )\r
- struct name* name;\r
- int direction, height, width, refid;\r
- uint8_t* filepath;\r
-{ int i;\r
- struct odat* curr_mem_odatp; //pointer to odat in odat_buf\r
- struct set* curr_mem_setp; //pointer to set in set_buf\r
- struct link* linkp;\r
-\r
- curr_mem_odatp = alloc_odat();\r
- curr_mem_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_mem_odatp->parent_odatp = CURR_SS_ODATP(); \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_mem_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_mem_odatp->ismap = 1;\r
- //set odat and set name\r
- name_u8_cpy(&curr_mem_odatp->name, name);\r
-\r
- /* set cdat idx values for both set and odat */\r
- curr_mem_setp->cdat_idx = num_cdats;\r
-\r
- /* TODO: INSERT MAP HEIGHT/WIDTH/NAME/FILEPATH INTO ODAT */\r
-\r
-\r
- /* Generate refid if needed, put into ref_buf */\r
- if(!refid)\r
- refid = ss_refid++;\r
-\r
- insert_ref(curr_mem_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
- { //alloc a link\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_mem_odatp->vdat_idx = CURR_SS_ODATP()->vdat_idx;\r
-\r
- \r
- \r
- \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
-\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
-( model_name, direction, height, width, refid, filepath )\r
- struct name* model_name;\r
- int direction, height, width, refid;\r
- uint8_t* filepath;\r
-{ struct vdat* curr_vdatp;\r
- struct model* curr_modelp;\r
- static struct name last_model_name[32];\r
-\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
- //push ref into 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
- /* TODO: INSERT FILEPATH INTO VDAT */\r
- u8_stpncpy(curr_modelp->spritesheet[direction].filepath, filepath, FPATH_MAX);\r
-\r
- name_u8_cpy(last_model_name, model_name);\r
-\r
- \r
-}\r
-\r
-\r
-\r
-//src_path is stored in link_namelist\r
-void\r
-insert_mlink\r
-( src_mapname, src_refid)\r
- struct name* src_mapname;\r
- 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
- /* Copy the entire namelist of the link, if it exists */\r
- for(i = 0; i < link_numnames; i--) //TODO MAX_DEPTH -> link_namelist_num??\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
-}\r
-\r
-void\r
-insert_link_name\r
-( 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
-}\r
-\r
-/* Nearly identical to mlink */\r
-void\r
-insert_vlink\r
-( src_animname, src_refid ) \r
- struct name* src_animname;\r
- 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++) //TODO MAX_DEPTH -> link_namelist_num??\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
- \r
- linkp->dest_odatp = CURR_SS_ODATP();//current odat on set_stack\r
-\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
-( odatp, refid )\r
- struct odat* odatp;\r
- 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
- }\r
- \r
- \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
-\r
-void\r
-insert_refid\r
-( refid )\r
- int refid;\r
-{ CURR_SS_ODATP()->refid = refid;\r
-}\r
-#if 0\r
-\r
-\r
-/* Called in the reduction of a set. While both odats (eles and sets)\r
- have identical label terminals, we are unable to give a single grammatical rule\r
- for both due to how we allocate odats in the odat buf. Due to the\r
- nature of bottom up parsing, the set label is recognized first, and then the\r
- sets elements are recognized. This means that after we have processed the sets elemenets,\r
- the curr_odat is going to be the last element and NOT the set that was first allocated.\r
- To get around this, we create a global variable set_odatp that will store the pointer\r
- to the odat when it is first allocated (in insert_set_label()) so that insert_set() can\r
- have access to it. Curr set points the sets representation in the cdat, curr_set_odatp\r
- points to the sets representation as an odat*/\r
-\r
-//TODO: Add insert_set_ref()\r
-//TODO: Is this the correct allocation scheme? No do the one ken suggested\r
-void\r
-insert_s_name\r
-( struct name* name\r
+void ir_set_assign_ref\r
+( struct ir_set_t* set,\r
+ long long ref\r
)\r
-{\r
-\r
- struct set* curr_setp;\r
-\r
- curr_setp = curr_set();\r
- curr_set_odatp = alloc_odat();\r
-\r
- u8_cpy(curr_set_odatp->name, name, 32);\r
- u8_cpy(curr_setp->name, name, 32);\r
- curr_set_odatp->parent_odatp = NULL;\r
- \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
-/* Inserting a olink instead of a set. Set is really just a placeholder\r
- for another set. Allocate the memory for the set so taht it can be populated*/\r
-void\r
-insert_set_olink\r
-( int refid\r
+void ir_data_assign_path\r
+( union ir_setdata_t* setdata,\r
+ uint8_t* path\r
)\r
-{\r
- struct set* curr_setp;\r
-\r
- curr_setp = curr_set();\r
-\r
- curr_setp->refid = refid;\r
-\r
+{ setdata->header.src_filename = path;\r
+ //TODO: internal strdup, not assign (= path;)\r
}\r
\r
-void\r
-insert_set_vlink\r
-( int refid,\r
- uint8_t* anim_name\r
-)\r
-{\r
- struct cdat* curr_cdatp;\r
- struct odat* curr_odatp;\r
- struct link* curr_linkp;\r
-\r
-\r
- curr_cdatp = curr_cdat();\r
- curr_odatp = curr_odat();\r
- curr_linkp = alloc_link();\r
-\r
- /* Insert vlink into link_stack so that it gets processed at\r
- output time */\r
- curr_linkp->type = 2;\r
- /* Store the target odat information*/\r
- curr_linkp->link_t.vlink.refid = refid;\r
- u8_cpy(curr_linkp->link_t.vlink.anim_name, anim_name, 32);\r
- /* Store the linking odat/cdat information */\r
- curr_linkp->classp = curr_cdatp;\r
- curr_linkp->odatp = curr_odatp;\r
- curr_linkp->set_idx = curr_cdatp->num_sets;\r
- // curr_linkp->ele_idx = -1;\r
-\r
-}\r
-\r
-/* Svlinks dont have animation names */\r
-void\r
-insert_set_svlink\r
-( int refid \r
-)\r
-{\r
- struct cdat* curr_cdatp;\r
- struct link* curr_linkp;\r
-\r
- curr_cdatp = curr_cdat();\r
- curr_linkp = alloc_link();\r
\r
- /* Insert svlink into link_stack so that it gets processed at\r
- output time */\r
- curr_linkp->type = 3;\r
- curr_linkp->classp = curr_cdatp;\r
- curr_linkp->set_idx = curr_cdatp->num_sets;\r
- // curr_linkp->ele_idx = -1;\r
- curr_linkp->link_t.svlink.refid = refid;\r
-\r
-}\r
-\r
-/* At the point of reducing to a set, most of the\r
- sets odat information has already been populated\r
- during the reduction of its right hand side\r
- non terminals (hitbox, root, quad_list). */\r
-void\r
-insert_set\r
-()\r
-{ int refid;\r
- struct odat* curr_odatp;\r
- struct cdat* curr_cdatp;\r
- struct set* curr_setp;\r
- struct ref* prev_refp;\r
- struct ref* curr_refp;\r
- struct vdat* curr_vdatp;\r
-\r
- curr_odatp = curr_set_odatp; //allocated at insert_set_label\r
- curr_cdatp = curr_cdat();\r
- curr_setp = curr_set();\r
- prev_refp = curr_ref();\r
- curr_refp = alloc_ref();\r
- curr_vdatp = curr_vdat();\r
-\r
- curr_vdatp->creator = curr_set_odatp;\r
-\r
- curr_setp->cdat_idx = curr_cdatp->idx; //does a set need its class idx?\r
- u8_cpy(curr_setp->name, curr_odatp->name, 32);\r
- curr_cdatp->num_sets++;\r
-\r
- curr_odatp->cdat_idx = curr_cdatp->idx;\r
- curr_odatp->refp = curr_refp;\r
-\r
- refid = curr_setp->refid; // refid set by insert_set_label(name, refid)\r
-\r
- curr_refp->refid = refid;\r
- curr_refp->lastref = prev_refp;\r
- curr_refp->odatp = curr_odatp;\r
- prev_refp->nextref = curr_refp;\r
-\r
-\r
-\r
-}\r
-/* Created as a seperate function, instead of setting the ODATS vdat_id and\r
- calling inc_vdat() inside of insert_set(), to account for the set reduction\r
- where a vdat is not created (o/v/svlinks). */\r
-void\r
-insert_set_vdatid\r
-()\r
-{\r
- struct vdat* curr_vdatp;\r
-\r
- curr_vdatp = curr_vdat();\r
-\r
- curr_set_odatp->vdat_id = num_vdats; //no vdat_id for odats that have vlinks/svlinks\r
- curr_set_odatp->vdatp = curr_vdatp;\r
- curr_set_odatp = NULL; //This sets odat shouldnt be modified after populating odats vdat info\r
-}\r
-\r
-/* Populates the odat name and refid for odat, allocate the odat here for the rest of\r
- the functions to use via curr_odat(). */\r
-void\r
-insert_ele_label\r
+//TODO: Macro ir_framsheet and mapsheet?\r
+union ir_setdata_t* ir_framesheet\r
( uint8_t* name,\r
- int refid\r
+ apc_facing d,\r
+ int width,\r
+ int height\r
)\r
-{\r
- struct odat* curr_odatp;\r
-\r
- curr_odatp = alloc_odat();\r
-\r
- u8_cpy(curr_odatp->name, name, 32);\r
- curr_odatp->map[0] = 0;\r
-\r
- if(refid != -1)\r
- curr_odatp->refid = refid;\r
- else\r
- curr_odatp->refid = ss_refid++;\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
-/* We don't make an odat here, at output time we will resolve\r
- the refid to the corresponding odat. */\r
-void\r
-insert_ele_olink\r
-( int refid\r
-)\r
-{\r
- /* Do nothing because we already know the refid that\r
- the odat needs for this element (in the quad_file) */\r
-}\r
-\r
-void\r
-insert_ele_vlink\r
-( int refid,\r
- uint8_t* anim_name\r
-)\r
-{\r
- struct cdat* curr_cdatp;\r
- struct set* curr_setp;\r
- struct link* curr_linkp;\r
-\r
- curr_cdatp = curr_cdat();\r
- curr_setp = curr_set();\r
- curr_linkp = alloc_link();\r
-\r
- /* Insert vlink into link_stack so that it gets processed at\r
- output time */\r
- curr_linkp->classp = curr_cdatp;\r
- curr_linkp->type = 2;\r
- curr_linkp->set_idx = curr_cdatp->num_sets;\r
- //curr_linkp->ele_idx = curr_setp->num_ele;\r
- curr_linkp->link_t.vlink.refid = refid;\r
- u8_cpy(curr_linkp->link_t.vlink.anim_name, anim_name, 32);\r
-\r
-}\r
-\r
-void\r
-insert_ele_svlink\r
-( int refid\r
+union ir_setdata_t* ir_mapsheet\r
+( uint8_t* name,\r
+ apc_facing d,\r
+ int width,\r
+ int height\r
)\r
-{\r
- struct cdat* curr_cdatp;\r
- struct set* curr_setp;\r
- struct link* curr_linkp;\r
-\r
- curr_cdatp = curr_cdat();\r
- curr_setp = curr_set();\r
- curr_linkp = alloc_link();\r
-\r
- curr_linkp->classp = curr_cdatp;\r
- curr_linkp->type = 3;\r
-\r
- //curr_linkp->ele_idx = curr_setp->num_ele;\r
- curr_linkp->link_t.svlink.refid = refid;\r
-\r
-\r
-}\r
-\r
-//Insert element into odat_buf and cdatpages\r
-void\r
-insert_ele()\r
-{\r
- int refid;\r
- struct cdat* curr_cdatp;\r
- struct odat* curr_odatp;\r
- struct vdat* curr_vdatp;\r
- struct set* curr_setp;\r
- struct ele* curr_elep;\r
- struct ref* curr_refp;\r
- struct ref* prev_refp;\r
-\r
-\r
- curr_odatp = curr_odat(); //malloced @ insert_ele_label\r
- curr_vdatp = curr_vdat();\r
- curr_setp = curr_set();\r
- prev_refp = curr_ref();\r
- curr_refp = alloc_ref();\r
-\r
- curr_vdatp->creator = curr_odatp;\r
-\r
- /* Populate odat for ele */\r
- curr_odatp->cdat_idx = curr_cdatp->idx;\r
- curr_odatp->refp = curr_refp;\r
- curr_odatp->parent_odatp = curr_set_odatp;\r
-\r
- refid = curr_odatp->refid;\r
-\r
- curr_refp->refid = refid;\r
- curr_refp->lastref = prev_refp;\r
- curr_refp->odatp = curr_odatp;\r
- prev_refp->nextref = curr_refp;\r
-\r
-}\r
-\r
-void\r
-insert_ele_vdatid\r
-()\r
-{ struct odat* curr_odatp;\r
- curr_odatp = curr_odat();\r
- curr_odatp->vdat_id = num_vdats;\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
+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
+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
+ 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
-\r
-#endif\r
-\r
-\r
- \r
-\r
-/* void */\r
-/* insert_quad */\r
-/* ( int x, int y, int z, int refid */\r
-/* ) */\r
-/* { */\r
-/* struct quad* curr_quadp; */\r
-\r
-/* curr_quadp = curr_quad(); */\r
-\r
-/* curr_quadp->x = x; */\r
-/* curr_quadp->y = y; */\r
-/* curr_quadp->z = z; */\r
-/* curr_quadp->refid = refid; */\r
- \r
-\r
-\r
-/* } */\r
-\r
-/* /\* serting the hitbox into the set */\r
-/* odat. Elements that don't have */\r
-/* a hitbox will use the sets root. *\/ */\r
-/* void */\r
-/* insert_hitbox */\r
-/* ( int hitbox */\r
-/* ) */\r
-/* { struct odat* curr_odatp; */\r
-\r
-/* curr_odatp = curr_odat(); */\r
-/* curr_odatp->hitbox = hitbox; */\r
-/* } */\r
-\r
-/* /\* Inserting the root into the set */\r
-/* odat. Elements that don't have */\r
-/* a root will use the sets root. *\/ */\r
-/* void */\r
-/* insert_root */\r
-/* ( int x, */\r
-/* int y, */\r
-/* int z */\r
-/* ) */\r
-/* { struct odat* curr_odatp; */\r
-\r
-/* curr_odatp = curr_odat(); */\r
-/* curr_odatp->root.x = x; */\r
-/* curr_odatp->root.y = y; */\r
-/* curr_odatp->root.z = z; */\r
-/* } */\r
-\r
-\r
-\r
-\r
-/* void */\r
-/* insert_frame_pointer */\r
-/* ( uint8_t direction, */\r
-/* void* frame */\r
-/* ) */\r
-/* { struct model* curr_modelp; */\r
-\r
-/* curr_modelp = curr_model(); */\r
-\r
-/* curr_modelp->spritesheet[(int)direction].frames[curr_modelp->spritesheet[(int)direction].num_frames++] = frame; */\r
-/* } */\r
-\r
projects / henge / apc.git / blobdiff