X-Git-Url: https://www.kengrimes.com/gitweb/?p=henge%2Fapc.git;a=blobdiff_plain;f=src%2Fparser.y;h=e1fe89651eb15c4f9f1878f5f5351b602ffe4e86;hp=c1f15f40289f1f37533f51316dd2be40bc143f39;hb=fc6b15eee27f77e01ed4a24bc11e7bfa5a812342;hpb=0dc97f87cbbe47ef84501678f302404d042428b1 diff --git a/src/parser.y b/src/parser.y index c1f15f4..e1fe896 100644 --- a/src/parser.y +++ b/src/parser.y @@ -1,44 +1,53 @@ /* Asset Package Compiler */ -%code requires { + +%code requires { #include + #include "ir.h" + #include "apc.h" + typedef struct class_state_t yycstate; + struct frame_spec_t { apc_facing d; int w, h; }; } - -%{ +%code provides { + yycstate* yycstate_new(void); + void yycstate_delete(yycstate*); +} +%code { #include #include #include #include #include "ir.h" - - struct frame_spec_t { enum facing d; int w, h; }; + + struct class_state_t { + ir_class *csp; + ir_class class_stack[]; + }; extern long sys_pagesize; extern int lexer(); - static void yyerror(char const*); + static void yyerror(yycstate*, char const*); + static inline ir_class yyclass_push(yycstate*, ir_class); + static inline ir_class yyclass_pop(yycstate*); /* Stack-based class handler */ - static ir_class *class_stack, *csp; - static size_t class_stack_size; - static ir_class class_stack_init(void); - #define class_stack_pop() (*--csp) - static ir_class class_stack_push(ir_class); - - #define yylex lexer - #define yyclass (*csp) - #define yyclassld (ir_classld_from_class(yyclass)) -%} + #define yyclass(CS) (*(CS->csp)) + #define yyclassld(CS) (ir_classld_from_class(yyclass(CS))) + #define DEFAULT_VARIANT "default" +} %define parse.error verbose +%define parse.lac full %define lr.type ielr %define api.pure full %define api.push-pull push +%parse-param {yycstate* cs} %union { - long long ref; - int val; - enum facing face; - uint8_t* str; - ir_class class; - ir_set set; - ir_setld ld; - ir_setdata data; + uint32_t ref; + int val; + apc_facing face; + uint8_t* str; + ir_class class; + ir_set set; + ir_setld ld; + ir_setdata data; struct frame_spec_t frame_spec; } /* Operators */ @@ -59,8 +68,6 @@ %type set_spec %type set_ld set_link %type frame_spec -/* Init */ -%initial-action { class_stack_init(); } %% /* Syntax Directed Translation Scheme of the APC grammar */ progn: @@ -75,9 +82,10 @@ class_list: ; class: - NAME CLOPEN { class_stack_push(ir_class_addchild(yyclass, $1)); } + NAME CLOPEN { yyclass_push(cs,ir_class_addchild(yyclass(cs), $1)); } progn - CLCLOSE { class_stack_pop(); } + CLCLOSE { yyclass_pop(cs); } +| CLCLOSE { yyclass_pop(cs); } ; statement_list: @@ -93,25 +101,27 @@ statement: data_spec: SS NAME frame_spec { $$ = ir_framesheet($2,$3.d,$3.w,$3.h); } +| SS frame_spec { $$ = ir_framesheet(DEFAULT_VARIANT,$2.d,$2.w,$2.h); } | MAP NAME frame_spec { $$ = ir_mapsheet($2,$3.d,$3.w,$3.h); } +| MAP frame_spec { $$ = ir_mapsheet(DEFAULT_VARIANT,$2.d,$2.w,$2.h); } | AUDIO NAME { $$ = ir_audio($2); } -| LINK set_ld { $$ = ir_link_odat($2); } -| LINK set_ld MAP { $$ = ir_link_mdat($2,NULL); } -| LINK set_ld MAP NAME { $$ = ir_link_mdat($2,$4); } -| LINK set_ld SS { $$ = ir_link_vdat($2,NULL); } -| LINK set_ld SS NAME { $$ = ir_link_vdat($2,$4); } -| LINK set_ld AUDIO { $$ = ir_link_adat($2,NULL); } -| LINK set_ld AUDIO NAME { $$ = ir_link_adat($2,$4); } +| LINK set_ld { $$ = ir_link(OLINK, $2, NULL); } +| LINK set_ld MAP { $$ = ir_link(MLINK, $2,NULL); } +| LINK set_ld MAP NAME { $$ = ir_link(MLINK, $2,$4); } +| LINK set_ld SS { $$ = ir_link(VLINK, $2,NULL); } +| LINK set_ld SS NAME { $$ = ir_link(VLINK, $2,$4); } +| LINK set_ld AUDIO { $$ = ir_link(ALINK, $2,NULL); } +| LINK set_ld AUDIO NAME { $$ = ir_link(ALINK, $2,$4); } ; set_spec: - set_spec NAME { $$ = ir_set_addchild($1,$2); } -| NAME { $$ = ir_class_addset(yyclass,$1); } + set_spec NAME { $$ = ir_set_addchild($1,$2); } +| NAME { $$ = ir_class_addset(yyclass(cs),$1); } ; set_link: set_link NAME { $$ = ir_setld_addchild($1,$2); } -| NAME { $$ = ir_setld_from_classld(yyclassld,$1) } +| NAME { $$ = ir_setld_from_classld(yyclassld(cs),$1); } ; set_ld: @@ -123,59 +133,51 @@ frame_spec: NUM NUM { $$ = (struct frame_spec_t) {SFACE,$1,$2}; } | FACING { $$ = (struct frame_spec_t) {$1,0,0}; } | FACING NUM NUM { $$ = (struct frame_spec_t) {$1,$2,$3}; } +| %empty { $$ = (struct frame_spec_t) {SFACE,0,0}; } ; %% -#define ERR_ALLOC "memory allocation error\n" - -/* print to stderr */ static void yyerror -( char const *s ) -{ fprintf(stderr, "%s\n", s); } - -/* Initialize the class stack - If the class_stack hasn't been allocated yet, allocates a page for pointers - to be stored in. Initializes class stack pointer, and inserts the root class - from IR - Returns the root class given by IR. -*/ -static -ir_class class_stack_init +( yycstate* cs, + char const *s +) +{ ir_class* iter; + fprintf(stderr, "[class->"); + for (iter = cs->class_stack; iter < cs->csp; iter++) + fprintf(stderr, "%s/", ir_class_name(*iter)); + fprintf(stderr, "]\n\t"); + fprintf(stderr, "%s\n", s); +} + +yycstate* yycstate_new ( void ) -{ if (class_stack == NULL) - { class_stack_size = (size_t) sys_pagesize; - class_stack = (ir_class*) malloc(class_stack_size); - if (class_stack == NULL) - { yyerror(ERR_MEM); - exit(1); - } +{ yycstate* class_state; + class_state = (yycstate*) malloc((size_t) sys_pagesize); + if(class_state == NULL) + { yyerror(class_state, "Memory allocation error."); + return NULL; } - csp = class_stack; - return class_stack_push(ir_class_root()); + class_state->csp = class_state->class_stack; + *(class_state->csp) = ir_class_root(); + return class_state; } -/* Add a Class to the Stack - Allocated in page-sized chunks, potentially infinite depth is supported. - Returns the input class. -*/ -static -ir_class class_stack_push -#define class_size (sizeof(*class_stack)) -( ir_class class ) -{ size_t class_stack_len = csp - class_stack; - ir_class* new_class_stack; - if ((class_stack_len * class_size + class_size) > class_stack_size) - { class_stack_size += (size_t) sys_pagesize; - new_class_stack = (ir_class*) realloc(class_stack, class_stack_size); - if (new_class_stack == NULL) - { free(class_stack); //realloc failure does not free class_stack - yyerror("realloc " ERR_MEM); - exit(1); - } - class_stack = new_class_stack; - csp = class_stack + class_stack_len; - } - return (*csp++ = class); +static inline +ir_class yyclass_pop +( yycstate* cs ) +{ cs->csp--; + return *(cs->csp + 1); } + +static inline +ir_class yyclass_push +( yycstate* cs, + ir_class class +) +{ return *++(cs->csp) = class; } + +void yycstate_delete +( yycstate* class_state ) +{ free(class_state); }