2 \brief IR Memory Implementation
3 \details Intermediary memory management
6 ----------------------------------------------------------------------------*/
9 #include <unitypes.h> //uint8_t as a char
10 #include <unistr.h> //u32_cpy
11 #include <stdint.h> //uint64_t
12 #include <string.h> //memset
13 #include <unistd.h> //u8_* functions
19 name_u8_cpy(struct name
*, struct name
*);
23 name_u8_cmp(struct name
*, struct name
*);
27 name_u8_set(struct name
*, ucs4_t
);
64 push_cdat(struct name
*);
70 insert_link_name(struct name
*);
72 insert_link_namelist(struct name
*);
74 insert_ss_name(struct name
*);
76 insert_ss_namelist(struct name
*);
78 insert_mlink(struct name
*, int);
80 insert_vlink(struct name
*, int);
82 insert_ref(struct odat
*, int);
88 insert_map(struct name
*, int, int, int, int, uint8_t*);
90 insert_framesheet(struct name
*, int, int, int, int, uint8_t*);
94 //type safety handled by macro expansion (do not call these directly from code, make dependent macros for access to these)
95 #define CHUNKS_LEN(STACK) ((STACK).csp - (STACK).chunks)
96 #define CURRENT_CHUNK(STACK) ((STACK).chunks[CHUNKS_LEN(STACK) - 1])
97 #define CHUNKS_FULL(STACK) ( (STACK).csp >= \
98 (STACK).chunks + MAX_CHUNKS * (STACK).chunk_size)
99 #define CURRENT_DSP(STACK,TYPE) ((TYPE*) ((STACK).dsp[CHUNKS_LEN(STACK) - 1]))
100 #define DATA_FULL(STACK,TYPE) ((void*) CURRENT_DSP(STACK,TYPE) >= \
101 (CURRENT_CHUNK(STACK) + (STACK).chunk_size))
102 #define CSP_PUSH(STACK) (*(++(STACK).csp) = malloc((STACK).chunk_size))
103 #define CURRENT_DATP(STACK,TYPE) (((TYPE**)(STACK).dsp)[CHUNKS_LEN(STACK) - 1])
104 #define PREVIOUS_DATP(STACK,TYPE) (((TYPE**)(STACK).dsp)[CHUNKS_LEN(STACK) - 2])
105 #define ALLOC_DAT(STACK,TYPE) (++CURRENT_DATP(STACK,TYPE))
106 #define INIT_STACK(STACK,TYPE) \
108 (STACK).chunk_size = PAGES_PER_CHUNK * pagesize; \
109 (STACK).max_dats = (STACK).chunk_size / sizeof (TYPE); \
111 for( i = 0; i < MAX_CHUNKS; i++){ \
112 (STACK).dsp[i] += pagesize; \
115 //Stack-specific macros (called directly from code (safety enforcement)
116 #define INIT_ODAT() (INIT_STACK(ocs, struct odat))
117 #define CURRENT_ODAT() (CURRENT_DATP(ocs,struct odat))
118 #define ODAT_FULL() (DATA_FULL(ocs,struct odat))
119 #define ODAT_ALLOC() (ALLOC_DAT(ocs,struct odat))
120 #define OCS_FULL() (CHUNKS_FULL(ocs))
121 #define INIT_VDAT() (INIT_STACK(vcs, struct vdat))
122 #define CURRENT_VDAT() (CURRENT_DATP(vcs,struct vdat))
123 #define VDAT_FULL() (DATA_FULL(vcs,struct vdat))
124 #define VDAT_ALLOC() (ALLOC_DAT(vcs,struct vdat))
125 #define VCS_FULL() (CHUNKS_FULL(vcs))
126 #define INIT_CDAT() (INIT_STACK(ccs, struct cdat))
127 #define CURRENT_CDAT() (CURRENT_DATP(ccs,struct cdat))
128 #define CDAT_FULL() (DATA_FULL(ccs, struct cdat))
129 #define CDAT_ALLOC() (ALLOC_DAT(ccs, struct cdat))
130 #define CCS_FULL() (CHUNKS_FULL(ccs))
131 #define INIT_SET() (INIT_STACK(scs, struct set))
132 #define CURRENT_SET() (CURRENT_DATP(scs, struct set))
133 #define SET_FULL() (DATA_FULL(scs, struct set))
134 #define SET_ALLOC() (ALLOC_DAT(scs, struct set))
135 #define SCS_FULL() (CHUNKS_FULL(scs))
136 #define INIT_LINK() (INIT_STACK(lcs, struct link))
137 #define CURRENT_LINK() (CURRENT_DATP(lcs,struct link))
138 #define LDAT_FULL() (DATA_FULL(lcs, struct link))
139 #define LDAT_ALLOC() (ALLOC_DAT(lcs, struct link))
140 #define LCS_FULL() (CHUNKS_FULL(lcs))
141 #define INIT_POST() (INIT_STACK(rcs, struct ref))
142 #define CURRENT_POST() (CURRENT_DATP(pcs,struct ref))
143 #define POST_FULL() (DATA_FULL(pcs,struct ref))
144 #define POST_ALLOC() (ALLOC_DAT(pcs,struct ref))
145 #define PCS_FULL() (CHUNKS_FULL(pcs))
146 #define INIT_REF() (INIT_STACK(rcs, struct ref))
147 #define CURRENT_REF() (CURRENT_DATP(rcs,struct ref))
148 #define PREVIOUS_REF() (PREVIOUS_DATP(rcs, struct ref))
149 #define REF_FULL() (DATA_FULL(rcs,struct ref))
150 #define REF_ALLOC() (ALLOC_DAT(rcs,struct ref))
151 #define RCS_FULL() (CHUNKS_FULL(rcs))
153 #define CURRENT_MODEL() (CURRENT_VDAT()->model_list[CURRENT_VDAT()->num_models])
157 /* Dynamically allocate memory for a class data structure, */
158 /* or cdat, after a class has been identified in a grammar. */
159 /* We also create a stack of class pointers so that */
160 /* we can access the cdat during processing of that */
161 /* cdats sets and elements, a requirement because the */
162 /* nature of recursive classes prevents us from accessing */
163 /* the cdat based on the previous index into cdat_buf, */
164 /* which is a list of all allocated cdats */
165 /* Cdats: A cdat is a class data structure. Cdats serve as the central */
166 /* data types of the IR. Cdats contain pointers to their subclasses so that the relationship between */
167 /* classes can be determined, but the subclasses are not represented inside */
168 /* of the cdat itself but rather in subsequent cdats in cdat_buf. We */
169 /* can determine the number of subclasses (the last index into cdat_buf */
170 /* that represents a subclass of some arbitrary cdat) each cdat has by */
171 /* incrementing num_classes during parse time. */
172 /* TODO: Should classes point to their parent class? */
173 /* TODO: Talk more about cdat set structure */
179 struct cdat
* class_list
[MAX_CLASSES
];
180 struct set
* set_list
[MAX_SETS
];
184 /* Sets: What is a set?
189 The set is populated at parse time AFTER the elements are populated, due to
190 the nature of bottom up parsing. */
194 struct set
* set_list
[MAX_SETS
];
197 /* Refs: Each set/ele has a reference to its object data (odat) through a refid.
198 refids are unsigned 64 byte integers that map to the hex values RGBA. During
199 the construction of the directory structure, users can choose a RGBA value for
200 each object that any other object can refer to via links (see link). If a user
201 does not choose an RGBA value, then the object is given one from the system space.
202 We maintain a doubly linked list of refs in the ref_buf at parse time so that
203 links can be resolved after the parsing of the directory structure is complete.
204 For every 16th ref, we create a post so that we can reduce on the search time for
208 int type
; //TODO: Is this needed?
212 int refid
; //0xFFFFFF->digit
215 /* Links: At parse time, a set/ele can include a link in their
216 grammar representation instead of the actual data and this signifies
217 to the APC that that set/ele wishes to use the data of another
218 set/ele, either its video data (vdat) or object data (odat). The link
219 itself contains the type of link it is, the refid OR name, and
220 which set/ele created the link. During parse time, links can be made
221 to o/vdats that have yet to be parsed. In order to accomodate for this,
222 we resolve all links AFTER parse time by iterating through the link_buf,
223 finding the refid that was stored for some object (if the refid exists),
224 and creating a relative pointer from the original object to the data that
227 /* TODO: Explain links more betta */
235 struct name src_animname
;
236 struct name src_namelist
[MAX_DEPTH
];
241 struct name src_mapname
;
242 struct name src_namelist
[MAX_DEPTH
];
253 /* From: src odat ()To: dest odat (refid)*/
255 int type
; //1 = olink, 2 = vlink, 3 = mlink
257 int dest_refid
; //if it exists
258 struct odat
* dest_odatp
;
266 uint8_t filepath
[FPATH_MAX
];
269 /* Odats: Odats consist of the object data necessary for
270 each object. Odats are sometimes referred to as archetypes
271 at compile-time, in order to distinguish the difference from
272 a runtime object and a compile-time object.
273 TODO: Need more info about objects at runtime, to described
274 the reasoning behind odat structure at compile-time*/
282 struct odat
* parent_odatp
; // odat == set ? null : set refid
283 struct ref
* refp
; /* pointer to it's ref on ref_list */
284 struct map map
; //only valid if odat ismap
288 /* A framesheet is a grouping of animation frames in
289 a single direction (N,W,S,E) */
297 /* A model is a collection of framesheets for every
298 direction (N,W,S,E,NW,NE,SW,SE)*/
299 /* NAMED spritesheet */
302 uint8_t filepath
[PATH_MAX
];
303 struct framesheet spritesheet
[8]; //one for each
306 /* Vdat: Vdats are the video data of each object. They can not be
307 created as a stand alone object (because they consist solely
308 of animation information and not the map which the
309 animation manipulates). Vdats have a list of models for every
310 animation that the vdats odat can do for that vdat*/
312 struct odat
* creator
; //pointer to odat that made this vdat
314 uint8_t filename
[FNAME_MAX
];
317 uint8_t filepath
[FPATH_MAX
];
318 struct model model_list
[MAX_MODELS
];
323 { struct name namelist
[MAX_DEPTH
];
332 { struct set_frame set_frames
[MAX_DEPTH
];
333 int curr_depth
; //used to get most recently created set/odat + to check for undefined parents of namelists
337 //"type free" chunk stacking
339 { void* chunks
[MAX_CHUNKS
];
340 void* *csp
; //chunk stack pointer
341 void* dsp
[MAX_CHUNKS
]; //dat stack pointer (per chunk)
342 int chunk_size
; //size of a chunk (including its forfeited page)
343 int max_dats
; //number of dats per chunk for this stack
344 } ocs
, vcs
, ccs
, rcs
, lcs
, pcs
, scs
; //odat, vdat, cdat, ref, link, post stacks
349 /* The cdat_stack is a stack pointers to cdat pointers, the top of which is
350 the cdat that is currently being parsed. Whenever a new cdat is recognized
351 by the grammar (CLOPEN), a cdat is pushed onto the cdat_stack, and we refer
352 to this cdat through the macro CURR_CDAT. By keeping a cdat_stack, we have
353 access to the current cdat so that the elements and sets can populate themselves
354 in the cdat accordingly. */
357 struct cdat
* cdat_stack
[MAX_CLASSES
];
358 struct cdat
** cdat_stackp
;
361 struct name set_namelist
[MAX_DEPTH
];
362 int set_numnames
= 0;
364 struct name link_namelist
[MAX_DEPTH
];
365 int link_numnames
= 0;
372 int ss_refid
= 0x0FFFFFFF; /* system space for refids */
379 /* The initalization function of the IR. */
385 uint8_t root
[4] = "root";
387 u8_stpncpy(name
.name
, root
, 4);
389 pagesize
= sysconf(_SC_PAGESIZE
);
392 *cdat_stackp
= CURRENT_CDAT();
393 name_u8_cpy(&(*cdat_stackp
)->name
, &name
);
397 VDAT_ALLOC(); //NULL vdat
398 VDAT_ALLOC(); //First vdat req. because alloc_vdat happens after vdat is reduced
414 for(i
= 0; i
< CHUNKS_LEN(ccs
) ; i
++)
418 for(i
= 0; i
< CHUNKS_LEN(ocs
); i
++)
422 for(i
= 0; i
< CHUNKS_LEN(vcs
) ; i
++)
426 for(i
= 0; i
< CHUNKS_LEN(rcs
); i
++)
430 for(i
= 0; i
< CHUNKS_LEN(lcs
); i
++)
434 for(i
= 0; i
< CHUNKS_LEN(pcs
); i
++)
447 { fprintf(stderr
, "You have allocated to many (%d) cdats ", num_cdats
);
456 return CURRENT_CDAT();
459 //these should probably be inline
467 { fprintf(stderr
, "You have allocated to many (%d) odats ", num_odats
);
476 return CURRENT_ODAT();
485 { fprintf(stderr
, "You have allocated to many (%d) vdats ", num_vdats
);
503 { fprintf(stderr
, "You have allocated to many (%d) sets ", num_sets
);
512 return CURRENT_SET();
522 { fprintf(stderr
, "You have allocated to many (%d) links ", num_links
);
531 return CURRENT_LINK();
541 { fprintf(stderr
, "You have allocated to many (%d) refs ", num_refs
);
551 if(num_refs
% 16 == 0)
552 { CURRENT_POST() = CURRENT_REF();
556 return CURRENT_REF();
564 { fprintf(stderr
, "You have allocated to many (%d) refs ", num_posts
);
579 return (*cdat_stackp
);
586 return CURRENT_ODAT();
593 return CURRENT_VDAT();
600 return CURRENT_SET();
609 for(i
= 0; i
<= depth
; i
++)
610 { if(!(setp
= setp
->set_list
[setp
->num_sets
]))
611 { printf("You are trying to access a set that does not exist irmem.c\n");
624 return CURRENT_REF();
630 return PREVIOUS_REF();
636 return &CURRENT_MODEL();
645 struct cdat
* curr_cdatp
;
647 curr_cdatp
= alloc_cdat();
649 name_u8_cpy(&curr_cdatp
->name
, name
);
650 curr_cdatp
->idx
= num_cdats
;
652 /* Set the cdat as a subclass of the previous cdat */
653 (*cdat_stackp
)->class_list
[(*cdat_stackp
)->num_classes
] = curr_cdatp
;
654 /* Push the cdat onto the cdat_stack */
655 *++cdat_stackp
= curr_cdatp
;
672 //Push name onto current namelist, set the set_namelist.
673 name_u8_cpy(&set_namelist
[set_numnames
++], name
);
683 { int depth
, nameidx
, i
;
685 insert_set_name(name
);
687 //Check if entire string matches first? Only possible if namelist is contiguous (uint8_t strings seperated by \0)
688 //Create odats/sets for each name in namelist where nameidx > ns_depth
689 //first check if any parts of namelist matches what is currently on namestack
690 //we can gauruntee that from ns_depth + 1 -> set_numnames namelists dont match. x
693 //if name_list doesnt match, from the first depth at which namelist doesnt match
694 //remove the nameframes namelist (zero out ones below?) and replace with current namelist,
695 //then allocate a new odat and set it to the current set_frame.
696 for( depth
= 0; depth
< set_numnames
; depth
++ )
697 { for (nameidx
= 0; nameidx
<= depth
; nameidx
++)
698 { if( name_u8_cmp(&set_namelist
[nameidx
], &ss
.set_frames
[depth
].namelist
[nameidx
]) != 0 )
699 { /* Populate the namelist of the set at the current depth */
700 for(i
= 0; i
<= depth
; i
++)
701 name_u8_cpy(&ss
.set_frames
[depth
].namelist
[i
], &set_namelist
[i
]);
703 /* Alloc set and odat */
704 ss
.set_frames
[depth
].odatp
= alloc_odat();
705 ss
.set_frames
[depth
].setp
= alloc_set();
707 /* populate set/odat name and cdat_idx */
708 name_u8_cpy(&ss
.set_frames
[depth
].odatp
->name
, &set_namelist
[depth
]);
709 ss
.set_frames
[depth
].setp
->cdat_idx
= ( *cdat_stackp
)->idx
;
711 /* Insert allocated set and odat into their respective trees if there is a depth
712 (they have parents) */
714 { ss
.set_frames
[depth
].odatp
->parent_odatp
= ss
.set_frames
[depth
-1].odatp
;
715 if(ss
.set_frames
[depth
-1].setp
->num_sets
< MAX_SETS
)
716 ss
.set_frames
[depth
-1].setp
->set_list
[ss
.set_frames
[depth
-1].setp
->num_sets
++] = ss
.set_frames
[depth
].setp
;
718 { printf("you have allocated too many sets in insert_namelist()\n");
722 else /* no parent set, so assign to cdat set_list */
723 { ss
.set_frames
[depth
].odatp
->parent_odatp
= NULL
; //no parent odat = NULL.
724 if(curr_cdat_set()->num_sets
< MAX_SETS
)
725 curr_cdat_set()->set_list
[curr_cdat_set()->num_sets
++] = ss
.set_frames
[depth
].setp
;
727 { printf("you have allocated too many sets in insert_namelist()\n");
733 ss
.set_frames
[depth
].num_names
= set_numnames
;
734 ss
.curr_depth
= depth
;
742 /*. We create new odats for each map variant that are children of the current odat/set
743 , set their name as the map name, and identify them by marking them as a map. This lets
744 us distinguish between sibling odatsthat have the same name because the map of the parent
745 odat had the same name as another, regular odat*/
746 #define CURR_SS_FRAME() (ss.set_frames[ss.curr_depth])
747 #define CURR_SS_SETP() (CURR_SS_FRAME().setp)
748 #define CURR_SS_ODATP() (CURR_SS_FRAME().odatp)
751 ( name
, direction
, height
, width
, refid
, filepath
)
753 int direction
, height
, width
, refid
;
756 struct odat
* curr_mem_odatp
; //pointer to odat in odat_buf
757 struct set
* curr_mem_setp
; //pointer to set in set_buf
760 curr_mem_odatp
= alloc_odat();
761 curr_mem_setp
= alloc_set();
762 //Create a new odat, make its parent be the set. Make a set for mdat, its name should
763 //be the name of the odat + name of model. That makes a conflict beween odats that are named
764 //the same thing as the model of a sibling odat that was created from a map. They can have
765 //same name if the map odat is marked. So mark the map odat.
768 curr_mem_odatp
->parent_odatp
= CURR_SS_ODATP();
769 //insert into set_list
770 if(CURR_SS_SETP()->num_sets
< MAX_SETS
)
771 CURR_SS_SETP()->set_list
[CURR_SS_SETP()->num_sets
++] = curr_mem_setp
;
773 { printf("You have allocated to many sets, error in insert_map()\n");
777 //indicate that newly created odat is a map
778 curr_mem_odatp
->ismap
= 1;
779 //set odat and set name
780 name_u8_cpy(&curr_mem_odatp
->name
, name
);
782 /* set cdat idx values for both set and odat */
783 curr_mem_setp
->cdat_idx
= num_cdats
;
785 /* TODO: INSERT MAP HEIGHT/WIDTH/NAME/FILEPATH INTO ODAT */
788 /* Generate refid if needed, put into ref_buf */
792 insert_ref(curr_mem_odatp
, refid
);
794 /* If current odatp on stack has a link, then we need to make our own link. just set the vdat_idx */
795 if(CURR_SS_ODATP()->vdat_idx
== 0)
797 linkp
= alloc_link();
798 linkp
->type
= CURR_SS_ODATP()->linkp
->type
;
799 linkp
->dest_odatp
= CURR_SS_ODATP();
800 linkp
->dest_refid
= refid
;
801 linkp
->link_t
.mlink
.src_refid
= CURR_SS_ODATP()->linkp
->link_t
.mlink
.src_refid
;
803 /* Copy the animation name of the vlink*/
804 name_u8_cpy(&linkp
->link_t
.vlink
.src_animname
, &CURR_SS_ODATP()->linkp
->link_t
.vlink
.src_animname
);
805 /* Copy the namelist of the vlink*/
806 for(i
= 0; i
< MAX_DEPTH
; i
++)
807 name_u8_cpy(&linkp
->link_t
.vlink
.src_namelist
[i
], &CURR_SS_ODATP()->linkp
->link_t
.vlink
.src_namelist
[i
]);
810 curr_mem_odatp
->vdat_idx
= CURR_SS_ODATP()->vdat_idx
;
818 /* 11/22 Each vdat has a multiple models. Each model has 8 framesheets, one in each
819 direction, that create a spritesheet. Inserting framesheets into the correct
820 model is just a matter of checking whether or not the last models name matches
822 the current one. We can never get a framesheet that is for the same model before
823 AND after some other model, due to alphasorting of the files in each directory */
826 ( model_name
, direction
, height
, width
, refid
, filepath
)
827 struct name
* model_name
;
828 int direction
, height
, width
, refid
;
830 { struct vdat
* curr_vdatp
;
831 struct model
* curr_modelp
;
832 static struct name last_model_name
[32];
835 curr_vdatp
= curr_vdat();
837 /* If the model name changed, that means there are no more
838 framesheets for that model to be processed, a guaruntee we make
839 b/c the filenames are alphabetically sorted */
840 if(!name_u8_cmp(last_model_name
, model_name
))
841 { if(curr_vdatp
->num_models
)
842 curr_vdatp
->num_models
++;
843 num_models
++; // total number of models
847 if(CURR_SS_ODATP()->refid
== 0)
850 insert_ref(CURR_SS_ODATP(), refid
);//given a odatp and a refid, insert the odatp into the ref_buf.
851 //push ref into ref_buf.
854 printf("error: redefining a previously set refid\n");
856 curr_modelp
= curr_model();
858 name_u8_cpy(&curr_modelp
->name
, model_name
);
859 curr_modelp
->spritesheet
[direction
].height
= height
;
860 curr_modelp
->spritesheet
[direction
].width
= width
;
861 /* TODO: INSERT FILEPATH INTO VDAT */
862 u8_stpncpy(curr_modelp
->spritesheet
[direction
].filepath
, filepath
, FPATH_MAX
);
864 name_u8_cpy(last_model_name
, model_name
);
871 //src_path is stored in link_namelist
874 ( src_mapname
, src_refid
)
875 struct name
* src_mapname
;
877 { struct link
* linkp
;
880 linkp
= alloc_link();
884 /* set the name of the src map for the link, if a name exists */
886 name_u8_cpy(&linkp
->link_t
.mlink
.src_mapname
, src_mapname
);
887 /* Set the source ref id of the link */
888 linkp
->link_t
.mlink
.src_refid
= src_refid
;
889 /* Copy the entire namelist of the link, if it exists */
890 for(i
= 0; i
< link_numnames
; i
--) //TODO MAX_DEPTH -> link_namelist_num??
891 { name_u8_cpy(&linkp
->link_t
.mlink
.src_namelist
[i
], &link_namelist
[i
]);
892 name_u8_set(&link_namelist
[i
], (ucs4_t
) 0);
896 linkp
->dest_odatp
= CURR_SS_ODATP();//current odat on set_stack
905 //Push name onto current namelist, set the set_namelist.
906 name_u8_cpy(&link_namelist
[link_numnames
++], name
);
910 /* Nearly identical to mlink */
913 ( src_animname
, src_refid
)
914 struct name
* src_animname
;
916 { struct link
* linkp
;
919 linkp
= alloc_link();
924 /* set the name of the src animname for the link, if a name exists */
926 name_u8_cpy(&linkp
->link_t
.vlink
.src_animname
, src_animname
);
928 /* Set the source ref id of the link */
929 linkp
->link_t
.mlink
.src_refid
= src_refid
;
931 /* Copy the entire namelist of the link, if it exists */
932 for(i
= 0; i
< link_numnames
; i
++) //TODO MAX_DEPTH -> link_namelist_num??
933 { name_u8_cpy(&linkp
->link_t
.vlink
.src_namelist
[i
], &link_namelist
[i
]);
934 name_u8_set(&link_namelist
[i
], (ucs4_t
) 0);//set to null for next link_namelist
937 linkp
->dest_odatp
= CURR_SS_ODATP();//current odat on set_stack
942 /* TODO: Do we really need to store the prev/next pointer? iterating through the
943 ref_buf could be achieved by iterating until the num_refs anyway. */
949 { struct ref
* curr_refp
;
950 struct ref
* prev_refp
;
952 curr_refp
= alloc_ref();
953 prev_refp
= prev_ref();
955 prev_refp
->nextref
= curr_refp
;
956 curr_refp
->lastref
= prev_refp
;
958 curr_refp
->odatp
= odatp
;
959 curr_refp
->refid
= refid
;
963 CURRENT_POST()->refid
= refid
;
964 CURRENT_POST()->odatp
= odatp
;
974 { struct vdat
* curr_vdatp
;
976 curr_vdatp
= curr_vdat();
978 curr_vdatp
->creator
= CURR_SS_ODATP();
979 CURR_SS_ODATP()->vdat_idx
= num_vdats
;
980 CURR_SS_ODATP()->vdatp
= curr_vdatp
;
988 { CURR_SS_ODATP()->refid
= refid
;
993 /* Called in the reduction of a set. While both odats (eles and sets)
994 have identical label terminals, we are unable to give a single grammatical rule
995 for both due to how we allocate odats in the odat buf. Due to the
996 nature of bottom up parsing, the set label is recognized first, and then the
997 sets elements are recognized. This means that after we have processed the sets elemenets,
998 the curr_odat is going to be the last element and NOT the set that was first allocated.
999 To get around this, we create a global variable set_odatp that will store the pointer
1000 to the odat when it is first allocated (in insert_set_label()) so that insert_set() can
1001 have access to it. Curr set points the sets representation in the cdat, curr_set_odatp
1002 points to the sets representation as an odat*/
1004 //TODO: Add insert_set_ref()
1005 //TODO: Is this the correct allocation scheme? No do the one ken suggested
1012 struct set
* curr_setp
;
1014 curr_setp
= curr_set();
1015 curr_set_odatp
= alloc_odat();
1017 u8_cpy(curr_set_odatp
->name
, name
, 32);
1018 u8_cpy(curr_setp
->name
, name
, 32);
1019 curr_set_odatp
->parent_odatp
= NULL
;
1024 /* Inserting a olink instead of a set. Set is really just a placeholder
1025 for another set. Allocate the memory for the set so taht it can be populated*/
1031 struct set
* curr_setp
;
1033 curr_setp
= curr_set();
1035 curr_setp
->refid
= refid
;
1045 struct cdat
* curr_cdatp
;
1046 struct odat
* curr_odatp
;
1047 struct link
* curr_linkp
;
1050 curr_cdatp
= curr_cdat();
1051 curr_odatp
= curr_odat();
1052 curr_linkp
= alloc_link();
1054 /* Insert vlink into link_stack so that it gets processed at
1056 curr_linkp
->type
= 2;
1057 /* Store the target odat information*/
1058 curr_linkp
->link_t
.vlink
.refid
= refid
;
1059 u8_cpy(curr_linkp
->link_t
.vlink
.anim_name
, anim_name
, 32);
1060 /* Store the linking odat/cdat information */
1061 curr_linkp
->classp
= curr_cdatp
;
1062 curr_linkp
->odatp
= curr_odatp
;
1063 curr_linkp
->set_idx
= curr_cdatp
->num_sets
;
1064 // curr_linkp->ele_idx = -1;
1068 /* Svlinks dont have animation names */
1074 struct cdat
* curr_cdatp
;
1075 struct link
* curr_linkp
;
1077 curr_cdatp
= curr_cdat();
1078 curr_linkp
= alloc_link();
1080 /* Insert svlink into link_stack so that it gets processed at
1082 curr_linkp
->type
= 3;
1083 curr_linkp
->classp
= curr_cdatp
;
1084 curr_linkp
->set_idx
= curr_cdatp
->num_sets
;
1085 // curr_linkp->ele_idx = -1;
1086 curr_linkp
->link_t
.svlink
.refid
= refid
;
1090 /* At the point of reducing to a set, most of the
1091 sets odat information has already been populated
1092 during the reduction of its right hand side
1093 non terminals (hitbox, root, quad_list). */
1098 struct odat
* curr_odatp
;
1099 struct cdat
* curr_cdatp
;
1100 struct set
* curr_setp
;
1101 struct ref
* prev_refp
;
1102 struct ref
* curr_refp
;
1103 struct vdat
* curr_vdatp
;
1105 curr_odatp
= curr_set_odatp
; //allocated at insert_set_label
1106 curr_cdatp
= curr_cdat();
1107 curr_setp
= curr_set();
1108 prev_refp
= curr_ref();
1109 curr_refp
= alloc_ref();
1110 curr_vdatp
= curr_vdat();
1112 curr_vdatp
->creator
= curr_set_odatp
;
1114 curr_setp
->cdat_idx
= curr_cdatp
->idx
; //does a set need its class idx?
1115 u8_cpy(curr_setp
->name
, curr_odatp
->name
, 32);
1116 curr_cdatp
->num_sets
++;
1118 curr_odatp
->cdat_idx
= curr_cdatp
->idx
;
1119 curr_odatp
->refp
= curr_refp
;
1121 refid
= curr_setp
->refid
; // refid set by insert_set_label(name, refid)
1123 curr_refp
->refid
= refid
;
1124 curr_refp
->lastref
= prev_refp
;
1125 curr_refp
->odatp
= curr_odatp
;
1126 prev_refp
->nextref
= curr_refp
;
1131 /* Created as a seperate function, instead of setting the ODATS vdat_id and
1132 calling inc_vdat() inside of insert_set(), to account for the set reduction
1133 where a vdat is not created (o/v/svlinks). */
1138 struct vdat
* curr_vdatp
;
1140 curr_vdatp
= curr_vdat();
1142 curr_set_odatp
->vdat_id
= num_vdats
; //no vdat_id for odats that have vlinks/svlinks
1143 curr_set_odatp
->vdatp
= curr_vdatp
;
1144 curr_set_odatp
= NULL
; //This sets odat shouldnt be modified after populating odats vdat info
1147 /* Populates the odat name and refid for odat, allocate the odat here for the rest of
1148 the functions to use via curr_odat(). */
1155 struct odat
* curr_odatp
;
1157 curr_odatp
= alloc_odat();
1159 u8_cpy(curr_odatp
->name
, name
, 32);
1160 curr_odatp
->map
[0] = 0;
1163 curr_odatp
->refid
= refid
;
1165 curr_odatp
->refid
= ss_refid
++;
1169 /* We don't make an odat here, at output time we will resolve
1170 the refid to the corresponding odat. */
1176 /* Do nothing because we already know the refid that
1177 the odat needs for this element (in the quad_file) */
1186 struct cdat
* curr_cdatp
;
1187 struct set
* curr_setp
;
1188 struct link
* curr_linkp
;
1190 curr_cdatp
= curr_cdat();
1191 curr_setp
= curr_set();
1192 curr_linkp
= alloc_link();
1194 /* Insert vlink into link_stack so that it gets processed at
1196 curr_linkp
->classp
= curr_cdatp
;
1197 curr_linkp
->type
= 2;
1198 curr_linkp
->set_idx
= curr_cdatp
->num_sets
;
1199 //curr_linkp->ele_idx = curr_setp->num_ele;
1200 curr_linkp
->link_t
.vlink
.refid
= refid
;
1201 u8_cpy(curr_linkp
->link_t
.vlink
.anim_name
, anim_name
, 32);
1210 struct cdat
* curr_cdatp
;
1211 struct set
* curr_setp
;
1212 struct link
* curr_linkp
;
1214 curr_cdatp
= curr_cdat();
1215 curr_setp
= curr_set();
1216 curr_linkp
= alloc_link();
1218 curr_linkp
->classp
= curr_cdatp
;
1219 curr_linkp
->type
= 3;
1221 //curr_linkp->ele_idx = curr_setp->num_ele;
1222 curr_linkp
->link_t
.svlink
.refid
= refid
;
1227 //Insert element into odat_buf and cdatpages
1232 struct cdat
* curr_cdatp
;
1233 struct odat
* curr_odatp
;
1234 struct vdat
* curr_vdatp
;
1235 struct set
* curr_setp
;
1236 struct ele
* curr_elep
;
1237 struct ref
* curr_refp
;
1238 struct ref
* prev_refp
;
1241 curr_odatp
= curr_odat(); //malloced @ insert_ele_label
1242 curr_vdatp
= curr_vdat();
1243 curr_setp
= curr_set();
1244 prev_refp
= curr_ref();
1245 curr_refp
= alloc_ref();
1247 curr_vdatp
->creator
= curr_odatp
;
1249 /* Populate odat for ele */
1250 curr_odatp
->cdat_idx
= curr_cdatp
->idx
;
1251 curr_odatp
->refp
= curr_refp
;
1252 curr_odatp
->parent_odatp
= curr_set_odatp
;
1254 refid
= curr_odatp
->refid
;
1256 curr_refp
->refid
= refid
;
1257 curr_refp
->lastref
= prev_refp
;
1258 curr_refp
->odatp
= curr_odatp
;
1259 prev_refp
->nextref
= curr_refp
;
1266 { struct odat
* curr_odatp
;
1267 curr_odatp
= curr_odat();
1268 curr_odatp
->vdat_id
= num_vdats
;
1280 /* ( int x, int y, int z, int refid */
1283 /* struct quad* curr_quadp; */
1285 /* curr_quadp = curr_quad(); */
1287 /* curr_quadp->x = x; */
1288 /* curr_quadp->y = y; */
1289 /* curr_quadp->z = z; */
1290 /* curr_quadp->refid = refid; */
1296 /* /\* serting the hitbox into the set */
1297 /* odat. Elements that don't have */
1298 /* a hitbox will use the sets root. *\/ */
1303 /* { struct odat* curr_odatp; */
1305 /* curr_odatp = curr_odat(); */
1306 /* curr_odatp->hitbox = hitbox; */
1309 /* /\* Inserting the root into the set */
1310 /* odat. Elements that don't have */
1311 /* a root will use the sets root. *\/ */
1318 /* { struct odat* curr_odatp; */
1320 /* curr_odatp = curr_odat(); */
1321 /* curr_odatp->root.x = x; */
1322 /* curr_odatp->root.y = y; */
1323 /* curr_odatp->root.z = z; */
1330 /* insert_frame_pointer */
1331 /* ( uint8_t direction, */
1334 /* { struct model* curr_modelp; */
1336 /* curr_modelp = curr_model(); */
1338 /* curr_modelp->spritesheet[(int)direction].frames[curr_modelp->spritesheet[(int)direction].num_frames++] = frame; */