/* Asset Package Compiler */
-%code requires {
+
+%code requires {
#include <unitypes.h>
+ #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 <stdio.h>
#include <string.h>
#include <dirent.h>
#include <unitypes.h>
#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 */
%type<set> set_spec
%type<ld> set_ld set_link
%type<frame_spec> frame_spec
-/* Init */
-%initial-action { class_stack_init(); }
%%
/* Syntax Directed Translation Scheme of the APC grammar */
progn:
;
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:
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:
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); }
projects / henge / apc.git / blobdiff