--- /dev/null
+/*!@file\r
+ \brief APC Directory Scanner\r
+ \details This hand-written parser/scanner traverses a directory tree and\r
+ tokenizes elements of the structure which correspond to APC grammar.\r
+ The parser is implemented as a 2D stack which populates a list of\r
+ child directories at each depth, handling only the leaf nodes\r
+ (regular files) of the directory open at the current depth to\r
+ conserve memory and speed up traversal.\r
+ The scanner works with the lexer to lexically analyze text, and\r
+ assumes the existence of an external 'lex' function\r
+ \author Jordan Lavatai\r
+ \date Aug 2016\r
+ ----------------------------------------------------------------------------*/\r
+/* Standard */\r
+#include <stdio.h> //print\r
+#include <errno.h> //errno\r
+/* Posix */\r
+#include <err.h> //warnx\r
+#include <stdlib.h> //exit\r
+#include <unistd.h> //chdir\r
+#include <dirent.h> //opendir\r
+\r
+#include "parser.tab.h"\r
+/* Public */\r
+int scanner_init(void);\r
+void scanner_quit(void);\r
+int scanner(void);\r
+/* Private */\r
+#ifndef DL_STACKSIZE\r
+#define DL_STACKSIZE 64\r
+#endif\r
+#ifndef DL_CD_STACKSIZE\r
+#define DL_CD_STACKSIZE DL_STACKSIZE //square tree\r
+#endif\r
+extern //lexer.c\r
+int lexer_lex(const char*);\r
+extern //lexer.c\r
+void lexer_pushtok(int, int);\r
+static\r
+int dredge_current_depth(void);\r
+extern //lexer.c\r
+struct dirent* lexer_direntpa[], **lexer_direntpp;\r
+extern //SRC_DIR/bin/tools/apc.c\r
+const char* cargs['Z'];\r
+\r
+struct dirlist\r
+{ DIR* dirp;\r
+ struct dirent* child_directory_stack[DL_CD_STACKSIZE],** cds;\r
+} directory_list_stack[DL_STACKSIZE + 1],* dls; //+1 for the root dir\r
+\r
+/* Directory Listing Stack\r
+ FILO Stack for keeping an open DIR* at each directory depth for treewalk.\r
+ This stack is depth-safe, checking its depth during push operations, but not\r
+ during pop operations, to ensure the thread doesn't open too many files at\r
+ once (512 in c runtime), or traverse too far through symbolic links.\r
+ A directory listing includes a DIR* and all DIR-typed entity in the directory\r
+ as recognized by dirent, populated externally (and optionally).\r
+ This stack behaves abnormally by incrementing its PUSH operation prior to\r
+ evaluation, and the POP operations after evaluation. This behavior allows\r
+ the 'DL_CURDEPTH' operation to map to the current element in the 'dl_stack'\r
+ array, and it is always treated as the "current depth". This also allows us\r
+ to init the root directory to 'directory_list_stack'[0] and pop it in a safe\r
+ and explicit manner.\r
+*/\r
+#define DL_STACK (directory_list_stack)\r
+#define DL_STACKP (dls)\r
+#define DL_CD_STACK ((*DL_STACKP).child_directory_stack)\r
+#define DL_CD_STACKP ((*DL_STACKP).cds)\r
+#define DL_CURDIR() ((*DL_STACKP).dirp)\r
+#define DL_LEN() (DL_STACKP - DL_STACK)\r
+#define DL_CD_LEN() (DL_CD_STACKP - DL_CD_STACK)\r
+#define DL_INIT() (DL_STACKP = DL_STACK)\r
+#define DL_CD_INIT() (DL_CD_STACKP = DL_CD_STACK)\r
+#define DL_POP() ((*DL_STACKP--).dirp)\r
+#define DL_CD_POP() (*--DL_CD_STACKP)\r
+#define DL_PUSH(D) ((*++DL_STACKP).dirp = D)\r
+#define DL_CD_PUSH(E) (*DL_CD_STACKP++ = E)\r
+\r
+\r
+/* Initializer\r
+ Initializer expects a function pointer to its lexical analysis function.\r
+ Sets up stack pointers and returns boolean true if 'opendir' encounters an\r
+ error, or if dredge_current_depth returns boolean true.\r
+*/\r
+int scanner_init\r
+#define CWDSTR "./"\r
+#define ROOTDIR (cargs['d'] ? cargs['d'] : CWDSTR)\r
+()\r
+{ DL_INIT();\r
+ DL_STACK[0].dirp = opendir(ROOTDIR);\r
+ printf("Root dir %s\n",ROOTDIR);\r
+ return !chdir(ROOTDIR) && (DL_STACK[0].dirp == NULL || dredge_current_depth() == -1);\r
+}\r
+\r
+/* Quit */\r
+void scanner_quit\r
+()\r
+{ if (DL_CURDIR())\r
+ closedir(DL_CURDIR());\r
+}\r
+\r
+/* Scanner\r
+ The main driver of the scanner will advance the current treewalk state and\r
+ tokenize tree-based push/pop operations. It will call 'lexer_lex' to\r
+ tokenize directory names prior to making a push operation. safe checking for\r
+ all returns from the filesystem handler will exit on serious system errors.\r
+\r
+ after pushing a new directory to the directory list, the scanner will dredge\r
+ the directory and alphabetically sort all file entries into the lexer's file\r
+ array, while placing all subdirectory entries in the current depth's child\r
+ directory stack to be scanned later.\r
+\r
+ Returns the number of elements added to the lexer's file array, or -1 on\r
+ error\r
+*/\r
+int scanner\r
+#define $($)#$ //stringifier\r
+#define ERR_CHILD "Fatal: Maximum of " $(DL_CD_STACKSIZE) \\r
+ " child directories exceeded for directory at depth %i\n" \\r
+ ,DL_LEN()\r
+#define ERR_DEPTH "Fatal: Maximum directory depth of " $(DL_STACKSIZE) \\r
+ " exceeded during directory scan\n"\r
+#define ERR_DL "Fatal: Directory List Stack Corruption %x\n", DL_LEN()\r
+#define TOK_CLOPEN 0x55, 1 //TODO\r
+#define TOK_CLCLOSE 0x56, 1 //TODO\r
+()\r
+{ struct dirent* direntp;\r
+ struct DIR* DIRp;\r
+ parse:\r
+ if (DL_CD_LEN() >= DL_CD_STACKSIZE)//fail if maxchildren exceeded\r
+ { fprintf(stderr, ERR_CHILD);\r
+ goto fail;\r
+ }\r
+ if (DL_CD_LEN() > 0) //There are entities to process\r
+ { if ((direntp = DL_CD_POP()) == NULL)//If the dirent is null, the library\r
+ goto libfail; //function in dirent has failed\r
+ lexer_lex(direntp->d_name); //lex the directory name\r
+ if (DL_LEN() >= DL_STACKSIZE) //fail if maxdepth exceeded\r
+ { fprintf(stderr, ERR_DEPTH);\r
+ goto fail;\r
+ }\r
+ if (chdir(direntp->d_name)) //move into the new directory\r
+ goto libfail;\r
+ DL_PUSH(opendir(CWDSTR));\r
+ if (DL_CURDIR() == NULL) //open the cwd\r
+ goto libfail;\r
+ lexer_pushtok(TOK_CLOPEN); //Push "Open Directory" token\r
+ return dredge_current_depth(); //Filter and sort the current depth\r
+ }\r
+ else if (DL_LEN() >= 0) //Any dirs left? (Including root)\r
+ { if (closedir(DL_POP())) //close the directory we just left\r
+ goto libfail;\r
+ if (DL_LEN() == -1) //If we just popped root,\r
+ return 0; //we're done\r
+ lexer_pushtok(TOK_CLCLOSE); //Else push "Close Directory" token,\r
+ if (!chdir("..")) //move up a directory and\r
+ goto parse; //start over\r
+ }\r
+ fprintf(stderr, ERR_DL);\r
+ libfail:\r
+ perror("parsedir");\r
+ fail:\r
+ exit(EXIT_FAILURE);\r
+}\r
+\r
+/* Directory Entity Sort and Filter (Dredge)\r
+ This filter removes all unhandled file types, and places any 'DT_DIR' type\r
+ files in the current Directory List's directory stack. Upon finishing,\r
+ the 'CE_STACK' is sorted alphabetically, and the current 'DL_CD_STACK' is\r
+ populated. Prints warnings for unhandled files.\r
+\r
+ Returns -1 if 'readdir' encounters an error, otherwise returns the number of\r
+ directory entries sent to the external 'lexer_direntpa' array.\r
+*/\r
+typedef\r
+int (*qcomp)(const void*, const void*);\r
+static inline\r
+int dredge_current_depth\r
+#define READDIR_ERROR (-1)\r
+#define READDIR_DONE (0)\r
+#define DPS_LEN() (lexer_direntpp - lexer_direntpa)\r
+#define DPS_PUSH(E) (*lexer_direntpp++ = E)\r
+()\r
+{ struct dirent** direntpp = lexer_direntpa;\r
+ DIR* cwd = DL_CURDIR();\r
+ struct dirent* direntp;\r
+ DL_CD_INIT();\r
+ scan_next:\r
+ if ((direntp = readdir(cwd)) != NULL)\r
+ { switch (direntp->d_type)\r
+ { case DT_REG:\r
+ DPS_PUSH(direntp);\r
+ goto scan_next;\r
+ case DT_DIR:\r
+ if (*(direntp->d_name) == '.') //skip hidden files and relative dirs\r
+ goto scan_next;\r
+ DL_CD_PUSH(direntp);\r
+ goto scan_next;\r
+ case DT_UNKNOWN:\r
+ warnx("unknown file %s: ignoring", direntp->d_name);\r
+ default:\r
+ goto scan_next;\r
+ }\r
+ }\r
+ if (errno)\r
+ return -1;\r
+ qsort(lexer_direntpa, DPS_LEN(), sizeof direntp, (qcomp)alphasort);\r
+ return DPS_LEN();\r
+}\r
+\r
--- /dev/null
+/*!@file\r
+ \brief lexical analyzer implementation for APC\r
+ \details The lexer manages two FIFO stacks. One for maintaining tokens, the\r
+ other for maintaining a list of files to be scanned. During\r
+ execution, the lexer will return a token from its token queue if any\r
+ are present. If not, the lexer will will pop an element from its\r
+ file queue to 'scanner' to be tokenized. If the file queue is empty,\r
+ the lexer will instead call 'parsedir' to traverse the directory tree\r
+ and tokenize the results. If 'parsedir' does not generate any new\r
+ tokens, we are done.\r
+ \author Jordan Lavatai\r
+ \date Aug 2016\r
+ ----------------------------------------------------------------------------*/\r
+/* Standard */\r
+#include <stdio.h>\r
+#include <string.h>\r
+#include <errno.h>\r
+/* Posix */\r
+#include <unistd.h>\r
+#include <stdlib.h>\r
+#include <dirent.h>\r
+/* Local */\r
+#include "parser.tab.h"\r
+#ifndef DE_STACKSIZE\r
+#define DE_STACKSIZE 1024\r
+#endif\r
+#ifndef TK_STACKSIZE\r
+#define TK_STACKSIZE 1024\r
+#endif\r
+/* Public */\r
+int lexer_init(void);\r
+int lexer(void);\r
+int lexer_lexfile(const char*);\r
+void lexer_pushtok(int, YYSTYPE);\r
+extern //lexer_lex.rl\r
+int lexer_lex(const char*);\r
+struct dirent* lexer_direntpa[DE_STACKSIZE], **lexer_direntpp;\r
+/* Private */\r
+extern //scanner.c\r
+int scanner_init(void);\r
+extern //scanner.c\r
+int scanner(void);\r
+static inline\r
+int dredge_current_depth(void);\r
+extern //bison\r
+YYSTYPE yylval;\r
+static\r
+struct tok\r
+{ YYSTYPE lval; //token val\r
+ int tok_t; //token type\r
+} token_stack[TK_STACKSIZE];\r
+static\r
+union tokp\r
+{ int* tpt; //token pointer type\r
+ struct tok* tok;\r
+ YYSTYPE* tvp; //token value pointer\r
+} tks, tkx;\r
+\r
+/* Directory Entity Array/Stack\r
+ Simple array for keeping track of dirents yet to be processed by the scanner.\r
+ If this list is empty and there are no tokens, the lexer is done.\r
+ This array is populated by the scanner as an array, and popped locally by the\r
+ lexer as a stack.\r
+*/\r
+#define DE_STACK (lexer_direntpa)\r
+#define DE_STACKP (lexer_direntpp)\r
+#define DE_LEN() (DE_STACKP - DE_STACK)\r
+#define DE_INIT() (DE_STACKP = DE_STACK)\r
+#define DE_POP() (*--DE_STACKP)\r
+\r
+/* Token Stack\r
+ This is a FIFO stack whose pointers are a union of either a pointer to an\r
+ integer, or a pointer to two integers (a struct tok). This way, integers may\r
+ be added or removed from the stack either singularly (IPUSH/IPOP), or as a\r
+ full token of two integers (PUSH/POP).\r
+ An alignment error will occur if IPOP or IPUSH are used a non-even number of\r
+ times in a sequence!\r
+*/\r
+#define TK_STACK (token_stack)\r
+#define TK_STACKP (tks.tok)\r
+#define TK_STACKPI (tks.tpt)\r
+#define TK_STACKPL (tks.tvp)\r
+#define TK_STACKX (tkx.tok)\r
+#define TK_STACKXI (tkx.tpt)\r
+#define TK_LEN() (TK_STACKX - TK_STACKP)\r
+#define TK_INIT() (TK_STACKP = TK_STACKX = TK_STACK)\r
+#define TK_POP() (*TK_STACKP++)\r
+#define TK_POPI() (*TK_STACKPI++);\r
+#define TK_POPL() (*TK_STACKPL++);\r
+#define TK_PUSH(T,L) (*TK_STACKX++ = (struct tok){L,T})\r
+\r
+/* Initializer\r
+ The initializer returns boolean true if an error occurs, which may be handled with standard errno.\r
+*/\r
+int lexer_init\r
+()\r
+{ TK_INIT();\r
+ DE_INIT();\r
+ return scanner_init();\r
+}\r
+\r
+/* Lexer\r
+ If the token buffer is empty, 'lexer' will initialize the token buffer and\r
+ call 'lexer_scandir'. If SCAN_ERROR is returned, an error is printed\r
+ before sending a null return to bison. If 0 tokens are generated, the error\r
+ printing is skipped. In all other cases, 'yylval' is set, and the token's\r
+ integer representation is returned.\r
+*/\r
+int lexer\r
+#define $($)#$\r
+#define SCAN_ERROR -1\r
+#define TK_EMPTY (TK_STACKP == TK_STACKX)\r
+#define FAIL(...) \\r
+ do { \\r
+ fprintf(stderr,__VA_ARGS__); \\r
+ goto done; \\r
+ } while (0)\r
+()\r
+{start:\r
+ while (DE_LEN() > 0) //lex any directory entries in our stack\r
+ if (lexer_lexfile(DE_POP()->d_name) == 0)\r
+ FAIL("Lexer failed to tokenize [%s]\n",(*DE_STACKP)->d_name);\r
+ if (TK_EMPTY) //if there are no tokens,\r
+ { TK_INIT(); //initialize the token stack back to 0\r
+ switch (scanner())\r
+ { case SCAN_ERROR: //if an error occurred,\r
+ FAIL("Scanner error\n");\r
+ case 0: //if the the scanner finds no dirents,\r
+ goto done; //then we are done\r
+ default: //if we found some elements to scan,\r
+ goto start; //start over and lex them\r
+ }\r
+ }\r
+ yylval = TK_POPL();\r
+ return TK_POPI();\r
+ done:\r
+ yylval.val = 0;\r
+ return 0;\r
+}\r
+\r
+\r
+/* Token Receiver\r
+ This receiver takes a struct tok and pushes it to the FIFO stack.\r
+*/\r
+void lexer_pushtok\r
+#define $($)#$ //stringifier\r
+#define ERR_TK "Fatal: Generated over " $(TK_STACKSIZE) " tokens in one pass."\r
+( int tok, YYSTYPE lval )\r
+{ if (TK_LEN() >= TK_STACKSIZE)\r
+ { fprintf(stderr, ERR_TK);\r
+ exit(EXIT_FAILURE);\r
+ }\r
+ TK_PUSH(tok, lval);\r
+ printf("Pushed Token %i | %i\n", TK_STACK[TK_LEN() - 1].tok_t, TK_STACK[TK_LEN() - 1].lval.val);\r
+}\r
+\r
+/* Lexical analysis of a file\r
+ Strips a filename to its base name, then sends it to lexer_lex\r
+*/\r
+int lexer_lexfile\r
+#define MAX_FNAME 2048\r
+#define HIDDEN_WARNING "%s is hidden and will not be parsed!\n", filename\r
+( const char *filename\r
+)\r
+{ static char fname[MAX_FNAME];\r
+ char *last_period = NULL, *iter;\r
+\r
+ if (*filename == '.')\r
+ { fprintf (stderr, HIDDEN_WARNING);\r
+ return 0;\r
+ }\r
+ strncpy(fname,filename,MAX_FNAME);\r
+ last_period = NULL;\r
+ for (iter = fname; *iter; iter++)\r
+ if (*iter == '.')\r
+ last_period = iter;\r
+ if (last_period)\r
+ *last_period = '\0';\r
+ return lexer_lex(fname);\r
+}\r
--- /dev/null
+/* Ragel State Machine for tokenizing text */\r
+#include <stdio.h>\r
+#include <string.h>\r
+#include <apc/parser.tab.h>\r
+\r
+extern void lexer_pushtok(int, YYSTYPE);\r
+\r
+int lexer_lex(const char*);\r
+int ipow(int, int);\r
+int ttov(const char* str, int);\r
+uint64_t ttor(const char* str, int);\r
+char* ttos(const char* str, int);\r
+\r
+\r
+#define MAX_TOK_LEN 64\r
+#define MAX_TOKENS 16\r
+#define MAX_STR_SIZE (MAX_TOK_LEN * MAX_TOKENS)\r
+#define $($)#$\r
+#define PUSHTOK(TOK,LFUNC,UTYPE) \\r
+ do { \\r
+ printf("PUSHTOK(" $(TOK) $(LFUNC) $(UTYPE) ")\n"); \\r
+ tok_t = TOK; \\r
+ yylval.UTYPE = LFUNC(ts, p-ts); \\r
+ lexer_pushtok(tok_t, yylval); \\r
+ ++ntok; \\r
+ } while (0)\r
+\r
+%%{\r
+ machine token_matcher;\r
+\r
+ # set up yylval and tok_t to be pushed to stack\r
+ action set_ref { PUSHTOK(REF, ttor, ref); }\r
+ action set_val { PUSHTOK(NUM, ttov, val); }\r
+ action set_name { PUSHTOK(NAME, ttos, str); }\r
+ action set_ts { ts = p; }\r
+ action lex_error {printf("input error: character %c in filename %s is invalid\n", fc, str);}\r
+\r
+ # instantiate machines for each possible token\r
+ ref = '0x' xdigit+ %set_ref;\r
+ val = digit+ %set_val;\r
+ name = alpha+ %set_name;\r
+ tok = ref | val | name;\r
+ segment = (tok . '_') %set_ts;\r
+\r
+ main := segment* . tok $lerr(lex_error);\r
+}%%\r
+\r
+\r
+%%write data;\r
+\r
+/* Scan filename and push the its tokens\r
+ onto the stack */\r
+int lexer_lex (const char* str)\r
+{\r
+ const char *p, *pe, *ts, *eof;\r
+ int cs, tok_t, ntok = 0;\r
+ printf ("Lexing: %s\n",str);\r
+ p = ts = str;\r
+ pe = p + strlen(str);\r
+ %%write init;\r
+ %%write exec;\r
+ printf ("Lexed %i tokens\n",ntok);\r
+ return ntok;\r
+}\r
+\r
+int ipow(int base, int exp)\r
+{\r
+ int result = 1;\r
+ while (exp)\r
+ {\r
+ if (exp & 1)\r
+ result = result * base;\r
+ exp = exp >> 1;\r
+ base *= base;\r
+ }\r
+\r
+ return result;\r
+}\r
+\r
+/* Token to Value */\r
+int ttov(const char* str, int len)\r
+{\r
+ int i, val = 0;\r
+\r
+ for (i = 0; i < len; i++)\r
+ {\r
+ val += ((str[len - (i + 1)] - '0') * ipow(10,i));\r
+ }\r
+\r
+ return val;\r
+}\r
+\r
+uint64_t ttor(const char* str, int len)\r
+{\r
+ int i;\r
+ uint64_t num = 0;\r
+\r
+ for (i = 0; i < len; i++)\r
+ {\r
+ num += ((str[len - (i + 1)] - '0') * ipow(10,i));\r
+ }\r
+\r
+ return num;\r
+}\r
+\r
+char* ttos(const char* str, int len)\r
+{\r
+ int i;\r
+ char token_buf[MAX_TOK_LEN];\r
+\r
+ memmove(token_buf, str, len);\r
+ token_buf[len+1] = '\0';\r
+\r
+ return strdup(token_buf);\r
+}\r
--- /dev/null
+/*!@file\r
+ \brief IR Memory Implementation\r
+ \details Intermediary memory management\r
+ \author Jordan Lavatai\r
+ \date Aug 2016\r
+ ----------------------------------------------------------------------------*/\r
+#include <errno.h>\r
+#include <stdio.h>\r
+#include <stdint.h> //uint64_t\r
+#include <string.h> //memmove\r
+#include <stdlib.h> //malloc\r
+#include <apc/ir.h>\r
+\r
+\r
+\r
+/* functions needed from irmem.c */\r
+extern\r
+void\r
+ir_init(void);\r
+\r
+extern\r
+struct cdat*\r
+alloc_cdat(void);\r
+\r
+extern\r
+struct odat*\r
+alloc_odat(void);\r
+\r
+extern\r
+void\r
+alloc_vdat(void);\r
+\r
+extern\r
+struct link*\r
+alloc_link(void);\r
+\r
+extern\r
+struct ref*\r
+alloc_ref(void);\r
+\r
+extern\r
+struct cdat*\r
+curr_cdat(void);\r
+\r
+extern\r
+struct odat*\r
+curr_odat(void);\r
+\r
+extern\r
+struct vdat*\r
+curr_vdat(void);\r
+\r
+extern\r
+struct set*\r
+curr_set(void);\r
+\r
+extern\r
+struct ref*\r
+curr_ref(void);\r
+\r
+extern\r
+struct quad*\r
+curr_quad(void);\r
+\r
+extern\r
+struct model*\r
+curr_model(void);\r
+\r
+/* struct definitions needed from irmem.c */\r
+extern int num_cdats;\r
+extern struct cdat** cdat_stackp;\r
+extern struct odat* curr_set_odatp;\r
+extern uint64_t ss_ref_id;\r
+\r
+extern int num_vdats;\r
+/* Dynamically allocate memory for a class data structure,\r
+ or cdat, after a class has been identified in a grammar.\r
+ We also create a stack of class pointers so that\r
+ we can access the cdat during processing of that\r
+ cdats sets and elements, a requirement because the\r
+ nature of recursive classes prevents us from accessing\r
+ the cdat based on the previous index into cdat_buf,\r
+ which is a list of all allocated cdats*/\r
+void\r
+push_cdat\r
+( char* name\r
+)\r
+{\r
+ struct cdat* curr_cdatp;\r
+\r
+ curr_cdatp = alloc_cdat();\r
+\r
+ memmove(curr_cdatp->name, name, 32);\r
+ curr_cdatp->idx = num_cdats;\r
+\r
+ /* Set the cdat as a subclass of the previous cdat */\r
+ (*cdat_stackp)->class_list[(*cdat_stackp)->num_classes] = curr_cdatp;\r
+ /* Push the cdat onto the cdat_stack */\r
+ *++cdat_stackp = curr_cdatp;\r
+\r
+}\r
+\r
+void\r
+pop_cdat\r
+()\r
+{\r
+ cdat_stackp--;\r
+}\r
+\r
+/* Called in the reduction of a set. While both odats (eles and sets)\r
+ have identical label terminals, we are unable to give a single grammatical rule\r
+ for both due to how we allocate odats in the odat buf. Due to the\r
+ nature of bottom up parsing, the set label is recognized first, and then the\r
+ sets elements are recognized. This means that after we have processed the sets elemenets,\r
+ the curr_odat is going to be the last element and NOT the set that was first allocated.\r
+ To get around this, we create a global variable set_odatp that will store the pointer\r
+ to the odat when it is first allocated (in insert_set_label()) so that insert_set() can\r
+ have access to it. Curr set points the sets representation in the cdat, curr_set_odatp\r
+ points to the sets representation as an odat*/\r
+\r
+void\r
+insert_set_label\r
+( char* name,\r
+ uint64_t ref_id\r
+)\r
+{\r
+\r
+ struct set* curr_setp;\r
+\r
+ curr_setp = curr_set();\r
+ curr_set_odatp = alloc_odat();\r
+\r
+ memmove(curr_set_odatp->name, name, 32);\r
+ memmove(curr_setp->name, name, 32);\r
+\r
+ if(ref_id != -1)\r
+ { curr_set_odatp->ref_id = ref_id;\r
+ curr_setp->ref_id = ref_id;\r
+ }\r
+ else\r
+ { curr_setp->ref_id = ss_ref_id;\r
+ curr_set_odatp->ref_id = ss_ref_id++;\r
+ }\r
+\r
+}\r
+\r
+/* Inserting a olink instead of a set. Set is really just a placeholder\r
+ for another set. Allocate the memory for the set so taht it can be populated*/\r
+void\r
+insert_set_olink\r
+( uint64_t ref_id\r
+)\r
+{\r
+ struct set* curr_setp;\r
+\r
+ curr_setp = curr_set();\r
+\r
+ curr_setp->ref_id = ref_id;\r
+\r
+}\r
+\r
+void\r
+insert_set_vlink\r
+( uint64_t ref_id,\r
+ char* anim_name\r
+)\r
+{\r
+ struct cdat* curr_cdatp;\r
+ struct odat* curr_odatp;\r
+ struct link* curr_linkp;\r
+\r
+\r
+ curr_cdatp = curr_cdat();\r
+ curr_odatp = curr_odat();\r
+ curr_linkp = alloc_link();\r
+\r
+ /* Insert vlink into link_stack so that it gets processed at\r
+ output time */\r
+ curr_linkp->type = 2;\r
+ /* Store the target odat information*/\r
+ curr_linkp->link_t.vlink.ref_id = ref_id;\r
+ memmove(curr_linkp->link_t.vlink.anim_name, anim_name, 32);\r
+ /* Store the linking odat/cdat information */\r
+ curr_linkp->classp = curr_cdatp;\r
+ curr_linkp->odatp = curr_odatp;\r
+ curr_linkp->set_idx = curr_cdatp->num_sets;\r
+ curr_linkp->ele_idx = -1;\r
+\r
+}\r
+\r
+/* Svlinks dont have animation names */\r
+void\r
+insert_set_svlink\r
+( uint64_t ref_id \r
+)\r
+{\r
+ struct cdat* curr_cdatp;\r
+ struct link* curr_linkp;\r
+\r
+ curr_cdatp = curr_cdat();\r
+ curr_linkp = alloc_link();\r
+\r
+ /* Insert svlink into link_stack so that it gets processed at\r
+ output time */\r
+ curr_linkp->type = 3;\r
+ curr_linkp->classp = curr_cdatp;\r
+ curr_linkp->set_idx = curr_cdatp->num_sets;\r
+ curr_linkp->ele_idx = -1;\r
+ curr_linkp->link_t.svlink.ref_id = ref_id;\r
+\r
+}\r
+\r
+/* At the point of reducing to a set, most of the\r
+ sets odat information has already been populated\r
+ during the reduction of its right hand side\r
+ non terminals (hitbox, root, quad_list). */\r
+void\r
+insert_set\r
+()\r
+{ uint64_t ref_id;\r
+ struct odat* curr_odatp;\r
+ struct cdat* curr_cdatp;\r
+ struct set* curr_setp;\r
+ struct ref* prev_refp;\r
+ struct ref* curr_refp;\r
+ struct vdat* curr_vdatp;\r
+\r
+ curr_odatp = curr_set_odatp; //allocated at insert_set_label, preserved in global space\r
+ curr_cdatp = curr_cdat();\r
+ curr_setp = curr_set();\r
+ prev_refp = curr_ref();\r
+ curr_refp = alloc_ref();\r
+ curr_vdatp = curr_vdat();\r
+\r
+ curr_vdatp->creator = curr_set_odatp;\r
+\r
+ curr_setp->cdat_idx = curr_cdatp->idx; //does a set need its class idx?\r
+ memmove(curr_setp->name, curr_odatp->name, 32);\r
+ curr_cdatp->num_sets++;\r
+\r
+ curr_odatp->cdat_idx = curr_cdatp->idx;\r
+ curr_odatp->refp = curr_refp;\r
+\r
+ ref_id = curr_setp->ref_id; // ref_id set by insert_set_label(name, ref_id)\r
+\r
+ curr_refp->ref_id = ref_id;\r
+ curr_refp->lastref = prev_refp;\r
+ curr_refp->odatp = curr_odatp;\r
+ prev_refp->nextref = curr_refp;\r
+\r
+\r
+\r
+}\r
+/* Created as a seperate function, instead of setting the ODATS vdat_id and\r
+ calling inc_vdat() inside of insert_set(), to account for the set reduction\r
+ where a vdat is not created (o/v/svlinks). */\r
+void\r
+insert_set_vdatid\r
+()\r
+{\r
+ struct vdat* curr_vdatp;\r
+\r
+ curr_vdatp = curr_vdat();\r
+\r
+ curr_set_odatp->vdat_id = num_vdats; //no vdat_id for odats that have vlinks/svlinks\r
+ curr_set_odatp->vdatp = curr_vdatp;\r
+ curr_set_odatp = NULL; //This sets odat shouldnt be modified after populating odats vdat info\r
+}\r
+\r
+/* Populates the odat name and ref_id for odat, allocate the odat here for the rest of\r
+ the functions to use via curr_odat(). */\r
+void\r
+insert_ele_label\r
+( char* name,\r
+ uint64_t ref_id\r
+)\r
+{\r
+ struct odat* curr_odatp;\r
+\r
+ curr_odatp = alloc_odat();\r
+\r
+ memmove(curr_odatp->name, name, 32);\r
+\r
+ if(ref_id != -1)\r
+ curr_odatp->ref_id = ref_id;\r
+ else\r
+ curr_odatp->ref_id = ss_ref_id++;\r
+\r
+}\r
+\r
+/* We don't make an odat here, at output time we will resolve\r
+ the ref_id to the corresponding odat. */\r
+void\r
+insert_ele_olink\r
+( uint64_t ref_id\r
+)\r
+{\r
+ /* Do nothing because we already know the ref_id that\r
+ the odat needs for this element (in the quad_file) */\r
+}\r
+\r
+void\r
+insert_ele_vlink\r
+( uint64_t ref_id,\r
+ char* anim_name\r
+)\r
+{\r
+ struct cdat* curr_cdatp;\r
+ struct set* curr_setp;\r
+ struct link* curr_linkp;\r
+\r
+ curr_cdatp = curr_cdat();\r
+ curr_setp = curr_set();\r
+ curr_linkp = alloc_link();\r
+\r
+ /* Insert vlink into link_stack so that it gets processed at\r
+ output time */\r
+ curr_linkp->classp = curr_cdatp;\r
+ curr_linkp->type = 2;\r
+ curr_linkp->set_idx = curr_cdatp->num_sets;\r
+ //curr_linkp->ele_idx = curr_setp->num_ele;\r
+ curr_linkp->link_t.vlink.ref_id = ref_id;\r
+ memmove(curr_linkp->link_t.vlink.anim_name, anim_name, 32);\r
+\r
+}\r
+\r
+void\r
+insert_ele_svlink\r
+( uint64_t ref_id\r
+)\r
+{\r
+ struct cdat* curr_cdatp;\r
+ struct set* curr_setp;\r
+ struct link* curr_linkp;\r
+\r
+ curr_cdatp = curr_cdat();\r
+ curr_setp = curr_set();\r
+ curr_linkp = alloc_link();\r
+\r
+ curr_linkp->classp = curr_cdatp;\r
+ curr_linkp->type = 3;\r
+\r
+ //curr_linkp->ele_idx = curr_setp->num_ele;\r
+ curr_linkp->link_t.svlink.ref_id = ref_id;\r
+\r
+\r
+}\r
+\r
+//Insert element into odat_buf and cdatpages\r
+void\r
+insert_ele()\r
+{\r
+ uint64_t ref_id;\r
+ struct cdat* curr_cdatp;\r
+ struct odat* curr_odatp;\r
+ struct vdat* curr_vdatp;\r
+ struct set* curr_setp;\r
+ struct ele* curr_elep;\r
+ struct ref* curr_refp;\r
+ struct ref* prev_refp;\r
+\r
+\r
+ curr_odatp = curr_odat(); //malloced @ insert_ele_label\r
+ curr_vdatp = curr_vdat();\r
+ curr_setp = curr_set();\r
+ prev_refp = curr_ref();\r
+ curr_refp = alloc_ref();\r
+\r
+ curr_vdatp->creator = curr_odatp;\r
+\r
+ /* Populate odat for ele */\r
+ curr_odatp->cdat_idx = curr_cdatp->idx;\r
+ curr_odatp->refp = curr_refp;\r
+\r
+ ref_id = curr_odatp->ref_id;\r
+\r
+ curr_refp->ref_id = ref_id;\r
+ curr_refp->lastref = prev_refp;\r
+ curr_refp->odatp = curr_odatp;\r
+ prev_refp->nextref = curr_refp;\r
+\r
+}\r
+\r
+void\r
+insert_ele_vdatid\r
+()\r
+{ struct odat* curr_odatp;\r
+ curr_odatp = curr_odat();\r
+ curr_odatp->vdat_id = num_vdats;\r
+}\r
+\r
+void\r
+insert_quad\r
+( void* quad_filep\r
+)\r
+{\r
+ struct odat* curr_odatp;\r
+\r
+ curr_odatp->quad_filep = quad_filep;\r
+}\r
+\r
+/* Inserting the hitbox into the set\r
+ odat. Elements that don't have\r
+ a hitbox will use the sets root. */\r
+void\r
+insert_hitbox\r
+( int hitbox\r
+)\r
+{ struct odat* curr_odatp;\r
+\r
+ curr_odatp = curr_odat();\r
+ curr_odatp->hitbox = hitbox;\r
+}\r
+\r
+/* Inserting the root into the set\r
+ odat. Elements that don't have\r
+ a root will use the sets root. */\r
+void\r
+insert_root\r
+( int x,\r
+ int y,\r
+ int z\r
+)\r
+{ struct odat* curr_odatp;\r
+\r
+ curr_odatp = curr_odat();\r
+ curr_odatp->root.x = x;\r
+ curr_odatp->root.y = y;\r
+ curr_odatp->root.z = z;\r
+}\r
+\r
+\r
+void\r
+insert_framesheet\r
+( char direction,\r
+ char* name,\r
+ uint64_t ref_id,\r
+ int height ,\r
+ int width,\r
+ int num_frames\r
+)\r
+{ struct vdat* curr_vdatp;\r
+ struct model* curr_modelp;\r
+\r
+ curr_vdatp = curr_vdat();\r
+ curr_modelp = curr_model();\r
+\r
+ curr_modelp->spritesheet[(int)direction].height = height;\r
+ curr_modelp->spritesheet[(int)direction].width = width;\r
+ curr_modelp->spritesheet[(int)direction].num_frames = num_frames;\r
+ curr_vdatp->num_models++;\r
+}\r
+\r
+void\r
+insert_frame_pointer\r
+( char direction,\r
+ void* frame\r
+)\r
+{ struct model* curr_modelp;\r
+\r
+ curr_modelp = curr_model();\r
+\r
+ curr_modelp->spritesheet[(int)direction].frames[curr_modelp->spritesheet[(int)direction].num_frames++] = frame;\r
+}\r
+\r
--- /dev/null
+/*!@file\r
+ \brief Intermediate Representation (IR) between Directory Structure and Engine Grammar\r
+ \details The IR serves as a storage structure that is populated during the\r
+ parsing of the input directory structure. After parsing is complete,\r
+ the IR will be condensed (removed of excess allocated space) and then\r
+ output as the Engine Grammar. In this file we describe the semantic actions\r
+ that are called at each step, and the memory buffers that they populate.\r
+ See parser.y for the description on how the input grammar is constructed,\r
+ and where/when semantic actions are called.\r
+ TODO: or just write it here.\r
+ \author Jordan Lavatai\r
+ \date Aug 2016\r
+ ----------------------------------------------------------------------------*/\r
+\r
+\r
+#include <stdint.h>\r
+\r
+#define BUF_SIZE 256\r
+#define MAX_SETS 256\r
+#define MAX_ELES 256\r
+#define MAX_QUADS 256\r
+#define MAX_MODELS 256\r
+#define MAX_POSTS 256\r
+#define MAX_CLASS_DEPTH 256\r
+#define MAX_CLASSES 256\r
+#define MAX_FRAMES 256\r
+#define PTRS_IN_PAGE 1024\r
+#define MAX_CHUNKS 256\r
+#define PAGES_PER_CHUNK 16\r
+\r
+/* Sets: elements. The set is populated at parse time AFTER the\r
+ elements are populated, due to the nature of bottom up parsing. */\r
+\r
+struct set {\r
+ char name[32];\r
+ uint64_t ref_id;\r
+ int cdat_idx;\r
+};\r
+\r
+/* Cdats: A cdat is a class data structure. Cdats serve as the central */\r
+/* data types of the IR. For each cdat, sets and element */\r
+/* ref_ids must be dereferenced to determine the odat information. Cdats */\r
+/* contain pointers to their subclasses so that the relationship between */\r
+/* classes can be determined, but the subclasses are not represented inside */\r
+/* of the cdat itself but rather in subsequent cdats in cdat_buf. We */\r
+/* can determine the number of subclasses (the last index into cdat_buf */\r
+/* that represents a subclass of some arbitrary cdat) each cdat has by */\r
+/* incrementing num_classes during parse time. */\r
+/* TODO: Should classes point to their parent class? */\r
+\r
+struct cdat {\r
+ char name[32];\r
+ int idx;\r
+ int num_classes;\r
+ int num_sets;\r
+ struct cdat* class_list[MAX_CLASSES];\r
+ struct set set_list[MAX_SETS];\r
+};\r
+\r
+/* The cdat_stack is a stack pointers to cdat pointers, the top of which is\r
+ the cdat that is currently being parsed. Whenever a new cdat is recognized\r
+ by the grammar (CLOPEN), a cdat is pushed onto the cdat_stack, and we refer\r
+ to this cdat through the macro CURR_CDAT. By keeping a cdat_stack, we have\r
+ access to the current cdat so that the elements and sets can populate themselves\r
+ in the cdat accordingly. */\r
+\r
+\r
+/* Refs: Each set/ele has a reference to its object data (odat) through a ref_id.\r
+ Ref_ids are unsigned 64 byte integers that map to the hex values RGBA. During\r
+ the construction of the directory structure, users can choose a RGBA value for\r
+ each object that any other object can refer to via links (see link). If a user\r
+ does not choose an RGBA value, then the object is given one from the system space.\r
+ We maintain a doubly linked list of refs in the ref_buf at parse time so that\r
+ links can be resolved after the parsing of the directory structure is complete.\r
+ For every 16th ref, we create a post so that we can reduce on the search time for\r
+ a random access. */\r
+\r
+struct ref {\r
+ int type;\r
+ struct ref* nextref;\r
+ struct ref* lastref;\r
+ struct odat* odatp;\r
+ uint64_t ref_id; //0xFFFFFF->digit\r
+};\r
+\r
+\r
+/* Links: At parse time, a set/ele can include a link in their\r
+ grammar representation instead of the actual data and this signifies\r
+ to the APC that that set/ele wishes to use the data of another\r
+ set/ele, either its video data (vdat) or object data (odat). The link\r
+ itself contains the type of link it is, the ref_id OR name, and\r
+ which set/ele created the link. During parse time, links can be made\r
+ to o/vdats that have yet to be parsed. In order to accomodate for this,\r
+ we resolve all links AFTER parse time by iterating through the link_buf,\r
+ finding the ref_id that was stored for some object (if the ref_id exists),\r
+ and creating a relative pointer from the original object to the data that\r
+ was linked */\r
+\r
+/* Svlinks stand for short vlink, which is a link to a vdat. svlinks\r
+ differ from vlinks because they do not have a name */\r
+\r
+struct svlink {\r
+ uint64_t ref_id;\r
+};\r
+\r
+/* A vlink is what it sounds like, a link to a vdat */\r
+struct vlink {\r
+ uint64_t ref_id;\r
+ char anim_name[32];\r
+};\r
+\r
+union link_t {\r
+ struct vlink vlink;\r
+ struct svlink svlink;\r
+};\r
+\r
+/* From: src odat ()To: dest odat (ref_id)*/\r
+struct link {\r
+ int type; //1 = olink, 2 = vlink, 3 = svlink\r
+ union link_t link_t;\r
+ struct cdat* classp;\r
+ struct odat* odatp;\r
+ int set_idx;\r
+ int ele_idx;\r
+};\r
+\r
+\r
+/* Odats: Odats consist of the object data necessary for\r
+ each object. Odats are sometimes referred to as archetypes\r
+ at compile-time, in order to distinguish the difference from\r
+ a runtime object and a compile-time object.\r
+ TODO: Need more info about objects at runtime, to described\r
+ the reasoning behind odat structure at compile-time*/\r
+\r
+struct root {\r
+ int x, y, z;\r
+};\r
+\r
+struct odat {\r
+ char name[32];\r
+ struct vdat* vdatp;\r
+ int vdat_id; //\r
+ int cdat_idx;\r
+ int hitbox;\r
+ uint64_t ref_id;\r
+ struct root root;\r
+ struct ref* refp; /* pointer to it's ref on ref_list */\r
+ void* quad_filep;\r
+};\r
+\r
+struct odat* curr_set_odatp; //when a set has elements, insert_set() can no longer\r
+ //refer to its odat via curr_odat, so save the set odat. \r
+\r
+/* A framesheet is a grouping of animation frames in\r
+ a single direction (N,W,S,E) */\r
+struct framesheet {\r
+ int width;\r
+ int height;\r
+ int num_frames;\r
+ void* frames[MAX_FRAMES];\r
+};\r
+\r
+/* A model is a collection of framesheets for every\r
+ direction (N,W,S,E,NW,NE,SW,SE)*/\r
+/* NAMED spritesheet */\r
+struct model {\r
+ char name[32];\r
+ struct framesheet spritesheet[8]; //one for each\r
+};\r
+\r
+/* Vdat: Vdats are the video data of each object. They can not be\r
+ created as a stand alone object (because they consist solely\r
+ of animation information and not the skeleton on which the\r
+ animation manipulates). Vdats have a list of models for every\r
+ animation that the vdats odat can do for that vdat*/\r
+struct vdat {\r
+ struct odat* creator; //pointer to odat that made this vdat\r
+ int num_models;\r
+ struct model model_list[MAX_MODELS];\r
+};\r
+\r
+/* Called after the cdat open operator has been recognized in grammar. Allocates\r
+ the space for a cdat on the cdat_buf, pushes that pointer onto\r
+ the cdat_stack */\r
+void\r
+push_cdat(char*);\r
+\r
+/* Called after a cdat end operator has been recognized in grammar. Sets\r
+ top stack cdat ** to null and decrements stack pointer */\r
+void\r
+pop_cdat(void);\r
+\r
+/* Called after an odat has been populated. Allocates memory for\r
+ the next odat. */\r
+\r
+void\r
+insert_set_label(char*, uint64_t);\r
+\r
+/* Populate the sets representation in CURR_CDAT with a ref_id and insert a link\r
+ into the link_buf that will resolve the ref_id to an actual odat after parse time. */\r
+void\r
+insert_set_olink(uint64_t);\r
+\r
+/* Put the vlink in the link_buf to be processed after parsetime */\r
+void\r
+insert_set_vlink(uint64_t, char*);\r
+\r
+/* Put svlink in the link_buf to be processed after parsetime */\r
+void\r
+insert_set_svlink(uint64_t);\r
+\r
+/* Called for every set reduction except for sets with olinks. Populates the\r
+ set data structures in the CDAT and in the ODAT. Uses the name and ref_id\r
+ from insert_set_label. Also inserts a ref into the ref_buf with the CURR_ODAT\r
+ pointer so that we can also resolve the odat from its ref_id. */\r
+void\r
+insert_set(void);\r
+\r
+/* Insertion of eles is practically equivalent to how sets are inserted because both\r
+ share the same data type (ODAT). Like sets, eles have links, labels\r
+ and odats. Eles have the added notion of a parent set, and so must be inserted\r
+ into said parent set, but this is the only place they truly differ from sets. */\r
+\r
+void\r
+insert_set_vdatid(void);\r
+\r
+void\r
+insert_ele_label(char*, uint64_t);\r
+\r
+/* Insert an ele olink into the CURR_ODAT */\r
+void\r
+insert_ele_olink(uint64_t);\r
+\r
+/* Insert a ele vlink into CURR_ODAT*/\r
+void\r
+insert_ele_vlink(uint64_t, char*);\r
+\r
+/* Inserts an ele short vlink into CURR_ODAT*/\r
+void\r
+insert_ele_svlink(uint64_t);\r
+\r
+/* inserts ele into CURR_CLASS and CURR_ODAT */\r
+void\r
+insert_ele(void);\r
+\r
+void\r
+insert_ele_vdatid(void);\r
+\r
+/* Inserts the hitbox into the CURR_ODAT */\r
+void\r
+insert_hitbox(int);\r
+\r
+/* Inserts the root into the CURR_ODAT */\r
+void\r
+insert_root(int, int, int);\r
+\r
+/* Inserts a quad into the CURR_ODAT */\r
+void\r
+insert_quad(void*);\r
+\r
+void\r
+insert_model(void);\r
+\r
+void\r
+insert_framesheet(char, char*, uint64_t, int, int, int);\r
+\r
+void\r
+insert_frame_pointer(char, void*);\r
+\r
+void\r
+alloc_vdat(void);\r
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <apc/ir.h>
+#include <unistd.h>
+
+struct cdat*
+alloc_cdat(void);
+struct odat*
+alloc_odat(void);
+void
+alloc_vdat(void);
+struct link*
+alloc_link(void);
+struct ref*
+alloc_ref(void);
+struct cdat*
+curr_cdat(void);
+struct odat*
+curr_odat(void);
+struct vdat*
+curr_vdat(void);
+struct set*
+curr_set(void);
+struct ref*
+curr_ref(void);
+struct model*
+curr_model(void);
+void
+inc_posts(void);
+
+#define PAGES_PER_CHUNK 16
+
+//"type free" chunk stacking
+struct chunk_stack
+{ void* chunks[MAX_CHUNKS];
+ void* *csp; //chunk stack pointer
+ void* dsp[MAX_CHUNKS]; //dat stack pointer (per chunk)
+ int chunk_size; //size of a chunk (including its forfeited page)
+ int max_dats; //number of dats per chunk for this stack
+} ocs, vcs, ccs, rcs, lcs, pcs; //odat, vdat, and cdat, ref, link, post stacks
+
+//type safety handled by macro expansion (do not call these directly from code, make dependent macros for access to these)
+#define CHUNKS_LEN(STACK) ((STACK).csp - (STACK).chunks)
+#define CURRENT_CHUNK(STACK) ((STACK).chunks[CHUNKS_LEN(STACK) - 1])
+#define CHUNKS_FULL(STACK) ( (STACK).csp >= \
+ (STACK).chunks + MAX_CHUNKS * (STACK).chunk_size)
+#define CURRENT_DSP(STACK,TYPE) ((TYPE*) ((STACK).dsp[CHUNKS_LEN(STACK) - 1]))
+#define DATA_FULL(STACK,TYPE) ((void*) CURRENT_DSP(STACK,TYPE) >= \
+ (CURRENT_CHUNK(STACK) + (STACK).chunk_size))
+#define CSP_PUSH(STACK) (*(++(STACK).csp) = malloc((STACK).chunk_size))
+#define CURRENT_DATP(STACK,TYPE) (((TYPE**)(STACK).dsp)[CHUNKS_LEN(STACK) - 1])
+#define PREVIOUS_DATP(STACK,TYPE) (((TYPE**)(STACK).dsp)[CHUNKS_LEN(STACK) - 2])
+#define ALLOC_DAT(STACK,TYPE) (++CURRENT_DATP(STACK,TYPE))
+#define INIT_STACK(STACK,TYPE) \
+ { int i; \
+ (STACK).chunk_size = PAGES_PER_CHUNK * pagesize; \
+ (STACK).max_dats = (STACK).chunk_size / sizeof (TYPE); \
+ CSP_PUSH(STACK); \
+ for( i = 0; i < MAX_CHUNKS; i++){ \
+ (STACK).dsp[i] += pagesize; \
+ } \
+ }
+//Stack-specific macros (called directly from code (safety enforcement)
+#define INIT_ODAT() (INIT_STACK(ocs, struct odat))
+#define CURRENT_ODAT() (CURRENT_DATP(ocs,struct odat))
+#define ODAT_FULL() (DATA_FULL(ocs,struct odat))
+#define ODAT_ALLOC() (ALLOC_DAT(ocs,struct odat))
+#define OCS_FULL() (CHUNKS_FULL(ocs))
+#define INIT_VDAT() (INIT_STACK(vcs, struct vdat))
+#define CURRENT_VDAT() (CURRENT_DATP(vcs,struct vdat))
+#define VDAT_FULL() (DATA_FULL(vcs,struct vdat))
+#define VDAT_ALLOC() (ALLOC_DAT(vcs,struct vdat))
+#define VCS_FULL() (CHUNKS_FULL(vcs))
+#define INIT_CDAT() (INIT_STACK(ccs, struct cdat))
+#define CURRENT_CDAT() (CURRENT_DATP(ccs,struct cdat))
+#define CDAT_FULL() (DATA_FULL(ccs, struct cdat))
+#define CDAT_ALLOC() (ALLOC_DAT(ccs, struct cdat))
+#define CCS_FULL() (CHUNKS_FULL(ccs))
+#define INIT_LINK() (INIT_STACK(lcs, struct link))
+#define CURRENT_LINK() (CURRENT_DATP(lcs,struct link))
+#define LDAT_FULL() (DATA_FULL(lcs, struct link))
+#define LDAT_ALLOC() (ALLOC_DAT(lcs, struct link))
+#define LCS_FULL() (CHUNKS_FULL(lcs))
+#define INIT_POST() (INIT_STACK(rcs, struct ref))
+#define CURRENT_POST() (CURRENT_DATP(pcs,struct ref))
+#define POST_FULL() (DATA_FULL(pcs,struct ref))
+#define POST_ALLOC() (ALLOC_DAT(pcs,struct ref))
+#define PCS_FULL() (CHUNKS_FULL(pcs))
+#define INIT_REF() (INIT_STACK(rcs, struct ref))
+#define CURRENT_REF() (CURRENT_DATP(rcs,struct ref))
+#define PREVIOUS_REF() (PREVIOUS_DATP(rcs, struct ref))
+#define REF_FULL() (DATA_FULL(rcs,struct ref))
+#define REF_ALLOC() (ALLOC_DAT(rcs,struct ref))
+#define RCS_FULL() (CHUNKS_FULL(rcs))
+//Metadata
+#define CURRENT_SET() (CURRENT_CDAT()->set_list[CURRENT_CDAT()->num_sets])
+#define CURRENT_MODEL() (CURRENT_VDAT()->model_list[CURRENT_VDAT()->num_models])
+
+
+#define CURR_QUAD (CURR_ODAT->quad_file)
+
+long pagesize;
+
+int num_cdats = 0;
+
+struct cdat* cdat_stack[MAX_CLASSES];
+struct cdat** cdat_stackp;
+
+int num_odats = 0;
+
+int num_vdats = 0;
+
+int num_refs = 0;
+uint64_t ss_ref_id = 0x00FFFFFF; /* system space for ref_ids */
+
+int num_posts = 0;
+
+int num_links = 0;
+
+
+/* The initalization function of the IR. */
+int
+ir_init()
+{
+
+ char root[4] = "root";
+
+ pagesize = sysconf(_SC_PAGESIZE);
+
+ INIT_CDAT();
+ *cdat_stackp = CURRENT_CDAT();
+ memmove((*cdat_stackp)->name, root, 32);
+
+ INIT_ODAT();
+ INIT_VDAT();
+ INIT_LINK();
+ INIT_REF();
+ INIT_POST();
+
+
+ return 0;
+
+}
+
+void
+ir_quit()
+{
+ int i;
+
+ for(i = 0; i < CHUNKS_LEN(ccs) ; i++)
+ {
+ free(ccs.chunks[i]);
+ }
+ for(i = 0; i < CHUNKS_LEN(ocs); i++)
+ {
+ free(ocs.chunks[i]);
+ }
+ for(i = 0; i < CHUNKS_LEN(vcs) ; i++)
+ {
+ free(vcs.chunks[i]);
+ }
+ for(i = 0; i < CHUNKS_LEN(rcs); i++)
+ {
+ free(rcs.chunks[i]);
+ }
+ for(i = 0; i < CHUNKS_LEN(lcs); i++)
+ {
+ free(lcs.chunks[i]);
+ }
+ for(i = 0; i < CHUNKS_LEN(pcs); i++)
+ {
+ free(pcs.chunks[i]);
+ }
+
+}
+
+struct cdat*
+alloc_cdat()
+{
+ num_cdats++;
+ if(CDAT_FULL())
+ { if(CCS_FULL())
+ { fprintf(stderr, "You have allocated to many (%d) cdats ", num_cdats);
+ exit(EXIT_FAILURE);
+ }
+ else
+ CSP_PUSH(ccs);
+ }
+ else
+ CDAT_ALLOC();
+
+ return CURRENT_CDAT();
+}
+
+//these should probably be inline
+struct odat*
+alloc_odat
+()
+{
+ num_odats++;
+ if(ODAT_FULL())
+ { if(!OCS_FULL())
+ { fprintf(stderr, "You have allocated to many (%d) odats ", num_odats);
+ exit(EXIT_FAILURE);
+ }
+ else
+ CSP_PUSH(ocs);
+ }
+ else
+ ODAT_ALLOC();
+
+ return CURRENT_ODAT();
+}
+
+void
+alloc_vdat
+()
+{ num_vdats++;
+ if(VDAT_FULL())
+ { if(!VCS_FULL())
+ { fprintf(stderr, "You have allocated to many (%d) vdats ", num_vdats);
+ exit(EXIT_FAILURE);
+ }
+ else
+ CSP_PUSH(vcs);
+ }
+ else
+ VDAT_ALLOC();
+}
+
+struct link*
+alloc_link
+()
+{ num_links++;
+ if(LDAT_FULL())
+ { if(!LCS_FULL())
+ { fprintf(stderr, "You have allocated to many (%d) links ", num_links);
+ exit(EXIT_FAILURE);
+ }
+ else
+ CSP_PUSH(lcs);
+ }
+ else
+ LDAT_ALLOC();
+
+ return CURRENT_LINK();
+
+}
+
+struct ref*
+alloc_ref
+()
+{ num_refs++;
+ if(REF_FULL())
+ { if(!RCS_FULL())
+ { fprintf(stderr, "You have allocated to many (%d) refs ", num_refs);
+ exit(EXIT_FAILURE);
+ }
+ else
+ CSP_PUSH(rcs);
+ }
+ else
+ REF_ALLOC();
+
+
+ if(num_refs % 16 == 0)
+ { CURRENT_POST() = CURRENT_REF();
+ inc_posts();
+ }
+
+ return CURRENT_REF();
+}
+
+void
+inc_posts()
+{ num_posts++;
+ if(POST_FULL())
+ { if(!PCS_FULL())
+ { fprintf(stderr, "You have allocated to many (%d) refs ", num_posts);
+ exit(EXIT_FAILURE);
+ }
+ else
+ CSP_PUSH(pcs);
+ }
+ else
+ POST_ALLOC();
+
+}
+
+struct cdat*
+curr_cdat
+()
+{
+ return (*cdat_stackp);
+}
+
+struct odat*
+curr_odat
+()
+{
+ return CURRENT_ODAT();
+}
+struct vdat*
+curr_vdat
+()
+{
+ return CURRENT_VDAT();
+}
+struct set*
+curr_set
+()
+{
+ return &CURRENT_SET();
+}
+struct ref*
+curr_ref
+()
+{
+ return CURRENT_REF();
+}
+struct model*
+curr_model
+()
+{
+ return &CURRENT_MODEL();
+}
--- /dev/null
+/* Asset Package Compiler */
+%code requires{
+ #include <stdint.h>
+}
+%{
+ #include <stdio.h>
+ #include <string.h>
+ #include <dirent.h>
+ #include <png.h>
+ #include <apc/ir.h>
+
+ extern int lexer_init();
+ extern int lexer();
+ #define yylex lexer
+
+
+ void yyerror();
+%}
+%define parse.error verbose
+%define lr.type ielr
+
+%union {
+ uint64_t ref;
+ int val;
+ char *str;
+ void *voidp;
+
+}
+
+ //operators
+%token CLOPEN // (
+%token CLCLOSE // )
+%token SOPEN // {
+%token SCLOSE // }
+%token EOPEN // [
+%token ECLOSE // ]
+%token VOPEN // /
+%token VCLOSE // \
+
+%token QOPEN // !
+%token QCLOSE // @
+%token RT // &
+%token HB // #
+//nonterminal types
+%type <ref> olink
+%type <ref> ele_svlink
+%type <ref> set_svlink
+//terminals
+%token <val> NUM
+%token <str> STR
+%token <val> SS
+%token <str> NAME
+%token <ref> REF
+%token <val> SSD
+%token <voidp> FPTR
+%token <voidp> QPTR
+// Change width, height, num_ptrs to NUM because
+// when scanning, we can't determine which NUM
+// is which.
+%token <val> WIDTH
+%token <val> HEIGHT
+%token <val> NUM_PTRS
+//precedence
+%precedence LP
+%precedence MP
+%precedence HP
+
+ /* Syntax Directed Translation Scheme of the APC grammar */
+
+/* Rules */
+%%
+cdat_buf:
+class_list
+;
+
+class_list:
+class_list class
+| class
+;
+
+class:
+ CLOPEN NAME {push_cdat($2);} class_block CLCLOSE {pop_cdat();};
+;
+
+class_block:
+class_list
+| class_list set_list
+| set_list
+;
+
+set_list:
+set_list set
+| set
+;
+
+root:
+RT NUM NUM NUM {insert_root($2, $3, $4);};
+;
+
+quad_file:
+QOPEN QPTR QCLOSE {insert_quad($2);};
+
+hitbox:
+HB NUM {insert_hitbox($2);}
+;
+
+set_map_data:
+quad_file
+| quad_file hitbox
+| quad_file hitbox root
+| hitbox root
+| hitbox
+| root
+;
+
+set:
+SOPEN set_label set_map_data element_list {alloc_vdat();} vdat SCLOSE {insert_set(); insert_set_vdatid();};
+| SOPEN set_label set_map_data element_list set_vlink SCLOSE {insert_set();};
+| SOPEN set_label set_map_data element_list set_svlink SCLOSE {insert_set_svlink($5); insert_set(); };
+| SOPEN set_label element_list {alloc_vdat();} vdat SCLOSE {insert_set(); insert_set_vdatid();};
+| SOPEN set_label element_list set_vlink SCLOSE {insert_set(); }
+| SOPEN set_label element_list set_svlink SCLOSE {insert_set_svlink($4); insert_set();};
+| SOPEN olink SCLOSE {insert_set_olink($2);};
+;
+
+
+set_label:
+HP NAME REF {insert_set_label($2,$3);};
+| LP NAME {insert_set_label($2, -1);};
+;
+
+set_svlink:
+REF
+
+;
+
+set_vlink:
+REF NAME {insert_set_vlink($1, $2);};
+;
+
+olink:
+REF
+;
+
+//parent_id is the set_index of the subclass_index.
+element_list:
+element_list element MP
+| element LP
+;
+
+ele_label:
+HP NAME REF {insert_ele_label($2, $3);};
+| LP NAME {insert_ele_label($2, -1);};
+;
+
+ele_vlink:
+REF NAME {insert_ele_vlink($1, $2);};
+;
+
+ele_svlink:
+REF
+;
+
+element:
+EOPEN ele_label hitbox root {alloc_vdat();} vdat ECLOSE {insert_ele(); insert_ele_vdatid();};
+| EOPEN ele_label hitbox root ele_vlink ECLOSE {insert_ele(); };
+| EOPEN ele_label hitbox root ele_svlink ECLOSE {insert_ele_svlink($5);insert_ele(); };
+| EOPEN ele_label root {alloc_vdat();} vdat ECLOSE {insert_ele(); insert_ele_vdatid();};
+| EOPEN ele_label root ele_vlink ECLOSE {insert_ele(); };
+| EOPEN ele_label root ele_svlink ECLOSE {insert_ele_svlink($4); insert_ele(); };
+| EOPEN olink ECLOSE {insert_ele_olink($2);};
+;
+
+vdat:
+VOPEN model_list VCLOSE
+;
+
+model_list:
+model_list model
+| model
+ ;
+
+model:
+spritesheet LP
+;
+
+spritesheet:
+spritesheet HP framesheet
+| framesheet
+;
+
+framesheet:
+SSD NAME REF HEIGHT WIDTH NUM_PTRS frame_pointers LP {insert_framesheet($1, $2, $3, $4, $5, $6);};
+;
+
+frame_pointers:
+frame_pointers SSD HP FPTR {insert_frame_pointer($2, $4);};
+| SSD FPTR {insert_frame_pointer($1, $2);};
+;
+
+%%
+
+void
+yyerror (char const *s)
+{ fprintf(stderr, "%s\n", s);
+}
--- /dev/null
+* Project Deadlines
+
+** October
+*** TODO APC
+ :PROPERTIES:
+ :ATTACH_DIR: ~/proj/the_march/src/apc
+ :END:
+**** TODO Scanner :ATTACH:
+ :PROPERTIES:
+ :Attachments: scanner.c
+ :ID: 2dec5876-7b81-4b9c-97fe-03b152fa276a
+ :END:
+**** TODO Lexer :ATTACH:
+ :PROPERTIES:
+ :Attachments: lexer.c lexer_lex.rl
+ :ID: faf3ff67-f8e9-41fe-9a32-2ced4bbf5b99
+ :END:
+**** TODO Parser/IR :ATTACH:
+ :PROPERTIES:
+ :Attachments: parser.y irmem.c ir.c ir.h
+ :ID: fb24c302-4743-4a45-845a-4249d2b1a378
+ :END:
+**** TODO Output
+ DEADLINE: <2016-10-20 Thu>
+*** TODO Test Suite for APC
+ DEADLINE: <2016-10-20 Thu>
+*** TODO Animation Viewer
+ DEADLINE: <2016-10-31 Mon>
+
+** November
+*** TODO Core State Machine
+ DEADLINE: <2016-11-10 Thu>
+*** TODO Renderer
+ DEADLINE: <2016-11-10 Thu>
+*** TODO World Generator - Beta
+ DEADLINE: <2016-11-20 Sun>
+*** TODO Core Improvements
+ DEADLINE: <2016-11-20 Sun>
+*** TODO Front-end Hooks
+ DEADLINE: <2016-11-20 Sun>
+*** TODO World Generator - Stable
+ DEADLINE: <2016-11-30 Wed>
+*** TODO Physics Engine
+ SCHEDULED: <2016-11-30 Wed>
+ DEADLINE: <2016-12-20 Tue>
+*** TODO Actors
+ DEADLINE: <2016-11-30 Wed>
+*** TODO Audio Backend
+ DEADLINE: <2016-11-30 Wed>
+
+** December
+*** TODO Account Management
+ DEADLINE: <2016-12-10 Sat>
+*** TODO User Management
+ DEADLINE: <2016-12-10 Sat>
+*** TODO Controllers - Beta
+ DEADLINE: <2016-12-10 Sat>
+*** TODO Internal Data Handling
+ DEADLINE: <2016-12-10 Sat>
+*** TODO Network Skeleton
+ DEADLINE: <2016-12-10 Sat>
+*** TODO Social Media
+ SCHEDULED: <2016-12-10 Sat>
+*** TODO Core Gameplay
+ SCHEDULED: <2016-12-20 Tue>
+*** TODO Account Management - Stable
+ DEADLINE: <2016-12-20 Tue>
+*** TODO Controllers - Stable
+ DEADLINE: <2016-12-20 Tue>
+
+** Christmas Holiday (December 21 - January 5)
+*** TODO Gameplay Developments
+*** TODO Front-End Improvements (remote)
+*** TODO AI Start
+*** TODO Website Beta
+
+** January
+*** TODO Gameplay - Win Conditions
+ DEADLINE: <2017-01-10 Tue>
+*** TODO Social Media Integration
+ DEADLINE: <2017-01-10 Tue>
+*** TODO Viable AI (Lua ^ JS)
+ DEADLINE: <2017-01-20 Fri>
+
+** February
+*** TODO Beta Deployment
+ DEADLINE: <2017-02-01 Wed>
+*** TODO Multiplay Beta
+ DEADLINE: <2017-02-01 Wed>
+*** TODO Early Access for Marketing
+ DEADLINE: <2017-02-01 Wed>
+
+
+
+
projects / henge / webcc.git / commitdiff