Author: kjs
Date: Wed Apr 4 12:03:45 2007
New Revision: 17977
Modified:
trunk/compilers/pirc/src/jsonout.c (contents, props changed)
trunk/compilers/pirc/src/jsonout.h (props changed)
trunk/compilers/pirc/src/pastout.c (props changed)
trunk/compilers/pirc/src/pbcout.c
trunk/compilers/pirc/src/pirlexer.c (props changed)
trunk/compilers/pirc/src/pirlexer.h (props changed)
trunk/compilers/pirc/src/pirout.c (contents, props changed)
trunk/compilers/pirc/src/pirout.h (props changed)
trunk/compilers/pirc/src/pirparser.c (contents, props changed)
trunk/compilers/pirc/src/pirparser.h (props changed)
trunk/compilers/pirc/src/pirvtable.c
trunk/compilers/pirc/src/pirvtable.h
Log:
compilers/pirc:
* added more pirc vtable methods
* fixed minor things in grammar; now allow for "foo"() (+ updated docs for that)
* gradually completing emit calls.
Modified: trunk/compilers/pirc/src/jsonout.c
==============================================================================
--- trunk/compilers/pirc/src/jsonout.c (original)
+++ trunk/compilers/pirc/src/jsonout.c Wed Apr 4 12:03:45 2007
@@ -21,6 +21,12 @@
#define dedent(D) D->indent -= INDENT
+typedef struct target {
+ char *name;
+ struct target *next;
+
+} target;
+
/* Private declaration of emit_data.
*
*
@@ -28,9 +34,25 @@
typedef struct emit_data {
FILE *outfile;
int indent;
+ int need_comma;
+ struct target *targets;
} emit_data;
+/* helper methods */
+target *
+new_target(char *name) {
+ target *t = (target *)malloc(sizeof(target));
+ t->name = name;
+ t->next = NULL;
+ return t;
+}
+
+static void
+add_target(emit_data *data, target *t) {
+ t->next = data->targets;
+ data->targets = t;
+}
/* Implementation of methods */
@@ -51,13 +73,13 @@
json_sub_start(emit_data *data, char *source, int pos) {
fprintf(OUT, "%*s\"sub\" : {\n", data->indent, " ");
indent(data);
- fprintf(OUT, "%*s\"source\" : \"%s\",\n", data->indent, " ", source);
- fprintf(OUT, "%*s\"pos\" : %d,\n", data->indent, " ", pos);
+ fprintf(OUT, "%*s{ \"source\" : \"%s\" },\n", data->indent, " ", source);
+ fprintf(OUT, "%*s{ \"pos\" : %d },\n", data->indent, " ", pos);
}
static void
json_name(emit_data *data, char *name) {
- fprintf(OUT, "%*s\"name\" : \"%s\"\n", data->indent, " ", name);
+ fprintf(OUT, "%*s{ \"name\" : \"%s\" }\n", data->indent, " ", name);
}
static void
@@ -74,18 +96,22 @@
static void
json_sub_flag_start(emit_data *data) {
- fprintf(OUT, "%*s\"subflags\" : [\n", data->indent, " ");
+ fprintf(OUT, "%*s{ \"subflags\" : [\n", data->indent, " ");
indent(data);
}
static void
json_sub_flag_end(emit_data *data) {
dedent(data);
- fprintf(OUT, "%*s]\n", data->indent, " ");
+ fprintf(OUT, "%*s] }\n", data->indent, " ");
}
static void
json_sub_flag(emit_data *data, int flag) {
+ if (data->need_comma) {
+ fprintf(OUT, ",");
+ data->need_comma = 0;
+ }
fprintf(OUT, "%*s{ \"subflag\" : \"%s\" }\n", data->indent, " ", "TODO");
}
@@ -93,6 +119,7 @@
json_list_start(emit_data *data) {
fprintf(OUT, "%*s[\n", data->indent, " ");
indent(data);
+ data->need_comma = 0;
}
static void
@@ -131,12 +158,57 @@
data = NULL;
}
-/*
+
static void
-json_next(void) {
- fprintf(OUT, ", ");
+json_method(emit_data *data, char *name) {
+ fprintf(OUT, "%*s\"method\" : \"%s\"\n", data->indent, " ", name);
+}
+
+static void
+json_invocant(emit_data *data, char *invocant) {
+ fprintf(OUT, "%*s\"invocant\" : \"%s\"\n", data->indent, " ", invocant);
+}
+
+static void
+json_args_start(emit_data *data) {
+ fprintf(OUT, "%*s{ \"arguments\" : [", data->indent, " ");
+ indent(data);
+}
+
+static void
+json_args_end(emit_data *data) {
+ /* fprintf(OUT, "%*s] }\n", data->indent, " "); */
+ dedent(data);
+ fprintf(OUT, "]\n");
+
+}
+
+
+static void
+json_target(emit_data *data, char *name) {
+ target *t = new_target(name);
+ add_target(data, t);
+}
+
+
+
+static void
+json_invokable(emit_data *data, char *invokable) {
+ fprintf(OUT, "%*s{ \"invokable\" : \"%s\" }\n", data->indent, " ",
invokable);
+ /* indent(data); */
+}
+
+static void
+json_invocation_start(emit_data *data) {
+ fprintf(OUT, "%*s{ \"invocation\" : {\n", data->indent, " ");
+ indent(data);
+}
+
+static void
+json_invocation_end(emit_data *data) {
+ dedent(data);
+ fprintf(OUT, "%*s}\n", data->indent, " ");
}
-*/
pirvtable *
@@ -144,25 +216,32 @@
pirvtable *vtable = new_pirvtable();
/* set vtable methods to the appropiate implementation */
- vtable->initialize = json_init;
- vtable->destroy = json_destroy;
- vtable->sub_start = json_sub_start;
- vtable->sub_end = json_end;
- vtable->end = json_end;
- vtable->stmts_start = json_stmts_start;
- vtable->stmts_end = json_list_end;
- vtable->name = json_name;
- vtable->sub_flag = json_sub_flag;
- vtable->op_start = json_op_start;
- vtable->op_end = json_op_end;
- vtable->param_start = json_param_start;
- vtable->param_end = json_list_end;
- vtable->sub_flag_start = json_sub_flag_start;
- vtable->sub_flag_end = json_sub_flag_end;
- vtable->list_start = json_list_start;
- vtable->list_end = json_list_end;
- vtable->expression = json_expr;
-
+ vtable->initialize = json_init;
+ vtable->destroy = json_destroy;
+ vtable->sub_start = json_sub_start;
+ vtable->sub_end = json_end;
+ vtable->end = json_end;
+ vtable->stmts_start = json_stmts_start;
+ vtable->stmts_end = json_list_end;
+ vtable->name = json_name;
+ vtable->sub_flag = json_sub_flag;
+ vtable->op_start = json_op_start;
+ vtable->op_end = json_op_end;
+ vtable->param_start = json_param_start;
+ vtable->param_end = json_list_end;
+ vtable->sub_flag_start = json_sub_flag_start;
+ vtable->sub_flag_end = json_sub_flag_end;
+ vtable->list_start = json_list_start;
+ vtable->list_end = json_list_end;
+ vtable->expression = json_expr;
+ vtable->invocant = json_invocant;
+ vtable->method_name = json_method;
+ vtable->args_start = json_args_start;
+ vtable->args_end = json_args_end;
+ vtable->target = json_target;
+ vtable->invokable = json_invokable;
+ vtable->invocation_start = json_invocation_start;
+ vtable->invocation_end = json_invocation_end;
vtable->data = (emit_data *)malloc(sizeof(emit_data));
if (vtable->data == NULL) {
Modified: trunk/compilers/pirc/src/pbcout.c
==============================================================================
--- trunk/compilers/pirc/src/pbcout.c (original)
+++ trunk/compilers/pirc/src/pbcout.c Wed Apr 4 12:03:45 2007
@@ -2,7 +2,12 @@
=head1 NAME
-pbcout.c - Back-end for emitting PBC. Not implemented.
+pbcout.c - Back-end for emitting PBC.
+
+
+XXX Not implemented XXX
+
+IIUC, the PBC format is not yet fixed.
=cut
Modified: trunk/compilers/pirc/src/pirout.c
==============================================================================
--- trunk/compilers/pirc/src/pirout.c (original)
+++ trunk/compilers/pirc/src/pirout.c Wed Apr 4 12:03:45 2007
@@ -1,3 +1,12 @@
+/*
+
+=head1 NAME
+
+pirout.c - Back-end for outputting PIR.
+
+=cut
+
+*/
#include "pirout.h"
#include "pirvtable.h"
#include "pirlexer.h"
@@ -104,6 +113,11 @@
data = NULL;
}
+static void
+pir_begin_return(emit_data *data) {
+ fprintf(OUT, " ");
+}
+
/*
=over 4
Modified: trunk/compilers/pirc/src/pirparser.c
==============================================================================
--- trunk/compilers/pirc/src/pirparser.c (original)
+++ trunk/compilers/pirc/src/pirparser.c Wed Apr 4 12:03:45 2007
@@ -386,8 +386,16 @@
*/
static void
method(parser_state *p) {
- if (p->curtoken == T_IDENTIFIER) next(p);
- else match(p, T_STRING_CONSTANT);
+ switch (p->curtoken) {
+ case T_IDENTIFIER:
+ case T_STRING_CONSTANT:
+ emit_method_name(p, get_current_token(p->lexer));
+ next(p);
+ break;
+ default:
+ syntax_error(p, 1, "method identifier expected");
+ break;
+ }
}
@@ -407,6 +415,7 @@
case T_PASM_PREG: case T_PREG: case T_PASM_IREG: case T_IREG:
case T_PASM_NREG: case T_NREG: case T_PASM_SREG: case T_SREG:
case T_IDENTIFIER:
+ emit_target(p, get_current_token(p->lexer));
next(p);
break;
default:
@@ -428,19 +437,10 @@
type(parser_state *p) {
switch (p->curtoken) {
case T_INT:
- emit_type(p, "int");
- next(p);
- break;
case T_NUM:
- emit_type(p, "num");
- next(p);
- break;
case T_PMC:
- emit_type(p, "pmc");
- next(p);
- break;
case T_STRING:
- emit_type(p, "string");
+ emit_type(p, get_current_token(p->lexer));
next(p);
break;
default:
@@ -560,6 +560,7 @@
*/
static void
arguments(parser_state *p) {
+ emit_args_start(p);
match(p, T_LPAREN);
if (p->curtoken != T_RPAREN) argument_list(p);
match(p, T_RPAREN);
@@ -587,6 +588,7 @@
/* clear heredoc index */
p->heredoc_index = 0;
}
+ emit_args_end(p);
}
@@ -601,9 +603,12 @@
*/
static void
methodcall(parser_state *p) {
+ emit_invocation_start(p);
+ emit_invocant(p, get_current_token(p->lexer));
match(p, T_INVOCANT_IDENT);
method(p);
arguments(p);
+ emit_invocation_end(p);
}
@@ -718,32 +723,47 @@
case T_INVOCANT_IDENT: /* method call */
methodcall(p);
break;
- case T_STRING_CONSTANT: /* "foo"() */
+ case T_STRING_CONSTANT: { /* "foo"() */
+ char *invokable = clone_string(get_current_token(p->lexer));
+ emit_invocation_start(p);
+ emit_invokable(p, invokable);
next(p);
arguments(p);
+ emit_invocation_end(p);
break;
+ }
case T_IDENTIFIER:
case T_PREG:
- case T_PASM_PREG:
+ case T_PASM_PREG: {
+ char *obj = clone_string(get_current_token(p->lexer)); /* save it
for now */
next(p);
switch (p->curtoken) {
case T_LPAREN: /* function call; foo() */
+ emit_invocation_start(p);
+ emit_invokable(p, obj);
arguments(p);
+ emit_invocation_end(p);
break;
case T_PTR: /* method call; foo '->' method arguments */
+ emit_invocation_start(p);
+ emit_invocant(p, obj);
next(p);
method(p);
arguments(p);
+ emit_invocation_end(p);
break;
case T_LBRACKET: /* target '=' target '[' expression ']' */
+ emit_target(p, obj);
keylist(p);
break;
default: /* expression with a PMC target/id as first operand */
+ emit_expr(p, obj);
arith_expression(p);
break;
}
break;
+ }
case T_GLOBAL: /* x = global string_value */
next(p);
string_value(p);
@@ -1096,37 +1116,38 @@
*/
static void
const_definition(parser_state *p) {
- switch (p->curtoken) {
+ token type = p->curtoken; /* save type for check later */
+ switch (type) {
case T_INT:
- emit_type(p, "int");
+ case T_NUM:
+ case T_STRING:
+ case T_PMC:
+ emit_type(p, get_current_token(p->lexer));
next(p);
- match(p, T_IDENTIFIER);
- match(p, T_ASSIGN);
+ break;
+ default:
+ syntax_error(p, 1, "type expected");
+ break;
+ }
+
+ match(p, T_IDENTIFIER);
+ match(p, T_ASSIGN);
+
+ /* parse a literal of the type according to the parsed type keyword */
+ emit_expr(p, get_current_token(p->lexer)); /* emit the literal */
+ switch (type) {
+ case T_INT:
match(p, T_INTEGER_CONSTANT);
break;
case T_NUM:
- emit_type(p, "num");
- next(p);
- match(p, T_IDENTIFIER);
- match(p, T_ASSIGN);
match(p, T_NUMBER_CONSTANT);
break;
- case T_STRING:
- emit_type(p, "string");
- next(p);
- match(p, T_IDENTIFIER);
- match(p, T_ASSIGN);
- match(p, T_STRING_CONSTANT);
- break;
- case T_PMC: /* both string and PMC have strings as constants */
- emit_type(p, "pmc");
- next(p);
- match(p, T_IDENTIFIER);
- match(p, T_ASSIGN);
+ case T_STRING: /* both string and PMC have strings as constants */
+ case T_PMC:
match(p, T_STRING_CONSTANT);
break;
default:
- syntax_error(p, 1, "type expected");
+ syntax_error(p, 2, find_keyword(type), "expected");
break;
}
}
@@ -1232,16 +1253,22 @@
long_invocation(parser_state *p) {
int more_results = 1; /* flag for while loop */
+ emit_invocation_start(p);
+
match(p, T_PCC_BEGIN); /* '.pcc_begin '\n' ... */
match(p, T_NEWLINE);
+ /* arguments */
+ emit_args_start(p);
while (p->curtoken == T_ARG) { /* ... { '.arg' expr [flag] '\n' } ... */
next(p);
expression(p);
arg_flags(p);
match(p, T_NEWLINE);
}
+ emit_args_end(p);
+ /* the invocant and/or sub to be called */
switch (p->curtoken) {
case T_PCC_CALL: /* ... '.pcc_call' target '\n' ... */
case T_NCI_CALL: /* ... '.nci_call' target '\n' ... */
@@ -1262,7 +1289,9 @@
break;
}
-
+ /* results */
+ /*emit_results_start(p);
+ */
while (more_results) {
switch (p->curtoken) {
case T_LOCAL:
@@ -1274,7 +1303,7 @@
param_flags(p);
match(p, T_NEWLINE);
break;
- case T_PCC_END:
+ case T_PCC_END: /* we encountered '.pcc_end', so stop looking for
more results */
more_results = 0; /* no more results, break loop */
break;
default:
@@ -1285,9 +1314,12 @@
break;
}
}
-
+ /*emit_results_end(p);
+ */
match(p, T_PCC_END); /* '.pcc_end' '\n' */
match(p, T_NEWLINE);
+
+ emit_invocation_end(p);
}
@@ -1315,6 +1347,7 @@
}
match(p, T_PCC_END_RETURN); /* ... '.pcc_end_return' '\n' */
match(p, T_NEWLINE);
+ emit_op_end(p);
}
/*
@@ -1368,6 +1401,7 @@
switch (p->curtoken) {
case T_ASSIGN: /* target '=' expression */
+
assignment(p);
break;
case T_PLUS_ASSIGN: /* target '+=' simple_expr '\n' (and '-=' etc.) */
@@ -1434,13 +1468,16 @@
=item *
- multi-result-invocation -> target_list '=' (subcall | methodcall)
+ multi-result-invocation -> target_list '=' (invokable arguments |
methodcall)) '\n'
+
+ invokable -> IDENTIFIER | PREG | STRINGC
=cut
*/
static void
multi_result_invocation(parser_state *p) {
+ emit_invocation_start(p);
target_list(p);
match(p, T_ASSIGN);
@@ -1448,18 +1485,22 @@
case T_IDENTIFIER: /* target_list '=' subcall */
case T_PASM_PREG:
case T_PREG:
+ case T_STRING_CONSTANT: {
+ char *invokable = clone_string(get_current_token(p->lexer));
+ emit_invokable(p, invokable);
next(p);
arguments(p);
- match(p, T_NEWLINE);
break;
+ }
case T_INVOCANT_IDENT: /* target_list '=' methodcall */
methodcall(p);
- match(p, T_NEWLINE);
break;
default:
syntax_error(p, 1, "sub or method invocation expected");
break;
}
+ match(p, T_NEWLINE);
+ emit_invocation_end(p);
}
/*
@@ -1571,6 +1612,7 @@
| yield_statement
| macro_expansion
| target_statement
+ | STRINGC arguments
| methodcall
| long_invocation
| long_return_statement
@@ -1647,6 +1689,15 @@
case T_PASM_SREG: case T_SREG: case T_PASM_IREG: case T_IREG:
target_statement(p);
break;
+ case T_STRING_CONSTANT: {
+ char *invokable = clone_string(get_current_token(p->lexer));
+ emit_invocation_start(p);
+ emit_invokable(p, invokable);
+ next(p);
+ arguments(p);
+ emit_invocation_end(p);
+ break;
+ }
case T_INVOCANT_IDENT: /* dot attached to identifier, like 'id.'
*/
methodcall(p);
match(p, T_NEWLINE);
@@ -1862,8 +1913,7 @@
case T_PMC:
case T_STRING:
emit_type(p, get_current_token(p->lexer));
- /* type(p); -- we know what it is; just skip it! */
- next(p);
+ next(p); /*we know what it is; just skip it! */
emit_name(p, get_current_token(p->lexer));
match(p, T_IDENTIFIER);
param_flags(p);
Modified: trunk/compilers/pirc/src/pirvtable.c
==============================================================================
--- trunk/compilers/pirc/src/pirvtable.c (original)
+++ trunk/compilers/pirc/src/pirvtable.c Wed Apr 4 12:03:45 2007
@@ -69,26 +69,34 @@
/* set all entries to 'default' by default. This way, another output module
* only needs to override the entries that are interesting for that module.
*/
- vtable->initialize = not_implemented;
- vtable->destroy = not_implemented; /* destructor; highly
recommended to implement! */
- vtable->name = not_implemented;
- vtable->sub_start = not_implemented;
- vtable->sub_end = not_implemented;
- vtable->stmts_start = not_implemented;
- vtable->stmts_end = not_implemented;
- vtable->end = not_implemented;
- vtable->param_start = not_implemented;
- vtable->param_end = not_implemented;
- vtable->type = not_implemented;
- vtable->sub_flag = not_implemented;
- vtable->expression = not_implemented;
- vtable->next_expr = not_implemented;
- vtable->op_start = not_implemented;
- vtable->op_end = not_implemented;
- vtable->list_start = not_implemented;
- vtable->list_end = not_implemented;
- vtable->sub_flag_start = not_implemented;
- vtable->sub_flag_end = not_implemented;
+ vtable->initialize = not_implemented;
+ vtable->destroy = not_implemented; /* destructor; highly
recommended to implement! */
+ vtable->name = not_implemented;
+ vtable->sub_start = not_implemented;
+ vtable->sub_end = not_implemented;
+ vtable->stmts_start = not_implemented;
+ vtable->stmts_end = not_implemented;
+ vtable->end = not_implemented;
+ vtable->param_start = not_implemented;
+ vtable->param_end = not_implemented;
+ vtable->type = not_implemented;
+ vtable->sub_flag = not_implemented;
+ vtable->expression = not_implemented;
+ vtable->next_expr = not_implemented;
+ vtable->op_start = not_implemented;
+ vtable->op_end = not_implemented;
+ vtable->list_start = not_implemented;
+ vtable->list_end = not_implemented;
+ vtable->sub_flag_start = not_implemented;
+ vtable->sub_flag_end = not_implemented;
+ vtable->method_name = not_implemented;
+ vtable->invocant = not_implemented;
+ vtable->args_start = not_implemented;
+ vtable->args_end = not_implemented;
+ vtable->target = not_implemented;
+ vtable->invokable = not_implemented;
+ vtable->invocation_start = not_implemented;
+ vtable->invocation_end = not_implemented;
/* set data to NULL, it's initialized in the backend module */
vtable->data = NULL;
Modified: trunk/compilers/pirc/src/pirvtable.h
==============================================================================
--- trunk/compilers/pirc/src/pirvtable.h (original)
+++ trunk/compilers/pirc/src/pirvtable.h Wed Apr 4 12:03:45 2007
@@ -10,52 +10,68 @@
* 'emit_data' structure is left to each back-end separately.
*/
typedef struct pirvtable {
- struct emit_data *data;
- void (* initialize) (struct emit_data *);
- void (* destroy) (struct emit_data *);
- void (* sub_start) (struct emit_data *, char *source, int pos);
- void (* sub_end) (struct emit_data *);
- void (* name) (struct emit_data *, char *name);
- void (* stmts_start) (struct emit_data *);
- void (* stmts_end) (struct emit_data *);
- void (* end) (struct emit_data *);
- void (* param_start) (struct emit_data *);
- void (* param_end) (struct emit_data *);
- void (* type) (struct emit_data *, char *type);
- void (* sub_flag) (struct emit_data *, int flag);
- void (* op_start) (struct emit_data *, char *op);
- void (* op_end) (struct emit_data *);
- void (* expression) (struct emit_data *, char *expr);
- void (* next_expr) (struct emit_data *);
- void (* list_start) (struct emit_data *);
- void (* list_end) (struct emit_data *);
- void (* sub_flag_start) (struct emit_data *);
- void (* sub_flag_end) (struct emit_data *);
+ struct emit_data *data;
+ void (* initialize) (struct emit_data *data);
+ void (* destroy) (struct emit_data *data);
+ void (* sub_start) (struct emit_data *data, char *source, int pos);
+ void (* sub_end) (struct emit_data *data);
+ void (* name) (struct emit_data *data, char *name);
+ void (* stmts_start) (struct emit_data *data);
+ void (* stmts_end) (struct emit_data *data);
+ void (* end) (struct emit_data *data);
+ void (* param_start) (struct emit_data *data);
+ void (* param_end) (struct emit_data *data);
+ void (* type) (struct emit_data *data, char *type);
+ void (* sub_flag) (struct emit_data *data, int flag);
+ void (* op_start) (struct emit_data *data, char *op);
+ void (* op_end) (struct emit_data *data);
+ void (* expression) (struct emit_data *data, char *expr);
+ void (* next_expr) (struct emit_data *data);
+ void (* list_start) (struct emit_data *data);
+ void (* list_end) (struct emit_data *data);
+ void (* sub_flag_start) (struct emit_data *data);
+ void (* sub_flag_end) (struct emit_data *data);
+ void (* method_name) (struct emit_data *data, char *name);
+ void (* invocant) (struct emit_data *data, char *invocant);
+ void (* args_start) (struct emit_data *data);
+ void (* args_end) (struct emit_data *data);
+ void (* target) (struct emit_data *data, char *target);
+ void (* invokable) (struct emit_data *data, char *invokable);
+ void (* invocation_start)(struct emit_data *data);
+ void (* invocation_end) (struct emit_data *data);
} pirvtable;
/* #defines for cleaner invocation syntax */
-# define emit_init(P) (*P->vtable->initialize)
(P->vtable->data)
-# define emit_destroy(P) (*P->vtable->destroy)
(P->vtable->data)
-# define emit_sub_start(P,S,L) (*P->vtable->sub_start)
(P->vtable->data, S,L)
-# define emit_sub_end(P) (*P->vtable->sub_end)
(P->vtable->data)
-# define emit_name(P,N) (*P->vtable->name)
(P->vtable->data, N)
-# define emit_stmts_start(P) (*P->vtable->stmts_start)
(P->vtable->data)
-# define emit_stmts_end(P) (*P->vtable->stmts_end)
(P->vtable->data)
-# define emit_end(P) (*P->vtable->end)
(P->vtable->data)
-# define emit_param_start(P) (*P->vtable->param_start)
(P->vtable->data)
-# define emit_param_end(P) (*P->vtable->param_end)
(P->vtable->data)
-# define emit_type(P,T) (*P->vtable->type)
(P->vtable->data, T)
-# define emit_sub_flag(P,F) (*p->vtable->sub_flag)
(P->vtable->data, F)
-# define emit_sub_flag_start(P)
(*P->vtable->sub_flag_start)(P->vtable->data)
-# define emit_sub_flag_end(P) (*P->vtable->sub_flag_end)
(P->vtable->data)
-# define emit_op_start(P,O) (*P->vtable->op_start)
(P->vtable->data, O)
-# define emit_op_end(P) (*P->vtable->op_end)
(P->vtable->data)
-# define emit_expr(P,E) (*P->vtable->expression)
(P->vtable->data, E)
-# define emit_next_expr(P) (*P->vtable->next_expr)
(P->vtable->data)
-# define emit_list_start(P) (*P->vtable->list_start)
(P->vtable->data)
-# define emit_list_end(P) (*P->vtable->list_end)
(P->vtable->data)
+# define emit_init(P) (*P->vtable->initialize)
(P->vtable->data)
+# define emit_destroy(P) (*P->vtable->destroy)
(P->vtable->data)
+# define emit_sub_start(P,S,L) (*P->vtable->sub_start)
(P->vtable->data, S,L)
+# define emit_sub_end(P) (*P->vtable->sub_end)
(P->vtable->data)
+# define emit_name(P,N) (*P->vtable->name)
(P->vtable->data, N)
+# define emit_stmts_start(P) (*P->vtable->stmts_start)
(P->vtable->data)
+# define emit_stmts_end(P) (*P->vtable->stmts_end)
(P->vtable->data)
+# define emit_end(P) (*P->vtable->end)
(P->vtable->data)
+# define emit_param_start(P) (*P->vtable->param_start)
(P->vtable->data)
+# define emit_param_end(P) (*P->vtable->param_end)
(P->vtable->data)
+# define emit_type(P,T) (*P->vtable->type)
(P->vtable->data, T)
+# define emit_sub_flag(P,F) (*p->vtable->sub_flag)
(P->vtable->data, F)
+# define emit_sub_flag_start(P) (*P->vtable->sub_flag_start)
(P->vtable->data)
+# define emit_sub_flag_end(P) (*P->vtable->sub_flag_end)
(P->vtable->data)
+# define emit_op_start(P,O) (*P->vtable->op_start)
(P->vtable->data, O)
+# define emit_op_end(P) (*P->vtable->op_end)
(P->vtable->data)
+# define emit_expr(P,E) (*P->vtable->expression)
(P->vtable->data, E)
+# define emit_next_expr(P) (*P->vtable->next_expr)
(P->vtable->data)
+# define emit_list_start(P) (*P->vtable->list_start)
(P->vtable->data)
+# define emit_list_end(P) (*P->vtable->list_end)
(P->vtable->data)
+# define emit_method_name(P,N) (*P->vtable->method_name)
(P->vtable->data, N)
+# define emit_invocant(P,N) (*P->vtable->invocant)
(P->vtable->data, N)
+# define emit_args_start(P) (*P->vtable->args_start)
(P->vtable->data)
+# define emit_args_end(P) (*P->vtable->args_end)
(P->vtable->data)
+# define emit_target(P,T) (*P->vtable->target)
(P->vtable->data, T)
+# define emit_invokable(P,S) (*P->vtable->invokable)
(P->vtable->data, S)
+# define emit_invocation_start(P) (*P->vtable->invocation_start)
(P->vtable->data)
+# define emit_invocation_end(P) (*P->vtable->invocation_end)
(P->vtable->data)
extern pirvtable *new_pirvtable(void);
