From: jordan@hack_attack Date: Thu, 29 Sep 2016 20:31:11 +0000 (-0700) Subject: still converting to a reasonable api X-Git-Url: https://git.kengrimes.com/?p=henge%2Fwebcc.git;a=commitdiff_plain;h=8f78f017187cf9c5c94cb302246634de248a36d0 still converting to a reasonable api --- diff --git a/src/apc/irmem.c b/src/apc/irmem.c index 3b62201..3632ea2 100644 --- a/src/apc/irmem.c +++ b/src/apc/irmem.c @@ -1,16 +1,31 @@ -/*!@file - \brief IR Memory Implementation - \details Intermediary memory management - \author Jordan Lavatai - \date Aug 2016 - ----------------------------------------------------------------------------*/ -#include #include -#include //uint64_t -#include //memmove -#include //malloc +#include +#include +#include +#include +#include #include + +struct odat* +alloc_odat(void); +void +alloc_vdat(void); +struct ref* +alloc_link(void); +struct ref* +alloc_ref(void); +struct cdat* +curr_cdat(void); +struct odat* +curr_odat(void); +struct ele* +curr_ele(void); +struct set* +curr_set(void); +struct ref* +prev_ref(void); + #define CURR_CDAT (*cdat_stackp) #define CURR_SET set_list[CURR_CDAT->num_sets] #define CURR_ELE ele_list[CURR_CDAT->CURR_SET.num_ele] @@ -24,21 +39,6 @@ #define CURR_LINK (link_buf[num_links]) #define CURR_POST (post_buf[num_posts]) -void -inc_odat(void); -void -inc_vdat(void); -void -inc_link(void); -void -inc_ref(void); -void -ir_init(void); -void -malloc_cdat(void); - - - /* General: All information from the directory structure is stored in */ /* five buffers that comprise the IR: cdat_buf, odat_buf, vdat_buf, ref_buf */ /* and link_buf. Each buf corresponds to the data structure that it stores. */ @@ -277,114 +277,11 @@ struct vdat* vdat_buf[PTRS_IN_PAGE]; int num_vdats = 0; int curr_max_vdats = PTRS_IN_PAGE; - -/* The initalization function of the IR. Mallocs the - first c/v/odat and the first links and refs and - inits the cdat_stack */ -void -ir_init() -{ - - /* Init root cdat and stack */ - char root[4] = "root"; - - cdat_buf[num_cdats] = (struct cdat*) malloc(sizeof(struct cdat) ); - cdat_buf[num_cdats]->idx = 0; - memmove(cdat_buf[num_cdats]->name, root, 4); - - cdat_stackp = cdat_stack; - *cdat_stackp = cdat_buf[num_cdats++]; - - /* Init first odat */ - if( (CURR_ODAT = (struct odat*) malloc(sizeof(struct odat))) == NULL) - perror("malloc first odat failed"); - - /* init first vdat*/ - if( (CURR_VDAT = (struct vdat*) malloc(sizeof(struct vdat))) == NULL) - perror("malloc first vdat failed"); - - /* Init first ref */ - if( (CURR_REF = (struct ref*) malloc(sizeof(struct ref))) == NULL) - perror("malloc first ref failed"); - - /* Init first link */ - if( (CURR_LINK = (struct link*) malloc(sizeof(struct link))) == NULL) - perror("malloc first link failed"); - - /* Init first post */ - if( (CURR_POST = (struct ref*) malloc(sizeof(struct ref))) == NULL) - perror("malloc first post failed"); -} - -//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"); - - -} - -/* 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 -) -{ - malloc_cdat(); - - memmove(cdat_buf[num_cdats]->name, name, 32); - cdat_buf[num_cdats]->idx = num_cdats; - - /* Set the cdat as a class of the previous cdat */ - (*cdat_stackp)->class_list[(*cdat_stackp)->num_classes++] = cdat_buf[num_cdats]; - - /* Push the cdat onto the cdat_stack */ - *++cdat_stackp = cdat_buf[num_cdats++]; - -} - -void -pop_cdat -() -{ - *cdat_stackp = NULL; - cdat_stackp--; -} - -void -inc_posts +struct odat* +alloc_odat () { - num_posts++; - if(num_posts >= curr_max_posts) - { if( (realloc((void*) post_buf, PTRS_IN_PAGE * 4)) == NULL) - perror("realloc post_buf failed"); - curr_max_posts += PTRS_IN_PAGE; - } - if( (CURR_POST = (struct ref*) malloc(sizeof (struct ref))) == NULL) - perror("malloc post failed"); -} -void -inc_odat -() -{ num_odats++; if(num_odats >= curr_max_odats) { if( (realloc((void*) odat_buf, PTRS_IN_PAGE * 4)) == NULL) @@ -394,10 +291,11 @@ inc_odat if( (CURR_ODAT = (struct odat*) malloc(sizeof (struct odat))) == NULL) perror("malloc odat failed"); + return CURR_ODAT; } void -inc_vdat +alloc_vdat () { num_vdats++; @@ -409,13 +307,16 @@ inc_vdat if((CURR_VDAT = (struct vdat*) malloc(sizeof (struct vdat))) == NULL) perror("malloc vdat failed"); + return CURR_VDAT; + } -void -inc_link +struct link* +alloc_link () { num_links++; + if(num_links >= curr_max_links) { if( (realloc((void*) link_buf, PTRS_IN_PAGE * 4)) == NULL) perror("realloc vdat_buf failed"); @@ -423,19 +324,21 @@ inc_link } if((CURR_LINK = (struct link*) malloc(sizeof (struct link))) == NULL) perror("malloc link failed"); + + return CURR_LINK; } -void -inc_ref +struct ref* +alloc_ref () { + num_refs++; if(num_refs % 16 == 0) { CURR_POST = CURR_REF; inc_posts(); } - num_refs++; if(num_refs >= curr_max_refs) { if( (realloc((void*) ref_buf, PTRS_IN_PAGE * 4)) == NULL) perror("realloc ref_buf failed"); @@ -443,281 +346,39 @@ inc_ref } if((CURR_REF = (struct ref*) malloc(sizeof (struct ref))) == NULL) perror("malloc ref failed"); -} -/* 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. */ - -void -insert_set_label -( char* name, - uint64_t ref_id -) -{ - memmove(CURR_CDAT->CURR_SET.name,name,32); - memmove(&CURR_CDAT->CURR_SET.ref_id,&ref_id,64); - -} -void -insert_set_olink -( uint64_t ref_id -) -{ - CURR_CDAT->CURR_SET.cdat_idx = CURR_CDAT->idx; - CURR_CDAT->CURR_SET.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; - - inc_link(); -} - -void -insert_set_vlink -( uint64_t ref_id, - char* anim_name -) -{ - /* Insert vlink into link_stack so that it gets processed at - output time */ - CURR_LINK->cdat_idx = CURR_CDAT->idx; - CURR_LINK->set_idx = CURR_CDAT->num_sets; - CURR_LINK->type = 2; - CURR_LINK->link_t.vlink.ref_id = ref_id; - memmove(CURR_LINK->link_t.vlink.anim_name, anim_name, 32); - + return CURR_REF; } -void -insert_set_svlink -( uint64_t ref_id -) -{ - - /* Insert vlink into link_stack so that it gets processed at - output time */ - CURR_LINK->cdat_idx = CURR_CDAT->idx; - CURR_LINK->set_idx = CURR_CDAT->num_sets; - CURR_LINK->type = 3; - CURR_LINK->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 +struct cdat* +curr_cdat () { - uint64_t ref_id; - - ref_id = CURR_CDAT->CURR_SET.ref_id; - - CURR_CDAT->CURR_SET.cdat_idx = CURR_CDAT->idx; - memmove(CURR_ODAT->name, CURR_CDAT->CURR_SET.name, 32); - CURR_CDAT->num_sets++; - - CURR_ODAT->cdat_idx = CURR_CDAT->idx; - CURR_ODAT->refp = CURR_REF; - - - CURR_REF->lastref = PREV_REF; - PREV_REF->nextref = CURR_REF; - CURR_REF->odatp = CURR_ODAT; - - - 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_ref(); - inc_odat(); + return CURR_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). Because insert_set/ele is always - called before insert_vdat, and thus increments the CURR_ODAT to be the next - ODAT to be populated, insert_vdat() targets the last ODAT that was populated, - via PREV_ODAT. */ -void -insert_vdat +struct odat* +curr_odat () { - PREV_ODAT->vdat_id = num_vdats; //NULL for vlink, svlink - inc_vdat(); + return CURR_ODAT; } - -/* Populates both the odat name and ref_id - for element. */ -void -insert_ele_label -( char* name, - uint64_t ref_id -) -{ - memmove(CURR_CDAT->CURR_SET.CURR_ELE.name, name, 32); - memmove(&CURR_CDAT->CURR_SET.ele_list[CURR_CDAT->CURR_SET.ref_id].ref_id, &ref_id, 64); -} - -void -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 - 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++; - -} - -void -insert_ele_vlink -( uint64_t ref_id, - char* anim_name -) -{ - - /* 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); - -} - -void -insert_ele_svlink -( uint64_t ref_id -) -{ - - 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; - - -} - -//Insert element into odat_buf and cdatpages -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; - - 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(); - -} - -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++; -} - -void -insert_quad -( int x, - int y, - 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++; -} - -/* 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 set* +curr_set +() { - CURR_ODAT->hitbox = hitbox; + return CURR_CDAT->CURR_SET; } - -/* 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 ele* +curr_ele +() { - - CURR_ODAT->root.x = x; - CURR_ODAT->root.y = y; - CURR_ODAT->root.z = z; + return CURR_CDAT->CURR_SET->CURR_ELE; } -void -insert_frame_pointer -( char direction, - void* frame -) +struct ref* +prev_ref +() { - CURR_VDAT->CURR_MODEL.spritesheet[(int)direction].frames[CURR_VDAT->CURR_MODEL.spritesheet[(int)direction].num_frames++] = frame; -} - + return PREV_REF; +} \ No newline at end of file