2 \brief Intermediate Representation (IR) between Directory Structure and Engine Grammar
3 \details The IR serves as a storage structure that is populated during the
4 parsing of the input directory structure. After parsing is complete,
5 the IR will be condensed (removed of excess allocated space) and then
6 output as the Engine Grammar. In this file we describe the semantic actions
7 that are called at each step, and the memory buffers that they populate.
8 See parser.y for the description on how the input grammar is constructed,
9 and where/when semantic actions are called.
10 TODO: or just write it here.
11 \author Jordan Lavatai
13 ----------------------------------------------------------------------------*/
24 #define MAX_MODELS 256
25 #define MAX_MODEL_LEN 256
28 #define MAX_CLASS_DEPTH 256
29 #define MAX_CLASSES 256
30 #define MAX_FRAMES 256
31 #define PTRS_IN_PAGE 1024
32 #define MAX_CHUNKS 256
33 #define PAGES_PER_CHUNK 16
35 /* Sets: elements. The set is populated at parse time AFTER the
36 elements are populated, due to the nature of bottom up parsing. */
44 /* Cdats: A cdat is a class data structure. Cdats serve as the central */
45 /* data types of the IR. For each cdat, sets and element */
46 /* ref_ids must be dereferenced to determine the odat information. Cdats */
47 /* contain pointers to their subclasses so that the relationship between */
48 /* classes can be determined, but the subclasses are not represented inside */
49 /* of the cdat itself but rather in subsequent cdats in cdat_buf. We */
50 /* can determine the number of subclasses (the last index into cdat_buf */
51 /* that represents a subclass of some arbitrary cdat) each cdat has by */
52 /* incrementing num_classes during parse time. */
53 /* TODO: Should classes point to their parent class? */
60 struct cdat
* class_list
[MAX_CLASSES
];
61 struct set set_list
[MAX_SETS
];
64 /* The cdat_stack is a stack pointers to cdat pointers, the top of which is
65 the cdat that is currently being parsed. Whenever a new cdat is recognized
66 by the grammar (CLOPEN), a cdat is pushed onto the cdat_stack, and we refer
67 to this cdat through the macro CURR_CDAT. By keeping a cdat_stack, we have
68 access to the current cdat so that the elements and sets can populate themselves
69 in the cdat accordingly. */
72 /* Refs: Each set/ele has a reference to its object data (odat) through a ref_id.
73 Ref_ids are unsigned 64 byte integers that map to the hex values RGBA. During
74 the construction of the directory structure, users can choose a RGBA value for
75 each object that any other object can refer to via links (see link). If a user
76 does not choose an RGBA value, then the object is given one from the system space.
77 We maintain a doubly linked list of refs in the ref_buf at parse time so that
78 links can be resolved after the parsing of the directory structure is complete.
79 For every 16th ref, we create a post so that we can reduce on the search time for
87 int ref_id
; //0xFFFFFF->digit
91 /* Links: At parse time, a set/ele can include a link in their
92 grammar representation instead of the actual data and this signifies
93 to the APC that that set/ele wishes to use the data of another
94 set/ele, either its video data (vdat) or object data (odat). The link
95 itself contains the type of link it is, the ref_id OR name, and
96 which set/ele created the link. During parse time, links can be made
97 to o/vdats that have yet to be parsed. In order to accomodate for this,
98 we resolve all links AFTER parse time by iterating through the link_buf,
99 finding the ref_id that was stored for some object (if the ref_id exists),
100 and creating a relative pointer from the original object to the data that
103 /* Svlinks stand for short vlink, which is a link to a vdat. svlinks
104 differ from vlinks because they do not have a name */
110 /* A vlink is what it sounds like, a link to a vdat */
113 uint8_t anim_name
[32];
118 struct svlink svlink
;
121 /* From: src odat ()To: dest odat (ref_id)*/
123 int type
; //1 = olink, 2 = vlink, 3 = svlink
142 /* maps: maps store the different map data for each archetype. */
144 uint8_t name
[NAME_MAX
];//TODO:Rename
145 uint8_t filepath
[PATH_MAX
];//TODO: Rename
150 /* Odats: Odats consist of the object data necessary for
151 each object. Odats are sometimes referred to as archetypes
152 at compile-time, in order to distinguish the difference from
153 a runtime object and a compile-time object.
154 TODO: Need more info about objects at runtime, to described
155 the reasoning behind odat structure at compile-time*/
163 struct odat
* parent_odatp
; // odat == set ? null : set ref_id
165 struct ref
* refp
; /* pointer to it's ref on ref_list */
167 //int mli; //map list index
170 struct odat
* curr_set_odatp
; //when a set has elements, insert_set() can no longer
171 //refer to its odat via curr_odat, so save the set odat.
173 /* A framesheet is a grouping of animation frames in
174 a single direction (N,W,S,E) */
179 void* frames
[MAX_FRAMES
];
182 /* A model is a collection of framesheets for every
183 direction (N,W,S,E,NW,NE,SW,SE)*/
184 /* NAMED spritesheet */
186 uint8_t name
[MAX_MODEL_LEN
];
187 uint8_t filepath
[PATH_MAX
];
188 struct framesheet spritesheet
[8]; //one for each
191 /* Vdat: Vdats are the video data of each object. They can not be
192 created as a stand alone object (because they consist solely
193 of animation information and not the map which the
194 animation manipulates). Vdats have a list of models for every
195 animation that the vdats odat can do for that vdat*/
197 struct odat
* creator
; //pointer to odat that made this vdat
199 uint8_t filename
[NAME_MAX
/sizeof(ucs4_t
)];
202 uint8_t filepath
[PATH_MAX
/sizeof(ucs4_t
)];
203 struct model model_list
[MAX_MODELS
];
206 /* Called after the cdat open operator has been recognized in grammar. Allocates
207 the space for a cdat on the cdat_buf, pushes that pointer onto
212 /* Called after a cdat end operator has been recognized in grammar. Sets
213 top stack cdat ** to null and decrements stack pointer */
217 /* Called after an odat has been populated. Allocates memory for
221 insert_set_label(uint8_t*, int);
223 /* Populate the sets representation in CURR_CDAT with a ref_id and insert a link
224 into the link_buf that will resolve the ref_id to an actual odat after parse time. */
226 insert_set_olink(int);
228 /* Put the vlink in the link_buf to be processed after parsetime */
230 insert_set_vlink(int, uint8_t*);
232 /* Put svlink in the link_buf to be processed after parsetime */
234 insert_set_svlink(int);
236 /* Called for every set reduction except for sets with olinks. Populates the
237 set data structures in the CDAT and in the ODAT. Uses the name and ref_id
238 from insert_set_label. Also inserts a ref into the ref_buf with the CURR_ODAT
239 pointer so that we can also resolve the odat from its ref_id. */
243 /* Insertion of eles is practically equivalent to how sets are inserted because both
244 share the same data type (ODAT). Like sets, eles have links, labels
245 and odats. Eles have the added notion of a parent set, and so must be inserted
246 into said parent set, but this is the only place they truly differ from sets. */
249 insert_set_vdatid(void);
252 insert_ele_label(uint8_t*, int);
254 /* Insert an ele olink into the CURR_ODAT */
256 insert_ele_olink(int);
258 /* Insert a ele vlink into CURR_ODAT*/
260 insert_ele_vlink(int, uint8_t*);
262 /* Inserts an ele short vlink into CURR_ODAT*/
264 insert_ele_svlink(int);
266 /* inserts ele into CURR_CLASS and CURR_ODAT */
271 insert_ele_vdatid(void);
274 insert_vdat(uint8_t*, int, int, uint8_t*);
275 /* Inserts the hitbox into the CURR_ODAT */
279 /* Inserts the root into the CURR_ODAT */
281 insert_root(int, int, int);
283 /* Inserts a quad into the CURR_ODAT */
285 insert_quad(int, int, int, int);
288 insert_map(uint8_t*, int, int, uint8_t*);
294 insert_framesheet(uint8_t, uint8_t*, int, int, int, int);
297 insert_frame_pointer(uint8_t, void*);