+/*!@file
+ \brief IR Memory Implementation
+ \details Intermediary memory management
+ \author Jordan Lavatai
+ \date Aug 2016
+ ----------------------------------------------------------------------------*/
#include <errno.h>
#include <stdio.h>
-#include <string.h>
+#include <stdint.h> //uint64_t
+#include <string.h> //memmove
+#include <stdlib.h> //malloc
#include <apc/ir.h>
-#define CURR_ODAT (odat_buf[obi])
-#define CURR_VDAT (vdat_buf[vbi])
-#define CURR_CDAT (cdat_buf[cbi]) //more like the base cdat
-//TODO: label and vdat_id
+
+/* functions needed from irmem.c */
+extern
+void
+ir_init(void);
+
+extern
+struct cdat*
+alloc_cdat(void);
+
+extern
+struct odat*
+alloc_odat(void);
+
+extern
void
-insert_set()
+alloc_vdat(void);
+
+extern
+struct link*
+alloc_link(void);
+
+extern
+struct ref*
+alloc_ref(void);
+
+extern
+struct cdat*
+curr_cdat(void);
+
+extern
+struct odat*
+curr_odat(void);
+
+extern
+struct vdat*
+curr_vdat(void);
+
+extern
+struct ele*
+curr_ele(void);
+
+extern
+struct set*
+curr_set(void);
+
+extern
+struct ref*
+prev_ref(void);
+
+extern
+struct quad*
+curr_quad(void);
+
+extern
+struct model*
+curr_model(void);
+
+/* struct definitions needed from irmem.c */
+extern int num_cdats;
+extern struct cdat** cdat_stackp;
+extern struct odat* curr_set_odatp;
+extern uint64_t ss_ref_id;
+
+extern int num_vdats;
+/* Dynamically allocate memory for a class data structure,
+ or cdat, after a class has been identified in a grammar.
+ We also create a stack of class pointers so that
+ we can access the cdat during processing of that
+ cdats sets and elements, a requirement because the
+ nature of recursive classes prevents us from accessing
+ the cdat based on the previous index into cdat_buf,
+ which is a list of all allocated cdats*/
+void
+push_cdat
+( char* name
+)
{
- CURR_CDAT.set_list[CURR_CDAT.set_index].odat_id = obi;
- CURR_CDAT.set_list[CURR_CDAT.set_index].parent_id = 0;//from lexer
- //TODO: add ele_stack is created in element_list
- //TODO: add set to odat_buf
+ struct cdat* curr_cdatp;
+
+ curr_cdatp = alloc_cdat();
+
+ memmove(curr_cdatp->name, name, 32);
+ curr_cdatp->idx = num_cdats;
+
+ /* Set the cdat as a subclass of the previous cdat */
+ (*cdat_stackp)->class_list[(*cdat_stackp)->num_classes] = curr_cdatp;
+ /* Push the cdat onto the cdat_stack */
+ *++cdat_stackp = curr_cdatp;
}
-#define CURR_QUAD (CURR_ODAT.ref_list[CURR_ODAT.ref_index])
void
-insert_ref(int x, int y, int z, int ref)
+pop_cdat
+()
{
- CURR_QUAD.x = x;
- CURR_QUAD.y = y;
- CURR_QUAD.z = z;
- CURR_QUAD.objref = ref;
+ *cdat_stackp = NULL;
+ cdat_stackp--;
}
+/* Called in the reduction of a set. While both odats (eles and sets)
+ have identical label terminals, we are unable to give a single grammatical rule
+ for both due to how we allocate odats in the odat buf. Due to the
+ nature of bottom up parsing, the set label is recognized first, and then the
+ sets elements are recognized. This means that after we have processed the sets elemenets,
+ the curr_odat is going to be the last element and NOT the set that was first allocated.
+ To get around this, we create a global variable set_odatp that will store the pointer
+ to the odat when it is first allocated (in insert_set_label()) so that insert_set() can
+ have access to it. */
-//Insert element into odat_buf and cdat_buf
void
-insert_ele(char* label, int vdat_id)
+insert_set_label
+( char* name,
+ uint64_t ref_id
+)
{
+ struct set* curr_setp;
+ curr_setp = curr_set();
+ curr_set_odatp = alloc_odat();
- memmove(CURR_ODAT.label,label,32);
- CURR_ODAT.vdat_id = vdat_id;
- //TODO: check set_obi to see if set_map_data exists
- //comes from e
- //CURR_ODAT.num_ref = //comes from its set
- //CURR_ODAT.ref_list = //comes from its set
- //CURR_ODAT.class_id = //comes from lexer?
+ memmove(curr_set_odatp->name, name, 32);
+ memmove(curr_setp->name, name, 32);
+ curr_setp->ref_id = ref_id;
- obi++;
}
+void
+insert_set_olink
+( uint64_t ref_id
+)
+{
+ struct set* curr_setp;
+ struct cdat* curr_cdatp;
+ struct link* curr_linkp;
+
+ curr_setp = curr_set();
+ curr_cdatp = curr_cdat();
+ curr_linkp = alloc_link();
+ curr_setp->cdat_idx = curr_cdatp->idx;
+ curr_setp->ref_id = ref_id; /* Will be resolved to offset
+ when link is processed */
+ curr_linkp->type = 1;
+ curr_linkp->link_t.olink.ref_id = ref_id;
+ curr_linkp->cdat_idx = curr_cdatp->idx;
+ curr_linkp->set_idx = curr_cdatp->num_sets++;
+ curr_linkp->ele_idx = -1;
+
+}
-/* fd could be a directory entry */
void
-insert_fdat(char* label, char direction, int fd)
+insert_set_vlink
+( uint64_t ref_id,
+ char* anim_name
+)
{
- memmove(CURR_VDAT.model_list[CURR_VDAT.num_models].label,label,32);
- CURR_VDAT.model_list[CURR_VDAT.num_models].fdat_id[(int)direction] = fd;
+ struct cdat* curr_cdatp;
+ struct link* curr_linkp;
+
+ curr_cdatp = curr_cdat();
+ curr_linkp = alloc_link();
+
+ /* Insert vlink into link_stack so that it gets processed at
+ output time */
+ curr_linkp->type = 2;
+ curr_linkp->link_t.vlink.ref_id = ref_id;
+ curr_linkp->cdat_idx = curr_cdatp->idx;
+ curr_linkp->set_idx = curr_cdatp->num_sets;
+ curr_linkp->ele_idx = -1;
+ memmove(curr_linkp->link_t.vlink.anim_name, anim_name, 32);
+
}
+/* Svlinks dont have animation names */
void
-condense()
+insert_set_svlink
+( uint64_t ref_id
+)
{
- FILE *vp, *op, *cp;
- int v, m;
- int num_models;
+ struct cdat* curr_cdatp;
+ struct link* curr_linkp;
- vp = fopen("vdat_output", "w+");
- if(!vp)
- perror("vdat_output failed to open\n");
+ curr_cdatp = curr_cdat();
+ curr_linkp = alloc_link();
- op = fopen("odat_output", "w+");
- if(!op)
- perror("odat_output failed to open\n");
+ /* Insert svlink into link_stack so that it gets processed at
+ output time */
+ curr_linkp->type = 3;
+ curr_linkp->cdat_idx = curr_cdatp->idx;
+ curr_linkp->set_idx = curr_cdatp->num_sets;
+ curr_linkp->ele_idx = -1;
+ curr_linkp->link_t.svlink.ref_id = ref_id;
- cp = fopen("cdat_output", "w+");
- if(!cp)
- perror("cdat_output failed to open\n");
+}
+
+/* At the point of reducing to a set, most of the
+ sets odat information has already been populated
+ during the reduction of its right hand side
+ non terminals (hitbox, root, quad_list). */
+void
+insert_set
+()
+{ uint64_t ref_id;
+ struct odat* curr_odatp;
+ struct cdat* curr_cdatp;
+ struct set* curr_setp;
+ struct ref* prev_refp;
+ struct ref* curr_refp;
+ curr_odatp = curr_set_odatp; //allocated at insert_set_label, preserved in global space
+ curr_cdatp = curr_cdat();
+ curr_setp = curr_set();
+ prev_refp = prev_ref();
+ curr_refp = alloc_ref();
- /* fwrite vdat */
- for(v = 0; v <= vbi; v++)
- {
- num_models = vdat_buf[v].num_models; //data duplication for caching
- for(m = 0; m <= num_models; m++)
- {
-
- }
+ curr_setp->cdat_idx = curr_cdatp->idx; //does a set need its class idx?
+ memmove(curr_setp->name, curr_odatp->name, 32);
+ curr_cdatp->num_sets++;
+
+ curr_odatp->cdat_idx = curr_cdatp->idx;
+ curr_odatp->refp = curr_refp;
+
+ ref_id = curr_setp->ref_id; // ref_id set by insert_set_label(name, ref_id)
+
+ if(ref_id == -1) /* user did not define a ref_id */
+ { ref_id = ss_ref_id;
+ ss_ref_id++;
}
- /* fwrite odat */
- /* Convert ref_list to actual offset */
+ curr_refp->ref_id = ref_id;
+ curr_refp->lastref = prev_refp;
+ curr_refp->odatp = curr_odatp;
+ prev_refp->nextref = curr_refp;
- /* fwrite cdat */
}
+/* Created as a seperate function, instead of setting the ODATS vdat_id and
+ calling inc_vdat() inside of insert_set(), to account for the set reduction
+ where a vdat is not created (o/v/svlinks). */
void
-inc_cbi()
+insert_set_vdatid
+()
{
- cbi++;
+ curr_set_odatp->vdat_id = num_vdats; //no vdat_id for odats that have vlinks/svlinks
+ curr_set_odatp = NULL; //So this sets odat cant be modified after (which would be a bug)
}
+/* Populates both the odat name and ref_id
+ for odat and ele */
void
-set_class_label(char* label)
+insert_ele_label
+( char* name,
+ uint64_t ref_id
+)
{
- memmove(CURR_CDAT.label,label,32);
+ struct ele* curr_elep;
+ struct odat* curr_odatp;
+
+ curr_elep = curr_ele();
+ curr_odatp = alloc_odat();
+
+ memmove(curr_odatp->name, name, 32);
+
+ memmove(curr_elep->name, name, 32);
+ curr_elep->ref_id = ref_id;
}
+/* We don't make an odat here, at output time we will resolve
+ the ref_id to the corresponding odat. */
void
-inc_subclass_idx()
+insert_ele_olink
+( uint64_t ref_id
+)
{
- CURR_CDAT.subclass_index++;
+ struct cdat* curr_cdatp;
+ struct set* curr_setp;
+ struct ele* curr_elep;
+ struct link* curr_linkp;
+
+ curr_cdatp = curr_cdat();
+ curr_elep = curr_ele();
+ curr_linkp = alloc_link();
+
+ curr_elep->cdat_idx = curr_cdatp->idx;
+ curr_elep->ref_id = ref_id;
+
+ curr_linkp->type = 1;
+ curr_linkp->link_t.olink.ref_id = ref_id;
+ curr_linkp->cdat_idx = curr_cdatp->idx;
+ curr_linkp->set_idx = curr_cdatp->num_sets++;
+ curr_linkp->ele_idx = curr_setp->num_ele++;
+
}
void
-inc_set_index()
+insert_ele_vlink
+( uint64_t ref_id,
+ char* anim_name
+)
{
- cdat_buf[cbi].set_index++;
+ struct cdat* curr_cdatp;
+ struct set* curr_setp;
+ struct link* curr_linkp;
+
+ curr_cdatp = curr_cdat();
+ curr_setp = curr_set();
+ curr_linkp = alloc_link();
+
+ /* Insert vlink into link_stack so that it gets processed at
+ output time */
+ curr_linkp->cdat_idx = curr_cdatp->idx;
+ curr_linkp->type = 2;
+ curr_linkp->set_idx = curr_cdatp->num_sets;
+ curr_linkp->ele_idx = curr_setp->num_ele;
+ curr_linkp->link_t.vlink.ref_id = ref_id;
+ memmove(curr_linkp->link_t.vlink.anim_name, anim_name, 32);
+
}
void
-inc_ref()
+insert_ele_svlink
+( uint64_t ref_id
+)
{
- CURR_ODAT.ref_index++;
- CURR_ODAT.num_ref++;
+ struct cdat* curr_cdatp;
+ struct set* curr_setp;
+ struct link* curr_linkp;
+
+ curr_cdatp = curr_cdat();
+ curr_setp = curr_set();
+ curr_linkp = alloc_link();
+
+ curr_linkp->cdat_idx = curr_cdatp->idx;
+ curr_linkp->type = 3;
+
+ curr_linkp->ele_idx = curr_setp->num_ele;
+ curr_linkp->link_t.svlink.ref_id = ref_id;
+
+
}
-//TODO: This needs to be changed to account for
-// when the set is of a subclass.
+//Insert element into odat_buf and cdatpages
void
-inc_ele()
+insert_ele()
{
- CURR_CDAT.set_list[CURR_CDAT.set_index].num_ele++;
- vbi++;
+ uint64_t ref_id;
+ struct cdat* curr_cdatp;
+ struct odat* curr_odatp;
+ struct set* curr_setp;
+ struct ele* curr_elep;
+ struct ref* curr_refp;
+ struct ref* prev_refp;
+
+ curr_cdatp = curr_cdat();
+ curr_odatp = curr_odat(); //malloced @ insert_ele_label
+ curr_setp = curr_set();
+ curr_elep = curr_ele();
+ curr_refp = alloc_ref();
+ prev_refp = prev_ref();
+
+ /* Populate ele in cdat */
+ curr_elep->cdat_idx = curr_cdatp->idx;
+ curr_setp->num_ele++;
+
+ /* Populate odat for ele */
+ curr_odatp->cdat_idx = curr_cdatp->idx;
+ curr_odatp->refp = curr_refp;
+
+ /* Add ele to ref_buf */
+ ref_id = curr_elep->ref_id;
+
+ if(ref_id == -1) /* user did not define a ref_id so */
+ { ref_id = ss_ref_id;
+ ss_ref_id++;
+ }
+
+ curr_refp->ref_id = ref_id;
+ curr_refp->lastref = prev_refp;
+ curr_refp->odatp = curr_odatp;
+ prev_refp->nextref = curr_refp;
+
}
void
-inc_models()
+insert_ele_vdatid
+()
+{ struct odat* curr_odatp;
+ curr_odatp = curr_odat();
+ curr_odatp->vdat_id = num_vdats;
+}
+
+void
+insert_quad
+( int x,
+ int y,
+ int z,
+ uint64_t ref_id
+)
{
- CURR_VDAT.num_models++;
+
+ struct quad* curr_quadp;
+ struct odat* curr_odatp;
+
+ curr_quadp = curr_quad();
+ curr_odatp = curr_odat();
+
+ curr_quadp->x = x;
+ curr_quadp->y = y;
+ curr_quadp->z = z;
+ curr_quadp->ref_id = ref_id;
+ curr_odatp->num_quads++;
+}
+
+/* Inserting the hitbox into the set
+ odat. Elements that don't have
+ a hitbox will use the sets root. */
+void
+insert_hitbox
+( int hitbox
+)
+{ struct odat* curr_odatp;
+
+ curr_odatp = curr_odat();
+ curr_odatp->hitbox = hitbox;
}
+
+/* Inserting the root into the set
+ odat. Elements that don't have
+ a root will use the sets root. */
+void
+insert_root
+( int x,
+ int y,
+ int z
+)
+{ struct odat* curr_odatp;
+
+ curr_odatp = curr_odat();
+ curr_odatp->root.x = x;
+ curr_odatp->root.y = y;
+ curr_odatp->root.z = z;
+}
+
+
+void
+insert_framesheet
+( char direction,
+ char* name,
+ uint64_t ref_id,
+ int height ,
+ int width,
+ int num_frames
+)
+{ struct vdat* curr_vdatp;
+ struct model* curr_modelp;
+
+ curr_vdatp = curr_vdat();
+ curr_modelp = curr_model();
+
+ curr_modelp->spritesheet[(int)direction].height = height;
+ curr_modelp->spritesheet[(int)direction].width = width;
+ curr_modelp->spritesheet[(int)direction].num_frames = num_frames;
+ curr_vdatp->num_models++;
+}
+
+void
+insert_frame_pointer
+( char direction,
+ void* frame
+)
+{ struct model* curr_modelp;
+
+ curr_modelp = curr_model();
+
+ curr_modelp->spritesheet[(int)direction].frames[curr_modelp->spritesheet[(int)direction].num_frames++] = frame;
+}
+
projects / henge / webcc.git / blobdiff