X-Git-Url: https://www.kengrimes.com/gitweb/?p=henge%2Fwebcc.git;a=blobdiff_plain;f=src%2Fapc%2Fir.c;h=67a6aaf4f2cf62c3ffdfb73f82041f615141116c;hp=10aede80e4b0702c39fe57d4762b25f10708b836;hb=34fce8bbbe19608d819991617f8551a1fa1f0e99;hpb=6d5141829211936ecaed3d9d13a239a75ecae712

diff --git a/src/apc/ir.c b/src/apc/ir.c
index 10aede8..67a6aaf 100644
--- a/src/apc/ir.c
+++ b/src/apc/ir.c
@@ -1,110 +1,493 @@
+/*!@file
+  \brief   IR Memory Implementation
+  \details Intermediary memory management
+  \author  Jordan Lavatai
+  \date    Aug 2016
+  ----------------------------------------------------------------------------*/
 #include <errno.h>
-#include <ir.h>
+#include <stdio.h>
+#include <stdint.h> //uint64_t
+#include <string.h> //memmove
+#include <stdlib.h> //malloc
+#include <apc/ir.h>
 
-#define CURR_OBI (OB[obi])
-#define CURR_VBI (VB[vbi])
-#define CURR_CBI (CB[cbi])
-#define IS_SUBCLASS() (CB[cbi].num_subclasses)
 
-//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
+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
-insert_set()
+push_cdat
+( char* name
+)
 {
-  if(IS_SUBCLASS()) //if set is set of subclass
-    OB[obi].class_id = CB[cbi].subclass_list[subclass_index].label; //TODO: specify subclass other than label?
-  else
-    OB[obi].class_id = CB[cbi].label;
+  struct cdat* curr_cdatp;
 
-  CB[cbi].set_list[set_index].odat_id = obi;
-  CB[cbi].set_list[set_index].parent_id = OB[obi].class_id;
-  //TODO: add ele_stack is created in element_list
-  //TODO: add odat
+  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 (OB[obi].ref_list[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.ref = 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 OB and CB
 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();
 
-  OB[obi].label = label;
-  OB[obi].vdat_id = vdat_id;
-  //TODO: check set_obi to see if set_map_data exists
-  OB[obi].num_ref = OB[set_obi].num_ref;
-  OB[obi].ref_list = OB[set_obi].ref_list;
-  OB[obi].class_id = cbi;
+  memmove(curr_set_odatp->name, name, 32);
+  memmove(curr_setp->name, name, 32);
+  curr_setp->ref_id = ref_id;
 
-  if(IS_SUBCLASS())
-    {
-      CB[cbi].subclass_list[subclass_index].set_list[set_index].ele_list[ele_index].odat_id = obi;
-      CB[cbi].subclass_list[subclass_index].set_list[set_index].ele_list[ele_index].parent_id = CB[cbi].subclass_list[subclass_index].set_index;
-    }
-  else
-    {
-      CB[cbi].set_list[set_index].ele_list[ele_index].odat_id = obi;
-      CB[cbi].set_list[set_index].ele_list[ele_index].parent_id = CB[cbi].set_index;
+}
+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;
+
+}
+
+void
+insert_set_vlink
+( uint64_t ref_id,
+  char* anim_name
+)
+{
+  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
+insert_set_svlink
+( uint64_t ref_id
+)
+{
+  struct cdat* curr_cdatp;
+  struct link* curr_linkp;
+
+  curr_cdatp = curr_cdat();
+  curr_linkp = alloc_link();
+
+  /* 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;
+
+}
+
+/* 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();
+
+
+  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++;
     }
 
-  obi++;
+  curr_refp->ref_id = ref_id;
+  curr_refp->lastref = prev_refp;
+  curr_refp->odatp = curr_odatp;
+  prev_refp->nextref = curr_refp;
+
+
+
 }
+/* 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
+insert_set_vdatid
+()
+{
+  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
+insert_ele_label
+( char* name,
+  uint64_t ref_id
+)
+{
+  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;
+}
 
-/* fd could be a directory entry */
-int
-insert_fdat(char* label, char direction, int fd)
+/* We don't make an odat here, at output time we will resolve
+   the ref_id to the corresponding odat. */
+void
+insert_ele_olink
+( uint64_t ref_id
+)
 {
-  VB[vbi].model_list[VB[vbi].len].label = label;
-  VB[vbi].model_list[VB[vbi].len].fdat_id[(int)direction] = fd;
+  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
-condense()
+insert_ele_vlink
+( uint64_t ref_id,
+  char* anim_name
+)
 {
-  FILE* vp, op, cp;
-  int v, m;
-  int num_models;
+  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);
 
-  vp = fopen("vdat_output", w+);
-  if(!vp)
-    perror("vdat_output failed to open\n");
+}
+
+void
+insert_ele_svlink
+( uint64_t ref_id
+)
+{
+  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;
+
+
+}
+
+//Insert element into odat_buf and cdatpages
+void
+insert_ele()
+{
+  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;
 
-  op = fopen("odat_output", w+);
-  if(!op)
-    perror("odat_output failed to open\n");
+  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();
 
-  cp = fopen("cdat_output", w+);
-  if(!cp)
-    perror("cdat_output failed to open\n");
+  /* 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;
 
-  /* fwrite vdat */
-  for(v = 0; v <= vbi; v++)
-    {
-      num_models = VB[v].num_models; //data duplication for caching
-      for(m = 0; m <= num_models; m++)
-        {
-            
-        }
+  if(ref_id == -1) /* user did not define a ref_id so */
+    { 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 */
+}
+
+void
+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
+)
+{
+
+  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;
 }