X-Git-Url: https://www.kengrimes.com/gitweb/?p=henge%2Fwebcc.git;a=blobdiff_plain;f=src%2Fapc%2Fir.c;h=5673d0c107d24f39fa329e4e83991f49ded1e002;hp=ffc102099c61b3705bfee36be979a6f4198eeb08;hb=301cac5f6e2edcecf2e1bd89aee5182130a213fc;hpb=a00b12aee56b4e8f633a291d8ead2d3e169166ca

diff --git a/src/apc/ir.c b/src/apc/ir.c
old mode 100644
new mode 100755
index ffc1020..5673d0c
--- a/src/apc/ir.c
+++ b/src/apc/ir.c
@@ -1,148 +1,555 @@
-#include <errno.h>
-#include <ir.h> 
-
-//#define CURR_ODAT (OB[obi])
-//#define CURR_VDAT (VB[vbi])
-//#define CURR_CDAT (CB[cbi])
-
-//TODO: label and vdat_id
-void
-insert_set()
-{
-  cdat_buf[cbi].set_list[set_index].odat_id = obi;
-  cdat_buf[cbi].set_list[set_index].parent_id =//from lexer
-  //TODO: add ele_stack is created in element_list
-  //TODO: add set to odat_buf
-
-}
-
-#define CURR_QUAD (odat_buf[obi].ref_list[ref_index])
-void
-insert_ref(int x, int y, int z, int ref)
-{
-  CURR_QUAD.x = x;
-  CURR_QUAD.y = y;
-  CURR_QUAD.z = z;
-  CURR_QUAD.ref = ref;
-}
-
-
-//Insert element into odat_buf and cdat_buf
-void
-insert_ele(char* label, int vdat_id)
-{
-
-
-  odat_buf[obi].label = label;
-  odat_buf[obi].vdat_id = vdat_id;
-  //TODO: check set_obi to see if set_map_data exists
-  //comes from e
-  odat_buf[obi].num_ref = odat_buf[set_obi].num_ref;
-  odat_buf[obi].ref_list = odat_buf[set_obi].ref_list;
-  odat_buf[obi].class_id = cbi;
-
-  if(IS_SUBCLASS())
-    {
-      cdat_buf[cbi].subclass_list[subclass_index].set_list[set_index].ele_list[ele_index].odat_id = obi;
-      cdat_buf[cbi].subclass_list[subclass_index].set_list[set_index].ele_list[ele_index].parent_id = cdat_buf[cbi].subclass_list[subclass_index].set_index;
-    }
-  else
-    {
-      cdat_buf[cbi].set_list[set_index].ele_list[ele_index].odat_id = obi;
-      cdat_buf[cbi].set_list[set_index].ele_list[ele_index].parent_id = cdat_buf[cbi].set_index;
-    }
-
-  obi++;
-}
-
-
-/* fd could be a directory entry */
-int
-insert_fdat(char* label, char direction, int fd)
-{
-  vdat_buf[vbi].model_list[vdat_buf[vbi].len].label = label;
-  vdat_buf[vbi].model_list[vdat_buf[vbi].len].fdat_id[(int)direction] = fd;
-}
-
-void
-condense()
-{
-  FILE* vp, op, cp;
-  int v, m;
-  int num_models;
-
-  vp = fopen("vdat_output", w+);
-  if(!vp)
-    perror("vdat_output failed to open\n");
-
-  op = fopen("odat_output", w+);
-  if(!op)
-    perror("odat_output failed to open\n");
-
-  cp = fopen("cdat_output", w+);
-  if(!cp)
-    perror("cdat_output failed to open\n");
-
-
-
-  /* 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++)
-        {
-            
-        }
-    }
-
-  /* fwrite odat */
-  /* Convert ref_list to actual offset */
-
-  /* fwrite cdat */
-
-
-}
-void
-inc_cbi()
-{
-  cbi++;
-}
-
-void
-set_class_label(char* label)
-{
-  cdat_buf[cbi].label = $1;
-}
-
-void
-inc_subclass_idx()
-{
-  cdat_buf[cbi].subclass_index++;
-}
-
-void
-inc_set_index()
-{
-  odat_buf[cbi].set_index++;
-}
-
-void
-inc_ref()
-{
-  odat_buf[obi].ref_index++;
-  odat_buf[obi].num_ref++;
-}
-
-//TODO: This needs to be changed to account for
-//      when the set is of a subclass.
-void
-inc_ele()
-{
-  cdat_buf[cbi].set_stack[stack_index].num_ele++;
-}
-
-void
-inc_models()
-{
-  vdat_buf[vbi].num_models++;
-}
+/*!@file
+  \brief   IR Memory Implementation
+  \details Intermediary memory management
+  \author  Jordan Lavatai
+  \date    Aug 2016
+  ----------------------------------------------------------------------------*/
+#include <errno.h>
+#include <stdio.h>
+#include <unitypes.h> //uint8_t as a char
+#include <unistr.h> //u32_cpy
+#include <stdint.h> //uint64_t
+#include <stdlib.h> //malloc
+#include <apc/ir.h>
+
+//extern
+//scanner_scanpixels(int*, int);
+
+/* functions needed from irmem.c */
+extern
+void
+ir_init(void);
+
+extern
+struct cdat*
+alloc_cdat(void);
+
+extern
+struct odat*
+alloc_odat(void);
+
+extern
+struct vdat*
+alloc_vdat(void);
+
+extern
+void
+alloc_mdat(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 map*
+curr_map(void);
+
+extern
+struct map*
+alloc_map(void);
+
+extern
+struct vdat*
+curr_vdat(void);
+
+extern
+struct set*
+curr_set(void);
+
+extern
+struct ref*
+curr_ref(void);
+
+extern
+struct quad*
+curr_quad(void);
+
+extern
+struct model*
+curr_model(void);
+
+extern
+struct quad*
+curr_quad(void);
+
+/* struct definitions needed from irmem.c */
+extern int num_cdats;
+extern struct cdat** cdat_stackp;
+extern struct odat* curr_set_odatp;
+extern int 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
+( uint8_t* name
+)
+{
+  struct cdat* curr_cdatp;
+
+  curr_cdatp = alloc_cdat();
+
+  u8_cpy(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;
+
+}
+
+void
+pop_cdat
+()
+{
+  cdat_stackp--;
+}
+
+
+/* Every odat has a single map variant. We track the odats that have related map variants
+   by adding the name of the map to the end of the odat name. E.g. for an odat with name
+   A and map variants a,b,c we get A_a, A_b, A_c. We create new odats for each map variant*/
+void
+insert_map
+( uint8_t* name,
+  int height,
+  int width,
+  uint8_t* filepath
+)
+{
+  struct odat* curr_odatp;
+  int curr_odat_vdatid;
+
+  curr_odatp = curr_odat();
+
+  curr_odat_vdatid = curr_odatp->vdat_id;
+  
+
+   
+  if(curr_odatp->map.name[0] != 0) //odat already has a map so make a new odat
+    { curr_odatp = alloc_odat();
+      curr_odatp->vdat_id = curr_odat_vdatid;
+    }
+  /* Add a delimiter '_' in between odat name and map variant name */
+  u8_strcat(curr_odatp->map.name, (uint8_t*) '_'); 
+  u8_strcat(curr_odatp->map.name, name);
+  
+  u8_strcpy(curr_odatp->map.filepath, filepath);
+  curr_odatp->map.height = height;
+  curr_odatp->map.width = width;
+  
+}
+  
+
+
+
+
+/* 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. Curr set points the sets representation in the cdat, curr_set_odatp
+   points to the sets representation as an odat*/
+
+void
+insert_set_label
+( uint8_t* name,
+  int ref_id
+)
+{
+
+  struct set* curr_setp;
+
+  curr_setp = curr_set();
+  curr_set_odatp = alloc_odat();
+
+  u8_cpy(curr_set_odatp->name, name, 32);
+  u8_cpy(curr_setp->name, name, 32);
+  curr_set_odatp->parent_odatp = NULL;
+  curr_set_odatp->map.name[0] = 0;
+
+  if(ref_id != -1)
+    { curr_set_odatp->ref_id = ref_id;
+      curr_setp->ref_id = ref_id;
+    }
+  else
+    { curr_setp->ref_id = ss_ref_id;
+      curr_set_odatp->ref_id = ss_ref_id++;
+    }
+
+}
+
+/* Inserting a olink instead of a set. Set is really just a placeholder
+   for another set. Allocate the memory for the set so taht it can be populated*/
+void
+insert_set_olink
+( int ref_id
+)
+{
+  struct set* curr_setp;
+
+  curr_setp = curr_set();
+
+  curr_setp->ref_id = ref_id;
+
+}
+
+void
+insert_set_vlink
+( int ref_id,
+  uint8_t* anim_name
+)
+{
+  struct cdat* curr_cdatp;
+  struct odat* curr_odatp;
+  struct link* curr_linkp;
+
+
+  curr_cdatp = curr_cdat();
+  curr_odatp = curr_odat();
+  curr_linkp = alloc_link();
+
+  /* Insert vlink into link_stack so that it gets processed at
+     output time */
+  curr_linkp->type = 2;
+  /* Store the target odat information*/
+  curr_linkp->link_t.vlink.ref_id = ref_id;
+  u8_cpy(curr_linkp->link_t.vlink.anim_name, anim_name, 32);
+  /* Store the linking odat/cdat information */
+  curr_linkp->classp = curr_cdatp;
+  curr_linkp->odatp = curr_odatp;
+  curr_linkp->set_idx = curr_cdatp->num_sets;
+  curr_linkp->ele_idx = -1;
+
+}
+
+/* Svlinks dont have animation names */
+void
+insert_set_svlink
+( int 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->classp = curr_cdatp;
+  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
+()
+{ int ref_id;
+  struct odat* curr_odatp;
+  struct cdat* curr_cdatp;
+  struct set* curr_setp;
+  struct ref* prev_refp;
+  struct ref* curr_refp;
+  struct vdat* curr_vdatp;
+
+  curr_odatp = curr_set_odatp; //allocated at insert_set_label
+  curr_cdatp = curr_cdat();
+  curr_setp = curr_set();
+  prev_refp = curr_ref();
+  curr_refp = alloc_ref();
+  curr_vdatp = curr_vdat();
+
+  curr_vdatp->creator = curr_set_odatp;
+
+  curr_setp->cdat_idx = curr_cdatp->idx; //does a set need its class idx?
+  u8_cpy(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)
+
+  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
+()
+{
+  struct vdat* curr_vdatp;
+
+  curr_vdatp = curr_vdat();
+
+  curr_set_odatp->vdat_id = num_vdats; //no vdat_id for odats that have vlinks/svlinks
+  curr_set_odatp->vdatp = curr_vdatp;
+  curr_set_odatp = NULL; //This sets odat shouldnt be modified after populating odats vdat info
+}
+
+/* Populates the odat name and ref_id for odat, allocate the odat here for the rest of
+ the functions to use via curr_odat(). */
+void
+insert_ele_label
+( uint8_t* name,
+  int ref_id
+)
+{
+  struct odat* curr_odatp;
+
+  curr_odatp = alloc_odat();
+
+  u8_cpy(curr_odatp->name, name, 32);
+  curr_odatp->map.name[0] = 0;
+
+  if(ref_id != -1)
+    curr_odatp->ref_id = ref_id;
+  else
+    curr_odatp->ref_id = ss_ref_id++;
+
+}
+
+/* We don't make an odat here, at output time we will resolve
+   the ref_id to the corresponding odat. */
+void
+insert_ele_olink
+( int ref_id
+)
+{
+  /* Do nothing because we already know the ref_id that
+     the odat needs for this element (in the quad_file) */
+}
+
+void
+insert_ele_vlink
+( int ref_id,
+  uint8_t* anim_name
+)
+{
+  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->classp = curr_cdatp;
+  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;
+  u8_cpy(curr_linkp->link_t.vlink.anim_name, anim_name, 32);
+
+}
+
+void
+insert_ele_svlink
+( int 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->classp = curr_cdatp;
+  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()
+{
+  int ref_id;
+  struct cdat* curr_cdatp;
+  struct odat* curr_odatp;
+  struct vdat* curr_vdatp;
+  struct set* curr_setp;
+  struct ele* curr_elep;
+  struct ref* curr_refp;
+  struct ref* prev_refp;
+
+
+  curr_odatp = curr_odat(); //malloced @ insert_ele_label
+  curr_vdatp = curr_vdat();
+  curr_setp = curr_set();
+  prev_refp = curr_ref();
+  curr_refp = alloc_ref();
+
+  curr_vdatp->creator = curr_odatp;
+
+  /* Populate odat for ele */
+  curr_odatp->cdat_idx = curr_cdatp->idx;
+  curr_odatp->refp = curr_refp;
+  curr_odatp->parent_odatp = curr_set_odatp;
+
+  ref_id = curr_odatp->ref_id;
+
+  curr_refp->ref_id = ref_id;
+  curr_refp->lastref = prev_refp;
+  curr_refp->odatp = curr_odatp;
+  prev_refp->nextref = curr_refp;
+
+}
+
+void
+insert_ele_vdatid
+()
+{ struct odat* curr_odatp;
+  curr_odatp = curr_odat();
+  curr_odatp->vdat_id = num_vdats;
+}
+
+void
+insert_vdat
+(uint8_t* filename, int height, int width, uint8_t* filepath)
+{
+  struct vdat* curr_vdatp;
+  int filename_len, filepath_len;
+
+  curr_vdatp = alloc_vdat();
+
+  u8_strcpy(curr_vdatp->filename, filename);
+  u8_strcpy(curr_vdatp->filepath, filepath);
+  curr_vdatp->height = height;
+  curr_vdatp->width = width;
+  curr_vdatp->creator = curr_odat();
+  
+}
+
+
+  
+
+/* void */
+/* insert_quad */
+/* ( int x, int y, int z, int ref_id */
+/* ) */
+/* { */
+/*   struct quad* curr_quadp; */
+
+/*   curr_quadp = curr_quad(); */
+
+/*   curr_quadp->x = x; */
+/*   curr_quadp->y = y; */
+/*   curr_quadp->z = z; */
+/*   curr_quadp->ref_id = ref_id; */
+  
+
+
+/* } */
+
+/* /\* serting 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 */
+/* ( uint8_t direction, */
+/*   uint8_t* name, */
+/*   int 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 */
+/* ( uint8_t 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; */
+/* } */
+