X-Git-Url: https://git.kengrimes.com/?p=henge%2Fwebcc.git;a=blobdiff_plain;f=src%2Fapc%2Fir.c;h=bf622276fbdadca417817f731cb575072648c0f8;hp=1d56bd13860157457db661243c53c157cd9f1e40;hb=92d574d704e54743631464fac3ce739b1077222c;hpb=dc6e33a26d6488e388817d4dd255dcdff22b4a2a

diff --git a/src/apc/ir.c b/src/apc/ir.c
index 1d56bd1..bf62227 100644
--- a/src/apc/ir.c
+++ b/src/apc/ir.c
@@ -12,49 +12,71 @@
 #include <apc/ir.h>
 
 
+
+/* functions needed from irmem.c */
+extern
 void
 ir_init(void);
-void
-malloc_cdat(void);
 
+extern
+struct cdat*
+alloc_cdat(void);
 
+extern
+struct odat*
+alloc_odat(void);
 
-/* The initalization function of the IR. Mallocs the
-   first c/v/odat and the first links and refs and
-   inits the cdat_stack */
+extern
 void
-ir_init()
-{
+alloc_vdat(void);
 
-  /* Init root cdat and stack */
-  char root[4] = "root";
+extern
+struct link*
+alloc_link(void);
 
-  cdat_buf[num_cdats] = (struct cdat*) malloc(sizeof(struct cdat) );
-  cdat_buf[num_cdats]->idx = 0;
-  memmove(cdat_buf[num_cdats]->name, root, 4);
+extern
+struct ref*
+alloc_ref(void);
 
-  cdat_stackp = cdat_stack;
-  *cdat_stackp = cdat_buf[num_cdats++];
+extern
+struct cdat*
+curr_cdat(void);
 
-}
+extern
+struct odat*
+curr_odat(void);
 
-//TODO: FREE MEMORY!
-void
-malloc_cdat()
-{
-  if(curr_max_cdats <= num_cdats)
-    { if( (realloc((void*) cdat_buf, PTRS_IN_PAGE * 4)) == NULL)
-      perror("realloc cdat_buf failed");
-      curr_max_cdats += PTRS_IN_PAGE;
-      if( (realloc( (void*) cdat_stack, PTRS_IN_PAGE * 4)) == NULL) //increase cdat_stack also
-        perror("realloc cdat_stack failed");
-    }
-  if( (cdat_buf[num_cdats] = (struct cdat*) malloc(sizeof (struct cdat)) ) == NULL )
-    perror("malloc cdat failed");
+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
@@ -68,16 +90,17 @@ push_cdat
 ( char* name
 )
 {
-  malloc_cdat();
+  struct cdat* curr_cdatp;
 
-  memmove(cdat_buf[num_cdats]->name, name, 32);
-  cdat_buf[num_cdats]->idx = num_cdats;
+  curr_cdatp = alloc_cdat();
 
-  /* Set the cdat as a class of the previous cdat */
-  (*cdat_stackp)->class_list[(*cdat_stackp)->num_classes++] = cdat_buf[num_cdats];
+  memmove(curr_cdatp->name, name, 32);
+  curr_cdatp->idx = num_cdats;
+
+  /* Set the cdat as a subclass of the previous cdat */
 
   /* Push the cdat onto the cdat_stack */
-  *++cdat_stackp = cdat_buf[num_cdats++];
+  *++cdat_stackp = curr_cdatp;
 
 }
 
@@ -92,14 +115,12 @@ pop_cdat
 /* 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, all the elements will be inserted into the
-   odat_buf first, and then the set that contains these element is inserted. Since
-   the sets label comes before the element list in the grammar, we would be giving an element
-   a set label in its respective odat, which would then be replaced by the
-   elements label. Instead, we store the label in the sets representation inside
-   CURR_CDAT and after we are done parsing the element_list and know that the CURR_ODAT
-   is the set, we populate the sets label members in CURR_ODAT with the values we stored
-   previously in CURR_CDAT. */
+   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. */
 
 void
 insert_set_label
@@ -107,11 +128,14 @@ insert_set_label
   uint64_t ref_id
 )
 {
-  struct set* curr_set;
+  struct set* curr_setp;
+
+  curr_setp = curr_set();
+  curr_set_odatp = alloc_odat();
 
-  curr_set = curr_set();
-  memmove(curr_set.name,name,32);
-  curr_set.ref_id = ref_id;
+  memmove(curr_set_odatp->name, name, 32);
+  memmove(curr_setp->name, name, 32);
+  curr_setp->ref_id = ref_id;
 
 }
 void
@@ -119,22 +143,22 @@ insert_set_olink
 ( uint64_t ref_id
 )
 {
-  struct set* curr_set;
-  struct cdat* curr_cdat;
-  struct link* curr_link;
+  struct set* curr_setp;
+  struct cdat* curr_cdatp;
+  struct link* curr_linkp;
 
-  curr_set = curr_set();
-  curr_cdat = curr_cdat();
-  curr_link = alloc_link();
+  curr_setp = curr_set();
+  curr_cdatp = curr_cdat();
+  curr_linkp = alloc_link();
 
-  curr_set.cdat_idx = curr_cdat->idx;
-  curr_set.ref_id = ref_id; /* Will be resolved to offset
+  curr_setp->cdat_idx = curr_cdatp->idx;
+  curr_setp->ref_id = ref_id; /* Will be resolved to offset
                                           when link is processed */
-  curr_link->type = 1;
-  curr_link->link_t.olink.ref_id = ref_id;
-  curr_link->cdat_idx = curr_cdat->idx;
-  curr_link->set_idx = curr_cdat->num_sets++;
-  curr_link->ele_idx = -1;
+  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;
 
 }
 
@@ -144,19 +168,20 @@ insert_set_vlink
   char* anim_name
 )
 {
-  struct cdat* curr_cdat;
-  struct link* curr_link;
+  struct cdat* curr_cdatp;
+  struct link* curr_linkp;
 
-  curr_cdat = curr_cdat();
-  curr_link = alloc_link();
+  curr_cdatp = curr_cdat();
+  curr_linkp = alloc_link();
 
   /* Insert vlink into link_stack so that it gets processed at
      output time */
-  curr_link->type = 2;
-  curr_link->cdat_idx = curr_cdat->idx;
-  curr_link->set_idx = curr_cdat->num_sets;
-  curr_link->link_t.vlink.ref_id = ref_id;
-  memmove(curr_link->link_t.vlink.anim_name, anim_name, 32);
+  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);
 
 }
 
@@ -166,18 +191,18 @@ insert_set_svlink
 ( uint64_t ref_id
 )
 {
-  struct cdat* curr_cdat;
-  struct link* curr_link;
+  struct cdat* curr_cdatp;
+  struct link* curr_linkp;
 
-  curr_cdat = curr_cdat();
-  curr_link = alloc_link();
+  curr_cdatp = curr_cdat();
+  curr_linkp = alloc_link();
 
   /* Insert vlink into link_stack so that it gets processed at
      output time */
-  curr_link->type = 3;
-  curr_link->cdat_idx = curr_cdat->idx;
-  curr_link->set_idx = curr_cdat->num_sets;
-  curr_link->link_t.svlink.ref_id = ref_id;
+  curr_linkp->type = 3;
+  curr_linkp->cdat_idx = curr_cdatp->idx;
+  curr_linkp->set_idx = curr_cdatp->num_sets;
+  curr_linkp->link_t.svlink.ref_id = ref_id;
 
 }
 
@@ -188,68 +213,71 @@ insert_set_svlink
 void
 insert_set
 ()
-{
-  struct odat* curr_odat;
-  struct cdat* curr_cdat;
-  struct ref* prev_ref;
-  struct ref* curr_ref;
-
-  curr_odat = alloc_odat();
-  curr_cdat = curr_cdat();
-  curr_set = curr_set();
-  prev_ref = prev_ref();
-  curr_ref = alloc_ref();
+{ uint64_t ref_id;
+  struct odat* curr_odatp;
+  struct cdat* curr_cdatp;
+  struct set* curr_setp;
+  struct ref* prev_refp;
+  struct ref* curr_refp;
 
-  ref_id = curr_set.ref_id; // ref_id set by insert_set_label(name, ref_id)
+  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_set.cdat_idx = curr_cdat->idx;
-  memmove(curr_odat->name, curr_set.name, 32);
-  curr_cdat.num_sets++;
 
-  curr_odat->cdat_idx = curr_cdaat->idx;
-  curr_odat->refp = curr_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;
 
-  curr_ref->lastref = prev_ref;
-  prev_ref->nextref = curr_ref;
-  curr_ref->odatp = curr_odat;
+  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 so */
+  if(ref_id == -1) /* user did not define a ref_id  */
     { ref_id = ss_ref_id;
       ss_ref_id++;
     }
 
-  curr_ref->ref_id = 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_vdat_id
+insert_set_vdatid
 ()
 {
-  struct odat* curr_odat;
-  curr_odat = curr_odat();
-  curr_odat->vdat_id = num_vdats; //no vdat_id for odats that have vlinks/svlinks
+  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 element. */
+   for odat and ele */
 void
 insert_ele_label
 ( char* name,
   uint64_t ref_id
 )
 {
-  struct ele* curr_ele;
+  struct ele* curr_elep;
+  struct odat* curr_odatp;
+
+  curr_elep = curr_ele();
+  curr_odatp = alloc_odat();
 
-  curr_ele = curr_ele();
+  memmove(curr_odatp->name, name, 32);
 
-  memmove(curr_ele.name, name, 32);
-  curr_ele.ref_id = ref_id;
+  memmove(curr_elep->name, name, 32);
+  curr_elep->ref_id = ref_id;
 }
 
 void
@@ -257,14 +285,23 @@ insert_ele_olink
 ( uint64_t ref_id
 )
 {
-  CURR_CDAT->CURR_SET.CURR_ELE.cdat_idx = CURR_CDAT->idx;
-  CURR_CDAT->CURR_SET.CURR_ELE.ref_id = ref_id; /* Will be resolved to offset
+  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; /* Will be resolved to offset
                                                    when link is processed */
-  CURR_LINK->type = 1;
-  CURR_LINK->link_t.olink.ref_id = ref_id;
-  CURR_LINK->cdat_idx = CURR_CDAT->idx;
-  CURR_LINK->set_idx = CURR_CDAT->num_sets++;
-  CURR_LINK->ele_idx = CURR_CDAT->CURR_SET.num_ele++;
+  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++;
 
 }
 
@@ -274,15 +311,22 @@ insert_ele_vlink
   char* 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_LINK->cdat_idx = CURR_CDAT->idx;
-  CURR_LINK->type = 2;
-  CURR_LINK->set_idx = CURR_CDAT->num_sets;
-  CURR_LINK->ele_idx = CURR_CDAT->CURR_SET.num_ele;
-  CURR_LINK->link_t.vlink.ref_id = ref_id;
-  memmove(CURR_LINK->link_t.vlink.anim_name, anim_name, 32);
+  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);
 
 }
 
@@ -291,12 +335,19 @@ 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_LINK->cdat_idx = CURR_CDAT->idx;
-  CURR_LINK->type = 3;
-  CURR_LINK->set_idx = CURR_CDAT->num_sets;
-  CURR_LINK->ele_idx = CURR_CDAT->CURR_SET.num_ele;
-  CURR_LINK->link_t.svlink.ref_id = ref_id;
+  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;
 
 
 }
@@ -306,42 +357,49 @@ void
 insert_ele()
 {
   uint64_t ref_id;
-
-  ref_id = CURR_CDAT->CURR_SET.CURR_ELE.ref_id;
-
-  CURR_CDAT->CURR_SET.CURR_ELE.cdat_idx = CURR_CDAT->idx;
-  memmove(CURR_ODAT->name,CURR_CDAT->CURR_SET.CURR_ELE.name, 32);
-  CURR_CDAT->CURR_SET.num_ele++;
-
-  CURR_ODAT->cdat_idx = CURR_CDAT->idx;
-  CURR_ODAT->refp = CURR_REF;
+  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_REF->ref_id = ref_id;
-
-  inc_odat();
-  inc_ref();
+  curr_refp->ref_id = ref_id;
+  curr_refp->lastref = prev_refp;
+  curr_refp->odatp = curr_odatp;
+  prev_refp->nextref = curr_refp;
 
 }
 
 void
-insert_framesheet
-( char direction,
-  char* name,
-  uint64_t ref_id,
-  int height ,
-  int width,
-  int num_frames
-)
-{
-  CURR_VDAT->CURR_MODEL.spritesheet[(int)direction].height = height;
-  CURR_VDAT->CURR_MODEL.spritesheet[(int)direction].width = width;
-  CURR_VDAT->CURR_MODEL.spritesheet[(int)direction].num_frames = num_frames;
-  CURR_VDAT->num_models++;
+insert_ele_vdatid
+()
+{ struct odat* curr_odatp;
+  curr_odatp = curr_odat();
+  curr_odatp->vdat_id = num_vdats;
 }
 
 void
@@ -351,13 +409,19 @@ insert_quad
   int z,
   uint64_t ref_id
 )
-#define CURR_QUAD (CURR_ODAT->quad_list[CURR_ODAT->num_quads])
 {
-  CURR_QUAD.x = x;
-  CURR_QUAD.y = y;
-  CURR_QUAD.z = z;
-  CURR_QUAD.ref_id = ref_id;
-  CURR_ODAT->num_quads++;
+
+  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
@@ -367,8 +431,10 @@ void
 insert_hitbox
 ( int hitbox
 )
-{
-  CURR_ODAT->hitbox = hitbox;
+{ struct odat* curr_odatp;
+
+  curr_odatp = curr_odat();
+  curr_odatp->hitbox = hitbox;
 }
 
 /* Inserting the root into the set
@@ -380,11 +446,34 @@ insert_root
   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_ODAT->root.x = x;
-  CURR_ODAT->root.y = y;
-  CURR_ODAT->root.z = z;
+  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
@@ -392,7 +481,10 @@ insert_frame_pointer
 ( char direction,
   void* frame
 )
-{
-  CURR_VDAT->CURR_MODEL.spritesheet[(int)direction].frames[CURR_VDAT->CURR_MODEL.spritesheet[(int)direction].num_frames++] = frame;
+{ struct model* curr_modelp;
+
+  curr_modelp = curr_model();
+
+  curr_modelp->spritesheet[(int)direction].frames[curr_modelp->spritesheet[(int)direction].num_frames++] = frame;
 }