/* Asset Package Compiler */
-%code requires {
+%code requires {
#include <unitypes.h>
+ #include "ir.h"
typedef struct class_state_t yycstate;
-
+ struct frame_spec_t { ir_facing d; int w, h; };
+}
+%code provides {
yycstate* yycstate_new(void);
- void yycstate_delete(yycstate*);
+ void yycstate_delete(yycstate*);
}
-
-%{
+%code {
#include <stdio.h>
#include <string.h>
#include <dirent.h>
struct class_state_t {
ir_class *csp;
- size_t class_stack_size;
- ir_class *class_stack;
-
+ ir_class class_stack[];
};
- struct frame_spec_t { enum facing d; int w, h; };
-
extern long sys_pagesize;
extern int lexer();
static void yyerror(char const*);
/* Stack-based class handler */
- 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 CLASS_POP(CS) (*--(CS-csp))
+ #define CLASS_PUSH(CS,CL) (*(CS->csp)++ = CL)
+ #define yyclass(CS) (*(CS->csp))
+ #define yyclassld(CS) (ir_classld_from_class(yyclass(CS)))
+}
%define parse.error verbose
%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;
+ long long ref;
+ int val;
+ ir_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 { CLASS_PUSH(cs,ir_class_addchild(yyclass, $1)); }
progn
- CLCLOSE { class_stack_pop(); }
+ CLCLOSE { CLASS_POP(cs); }
;
statement_list:
%%
-#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
-( 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);
- }
- }
- csp = class_stack;
- return class_stack_push(ir_class_root());
-}
-
-/* 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);
-}
-
-yycstate*
-yycstate_new
+yycstate* yycstate_new
( void )
{ yycstate* class_state;
-
class_state = (yycstate*) malloc((size_t) sys_pagesize);
-
if(class_state == NULL)
{ yyerror(ERR_MEM);
exit(1);
}
-
- class_state.class_stack = class_stack;
- class_state.csp = class_state.class_stack;
- class_state.class_stack_size = (size_t) sys_pagesize;
- class_stack_push(ir_class_root());
-
+ class_state->csp = &class_state->class_stack[0];
+ CLASS_PUSH(class_state, ir_class_root());
return class_state;
-
}
-void
-yycstate_delete
+void yycstate_delete
( yycstate* class_state )
-{
- free(class_state);
-
-}
+{ free(class_state); }