[llvm-commits] CVS: llvm/test/Programs/MultiSource/Applications/d/CHANGES COPYRIGHT Makefile README UPGRADING arg.c arg.h d.h dparse.h dparse_tables.h dsymtab.h faq.html gram.c gram.h gramgram.h grammar.g.c index.html lex.c lex.h lr.c lr.h make_dparser.1 make_dparser.c make_dparser.cat manual.html parse.c parse.h parser_tests sample.g.d_parser.h scan.c scan.h symtab.c util.c util.h version.c write_ctables.c write_ctables.h
John Criswell
criswell at cs.uiuc.edu
Thu Jan 1 10:51:02 PST 2004
Changes in directory llvm/test/Programs/MultiSource/Applications/d:
CHANGES added (r1.1)
COPYRIGHT added (r1.1)
Makefile added (r1.1)
README added (r1.1)
UPGRADING added (r1.1)
arg.c added (r1.1)
arg.h added (r1.1)
d.h added (r1.1)
dparse.h added (r1.1)
dparse_tables.h added (r1.1)
dsymtab.h added (r1.1)
faq.html added (r1.1)
gram.c added (r1.1)
gram.h added (r1.1)
gramgram.h added (r1.1)
grammar.g.c added (r1.1)
index.html added (r1.1)
lex.c added (r1.1)
lex.h added (r1.1)
lr.c added (r1.1)
lr.h added (r1.1)
make_dparser.1 added (r1.1)
make_dparser.c added (r1.1)
make_dparser.cat added (r1.1)
manual.html added (r1.1)
parse.c added (r1.1)
parse.h added (r1.1)
parser_tests added (r1.1)
sample.g.d_parser.h added (r1.1)
scan.c added (r1.1)
scan.h added (r1.1)
symtab.c added (r1.1)
util.c added (r1.1)
util.h added (r1.1)
version.c added (r1.1)
write_ctables.c added (r1.1)
write_ctables.h added (r1.1)
---
Log message:
Adding the D Parser Generator to the test suite.
On Linux, LLVM has historically compiled this program with ease.
So, if this program doesn't work, something either very simple or very
obscure is wrong.
---
Diffs of the changes: (+14738 -0)
Index: llvm/test/Programs/MultiSource/Applications/d/CHANGES
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/CHANGES:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/CHANGES Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,54 ----
+ 1.6 Fixed missing test files
+ Fixed ${declare subparser XXX}
+ Fixed bug with multiple passes
+ Split states based on symboltable and globals
+ Added print_scope
+
+ 1.5 Fixed web pages
+ Fixed DEBUG compilation error
+ Fixed ${scan XXX} example (g4.test.g)
+ Fixed strings/chars in ANSI-C grammar
+ Fixed OSX/Darwin compilation
+ Fixed ws_before/ws_after
+ Added support for \xNN \d00 escape sequences
+ Added support for /i (ignore case) strings/regexes
+ Added support for starting in arbitrary states
+
+ 1.4 Added embedded actions
+ Added default actions
+ Added support for multi-pass compilation
+ Added support for mixed all/longest scanners
+ Enhanced python interface
+
+ 1.3 Made GC version end in _gc
+ Fixed symtab, changed interface and added test cases
+ Fixed other bugs
+ Added verilog grammar
+ Added python grammar
+ Added support for regular expression 'productions'
+
+ 1.2 Fixed a bug in cmp_reduction_priorities that could result in crashes
+ Fixed a bug which could result in ambiguity on final result
+ (thanx Thomas)
+ Fixed a bug in fixup of internal reductions which could result
+ in incorrectly ordered actions (thanx Tomas)
+ Fixed a bug in stack comparison pruning which could result in
+ incorrectly ruling out legal parses
+ Added python support (thanx to Brian Sabbey)
+ Added non-longest-match-only scanning
+
+ 1.1 Fixed bug in fixing up internal productions
+ Made the default using left recursion for EBNF internal productions
+
+ 1.0 Added full unambiguous ANSI C grammar
+ Added tokenizers (scanners shared over sets of states)
+ Added support for subparsers
+ Cleanup of header files
+ Fixed bugs in error recovery
+
+ 1.0b2 Improved memory utilization
+ Fixed bug with right epsilon grammars
+ Added simple error recovery
+ General bug fixes
+
+ 1.0b1 First release
Index: llvm/test/Programs/MultiSource/Applications/d/COPYRIGHT
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/COPYRIGHT:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/COPYRIGHT Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,9 ----
+ Copyright (c) 1994-2003 John Bradley Plevyak, All Rights Reserved
+
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Index: llvm/test/Programs/MultiSource/Applications/d/Makefile
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/Makefile:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/Makefile Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,6 ----
+ LEVEL = ../../../../..
+ PROG = make_dparser
+ Sources=make_dparser.c write_ctables.c gram.c lex.c lr.c arg.c parse.c scan.c symtab.c util.c
+ CPPFLAGS = -DD_BUILD_VERSION=5725
+ RUN_OPTIONS="-v $(BUILD_SRC_DIR)/grammar.g"
+ include ../../Makefile.multisrc
Index: llvm/test/Programs/MultiSource/Applications/d/README
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/README:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/README Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,20 ----
+ This is the D scannerless GLR parser. It uses to Tomita algorithm,
+ and incorporates BNF production syntax, regular expression terminals,
+ and a state-specific symbol table.
+
+ It can be compiled to work with or without the Boehm Garbage Collector.
+ To compile with GC, uncomment the line D_USE_GC=1 in the Makefile.
+
+ The result is natural grammars and powerful parsing.
+
+ To build: 'gmake' (only available with source code package)
+
+ To test: 'gmake test' (only available with source code package)
+
+ To install, 'gmake install' (binary or source code packages)
+
+ For python support, '(cd python; gmake install)'
+
+ Refer to the manual for more information.
+
+ See the UPGRADING for information on upgrading from previous version.
Index: llvm/test/Programs/MultiSource/Applications/d/UPGRADING
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/UPGRADING:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/UPGRADING Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,10 ----
+
+ from 1.1 to 1.2
+
+ - new_D_Parser now requires sizeof_D_ParseNode_User as an
+ argument because setting this value incorrectly can result in
+ subtle and confusing bugs.
+
+ - the parser now defaults to NOT doing longest match
+ disambiguation during scanning. If you want this behavior
+ either specify -l to make_dparser or use ${declare longest_match ... }.
Index: llvm/test/Programs/MultiSource/Applications/d/arg.c
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/arg.c:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/arg.c Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,201 ----
+ /*
+ Copyright 1994-2003 John Plevyak, All Rights Reserved
+ */
+ #include "d.h"
+
+ static char *SPACES = " ";
+ static char *arg_types_keys = (char *)"ISDfF+TL";
+ static char *arg_types_desc[] = {
+ (char *)"int ",
+ (char *)"string ",
+ (char *)"double ",
+ (char *)"set off ",
+ (char *)"set on ",
+ (char *)"incr ",
+ (char *)"toggle ",
+ (char *)"int64 ",
+ (char *)" "
+ };
+
+ void
+ process_arg(ArgumentState *arg_state, int i, char ***argv) {
+ char * arg = NULL;
+ ArgumentDescription *desc = arg_state->desc;
+ if (desc[i].type) {
+ char type = desc[i].type[0];
+ if (type=='F'||type=='f')
+ *(int *)desc[i].location = type=='F'?1:0;
+ else if (type=='T')
+ *(int *)desc[i].location = !*(int *)desc[i].location;
+ else if (type == '+')
+ (*(int *)desc[i].location)++;
+ else {
+ arg = *++(**argv) ? **argv : *++(*argv);
+ if (!arg) usage(arg_state, NULL);
+ switch (type) {
+ case 'I':
+ *(int *)desc[i].location = atoi(arg);
+ break;
+ case 'D':
+ *(double *)desc[i].location = atof(arg);
+ break;
+ case 'L':
+ *(int64 *)desc[i].location = atoll(arg);
+ break;
+ case 'S': strncpy((char *)desc[i].location,arg, atoi(desc[i].type+1));
+ break;
+ default:
+ fprintf(stderr, "%s:bad argument description\n",
+ arg_state->program_name);
+ exit(1);
+ break;
+ }
+ **argv += strlen(**argv)-1;
+ }
+ }
+ if (desc[i].pfn)
+ desc[i].pfn(arg_state, arg);
+ }
+
+ void
+ process_args(ArgumentState *arg_state, char **argv) {
+ int i = 0, len;
+ char *end;
+ ArgumentDescription *desc = arg_state->desc;
+ /* Grab Environment Variables */
+ for (i = 0;; i++) {
+ if (!desc[i].name)
+ break;
+ if (desc[i].env) {
+ char type = desc[i].type[0];
+ char * env = getenv(desc[i].env);
+ if (!env) continue;
+ switch (type) {
+ case 'A':
+ case 'f':
+ case 'F':
+ break;
+ case 'I': *(int *)desc[i].location = strtol(env, NULL, 0); break;
+ case 'D': *(double *)desc[i].location = strtod(env, NULL); break;
+ case 'L': *(int64 *)desc[i].location = strtoll(env, NULL, 0); break;
+ case 'S': strncpy((char *)desc[i].location,env,
+ strtol(desc[i].type+1, NULL, 0));
+ break;
+ }
+ if (desc[i].pfn)
+ desc[i].pfn(arg_state, env);
+ }
+ }
+
+ /*
+ Grab Command Line Arguments
+ */
+ arg_state->program_name = argv[0];
+ while ( *++argv ) {
+ if ( **argv == '-' ) {
+ if ((*argv)[1] == '-') {
+ for (i = 0;; i++) {
+ if (!desc[i].name)
+ usage(arg_state,NULL);
+ if ((end = strchr((*argv)+2, '=')))
+ len = end - ((*argv) + 2);
+ else
+ len = strlen((*argv) + 2);
+ if (len == strlen(desc[i].name) &&
+ !strncmp(desc[i].name,(*argv)+2, len))
+ {
+ if (!end)
+ *argv += strlen(*argv) - 1;
+ else
+ *argv = end;
+ process_arg(arg_state, i, &argv);
+ break;
+ }
+ }
+ } else {
+ while (*++(*argv))
+ for (i = 0;; i++) {
+ if (!desc[i].name)
+ usage(arg_state, NULL);
+ if (desc[i].key == **argv) {
+ process_arg(arg_state, i, &argv);
+ break;
+ }
+ }
+ }
+ } else {
+ arg_state->file_argument = (char **)REALLOC(
+ arg_state->file_argument,
+ sizeof(char**) * (arg_state->nfile_arguments + 2));
+ arg_state->file_argument[arg_state->nfile_arguments++] = *argv;
+ arg_state->file_argument[arg_state->nfile_arguments] = NULL;
+ }
+ }
+ }
+
+ void
+ usage(ArgumentState *arg_state, char *arg_unused) {
+ ArgumentDescription *desc = arg_state->desc;
+ int i;
+
+ (void)arg_unused;
+ fprintf(stderr,"Usage: %s [flags|args]\n",arg_state->program_name);
+ for (i = 0;; i++) {
+ if (!desc[i].name)
+ break;
+ if (!desc[i].description)
+ continue;
+ fprintf(stderr," %c%c%c --%s%s%s",
+ desc[i].key != ' ' ? '-' : ' ', desc[i].key,
+ desc[i].key != ' ' ? ',' : ' ', desc[i].name,
+ (strlen(desc[i].name) + 61 < 81) ?
+ &SPACES[strlen(desc[i].name)+61] : "",
+ arg_types_desc[desc[i].type?strchr(arg_types_keys,desc[i].type[0])-
+ arg_types_keys : strlen(arg_types_keys)]);
+ switch(desc[i].type?desc[i].type[0]:0) {
+ case 0: fprintf(stderr, " "); break;
+ case 'L':
+ fprintf(stderr,
+ #ifdef __alpha
+ " %-9ld",
+ #else
+ #ifdef FreeBSD
+ " %-9qd",
+ #else
+ " %-9lld",
+ #endif
+ #endif
+ *(int64*)desc[i].location);
+ break;
+ case 'S':
+ if (*(char*)desc[i].location) {
+ if (strlen((char*)desc[i].location) < 10)
+ fprintf(stderr, " %-9s", (char*)desc[i].location);
+ else {
+ ((char*)desc[i].location)[7] = 0;
+ fprintf(stderr, " %-7s..", (char*)desc[i].location);
+ }
+ } else
+ fprintf(stderr, " (null) ");
+ break;
+ case 'D':
+ fprintf(stderr, " %-9.3e", *(double*)desc[i].location);
+ break;
+ case '+':
+ case 'I':
+ fprintf(stderr, " %-9d", *(int *)desc[i].location);
+ break;
+ case 'T': case 'f': case 'F':
+ fprintf(stderr, " %-9s", *(int *)desc[i].location?"true ":"false");
+ break;
+ }
+ fprintf(stderr," %s\n",desc[i].description);
+ }
+ exit(1);
+ }
+
+ void
+ free_args(ArgumentState *arg_state) {
+ if (arg_state->file_argument)
+ FREE(arg_state->file_argument);
+ }
Index: llvm/test/Programs/MultiSource/Applications/d/arg.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/arg.h:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/arg.h Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,37 ----
+ /*
+ Copyright 1994-2003 John Plevyak, All Rights Reserved
+ */
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+
+ #ifndef __alpha
+ #define atoll atol
+ #endif
+
+ /* Argument Handling
+ */
+ struct ArgumentState;
+
+ typedef void ArgumentFunction(struct ArgumentState *arg_state, char *arg);
+
+ typedef struct {
+ char *name;
+ char key;
+ char *description;
+ char *type;
+ void *location;
+ char *env;
+ ArgumentFunction *pfn;
+ } ArgumentDescription;
+
+ typedef struct ArgumentState {
+ char **file_argument;
+ int nfile_arguments;
+ char *program_name;
+ ArgumentDescription *desc;
+ } ArgumentState;
+
+ void usage(ArgumentState *arg_state, char *arg_unused);
+ void process_args(ArgumentState *arg_state, char **argv);
+ void free_args(ArgumentState *arg_state);
Index: llvm/test/Programs/MultiSource/Applications/d/d.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/d.h:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/d.h Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,101 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+ #ifndef _d_H_
+ #define _d_H_
+
+ #ifdef MEMWATCH
+ #define MEMWATCH_STDIO 1
+ #include "../../src/memwatch-2.67/memwatch.h"
+ #define MEM_GROW_MACRO
+ #endif
+ #include <assert.h>
+ #include <stdarg.h>
+ #include <stdlib.h>
+ #include <stdio.h>
+ #include <limits.h>
+ #include <sys/types.h>
+ #ifndef __MINGW32__
+ #include <sys/mman.h>
+ #include <sys/uio.h>
+ #endif
+ #include <unistd.h>
+ #include <fcntl.h>
+ #include <time.h>
+ #include <sys/time.h>
+ #include <sys/stat.h>
+ #include <dirent.h>
+ #include <ctype.h>
+ #include <string.h>
+
+ #ifdef LEAK_DETECT
+ #define GC_DEBUG
+ #include "gc.h"
+ #define MALLOC(n) GC_MALLOC(n)
+ #define CALLOC(m,n) GC_MALLOC((m)*(n))
+ #define FREE(p) GC_FREE(p)
+ #define REALLOC(p,n) GC_REALLOC((p),(n))
+ #define CHECK_LEAKS() GC_gcollect()
+ #else
+ #ifdef USE_GC
+ #include "gc.h"
+ #define MALLOC GC_MALLOC
+ #define REALLOC GC_REALLOC
+ #define FREE(_x)
+ #define malloc dont_use_malloc_use_MALLOC_instead
+ #define relloc dont_use_realloc_use_REALLOC_instead
+ #define free dont_use_free_use_FREE_instead
+ #else
+ #define MALLOC malloc
+ #define REALLOC realloc
+ #define FREE free
+ #endif
+ #endif
+
+ #define D_MAJOR_VERSION 1
+ #define D_MINOR_VERSION 2
+ #define D_VERSION (\
+ (D_MAJOR_VERSION << 24) + (D_MINOR_VERSION << 16) + \
+ D_BUILD_VERSION)
+
+ /* Compilation Options
+ */
+
+ #define round2(_x,_n) ((_x + ((_n)-1)) & ~((_n)-1))
+ #define tohex1(_x) \
+ ((((_x)&15) > 9) ? (((_x)&15) - 10 + 'A') : (((_x)&15) + '0'))
+ #define tohex2(_x) \
+ ((((_x)>>4) > 9) ? (((_x)>>4) - 10 + 'A') : (((_x)>>4) + '0'))
+ #define numberof(_x) ((sizeof(_x))/(sizeof((_x)[0])))
+
+ typedef char int8;
+ typedef unsigned char uint8;
+ typedef int int32;
+ typedef unsigned int uint32;
+ typedef long long int64;
+ typedef unsigned long long uint64;
+ typedef short int16;
+ typedef unsigned short uint16;
+ /* typedef uint32 uint; * already part of most systems */
+
+ #include "dparse.h"
+ #include "arg.h"
+ #include "util.h"
+ #include "gram.h"
+ #include "lr.h"
+ #include "lex.h"
+ #include "scan.h"
+ #include "parse.h"
+ #include "write_ctables.h"
+
+ #ifdef D_DEBUG
+ #define DBG(_x) if (debug_level>1) { _x; }
+ #else
+ #define DBG(_x)
+ #endif
+
+ void d_version(char *);
+
+ #define USE_SCANNER 1
+
+ #endif
Index: llvm/test/Programs/MultiSource/Applications/d/dparse.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/dparse.h:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/dparse.h Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,87 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+ #ifndef _dparse_H_
+ #define _dparse_H_
+
+ #include <stdlib.h>
+ #if defined(__cplusplus)
+ extern "C" {
+ #endif
+ #include "dparse_tables.h"
+ #include "dsymtab.h"
+
+ struct D_Parser;
+ struct D_ParserTables;
+ struct D_Scope;
+ struct D_ParseNode;
+
+ typedef void *d_voidp;
+ #ifndef D_ParseNode_User
+ #define D_ParseNode_User d_voidp
+ #endif
+ #ifndef D_ParseNode_Globals
+ #define D_ParseNode_Globals void
+ #endif
+
+ typedef void (*D_SyntaxErrorFn)(struct D_Parser *);
+ typedef struct D_ParseNode *(*D_AmbiguityFn)(struct D_Parser *,
+ int n, struct D_ParseNode **v);
+ typedef void (*D_FreeNodeFn)(struct D_ParseNode *d);
+
+ typedef struct D_Parser {
+ D_ParseNode_Globals *initial_globals; /* global values */
+ D_WhiteSpaceFn initial_white_space_fn;
+ struct D_Scope *initial_scope;
+ D_SyntaxErrorFn syntax_error_fn;
+ D_AmbiguityFn ambiguity_fn;
+ D_FreeNodeFn free_node_fn;
+ d_loc_t loc; /* initial location, set on error */
+ int start_state;
+ /* user configurables */
+ int sizeof_user_parse_node;
+ int save_parse_tree;
+ int dont_compare_stacks;
+ int dont_fixup_internal_productions;
+ int dont_merge_epsilon_trees;
+ int dont_use_eagerness_for_disambiguation;
+ int dont_use_height_for_disambiguation;
+ int commit_actions_interval; /* 0 is immediate */
+ int error_recovery;
+ int partial_parses;
+ /* parse results */
+ int syntax_errors;
+ } D_Parser;
+
+ typedef struct D_ParseNode {
+ int symbol;
+ d_loc_t start_loc;
+ char *end;
+ char *end_skip;
+ struct D_Scope *scope;
+ D_WhiteSpaceFn white_space;
+ D_ParseNode_Globals *globals;
+ D_ParseNode_User user;
+ } D_ParseNode;
+
+ D_Parser *new_D_Parser(struct D_ParserTables *t, int sizeof_ParseNode_User);
+ void free_D_Parser(D_Parser *p);
+ D_ParseNode *dparse(D_Parser *p, char *buf, int buf_len);
+ void free_D_ParseNode(D_Parser *p, D_ParseNode *pn);
+ void free_D_ParseTreeBelow(D_Parser *p, D_ParseNode *pn);
+
+ int d_get_number_of_children(D_ParseNode *pn);
+ D_ParseNode *d_get_child(D_ParseNode *pn, int child);
+ D_ParseNode *d_find_in_tree(D_ParseNode *pn, int symbol);
+ char *d_ws_before(D_Parser *p, D_ParseNode *pn); /* points BEFORE leading ws */
+ char *d_ws_after(D_Parser *p, D_ParseNode *pn); /* points AFTER trailing ws */
+
+ void d_pass(D_Parser *p, D_ParseNode *pn, int pass_number);
+
+ char *d_dup_pathname_str(char *str);
+
+ #if defined(__cplusplus)
+ }
+ #endif
+
+ #endif
Index: llvm/test/Programs/MultiSource/Applications/d/dparse_tables.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/dparse_tables.h:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/dparse_tables.h Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,165 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+ #ifndef _dparse_tables_H_
+ #define _dparse_tables_H_
+
+ #define SCANNER_BLOCKS_POW2 2
+ #define SCANNER_BLOCKS (1 << SCANNER_BLOCKS_POW2)
+ #define SCANNER_BLOCK_SHIFT (8 - SCANNER_BLOCKS_POW2)
+ #define SCANNER_BLOCK_MASK ((1 << SCANNER_BLOCK_SHIFT) - 1)
+ #define SCANNER_BLOCK_SIZE (256 / SCANNER_BLOCKS)
+
+ struct D_Parser;
+ struct D_ShiftTable;
+
+ #define D_PN(_x, _o) ((D_ParseNode*)((char*)(_x) + _o))
+
+ typedef struct d_loc_t {
+ char *s, *pathname;
+ int previous_col, col, line;
+ } d_loc_t;
+
+ typedef void (*D_WhiteSpaceFn)(struct D_Parser *p,
+ d_loc_t *loc, void **p_globals);
+ typedef int (*D_ScanCode)(
+ char **s, int *col, int *line, unsigned short *symbol,
+ int *term_priority, unsigned char *op_assoc, int *op_priority);
+ typedef int (*D_ReductionCode)(
+ void *new_ps, void **children, int n_children, int pn_offset,
+ struct D_Parser *parser);
+
+ typedef struct D_Reduction {
+ unsigned short nelements;
+ unsigned short symbol;
+ D_ReductionCode speculative_code;
+ D_ReductionCode final_code;
+ unsigned short op_assoc;
+ unsigned short rule_assoc;
+ int op_priority;
+ int rule_priority;
+ int action_index;
+ int npass_code;
+ D_ReductionCode *pass_code;
+ } D_Reduction;
+
+ typedef struct D_RightEpsilonHint {
+ unsigned short depth;
+ unsigned short preceeding_state;
+ D_Reduction *reduction;
+ } D_RightEpsilonHint;
+
+ typedef struct D_ErrorRecoveryHint {
+ unsigned short depth;
+ unsigned short symbol;
+ char *string;
+ } D_ErrorRecoveryHint;
+
+ typedef struct D_Shift {
+ unsigned short symbol;
+ unsigned char shift_kind;
+ unsigned char op_assoc;
+ int op_priority;
+ int term_priority;
+ D_ReductionCode speculative_code;
+ } D_Shift;
+
+ typedef struct SB_uint8 {
+ D_Shift **shift;
+ unsigned char *scanner_block[SCANNER_BLOCKS];
+ } SB_uint8;
+
+ typedef struct SB_uint16 {
+ D_Shift **shift;
+ unsigned short *scanner_block[SCANNER_BLOCKS];
+ } SB_uint16;
+
+ typedef struct SB_uint32 {
+ D_Shift **shift;
+ unsigned int *scanner_block[SCANNER_BLOCKS];
+ } SB_uint32;
+
+ typedef struct SB_trans_uint8 {
+ unsigned char *scanner_block[SCANNER_BLOCKS];
+ } SB_trans_uint8;
+
+ typedef struct SB_trans_uint16 {
+ unsigned short *scanner_block[SCANNER_BLOCKS];
+ } SB_trans_uint16;
+
+ typedef struct SB_trans_uint32 {
+ unsigned int *scanner_block[SCANNER_BLOCKS];
+ } SB_trans_uint32;
+
+ #define D_SCAN_ALL 0
+ #define D_SCAN_LONGEST 1
+ #define D_SCAN_MIXED 2
+ #define D_SCAN_RESERVED 3
+ #define D_SCAN_DEFAULT D_SCAN_ALL
+
+ typedef struct D_State {
+ unsigned char *goto_valid;
+ int goto_table_offset;
+ struct {
+ unsigned int n;
+ D_Reduction **v;
+ } reductions;
+ struct {
+ unsigned int n;
+ D_RightEpsilonHint *v;
+ } right_epsilon_hints;
+ struct {
+ unsigned int n;
+ D_ErrorRecoveryHint *v;
+ } error_recovery_hints;
+ D_Shift **shifts;
+ D_ScanCode scanner_code;
+ void* scanner_table;
+ unsigned char scanner_size;
+ unsigned char accept;
+ unsigned char scan_kind;
+ void* transition_table;
+ D_Shift ***accepts_diff;
+ int reduces_to;
+ } D_State;
+
+ #define D_SHIFTS_CODE ((D_Shift**)-1)
+
+ #define D_SYMBOL_NTERM 1
+ #define D_SYMBOL_INTERNAL 2
+ #define D_SYMBOL_STRING 3
+ #define D_SYMBOL_REGEX 4
+ #define D_SYMBOL_CODE 5
+ #define D_SYMBOL_TOKEN 6
+ typedef struct D_Symbol {
+ unsigned int kind;
+ char *name;
+ int name_len;
+ } D_Symbol;
+
+ #define D_PASS_PRE_ORDER 0x0001
+ #define D_PASS_POST_ORDER 0x0002
+ #define D_PASS_MANUAL 0x0004
+ #define D_PASS_FOR_ALL 0x0008
+ #define D_PASS_FOR_UNDEFINED 0x0010
+ typedef struct D_Pass {
+ char *name;
+ unsigned int name_len;
+ unsigned int kind;
+ unsigned int index;
+ } D_Pass;
+
+ typedef struct D_ParserTables {
+ unsigned int nstates;
+ D_State *state;
+ unsigned short *goto_table;
+ unsigned int whitespace_state;
+ unsigned int nsymbols;
+ D_Symbol *symbols;
+ D_WhiteSpaceFn default_white_space;
+ unsigned int npasses;
+ D_Pass *passes;
+ unsigned int save_parse_tree;
+ } D_ParserTables;
+
+ #endif
Index: llvm/test/Programs/MultiSource/Applications/d/dsymtab.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/dsymtab.h:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/dsymtab.h Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,54 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+ #ifndef _dsymtab_H_
+ #define _dsymtab_H_
+
+ #ifndef D_UserSym
+ #define D_UserSym unsigned int
+ #endif
+
+ struct D_SymHash;
+
+ typedef struct D_Sym {
+ char *name;
+ int len;
+ unsigned int hash;
+ struct D_Sym *update_of;
+ struct D_Sym *next;
+ D_UserSym user;
+ } D_Sym;
+
+ #define SCOPE_INHERIT 0
+ #define SCOPE_RECURSIVE 1
+ #define SCOPE_PARALLEL 2
+ #define SCOPE_SEQUENTIAL 3
+
+ typedef struct D_Scope {
+ unsigned int owned_by_user:1; /* don't automatically delete */
+ unsigned int kind:2;
+ D_Sym *ll;
+ struct D_SymHash *hash;
+ D_Sym *updates;
+ struct D_Scope *search; /* scope to start search */
+ struct D_Scope *up; /* enclosing scope */
+ struct D_Scope *up_updates; /* prior scope in speculative parse */
+ struct D_Scope *down; /* enclosed scopes (for FREE) */
+ struct D_Scope *down_next; /* next enclosed scope */
+ } D_Scope;
+
+ D_Scope *new_D_Scope(D_Scope *parent);
+ D_Scope *enter_D_Scope(D_Scope *current, D_Scope *scope);
+ D_Scope *commit_D_Scope(D_Scope *scope);
+ void free_D_Scope(D_Scope *st, int force);
+ D_Sym *new_D_Sym(D_Scope *st, char *name, char *end, int sizeof_D_Sym);
+ #define NEW_D_SYM(_st, _name, _end) new_D_Sym(_st, _name, _end, sizeof(D_Sym))
+ void free_D_Sym(D_Sym *sym);
+ D_Sym *find_D_Sym(D_Scope *st, char *name, char *end);
+ D_Sym *update_D_Sym(D_Scope *st, D_Sym *sym, int sizeof_D_Sym);
+ #define UPDATE_D_SYM(_st, _sym) update_D_Sym(_st, _sym, sizeof(D_Sym))
+ D_Sym *current_D_Sym(D_Scope *st, D_Sym *sym);
+ D_Sym *find_D_Sym_in_Scope(D_Scope *st, char *name, char *end);
+ void print_scope(D_Scope *st);
+
+ #endif
Index: llvm/test/Programs/MultiSource/Applications/d/faq.html
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/faq.html:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/faq.html Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,62 ----
+ <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+ <html>
+ <head>
+ <meta http-equiv="content-type"
+ content="text/html; charset=ISO-8859-1">
+ <title>manual.html</title>
+ </head>
+ <body>
+ <div style="text-align: center;"> <big><big><span
+ style="font-weight: bold;">DParser FAQ<br>
+ </span></big></big>
+ <div style="text-align: left;"><big><br>
+ <br>
+ <span style="font-weight: bold;"></span></big><span
+ style="font-weight: bold;"><span style="font-weight: bold;">1. How do
+ I access the subnodes for expressions like "S: A*;" ?<br>
+ <span style="font-weight: bold;"><span style="font-weight: bold;"><span
+ style="font-weight: bold;"><br>
+ </span></span></span></span></span>In this case, "A*" is $n0 of type
+ D_ParseNode. In dparse.h the functions
+ d_get_number_of_children(D_ParseNode *) and d_get_child(D_ParseNode *,
+ int) allow you to get the number of children (<span
+ style="font-weight: bold;">A</span>'s) by calling
+ d_get_number_of_children(&$n0) and individual children by calling
+ d_get_child(&$n0, x).<br>
+ <br>
+ See the example: tests/g27.test.g<br>
+ <span style="font-weight: bold;"><br>
+ <span style="font-weight: bold;">2. Why doesn't '$n0.end_skip' include
+ the trailing whitespace when $n0 is a string/regex?<br>
+ <br>
+ </span></span>Whitespace is not skipped as part of the scan of a
+ string/regex but is done later (when the new parse state is
+ created). This makes it possible to change the whitespace parser
+ as a result of recognition of a particular string/regex. This is
+ used in the python grammar to handle implicit line joining.<br>
+ <br>
+ See the regex-productions LP RP LB RB LC RC in test/python.test.g.<br>
+ <br>
+ <span style="font-weight: bold;">3. What is the difference between
+ DParser and ANTLR?<br>
+ <span style="font-weight: bold;"></span></span><br>
+ The basic syntax of DParser and ANTLR grammars is very similar.
+ In fact, the DParser example ANSI-C grammar was ported from ANTLR in
+ less than an hour. <br>
+ <br>
+ Beyond that there are a number of differences. First of all ANTRL
+ has been developed for over a decade while DParser is relatively
+ young. Internally, DParser is a table-driven parser while ANTLR
+ generates directly executable parsers. DParser is a GLR parser
+ based on the Tomita algorithm while ANTLR is modified LL(k).
+ DParser is scannerless while ANTLR uses token streams. In terms
+ of power, both DParser and ANTLR are very powerful. In theory
+ DParser can handle any context free grammar, though not necessarily in
+ linear time. In practice ANTLR is likely to be faster (mostly
+ because it is more mature). Beyond that you would really
+ have ask Terance Parr who is more of a hard core parsing theory guru
+ than I am.<br>
+ <big><big><span style="font-weight: bold;"></span></big></big></div>
+ </div>
+ </body>
+ </html>
Index: llvm/test/Programs/MultiSource/Applications/d/gram.c
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/gram.c:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/gram.c Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,1322 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+
+ #include "d.h"
+
+ static char *action_types[] = { "ACCEPT", "SHIFT", "REDUCE" };
+
+ static void print_state(State *s);
+
+ Production *
+ new_production(Grammar *g, char *name) {
+ Production *p;
+ if ((p = lookup_production(g, name, strlen(name))))
+ return p;
+ p = MALLOC(sizeof(Production));
+ memset(p, 0, sizeof(Production));
+ vec_add(&g->productions, p);
+ p->name = name;
+ p->name_len = strlen(name);
+ return p;
+ }
+
+ static Elem *
+ new_elem() {
+ Elem *e = MALLOC(sizeof(Elem));
+ memset(e, 0, sizeof(Elem));
+ return e;
+ }
+
+ Rule *
+ new_rule(Grammar *g, Production *p) {
+ Rule *r = MALLOC(sizeof(Rule));
+ memset(r, 0, sizeof(Rule));
+ r->prod = p;
+ r->end = new_elem();
+ r->end->kind = ELEM_END;
+ r->end->rule = r;
+ r->action_index = g->action_index;
+ return r;
+ }
+
+ static Term *
+ new_term() {
+ Term *term = MALLOC(sizeof(Term));
+ memset(term, 0, sizeof(Term));
+ return term;
+ }
+
+ static Elem *
+ new_elem_term(Term *t, Rule *r) {
+ Elem *e = new_elem();
+ e->kind = ELEM_TERM;
+ e->e.term = t;
+ e->rule = r;
+ vec_add(&r->elems, e);
+ return e;
+ }
+
+ Elem *
+ new_elem_nterm(Production *p, Rule *r) {
+ Elem *e = new_elem();
+ e->kind = ELEM_NTERM;
+ e->e.nterm = p;
+ e->rule = r;
+ return e;
+ }
+
+ static Elem *
+ new_term_string(Grammar *g, char *s, char *e, Rule *r) {
+ Term *t = new_term();
+ Elem *elem;
+
+ t->string = MALLOC(e - s + 1);
+ memcpy(t->string, s, e - s);
+ t->string[e - s] = 0;
+ t->string_len = e - s;
+ vec_add(&g->terminals, t);
+ elem = new_elem_term(t, r);
+ return elem;
+ }
+
+ #define ESC(_c) *ss++ = '\\'; *ss++ = _c; break;
+ char *
+ escape_string_for_regex(char *s) {
+ char *ss = (char*)MALLOC((strlen(s) + 1) * 2), *sss = ss;
+ for (; *s; s++) {
+ switch (*s) {
+ case '(':
+ case ')':
+ case '[':
+ case ']':
+ case '-':
+ case '^':
+ case '*':
+ case '?':
+ case '+':
+ *ss++ = '\\';
+ /* fall through */
+ default: *ss++ = *s; break;
+ }
+ }
+ *ss = 0;
+ return sss;
+ }
+
+ static void
+ unescape_term_string(Term *t) {
+ char *s, *start = 0, *ss;
+ int length, base = 0;
+
+ for (ss = s = t->string; *s; s++) {
+ if (*s == '\\') {
+ switch (s[1]) {
+ case 'b': *ss = '\b'; s++; break;
+ case 'f': *ss = '\f'; s++; break;
+ case 'n': *ss = '\n'; s++; break;
+ case 'r': *ss = '\r'; s++; break;
+ case 't': *ss = '\t'; s++; break;
+ case 'v': *ss = '\v'; s++; break;
+ case 'a': *ss = '\a'; s++; break;
+ case 'c': *ss = 0; return;
+ case '\"':
+ if (t->kind == TERM_REGEX)
+ { *ss = '\"'; s++; break; }
+ else
+ goto Ldefault;
+ case '\'':
+ if (t->kind == TERM_STRING)
+ { *ss = '\''; s++; break; }
+ else
+ goto Ldefault;
+ case 'x':
+ length = 0;
+ if (isxdigit(s[2])) {
+ base = 16;
+ start = s + 2;
+ length++;
+ if (isxdigit(s[3]))
+ length++;
+ }
+ s += length + 1;
+ goto Lncont;
+ case 'd':
+ length = 0;
+ if (isdigit(s[2])) {
+ base = 10;
+ start = s + 2;
+ length++;
+ if (isdigit(s[3])) {
+ length++;
+ if (isdigit(s[4]) && ((s[2] < '2') || ((s[2] == '2') && ((s[3] < '5') ||
+ ((s[3] == '5') && (s[4] < '6'))))))
+ length++;
+ }
+ }
+ s += length + 1;
+ goto Lncont;
+ case '0': case '1': case '2': case '3':
+ case '4': case '5': case '6': case '7':
+ length = 1;
+ base = 8;
+ start = s + 1;
+ if (isdigit(s[2]) && (s[2] != '8') && (s[2] != '9')) {
+ length++;
+ if (isdigit(s[3]) && (s[3] != '8') && (s[3] != '9')) {
+ length++;
+ }
+ }
+ s += length;
+ /* fall through */
+ Lncont:
+ if (length > 0) {
+ char saved_c = start[length];
+ start[length] = '\0';
+ *ss = (char) strtol(start, NULL, base);
+ start[length] = saved_c;
+ if (*s > 0)
+ break;
+ d_fail("encountered an escaped NULL while processing '%s'", t->string);
+ } else
+ goto next;
+ Ldefault:
+ default:
+ *ss++ = *s;
+ *ss = s[1];
+ s++;
+ break;
+ }
+ } else
+ *ss = *s;
+ ss++;
+ next:;
+ }
+ *ss = 0;
+ t->string_len = strlen(t->string);
+ if (!t->string_len)
+ d_fail("empty string after unescape '%s'", t->string);
+ }
+
+ Elem *
+ new_string(Grammar *g, char *s, char *e, Rule *r) {
+ Elem *x = new_term_string(g, s + 1, e - 1, r);
+ x->e.term->kind = (*s == '"') ? TERM_REGEX : TERM_STRING;
+ unescape_term_string(x->e.term);
+ return x;
+ }
+
+ Elem *
+ new_ident(char *s, char *e, Rule *r) {
+ Elem *x = new_elem();
+ x->kind = ELEM_UNRESOLVED;
+ x->e.unresolved.string = dup_str(s, e);
+ x->e.unresolved.len = strlen(x->e.unresolved.string);
+ x->rule = r;
+ if (r)
+ vec_add(&r->elems, x);
+ return x;
+ }
+
+ void
+ new_token(Grammar *g, char *s, char *e) {
+ Term *t = new_term();
+ t->string = MALLOC(e - s + 1);
+ memcpy(t->string, s, e - s);
+ t->string[e - s] = 0;
+ t->string_len = e - s;
+ vec_add(&g->terminals, t);
+ t->kind = TERM_TOKEN;
+ }
+
+ Elem *
+ new_code(Grammar *g, char *s, char *e, Rule *r) {
+ Elem *x = new_term_string(g, s, e, r);
+ x->e.term->kind = TERM_CODE;
+ return x;
+ }
+
+ Elem *
+ dup_elem(Elem *e, Rule *r) {
+ Elem *ee = MALLOC(sizeof(Elem));
+ memcpy(ee, e, sizeof(Elem));
+ ee->rule = r;
+ return ee;
+ }
+
+ void
+ add_global_code(Grammar *g, char *start, char *end, int line) {
+ if (!g->code) g->code = MALLOC(sizeof(Code) * 4);
+ else if (!((g->ncode + 1) & 4))
+ g->code = REALLOC(g->code, sizeof(Code) * (g->ncode + 4));
+ g->code[g->ncode].code = dup_str(start, end);
+ g->code[g->ncode].line = line;
+ g->ncode++;
+ }
+
+ void
+ new_declaration(Grammar *g, Elem *e, uint kind) {
+ Declaration *d = MALLOC(sizeof(*d));
+ d->elem = e;
+ d->kind = kind;
+ d->index = g->declarations.n;
+ vec_add(&g->declarations, d);
+ }
+
+ void
+ add_declaration(Grammar *g, char *start, char *end, uint kind, uint line) {
+ if (start == end) {
+ switch (kind) {
+ case DECLARE_SET_OP_PRIORITY: g->set_op_priority_from_rule = 1; return;
+ case DECLARE_STATES_FOR_ALL_NTERMS: g->states_for_all_nterms = 1; return;
+ case DECLARE_LONGEST_MATCH: g->longest_match = 1; return;
+ case DECLARE_ALL_MATCHES: g->longest_match = 0; return;
+ case DECLARE_TOKENIZE: g->tokenizer = 1; return;
+ case DECLARE_SAVE_PARSE_TREE: g->save_parse_tree = 1; return;
+ default: d_fail("declare expects argument, line %d", line);
+ }
+ }
+ switch (kind) {
+ case DECLARE_WHITESPACE: g->default_white_space = dup_str(start, end); return;
+ case DECLARE_SET_OP_PRIORITY:
+ d_fail("declare does not expect argument, line %d", line);
+ default:
+ new_declaration(g, new_ident(start, end, NULL), kind);
+ break;
+ }
+ }
+
+ D_Pass *
+ find_pass(Grammar *g, char *start, char *end) {
+ int i, l;
+ while (*start && isspace(*start)) start++;
+ l = end - start;
+ for (i = 0; i < g->passes.n; i++)
+ if (l == g->passes.v[i]->name_len &&
+ !strncmp(g->passes.v[i]->name, start, l))
+ return g->passes.v[i];
+ return NULL;
+ }
+
+ void
+ add_pass(Grammar *g, char *start, char *end, uint kind, uint line) {
+ if (find_pass(g, start, end))
+ d_fail("duplicate pass '%s' line %d", dup_str(start, end), line);
+ else {
+ D_Pass *p = MALLOC(sizeof(*p));
+ p->name = dup_str(start, end);
+ p->name_len = end - start;
+ p->kind = kind;
+ p->index = g->pass_index++;
+ vec_add(&g->passes, p);
+ }
+ }
+
+ void
+ add_pass_code(Grammar *g, Rule *r, char *pass_start, char *pass_end,
+ char *code_start, char *code_end, uint pass_line, uint code_line)
+ {
+ D_Pass *p = find_pass(g, pass_start, pass_end);
+ if (!p)
+ d_fail("unknown pass '%s' line %d", dup_str(pass_start, pass_end), pass_line);
+ while (r->pass_code.n <= p->index) vec_add(&r->pass_code, NULL);
+ r->pass_code.v[p->index] = MALLOC(sizeof(Code));
+ r->pass_code.v[p->index]->code = dup_str(code_start, code_end);
+ r->pass_code.v[p->index]->line = code_line;
+ }
+
+
+ Production *
+ new_internal_production(Grammar *g, Production *p) {
+ char *n = p ? p->name : " _synthetic";
+ char *name = MALLOC(strlen(n) + 20);
+ Production *pp = NULL, *tp = NULL, *ttp;
+ int i, found = 0;
+ sprintf(name, "%s.%d", n, g->productions.n);
+ pp = new_production(g, name);
+ pp->internal = INTERNAL_HIDDEN;
+ pp->regex = p ? p->regex : 0;
+ if (p) {
+ for (i = 0; i < g->productions.n; i++) {
+ if (found) {
+ ttp = g->productions.v[i];
+ g->productions.v[i] = tp;
+ tp = ttp;
+ } else if (p == g->productions.v[i]) {
+ found = 1;
+ tp = g->productions.v[i+1];
+ g->productions.v[i+1] = pp;
+ i++;
+ }
+ }
+ }
+ return pp;
+ }
+
+ void
+ conditional_EBNF(Grammar *g) {
+ Production *pp;
+ Rule *rr;
+
+ pp = new_internal_production(g, g->p);
+ pp->internal = INTERNAL_CONDITIONAL;
+ rr = new_rule(g, pp);
+ vec_add(&rr->elems, last_elem(g->r));
+ last_elem(g->r)->rule = rr;
+ rr->elems.v[rr->elems.n - 1]->rule = rr;
+ vec_add(&pp->rules, rr);
+ vec_add(&pp->rules, new_rule(g, pp));
+ last_elem(g->r) = new_elem_nterm(pp, g->r);
+ }
+
+ void
+ star_EBNF(Grammar *g) {
+ Production *pp;
+ Rule *rr;
+
+ pp = new_internal_production(g, g->p);
+ pp->internal = INTERNAL_STAR;
+ rr = new_rule(g, pp);
+ if (!g->right_recursive_BNF) {
+ vec_add(&rr->elems, new_elem_nterm(pp, rr));
+ vec_add(&rr->elems, last_elem(g->r));
+ last_elem(g->r) = new_elem_nterm(pp, g->r);
+ last_elem(rr)->rule = rr;
+ } else {
+ vec_add(&rr->elems, last_elem(g->r));
+ last_elem(g->r) = new_elem_nterm(pp, g->r);
+ last_elem(rr)->rule = rr;
+ vec_add(&rr->elems, new_elem_nterm(pp, rr));
+ }
+ vec_add(&pp->rules, rr);
+ vec_add(&pp->rules, new_rule(g, pp));
+ }
+
+ void
+ plus_EBNF(Grammar *g) {
+ Production *pp;
+ Rule *rr;
+ Elem *elem;
+
+ pp = new_internal_production(g, g->p);
+ pp->internal = INTERNAL_PLUS;
+ rr = new_rule(g, pp);
+ if (!g->right_recursive_BNF) {
+ elem = last_elem(g->r);
+ vec_add(&rr->elems, new_elem_nterm(pp, rr));
+ vec_add(&rr->elems, dup_elem(elem, rr));
+ last_elem(g->r) = new_elem_nterm(pp, g->r);
+ } else {
+ elem = last_elem(g->r);
+ vec_add(&rr->elems, dup_elem(elem, rr));
+ last_elem(g->r) = new_elem_nterm(pp, g->r);
+ vec_add(&rr->elems, new_elem_nterm(pp, rr));
+ }
+ vec_add(&pp->rules, rr);
+ rr = new_rule(g, pp);
+ vec_add(&rr->elems, elem);
+ elem->rule = rr;
+ vec_add(&pp->rules, rr);
+ }
+
+ void
+ initialize_productions(Grammar *g) {
+ Production *pp, *ppp;
+ Rule *rrr;
+
+ ppp = new_production(g, strdup("0 Start"));
+ ppp->internal = INTERNAL_HIDDEN;
+ rrr = new_rule(g, ppp);
+ vec_add(&rrr->elems, new_elem_nterm(NULL, rrr));
+ vec_add(&ppp->rules, rrr);
+ pp = new_production(g, strdup("1 Start"));
+ pp->internal = INTERNAL_HIDDEN;
+ rrr->elems.v[0]->e.nterm = pp;
+ }
+
+ void
+ finish_productions(Grammar *g) {
+ Production *pp = g->productions.v[1];
+ Rule *rr = new_rule(g, g->productions.v[1]);
+ vec_add(&rr->elems, new_elem_nterm(NULL, rr));
+ vec_add(&pp->rules, rr);
+ rr->elems.v[0]->e.nterm = g->productions.v[2];
+ }
+
+ Production *
+ lookup_production(Grammar *g, char *name, int l) {
+ int i;
+
+ for (i = 0; i < g->productions.n; i++) {
+ Production *pp = g->productions.v[i];
+ if (pp->name_len != l || strncmp(pp->name, name, l))
+ continue;
+ return pp;
+ }
+ return NULL;
+ }
+
+ static Term *
+ lookup_token(Grammar *g, char *name, int l) {
+ int i;
+
+ for (i = 0; i < g->terminals.n; i++) {
+ Term *t = g->terminals.v[i];
+ if (t->kind != TERM_TOKEN || t->string_len != l ||
+ strncmp(t->string, name, l))
+ continue;
+ return t;
+ }
+ return NULL;
+ }
+
+ static Term *
+ unique_term(Grammar *g, Term *t) {
+ int i;
+ for (i = 0; i < g->terminals.n; i++)
+ if (t->kind == g->terminals.v[i]->kind &&
+ t->string_len == g->terminals.v[i]->string_len &&
+ t->term_priority == g->terminals.v[i]->term_priority &&
+ (!g->set_op_priority_from_rule ||
+ (t->op_assoc == g->terminals.v[i]->op_assoc &&
+ t->op_priority == g->terminals.v[i]->op_priority)) &&
+ !strncmp(t->string, g->terminals.v[i]->string, t->string_len))
+ return g->terminals.v[i];
+ return t;
+ }
+
+ static void
+ compute_nullable(Grammar *g) {
+ int i, j, k, changed = 1;
+ Elem *e;
+
+ /* ensure that the trivial case is the first cause */
+ for (i = 0; i < g->productions.n; i++) {
+ for (j = 0; j < g->productions.v[i]->rules.n; j++)
+ if (!g->productions.v[i]->rules.v[j]->elems.n) {
+ g->productions.v[i]->nullable = g->productions.v[i]->rules.v[j];
+ break;
+ }
+ }
+ /* transitive closure */
+ while (changed) {
+ changed = 0;
+ for (i = 0; i < g->productions.n; i++) {
+ if (!g->productions.v[i]->nullable)
+ for (j = 0; j < g->productions.v[i]->rules.n; j++) {
+ for (k = 0; k < g->productions.v[i]->rules.v[j]->elems.n; k++) {
+ e = g->productions.v[i]->rules.v[j]->elems.v[k];
+ if (e->kind != ELEM_NTERM || !e->e.nterm->nullable)
+ goto Lnot_nullable;
+ }
+ changed = 1;
+ g->productions.v[i]->nullable = g->productions.v[i]->rules.v[j];
+ break;
+ }
+ Lnot_nullable:;
+ }
+ }
+ }
+
+ /*
+ verify and cleanup the grammar datastructures
+ - resolve non-terminals
+ - set element indexes
+ */
+ static void
+ resolve_grammar(Grammar *g) {
+ int i, j, k, l;
+ Production *p, *pp;
+ Rule *r;
+ Elem *e;
+ Term *last_term, *t;
+
+ g->rule_index = 0;
+ for (i = 0; i < g->productions.n; i++) {
+ p = g->productions.v[i];
+ if (p != lookup_production(g, p->name, p->name_len))
+ d_fail("duplicate production '%s'", p->name);
+ p->index = i;
+ for (j = 0; j < p->rules.n; j++) {
+ r = p->rules.v[j];
+ r->index = g->rule_index++;
+ last_term = NULL;
+ for (k = 0; k < r->elems.n; k++) {
+ e = r->elems.v[k];
+ e->index = k;
+ if (e->kind == ELEM_UNRESOLVED) {
+ l = e->e.unresolved.len;
+ if ((pp = lookup_production(g, e->e.unresolved.string, l))) {
+ e->kind = ELEM_NTERM;
+ e->e.nterm = pp;
+ } else if ((t = lookup_token(g, e->e.unresolved.string, l))) {
+ e->kind = ELEM_TERM;
+ e->e.term = t;
+ } else {
+ char str[256];
+ strncpy(str, e->e.unresolved.string, l);
+ str[l < 255 ? l : 255] = 0;
+ d_fail("unresolved identifier: '%s'", str);
+ }
+ }
+ if (e->kind == ELEM_TERM)
+ last_term = e->e.term;
+ }
+ r->end->index = r->elems.n;
+ if (g->set_op_priority_from_rule) {
+ if (last_term && r->rule_assoc) {
+ last_term->op_assoc = r->rule_assoc;
+ last_term->op_priority = r->rule_priority;
+ }
+ }
+ }
+ }
+ for (i = 0; i < g->terminals.n; i++)
+ g->terminals.v[i]->index = i;
+ compute_nullable(g);
+ }
+
+ static void
+ merge_identical_terminals(Grammar *g) {
+ int i, j, k;
+ Production *p;
+ Rule *r;
+ Elem *e;
+
+ for (i = 0; i < g->productions.n; i++) {
+ p = g->productions.v[i];
+ for (j = 0; j < p->rules.n; j++) {
+ r = p->rules.v[j];
+ for (k = 0; k < r->elems.n; k++) {
+ e = r->elems.v[k];
+ if (e->kind == ELEM_TERM)
+ e->e.term = unique_term(g, e->e.term);
+ }
+ }
+ }
+ }
+
+ void
+ print_term(Term *t) {
+ char *s = t->string ? escape_string(t->string) : NULL;
+ if (t->kind == TERM_STRING) {
+ if (!t->string || !*t->string)
+ printf("<EOF> ");
+ else
+ printf("string(\"%s\") ", s);
+ } else if (t->kind == TERM_REGEX)
+ printf("regex(\"%s\") ", s);
+ else if (t->kind == TERM_CODE)
+ printf("code(\"%s\") ", s);
+ else if (t->kind == TERM_TOKEN)
+ printf("token(\"%s\") ", s);
+ else
+ d_fail("unknown token kind");
+ if (s)
+ FREE(s);
+ }
+
+ void
+ print_elem(Elem *ee) {
+ if (ee->kind == ELEM_TERM)
+ print_term(ee->e.term);
+ else if (ee->kind == ELEM_UNRESOLVED)
+ printf("%s ", ee->e.unresolved.string);
+ else
+ printf("%s ", ee->e.nterm->name);
+ }
+
+ struct EnumStr {
+ uint e;
+ char *s;
+ } assoc_strings[] = {
+ { ASSOC_NONE, "$none" },
+ { ASSOC_NARY_LEFT, "$left" },
+ { ASSOC_NARY_RIGHT, "$right" },
+ { ASSOC_UNARY_LEFT, "$unary_left" },
+ { ASSOC_UNARY_RIGHT, "$unary_right" },
+ { ASSOC_BINARY_LEFT, "$binary_left" },
+ { ASSOC_BINARY_RIGHT, "$binary_right" },
+ { ASSOC_NO, "$noassoc" }
+ };
+
+ static char *
+ assoc_str(uint e) {
+ int i;
+
+ for (i = 0; i < sizeof(assoc_strings) / sizeof(assoc_strings[0]); i++)
+ if (e == assoc_strings[i].e)
+ return assoc_strings[i].s;
+ return assoc_strings[0].s;
+ }
+
+ void
+ print_rule(Rule *r) {
+ int k;
+
+ printf("%s: ", r->prod->name);
+ for (k = 0; k < r->elems.n; k++)
+ print_elem(r->elems.v[k]);
+ if (r->speculative_code.code)
+ printf("SPECULATIVE_CODE\n%s\nEND CODE\n", r->speculative_code.code);
+ if (r->final_code.code)
+ printf("FINAL_CODE\n%s\nEND CODE\n", r->final_code.code);
+ }
+
+ void
+ print_grammar(Grammar *g) {
+ uint i, j, k;
+ Production *pp;
+ Rule *rr;
+
+ if (!g->productions.n)
+ return;
+ printf("PRODUCTIONS\n\n");
+ for (i = 0; i < g->productions.n; i++) {
+ pp = g->productions.v[i];
+ printf("%s (%d)\n", pp->name, i);
+ for (j = 0; j < pp->rules.n; j++) {
+ rr = pp->rules.v[j];
+ if (!j)
+ printf("\t: ");
+ else
+ printf("\t| ");
+ for (k = 0; k < rr->elems.n; k++)
+ print_elem(rr->elems.v[k]);
+ if (rr->op_priority)
+ printf("op %d ", rr->op_priority);
+ if (rr->op_assoc)
+ printf("%s ", assoc_str(rr->op_assoc));
+ if (rr->rule_priority)
+ printf("rule %d ", rr->rule_priority);
+ if (rr->rule_assoc)
+ printf("%s ", assoc_str(rr->rule_assoc));
+ if (rr->speculative_code.code)
+ printf("%s ", rr->speculative_code.code);
+ if (rr->final_code.code)
+ printf("%s ", rr->final_code.code);
+ printf("\n");
+ }
+ printf("\t;\n");
+ printf("\n");
+ }
+ printf("TERMINALS\n\n");
+ for (i = 0; i < g->terminals.n; i++) {
+ printf("\t");
+ print_term(g->terminals.v[i]);
+ printf("(%d)\n", i + g->productions.n);
+ }
+ printf("\n");
+ }
+
+ static void
+ print_item(Item *i) {
+ int j, end = 1;
+
+ printf("\t%s: ", i->rule->prod->name);
+ for (j = 0; j < i->rule->elems.n; j++) {
+ Elem *e = i->rule->elems.v[j];
+ if (i == e) {
+ printf(". ");
+ end = 0;
+ }
+ print_elem(e);
+ }
+ if (end)
+ printf(". ");
+ printf("\n");
+ }
+
+ static void
+ print_conflict(char *kind, int *conflict) {
+ if (!*conflict) {
+ printf(" CONFLICT (before precedence and associativity)\n");
+ *conflict = 1;
+ }
+ printf("\t%s conflict ", kind);
+ printf("\n");
+ }
+
+ static void
+ print_state(State *s) {
+ int j, conflict = 0;
+
+ printf("STATE %d (%d ITEMS)%s\n", s->index, s->items.n,
+ s->accept ? " ACCEPT" : "");
+ for (j = 0; j < s->items.n; j++)
+ print_item(s->items.v[j]);
+ if (s->gotos.n)
+ printf(" GOTO\n");
+ for (j = 0; j < s->gotos.n; j++) {
+ printf("\t");
+ print_elem(s->gotos.v[j]->elem);
+ printf(" : %d\n", s->gotos.v[j]->state->index);
+ }
+ printf(" ACTION\n");
+ for (j = 0; j < s->reduce_actions.n; j++) {
+ Action *a = s->reduce_actions.v[j];
+ printf("\t%s\t", action_types[a->kind]);
+ print_rule(a->rule);
+ printf("\n");
+ }
+ for (j = 0; j < s->shift_actions.n; j++) {
+ Action *a = s->shift_actions.v[j];
+ printf("\t%s\t", action_types[a->kind]);
+ if (a->kind == ACTION_SHIFT) {
+ print_term(a->term);
+ printf("%d", a->state->index);
+ }
+ printf("\n");
+ }
+ if (s->reduce_actions.n > 1)
+ print_conflict("reduce/reduce", &conflict);
+ if (s->reduce_actions.n && s->shift_actions.n)
+ print_conflict("shift/reduce", &conflict);
+ printf("\n");
+ }
+
+ void
+ print_states(Grammar *g) {
+ int i;
+
+ for (i = 0; i < g->states.n; i++)
+ print_state(g->states.v[i]);
+ }
+
+ int
+ state_for_declaration(Grammar *g, int iproduction) {
+ int i;
+ for (i = 0; i < g->declarations.n; i++)
+ if (g->declarations.v[i]->kind == DECLARE_STATE_FOR &&
+ g->declarations.v[i]->elem->e.nterm->index == iproduction)
+ return 1;
+ return 0;
+ }
+
+ static void
+ make_elems_for_productions(Grammar *g) {
+ int i, j, k, l;
+ Rule *rr;
+ Production *pp, *ppp;
+
+ pp = g->productions.v[0];
+ for (i = 0; i < g->productions.n; i++)
+ if (!g->productions.v[i]->internal) {
+ if (g->states_for_all_nterms ||
+ state_for_declaration(g, i)) {
+ /* try to find an existing elem */
+ for (j = 0; j < g->productions.n; j++)
+ for (k = 0; k < g->productions.v[j]->rules.n; k++) {
+ rr = g->productions.v[j]->rules.v[k];
+ for (l = 0; l < rr->elems.n; l++)
+ if (rr->elems.v[l]->e.term_or_nterm == g->productions.v[i]) {
+ g->productions.v[i]->elem = rr->elems.v[l];
+ break;
+ }
+ }
+ if (j >= g->productions.n) { /* not found */
+ g->productions.v[i]->elem =
+ new_elem_nterm(g->productions.v[i], new_rule(g, pp));
+ g->productions.v[i]->elem->rule->index = g->rule_index++; /* fake */
+ }
+ }
+ }
+ if (!g->states_for_all_nterms &&
+ g->states_for_whitespace &&
+ (ppp = lookup_production(g, "whitespace", sizeof("whitespace")-1)))
+ {
+ ppp->elem = new_elem_nterm(ppp, new_rule(g, pp));
+ ppp->elem->rule->index = g->rule_index++; /* fake */
+ }
+ }
+
+ static void
+ convert_regex_production_one(Grammar *g, Production *p) {
+ int j, k, l;
+ Production *pp;
+ Rule *r, *rr;
+ Elem *e;
+ Term *t;
+ int circular = 0;
+ char *buf = 0, *b, *s;
+ int buf_len = 0;
+
+ if (p->regex_term) /* already done */
+ return;
+ if (p->in_regex)
+ d_fail("circular regex production '%s'", p->name);
+ p->in_regex = 1;
+ for (j = 0; j < p->rules.n; j++) {
+ r = p->rules.v[j];
+ if (r->final_code.code || (r->speculative_code.code && p->rules.n > 1))
+ d_fail("final and/or multi-rule code not permitted in regex productions '%s'", p->name);
+ for (k = 0; k < r->elems.n; k++) {
+ e = r->elems.v[k];
+ if (e->kind == ELEM_NTERM) {
+ if (!e->e.nterm->regex)
+ d_fail("regex production '%s' cannot invoke non-regex production '%s'",
+ p->name, e->e.nterm->name);
+ pp = e->e.nterm;
+ for (l = 0; l < pp->rules.n; l++)
+ if (pp->rules.v[l]->speculative_code.code || pp->rules.v[l]->final_code.code)
+ d_fail("code not permitted in rule %d of regex productions '%s'", l, p->name);
+ if (p != pp) {
+ convert_regex_production_one(g, pp);
+ buf_len += pp->regex_term->string_len + 5;
+ } else {
+ circular = 1;
+ buf_len += 5;
+ }
+ } else { /* e->kind == ELEM_TERM */
+ if (e->e.term->kind == TERM_CODE || e->e.term->kind == TERM_TOKEN)
+ d_fail("regex production '%s' cannot include scanners or tokens");
+ buf_len += e->e.term->string_len + 5;
+ }
+ }
+ }
+ b = buf = (char*)MALLOC(buf_len + 1);
+ t = new_term();
+ t->kind = TERM_REGEX;
+ t->string = buf;
+ t->index = g->terminals.n;
+ t->regex_production = p;
+ vec_add(&g->terminals, t);
+ p->regex_term = t;
+ if (circular) { /* attempt to match to regex operators */
+ if (p->rules.n != 2)
+ Lfail: d_fail("unable to resolve circular regex production: '%s'", p->name);
+ l = p->rules.v[0]->elems.n + p->rules.v[1]->elems.n;
+ if (l == 2 || l == 3) {
+ if (p->rules.v[0]->elems.n != 2 && p->rules.v[1]->elems.n != 2)
+ goto Lfail;
+ r = p->rules.v[0]->elems.n == 2 ? p->rules.v[0] : p->rules.v[1];
+ rr = p->rules.v[0] == r ? p->rules.v[1] : p->rules.v[0];
+ if (r->elems.v[0]->e.nterm != p && r->elems.v[1]->e.nterm != p)
+ goto Lfail;
+ e = r->elems.v[0]->e.nterm == p ? r->elems.v[1] : r->elems.v[1];
+ if (rr->elems.n && e->e.term_or_nterm != rr->elems.v[0]->e.term_or_nterm)
+ goto Lfail;
+ t = e->kind == ELEM_TERM ? e->e.term : e->e.nterm->regex_term;
+ *b++ = '(';
+ if (t->kind == TERM_STRING)
+ s = escape_string_for_regex(t->string);
+ else
+ s = t->string;
+ memcpy(b, s, strlen(s)); b += strlen(s);
+ if (t->kind == TERM_STRING)
+ FREE(s);
+ *b++ = ')';
+ if (l == 2)
+ *b++ = '*';
+ else
+ *b++ = '+';
+ *b = 0;
+ p->regex_term->string_len = strlen(p->regex_term->string);
+ } else
+ goto Lfail;
+ } else { /* handle the base case, p = (r | r'), r = (e e') */
+ if (p->rules.n > 1)
+ *b++ = '(';
+ for (j = 0; j < p->rules.n; j++) {
+ r = p->rules.v[j];
+ if (r->elems.n > 1)
+ *b++ = '(';
+ for (k = 0; k < r->elems.n; k++) {
+ e = r->elems.v[k];
+ t = e->kind == ELEM_TERM ? e->e.term : e->e.nterm->regex_term;
+ if (t->kind == TERM_STRING)
+ s = escape_string_for_regex(t->string);
+ else
+ s = t->string;
+ memcpy(b, s, strlen(s)); b += strlen(s);
+ if (t->kind == TERM_STRING)
+ FREE(s);
+ }
+ if (r->elems.n > 1)
+ *b++ = ')';
+ if (j != p->rules.n - 1)
+ *b++ = '|';
+ }
+ if (p->rules.n > 1)
+ *b++ = ')';
+ *b = 0;
+ p->regex_term->string_len = strlen(p->regex_term->string);
+ }
+ p->in_regex = 0;
+ }
+
+ static void
+ convert_regex_productions(Grammar *g) {
+ int i, j, k;
+ Production *p;
+ Rule *r;
+
+ for (i = 0; i < g->productions.n; i++) {
+ p = g->productions.v[i];
+ if (!p->regex)
+ continue;
+ convert_regex_production_one(g, p);
+ }
+ for (i = 0; i < g->productions.n; i++) {
+ p = g->productions.v[i];
+ for (j = 0; j < p->rules.n; j++) {
+ r = p->rules.v[j];
+ for (k = 0; k < r->elems.n; k++) {
+ if (r->elems.v[k]->kind == ELEM_NTERM && r->elems.v[k]->e.nterm->regex_term) {
+ r->elems.v[k]->e.term = r->elems.v[k]->e.nterm->regex_term;
+ r->elems.v[k]->kind = ELEM_TERM;
+ }
+ }
+ }
+ }
+ }
+
+ static void
+ check_default_actions(Grammar *g) {
+ Production *pdefault;
+
+ pdefault = lookup_production(g, "_", 1);
+ if (pdefault && pdefault->rules.n > 1)
+ d_fail("number of rules in default action != 1");
+ }
+
+ typedef struct {
+ struct State *eq;
+ struct Rule *diff_rule;
+ struct State *diff_state;
+ } EqState;
+
+ void
+ build_eq(Grammar *g) {
+ int i, j, k, changed = 1, x, xx;
+ State *s, *ss;
+ EqState *eq, *e, *ee;
+
+ eq = (EqState*)MALLOC(sizeof(EqState)*g->states.n);
+ memset(eq, 0, sizeof(EqState)*g->states.n);
+ while (changed) {
+ changed = 0;
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ e = &eq[s->index];
+ for (j = i + 1; j < g->states.n; j++) {
+ ss = g->states.v[j];
+ ee = &eq[ss->index];
+ if (e->eq || ee->eq)
+ continue;
+ if (s->same_shifts != ss->same_shifts && ss->same_shifts != s)
+ continue;
+ /* check gotos */
+ if (s->gotos.n != ss->gotos.n)
+ continue;
+ for (k = 0; k < s->gotos.n; k++) {
+ if (elem_symbol(g, s->gotos.v[k]->elem) != elem_symbol(g, ss->gotos.v[k]->elem))
+ goto Lcontinue;
+ if (s->gotos.v[k]->state != ss->gotos.v[k]->state) {
+ EqState *ge = &eq[s->gotos.v[k]->state->index];
+ EqState *gee = &eq[ss->gotos.v[k]->state->index];
+ if (ge->eq != ss->gotos.v[k]->state && gee->eq != s->gotos.v[k]->state)
+ goto Lcontinue;
+ if ((ee->diff_state && ee->diff_state != eq[ss->gotos.v[k]->state->index].eq) ||
+ (e->diff_state && e->diff_state != eq[s->gotos.v[k]->state->index].eq))
+ goto Lcontinue;
+ /* allow one different state */
+ ee->diff_state = ss->gotos.v[k]->state;
+ e->diff_state = s->gotos.v[k]->state;
+ }
+ }
+ /* check reductions */
+ if (s->reduce_actions.n != ss->reduce_actions.n)
+ continue;
+ for (k = 0; k < s->reduce_actions.n; k++) {
+ if (s->reduce_actions.v[k]->rule == ss->reduce_actions.v[k]->rule)
+ continue;
+ if (s->reduce_actions.v[k]->rule->prod !=
+ ss->reduce_actions.v[k]->rule->prod)
+ goto Lcontinue;
+ if ((x = s->reduce_actions.v[k]->rule->elems.n) !=
+ (xx = ss->reduce_actions.v[k]->rule->elems.n)) {
+ if ((ee->diff_rule && ee->diff_rule != ss->reduce_actions.v[k]->rule) ||
+ (e->diff_rule && e->diff_rule != s->reduce_actions.v[k]->rule))
+ goto Lcontinue;
+ /* allow one different rule */
+ ee->diff_rule = ss->reduce_actions.v[k]->rule;
+ e->diff_rule = s->reduce_actions.v[k]->rule;
+ }
+ }
+ ee->eq = s;
+ changed = 1;
+ Lcontinue:;
+ }
+ }
+ }
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ e = &eq[s->index];
+ if (e->eq) {
+ if (verbose_level > 2) {
+ printf("eq %d %d ", s->index, e->eq->index);
+ if (e->diff_state)
+ printf("diff state (%d %d) ",
+ e->diff_state->index,
+ eq[e->eq->index].diff_state->index);
+ if (e->diff_rule) {
+ printf("diff rule ");
+ printf("[ ");
+ print_rule(e->diff_rule);
+ printf("][ ");
+ print_rule(eq[e->eq->index].diff_rule);
+ printf("]");
+ }
+ printf("\n");
+ }
+ }
+ }
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ e = &eq[s->index];
+ if (e->eq && e->diff_state) {
+ if (eq[e->diff_state->index].diff_rule &&
+ eq[e->diff_state->index].diff_rule->elems.n == 2)
+ {
+ s->reduces_to = e->eq;
+ s->reduces_with = eq[e->eq->index].diff_rule;
+ s->reduces_to_then_with = e->diff_rule;
+ } else if (eq[eq[e->eq->index].diff_state->index].diff_rule &&
+ eq[eq[e->eq->index].diff_state->index].diff_rule->elems.n == 2)
+ {
+ e->eq->reduces_to = s;
+ s->reduces_with = e->diff_rule;
+ s->reduces_to_then_with = eq[e->eq->index].diff_rule;
+ }
+ }
+ }
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ if (s->reduces_to)
+ if (verbose_level)
+ printf("reduces_to %d %d\n", s->index, s->reduces_to->index);
+ }
+ FREE(eq);
+ }
+
+ Grammar *
+ new_D_Grammar(char *pathname) {
+ Grammar *g = (Grammar *)MALLOC(sizeof(Grammar));
+ memset(g, 0, sizeof(Grammar));
+ g->pathname = dup_str(pathname, pathname + strlen(pathname));
+ return g;
+ }
+
+ void
+ free_D_Grammar(Grammar *g) {
+ FREE(g->pathname);
+ }
+
+ int
+ parse_grammar(Grammar *g, D_ParserTables *t, int sizeof_ParseNode_User) {
+ FILE *fp = fopen(g->pathname, "r");
+ char *s;
+ D_Parser *p;
+
+ if (!fp)
+ return -1;
+ if (!(s = sbuf_read(g->pathname)))
+ return -1;
+ initialize_productions(g);
+ p = new_D_Parser(t, sizeof_ParseNode_User);
+ p->initial_globals = g;
+ p->loc.pathname = g->pathname;
+ if (dparse(p, s, strlen(s))) {
+ if (g->productions.n > 2)
+ finish_productions(g);
+ return 0;
+ } else
+ return -1;
+ }
+
+ static int
+ scanner_declaration(Declaration *d) {
+ switch (d->kind) {
+ case DECLARE_TOKENIZE:
+ case DECLARE_LONGEST_MATCH:
+ case DECLARE_ALL_MATCHES:
+ return 1;
+ default:
+ return 0;
+ }
+ }
+
+ static void
+ set_declaration_group(Production *p, Production *root, Declaration *d) {
+ int i, j;
+ if (p->declaration_group[d->kind] == root)
+ return;
+ if (d->kind == DECLARE_TOKENIZE && p->declaration_group[d->kind]) {
+ d_fail("shared tokenize subtrees");
+ return;
+ }
+ p->declaration_group[d->kind] = root;
+ p->last_declaration[d->kind] = d;
+ for (i = 0; i < p->rules.n; i++) {
+ for (j = 0; j < p->rules.v[i]->elems.n; j++)
+ if (p->rules.v[i]->elems.v[j]->kind == ELEM_NTERM)
+ set_declaration_group(p->rules.v[i]->elems.v[j]->e.nterm, root, d);
+ }
+ }
+
+ static void
+ propogate_declarations(Grammar *g) {
+ int i, j, k;
+ Production *p;
+ Rule *r;
+ Elem *e;
+
+ /* global defaults */
+ if (g->tokenizer)
+ new_declaration(g, new_elem_nterm(g->productions.v[0], NULL), DECLARE_TOKENIZE);
+ if (g->longest_match)
+ new_declaration(g, new_elem_nterm(g->productions.v[0], NULL), DECLARE_LONGEST_MATCH);
+ /* resolve declarations */
+ for (i = 0; i < g->declarations.n; i++) {
+ e = g->declarations.v[i]->elem;
+ if (e->kind == ELEM_UNRESOLVED) {
+ if (!(p = lookup_production(g, e->e.unresolved.string, e->e.unresolved.len)))
+ d_fail("unresolved declaration '%s'", e->e.unresolved.string);
+ e->kind = ELEM_NTERM;
+ e->e.nterm = p;
+ }
+ }
+ /* build declaration groups (covering a production subtrees) */
+ for (i = 0; i < g->declarations.n; i++) {
+ if (scanner_declaration(g->declarations.v[i])) {
+ p = g->declarations.v[i]->elem->e.nterm;
+ set_declaration_group(p, p, g->declarations.v[i]);
+ }
+ }
+ /* set terminal scan_kind */
+ for (i = 0; i < g->productions.n; i++) {
+ p = g->productions.v[i];
+ for (j = 0; j < p->rules.n; j++) {
+ r = p->rules.v[j];
+ for (k = 0; k < r->elems.n; k++) {
+ e = r->elems.v[k];
+ if (e->kind == ELEM_TERM) {
+ if (!p->declaration_group[DECLARE_LONGEST_MATCH] &&
+ !p->declaration_group[DECLARE_ALL_MATCHES])
+ e->e.term->scan_kind = D_SCAN_DEFAULT;
+ else if (p->declaration_group[DECLARE_LONGEST_MATCH] &&
+ !p->declaration_group[DECLARE_ALL_MATCHES])
+ e->e.term->scan_kind = D_SCAN_LONGEST;
+ else if (!p->declaration_group[DECLARE_LONGEST_MATCH] &&
+ p->declaration_group[DECLARE_ALL_MATCHES])
+ e->e.term->scan_kind = D_SCAN_ALL;
+ else {
+ if (p->last_declaration[DECLARE_LONGEST_MATCH]->index >
+ p->last_declaration[DECLARE_ALL_MATCHES]->index)
+ e->e.term->scan_kind = D_SCAN_LONGEST;
+ else
+ e->e.term->scan_kind = D_SCAN_ALL;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ static void
+ merge_shift_actions(State *to, State *from) {
+ int i, j;
+ for (i = 0; i < from->shift_actions.n; i++) {
+ for (j = 0; j < to->shift_actions.n; j++)
+ if (from->shift_actions.v[i]->term == to->shift_actions.v[j]->term)
+ goto Lnext;
+ vec_add(&to->shift_actions, from->shift_actions.v[i]);
+ Lnext:;
+ }
+ }
+
+ static void
+ compute_declaration_states(Grammar *g, Production *p, Declaration *d) {
+ State *s, *base_s = NULL;
+ int j, k, scanner = scanner_declaration(d);
+
+ for (j = 0; j < g->states.n; j++) {
+ s = g->states.v[j];
+ if (d->kind == DECLARE_TOKENIZE) {
+ if (!base_s)
+ base_s = s;
+ else {
+ s->same_shifts = base_s;
+ merge_shift_actions(base_s, s);
+ }
+ }
+ if (scanner) {
+ for (k = 0; k < s->items.n; k++)
+ if (s->items.v[k]->kind == ELEM_TERM)
+ switch (s->items.v[k]->e.term->scan_kind) {
+ case D_SCAN_LONGEST:
+ if (s->scan_kind == D_SCAN_RESERVED ||
+ s->scan_kind == D_SCAN_LONGEST)
+ s->scan_kind = D_SCAN_LONGEST;
+ else
+ s->scan_kind = D_SCAN_MIXED;
+ break;
+ case D_SCAN_ALL:
+ if (s->scan_kind == D_SCAN_RESERVED ||
+ s->scan_kind == D_SCAN_ALL)
+ s->scan_kind = D_SCAN_ALL;
+ else
+ s->scan_kind = D_SCAN_MIXED;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ }
+
+ static void
+ map_declarations_to_states(Grammar *g) {
+ int i;
+ State *s;
+
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ s->scan_kind = D_SCAN_RESERVED;
+ }
+ /* map groups to sets of states */
+ for (i = 0; i < g->declarations.n; i++)
+ if (scanner_declaration(g->declarations.v[i]))
+ compute_declaration_states(g, g->declarations.v[i]->elem->e.nterm,
+ g->declarations.v[i]);
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ if (s->scan_kind == D_SCAN_RESERVED)
+ s->scan_kind = D_SCAN_DEFAULT; /* set the default */
+ }
+ }
+
+ int
+ build_grammar(Grammar *g) {
+ resolve_grammar(g);
+ convert_regex_productions(g);
+ propogate_declarations(g);
+ merge_identical_terminals(g);
+ make_elems_for_productions(g);
+ check_default_actions(g);
+ build_LR_tables(g);
+ map_declarations_to_states(g);
+ if (verbose_level) {
+ printf("%d productions %d terminals %d states %d declarations\n",
+ g->productions.n, g->terminals.n, g->states.n,
+ g->declarations.n);
+ }
+ if (verbose_level > 1) {
+ print_grammar(g);
+ print_states(g);
+ }
+ build_scanners(g);
+ build_eq(g);
+ return 0;
+ }
Index: llvm/test/Programs/MultiSource/Applications/d/gram.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/gram.h:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/gram.h Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,268 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+
+ #ifndef _gram_H_
+ #define _gram_H_
+
+ #define EOF_SENTINAL "\377"
+ #define NO_PROD 0xFFFFFFFF
+
+ struct Production;
+ struct Rule;
+ struct Elem;
+ struct Term;
+ struct State;
+ struct ScanState;
+ struct ScanStateTransition;
+ struct D_ParserTables;
+
+ typedef struct Elem Item;
+
+ typedef struct Code {
+ char *code;
+ int line;
+ } Code;
+
+ typedef struct Goto {
+ struct Elem *elem;
+ struct State *state;
+ } Goto;
+ typedef Vec(Goto *) VecGoto;
+
+ typedef enum ActionKind {
+ ACTION_ACCEPT, ACTION_SHIFT, ACTION_REDUCE
+ } ActionKind;
+ typedef struct Action {
+ ActionKind kind;
+ struct Term *term;
+ struct Rule *rule;
+ struct State *state;
+ uint index;
+ char *temp_string;
+ } Action;
+ typedef Vec(Action *) VecAction;
+
+ typedef struct Hint {
+ uint depth;
+ struct State *state;
+ struct Rule *rule;
+ } Hint;
+ typedef Vec(Hint *) VecHint;
+
+ typedef Vec(struct ScanStateTransition*) VecScanStateTransition;
+ typedef Vec(struct ScanState *) VecScanState;
+
+ typedef struct Scanner {
+ VecScanState states;
+ VecScanStateTransition transitions;
+ } Scanner;
+
+ typedef struct State {
+ uint index;
+ uint64 hash;
+ Vec(Item*) items;
+ Vec(Item*) items_hash;
+ VecGoto gotos;
+ VecAction shift_actions;
+ VecAction reduce_actions;
+ VecHint right_epsilon_hints;
+ VecHint error_recovery_hints;
+ Scanner scanner;
+ uint accept:1;
+ uint scanner_code:1;
+ uint goto_on_token:1;
+ uint scan_kind:2;
+ uint8 *goto_valid;
+ int goto_table_offset;
+ struct State *same_shifts;
+ struct State *reduces_to;
+ struct Rule *reduces_with;
+ struct Rule *reduces_to_then_with;
+ } State;
+
+ #define ASSOC_LEFT 0x0001
+ #define ASSOC_RIGHT 0x0002
+ #define ASSOC_NARY 0x0004
+ #define ASSOC_UNARY 0x0008
+ #define ASSOC_BINARY 0x0010
+
+ typedef enum AssocKind {
+ ASSOC_NONE = 0,
+ ASSOC_NARY_LEFT = (ASSOC_NARY|ASSOC_LEFT),
+ ASSOC_NARY_RIGHT = (ASSOC_NARY|ASSOC_RIGHT),
+ ASSOC_UNARY_LEFT = (ASSOC_UNARY|ASSOC_LEFT),
+ ASSOC_UNARY_RIGHT = (ASSOC_UNARY|ASSOC_RIGHT),
+ ASSOC_BINARY_LEFT = (ASSOC_BINARY|ASSOC_LEFT),
+ ASSOC_BINARY_RIGHT = (ASSOC_BINARY|ASSOC_RIGHT),
+ ASSOC_NO = 0x0020
+ } AssocKind;
+ #define IS_RIGHT_ASSOC(_x) ((_x) & ASSOC_RIGHT)
+ #define IS_LEFT_ASSOC(_x) ((_x) & ASSOC_LEFT)
+ #define IS_NARY_ASSOC(_x) ((_x) & ASSOC_NARY)
+ #define IS_BINARY_ASSOC(_x) ((_x) & ASSOC_BINARY)
+ #define IS_UNARY_ASSOC(_x) ((_x) & ASSOC_UNARY)
+ #define IS_UNARY_BINARY_ASSOC(_x) (IS_BINARY_ASSOC(_x) || IS_UNARY_ASSOC(_x))
+ #define IS_BINARY_NARY_ASSOC(_x) (IS_BINARY_ASSOC(_x) || IS_NARY_ASSOC(_x))
+ /* not valid for NARY */
+ #define IS_EXPECT_RIGHT_ASSOC(_x) ((_x) && (_x) != ASSOC_UNARY_LEFT)
+ #define IS_EXPECT_LEFT_ASSOC(_x) ((_x) && _x != ASSOC_UNARY_RIGHT)
+ typedef struct Rule {
+ uint index;
+ struct Production *prod;
+ int op_priority;
+ AssocKind op_assoc;
+ int rule_priority;
+ AssocKind rule_assoc;
+ Vec(struct Elem*) elems;
+ struct Elem *end;
+ Code speculative_code;
+ Code final_code;
+ Vec(Code*) pass_code;
+ int action_index;
+ struct Rule *same_reduction;
+ } Rule;
+
+ typedef enum TermKind {
+ TERM_STRING, TERM_REGEX, TERM_CODE, TERM_TOKEN
+ } TermKind;
+ typedef struct Term {
+ TermKind kind;
+ uint index;
+ int term_priority;
+ AssocKind op_assoc;
+ int op_priority;
+ char *string;
+ int string_len;
+ uint scan_kind:3;
+ uint ignore_case:1;
+ struct Production *regex_production;
+ } Term;
+
+ typedef Vec(Term *) TermVec;
+
+ typedef enum DeclarationKind {
+ DECLARE_TOKENIZE, DECLARE_LONGEST_MATCH, DECLARE_ALL_MATCHES,
+ DECLARE_SET_OP_PRIORITY, DECLARE_STATES_FOR_ALL_NTERMS,
+ DECLARE_STATE_FOR, DECLARE_WHITESPACE, DECLARE_SAVE_PARSE_TREE, DECLARE_NUM
+ } DeclarationKind;
+ typedef struct Declaration {
+ struct Elem * elem;
+ uint kind;
+ uint index;
+ } Declaration;
+
+ typedef enum InternalKind {
+ INTERNAL_NOT, INTERNAL_HIDDEN, INTERNAL_CONDITIONAL, INTERNAL_STAR, INTERNAL_PLUS
+ } InternalKind;
+
+ typedef struct Production {
+ char *name;
+ uint name_len;
+ Vec(Rule *) rules;
+ uint index;
+ uint regex:1;
+ uint in_regex:1;
+ uint internal:3; /* production used for EBNF */
+ Rule *nullable; /* shortest rule for epsilon reduction */
+ struct Production *declaration_group[DECLARE_NUM];
+ struct Declaration *last_declaration[DECLARE_NUM];
+ State *state; /* state for independent parsing of this productions*/
+ struct Elem *elem; /* base elem for the item set of the above state */
+ struct Term *regex_term; /* regex production terminal */
+ struct Production *next;
+ } Production;
+
+ typedef enum ElemKind {
+ ELEM_NTERM, ELEM_TERM, ELEM_UNRESOLVED, ELEM_END
+ } ElemKind;
+ typedef struct Elem {
+ ElemKind kind;
+ uint index;
+ Rule *rule;
+ union {
+ Production *nterm;
+ Term *term;
+ void *term_or_nterm;
+ struct Unresolved {
+ char *string;
+ uint len;
+ } unresolved;
+ } e;
+ } Elem;
+
+ typedef struct Grammar {
+ char *pathname;
+ Vec(Production *) productions;
+ Vec(Term *) terminals;
+ Vec(State *) states;
+ Code scanner;
+ Code *code;
+ int ncode;
+ Vec(Declaration *) declarations;
+ Vec(D_Pass *) passes;
+ char *default_white_space;
+ /* grammar construction options */
+ int set_op_priority_from_rule;
+ int right_recursive_BNF;
+ int states_for_whitespace;
+ int states_for_all_nterms;
+ int tokenizer;
+ int longest_match;
+ int save_parse_tree;
+ /* grammar writing options */
+ char grammar_ident[256];
+ int scanner_blocks;
+ int scanner_block_size;
+ int write_line_directives;
+ int write_header;
+ int token_type;
+ /* temporary variables for grammar construction */
+ struct Production * p;
+ struct Rule * r;
+ struct Elem * e;
+ int action_index;
+ int action_count;
+ int pass_index;
+ int rule_index;
+ } Grammar;
+
+ /* automatically add %op_XXX to rightmost token of %XXX rule, default off */
+
+ Grammar *new_D_Grammar(char *pathname);
+ void free_D_Grammar(Grammar *g);
+ int build_grammar(Grammar *g);
+ int parse_grammar(Grammar *g, D_ParserTables *t, int sizeof_ParseNode_User);
+ void print_grammar(Grammar *g);
+ void print_states(Grammar *g);
+ void print_rule(Rule *r);
+ void print_term(Term *t);
+ Production *lookup_production(Grammar *g, char *name, int len);
+
+ /* for creating grammars */
+ #define last_elem(_r) ((_r)->elems.v[(_r)->elems.n-1])
+
+ Rule *new_rule(Grammar *g, Production *p);
+ Elem *new_elem_nterm(Production *p, Rule *r);
+ void new_declaration(Grammar *g, Elem *e, uint kind);
+ Production *new_production(Grammar *g, char *name);
+ Elem *new_string(Grammar *g, char *s, char *e, Rule *r);
+ Elem *new_ident(char *s, char *e, Rule *r);
+ void new_token(Grammar *g, char *s, char *e);
+ Elem *new_code(Grammar *g, char *s, char *e, Rule *r);
+ void add_global_code(Grammar *g, char *start, char *end, int line);
+ Production *new_internal_production(Grammar *g, Production *p);
+ Elem * dup_elem(Elem *e, Rule *r);
+ void add_declaration(Grammar *g, char *start, char *end, uint kind, uint line);
+ void add_pass(Grammar *g, char *start, char *end, uint kind, uint line);
+ void add_pass_code(Grammar *g, Rule *r, char *pass_start, char *pass_end,
+ char *code_start, char *code_end, uint line, uint pass_line);
+ D_Pass *find_pass(Grammar *g, char *start, char *end);
+ void conditional_EBNF(Grammar *g); /* applied to g->e,g->r,g->p */
+ void star_EBNF(Grammar *g); /* ditto */
+ void plus_EBNF(Grammar *g); /* ditto */
+ void initialize_productions(Grammar *g);
+ void finalize_productions(Grammar *g);
+ int state_for_declaration(Grammar *g, int iproduction);
+
+ #endif
Index: llvm/test/Programs/MultiSource/Applications/d/gramgram.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/gramgram.h:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/gramgram.h Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,18 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+ struct Production;
+ struct Rule;
+ struct Elem;
+
+ typedef struct ParseNode_User {
+ struct Production *p;
+ struct Rule *r;
+ struct Elem *e;
+ unsigned int kind;
+ } ParseNode_User;
+
+ #define D_ParseNode_User ParseNode_User
+
+ #define D_ParseNode_Globals struct Grammar
+
Index: llvm/test/Programs/MultiSource/Applications/d/grammar.g.c
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/grammar.g.c:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/grammar.g.c Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,5697 ----
+ #line 4 "grammar.g"
+
+ #include "gramgram.h"
+ #include "d.h"
+
+ #include "dparse.h"
+
+ D_Reduction d_reduction_0_dparser_gram = {1, 0, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_1_dparser_gram = {1, 1, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_2_dparser_gram = {2, 2, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_3_dparser_gram = {2, 3, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_4_dparser_gram = {1, 3, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_5_dparser_gram = {2, 4, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_6_dparser_gram = {2, 5, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_7_dparser_gram = {0, 5, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_8_dparser_gram = {2, 6, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_9_dparser_gram = {0, 6, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ int d_final_reduction_code_7_10_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 11 "grammar.g"
+
+ add_global_code((D_PN(_ps, _offset)->globals), (*(D_PN(_children[0], _offset))).start_loc.s+1, (*(D_PN(_children[0], _offset))).end-1,
+ (*(D_PN(_children[0], _offset))).start_loc.line);
+ return 0;}
+
+ D_Reduction d_reduction_10_dparser_gram = {1, 7, NULL, d_final_reduction_code_7_10_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_7_11_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 15 "grammar.g"
+
+ (D_PN(_ps, _offset)->globals)->scanner.code = dup_str((*(D_PN(_children[1], _offset))).start_loc.s, (*(D_PN(_children[1], _offset))).end);
+ (D_PN(_ps, _offset)->globals)->scanner.line = (*(D_PN(_children[0], _offset))).start_loc.line;
+ return 0;}
+
+ D_Reduction d_reduction_11_dparser_gram = {3, 7, NULL, d_final_reduction_code_7_11_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_7_12_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 19 "grammar.g"
+
+ if (!d_get_number_of_children(&(*(D_PN(_children[2], _offset)))))
+ add_declaration((D_PN(_ps, _offset)->globals), (*(D_PN(_children[2], _offset))).start_loc.s, (*(D_PN(_children[2], _offset))).end, (D_PN(_children[1], _offset)->user).kind, (*(D_PN(_children[2], _offset))).start_loc.line);
+ else {
+ int i, n = d_get_number_of_children(&(*(D_PN(_children[2], _offset))));
+ for (i = 0; i < n; i++) {
+ D_ParseNode *pn = d_get_child(&(*(D_PN(_children[2], _offset))), i);
+ add_declaration((D_PN(_ps, _offset)->globals), pn->start_loc.s, pn->end, (D_PN(_children[1], _offset)->user).kind, pn->start_loc.line);
+ }
+ }
+ return 0;}
+
+ D_Reduction d_reduction_12_dparser_gram = {4, 7, NULL, d_final_reduction_code_7_12_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_13_dparser_gram = {3, 7, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_7_14_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 31 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->action_index++; return 0;}
+
+ D_Reduction d_reduction_14_dparser_gram = {1, 7, NULL, d_final_reduction_code_7_14_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_7_15_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 32 "grammar.g"
+
+ add_pass((D_PN(_ps, _offset)->globals), (*(D_PN(_children[1], _offset))).start_loc.s, (*(D_PN(_children[1], _offset))).end, (D_PN(_children[2], _offset)->user).kind, (*(D_PN(_children[1], _offset))).start_loc.line);
+ return 0;}
+
+ D_Reduction d_reduction_15_dparser_gram = {4, 7, NULL, d_final_reduction_code_7_15_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_16_dparser_gram = {2, 8, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_17_dparser_gram = {1, 8, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_18_dparser_gram = {2, 9, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_19_dparser_gram = {0, 9, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_20_dparser_gram = {2, 10, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_21_dparser_gram = {1, 10, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_22_dparser_gram = {0, 11, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_11_23_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 38 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind = (D_PN(_children[0], _offset)->user).kind | (D_PN(_children[1], _offset)->user).kind; return 0;}
+
+ D_Reduction d_reduction_23_dparser_gram = {2, 11, NULL, d_final_reduction_code_11_23_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_12_24_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 41 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind |= D_PASS_PRE_ORDER; return 0;}
+
+ D_Reduction d_reduction_24_dparser_gram = {1, 12, NULL, d_final_reduction_code_12_24_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_12_25_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 42 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind |= D_PASS_POST_ORDER; return 0;}
+
+ D_Reduction d_reduction_25_dparser_gram = {1, 12, NULL, d_final_reduction_code_12_25_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_12_26_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 43 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind |= D_PASS_MANUAL; return 0;}
+
+ D_Reduction d_reduction_26_dparser_gram = {1, 12, NULL, d_final_reduction_code_12_26_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_12_27_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 44 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind |= D_PASS_FOR_ALL; return 0;}
+
+ D_Reduction d_reduction_27_dparser_gram = {1, 12, NULL, d_final_reduction_code_12_27_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_12_28_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 45 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind |= D_PASS_FOR_UNDEFINED; return 0;}
+
+ D_Reduction d_reduction_28_dparser_gram = {1, 12, NULL, d_final_reduction_code_12_28_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_13_29_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 48 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind = DECLARE_TOKENIZE; return 0;}
+
+ D_Reduction d_reduction_29_dparser_gram = {1, 13, NULL, d_final_reduction_code_13_29_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_13_30_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 49 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind = DECLARE_LONGEST_MATCH; return 0;}
+
+ D_Reduction d_reduction_30_dparser_gram = {1, 13, NULL, d_final_reduction_code_13_30_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_13_31_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 50 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind = DECLARE_WHITESPACE; return 0;}
+
+ D_Reduction d_reduction_31_dparser_gram = {1, 13, NULL, d_final_reduction_code_13_31_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_13_32_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 51 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind = DECLARE_ALL_MATCHES; return 0;}
+
+ D_Reduction d_reduction_32_dparser_gram = {1, 13, NULL, d_final_reduction_code_13_32_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_13_33_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 52 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind = DECLARE_SET_OP_PRIORITY; return 0;}
+
+ D_Reduction d_reduction_33_dparser_gram = {1, 13, NULL, d_final_reduction_code_13_33_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_13_34_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 53 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind = DECLARE_STATES_FOR_ALL_NTERMS; return 0;}
+
+ D_Reduction d_reduction_34_dparser_gram = {1, 13, NULL, d_final_reduction_code_13_34_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_13_35_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 54 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind = DECLARE_STATE_FOR; return 0;}
+
+ D_Reduction d_reduction_35_dparser_gram = {1, 13, NULL, d_final_reduction_code_13_35_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_13_36_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 55 "grammar.g"
+ (D_PN(_ps, _offset)->user).kind = DECLARE_SAVE_PARSE_TREE; return 0;}
+
+ D_Reduction d_reduction_36_dparser_gram = {1, 13, NULL, d_final_reduction_code_13_36_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_14_37_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 58 "grammar.g"
+ new_token((D_PN(_ps, _offset)->globals), (*(D_PN(_children[0], _offset))).start_loc.s, (*(D_PN(_children[0], _offset))).end); return 0;}
+
+ D_Reduction d_reduction_37_dparser_gram = {1, 14, NULL, d_final_reduction_code_14_37_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_38_dparser_gram = {4, 15, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_40_dparser_gram = {1, 15, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_16_41_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 63 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->p->regex = 1; return 0;}
+
+ D_Reduction d_reduction_41_dparser_gram = {1, 16, NULL, d_final_reduction_code_16_41_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_17_42_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 66 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->p = new_production((D_PN(_ps, _offset)->globals), dup_str((*(D_PN(_children[0], _offset))).start_loc.s, (*(D_PN(_children[0], _offset))).end)); return 0;}
+
+ D_Reduction d_reduction_42_dparser_gram = {1, 17, NULL, d_final_reduction_code_17_42_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_43_dparser_gram = {1, 18, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_45_dparser_gram = {2, 19, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_46_dparser_gram = {2, 20, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_47_dparser_gram = {0, 20, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_48_dparser_gram = {2, 21, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ int d_final_reduction_code_22_49_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 71 "grammar.g"
+
+ vec_add(&(D_PN(_ps, _offset)->globals)->p->rules, (D_PN(_ps, _offset)->globals)->r);
+ return 0;}
+
+ D_Reduction d_reduction_49_dparser_gram = {4, 22, NULL, d_final_reduction_code_22_49_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_50_dparser_gram = {2, 23, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_51_dparser_gram = {0, 23, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_52_dparser_gram = {1, 24, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_53_dparser_gram = {0, 24, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_54_dparser_gram = {3, 25, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_55_dparser_gram = {2, 26, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_56_dparser_gram = {0, 26, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_57_dparser_gram = {2, 27, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_58_dparser_gram = {0, 27, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_59_dparser_gram = {2, 28, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_60_dparser_gram = {2, 29, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_61_dparser_gram = {0, 29, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ int d_final_reduction_code_30_62_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 75 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->r = new_rule((D_PN(_ps, _offset)->globals), (D_PN(_ps, _offset)->globals)->p); return 0;}
+
+ D_Reduction d_reduction_62_dparser_gram = {0, 30, NULL, d_final_reduction_code_30_62_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_31_63_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 78 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->e = new_string((D_PN(_ps, _offset)->globals), (*(D_PN(_children[0], _offset))).start_loc.s, (*(D_PN(_children[0], _offset))).end, (D_PN(_ps, _offset)->globals)->r); return 0;}
+
+ D_Reduction d_reduction_63_dparser_gram = {1, 31, NULL, d_final_reduction_code_31_63_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_31_64_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 79 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->e = new_string((D_PN(_ps, _offset)->globals), (*(D_PN(_children[0], _offset))).start_loc.s, (*(D_PN(_children[0], _offset))).end, (D_PN(_ps, _offset)->globals)->r); return 0;}
+
+ D_Reduction d_reduction_64_dparser_gram = {1, 31, NULL, d_final_reduction_code_31_64_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_31_65_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 80 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->e = new_ident((*(D_PN(_children[0], _offset))).start_loc.s, (*(D_PN(_children[0], _offset))).end, (D_PN(_ps, _offset)->globals)->r); return 0;}
+
+ D_Reduction d_reduction_65_dparser_gram = {1, 31, NULL, d_final_reduction_code_31_65_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_31_66_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 81 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->e = new_code((D_PN(_ps, _offset)->globals), (*(D_PN(_children[1], _offset))).start_loc.s, (*(D_PN(_children[1], _offset))).end, (D_PN(_ps, _offset)->globals)->r); return 0;}
+
+ D_Reduction d_reduction_66_dparser_gram = {3, 31, NULL, d_final_reduction_code_31_66_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_31_67_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 82 "grammar.g"
+
+ (D_PN(_ps, _offset)->globals)->e = new_elem_nterm((D_PN(_ps, _offset)->globals)->p, (D_PN(_children[1], _offset)->user).r);
+ (D_PN(_ps, _offset)->globals)->p = (D_PN(_children[1], _offset)->user).p;
+ (D_PN(_ps, _offset)->globals)->r = (D_PN(_children[1], _offset)->user).r;
+ vec_add(&(D_PN(_ps, _offset)->globals)->r->elems, (D_PN(_ps, _offset)->globals)->e);
+ return 0;}
+
+ D_Reduction d_reduction_67_dparser_gram = {4, 31, NULL, d_final_reduction_code_31_67_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_68_dparser_gram = {2, 32, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_69_dparser_gram = {1, 32, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_70_dparser_gram = {1, 33, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_33_71_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 92 "grammar.g"
+
+ Production *p = new_internal_production((D_PN(_ps, _offset)->globals), NULL);
+ Rule *r = new_rule((D_PN(_ps, _offset)->globals), p);
+ vec_add(&p->rules, r);
+ r->speculative_code.code = dup_str((*(D_PN(_children[0], _offset))).start_loc.s + 1, (*(D_PN(_children[0], _offset))).end - 1);
+ r->speculative_code.line = (*(D_PN(_children[0], _offset))).start_loc.line;
+ (D_PN(_ps, _offset)->globals)->e = new_elem_nterm(p, (D_PN(_ps, _offset)->globals)->r);
+ vec_add(&(D_PN(_ps, _offset)->globals)->r->elems, (D_PN(_ps, _offset)->globals)->e);
+ return 0;}
+
+ D_Reduction d_reduction_71_dparser_gram = {1, 33, NULL, d_final_reduction_code_33_71_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_33_72_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 101 "grammar.g"
+
+ Production *p = new_internal_production((D_PN(_ps, _offset)->globals), NULL);
+ Rule *r = new_rule((D_PN(_ps, _offset)->globals), p);
+ vec_add(&p->rules, r);
+ r->final_code.code = dup_str((*(D_PN(_children[0], _offset))).start_loc.s + 1, (*(D_PN(_children[0], _offset))).end - 1);
+ r->final_code.line = (*(D_PN(_children[0], _offset))).start_loc.line;
+ (D_PN(_ps, _offset)->globals)->e = new_elem_nterm(p, (D_PN(_ps, _offset)->globals)->r);
+ vec_add(&(D_PN(_ps, _offset)->globals)->r->elems, (D_PN(_ps, _offset)->globals)->e);
+ return 0;}
+
+ D_Reduction d_reduction_72_dparser_gram = {1, 33, NULL, d_final_reduction_code_33_72_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_34_73_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 112 "grammar.g"
+
+ (D_PN(_ps, _offset)->user).p = (D_PN(_ps, _offset)->globals)->p;
+ (D_PN(_ps, _offset)->user).r = (D_PN(_ps, _offset)->globals)->r;
+ (D_PN(_ps, _offset)->globals)->p = new_internal_production((D_PN(_ps, _offset)->globals), (D_PN(_ps, _offset)->globals)->p);
+ (D_PN(_ps, _offset)->globals)->r = new_rule((D_PN(_ps, _offset)->globals), (D_PN(_ps, _offset)->globals)->p);
+ return 0;}
+
+ D_Reduction d_reduction_73_dparser_gram = {0, 34, NULL, d_final_reduction_code_34_73_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_35_74_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 120 "grammar.g"
+
+ if ((D_PN(_ps, _offset)->globals)->e->kind != ELEM_TERM)
+ d_fail("terminal priority on non-terminal");
+ (D_PN(_ps, _offset)->globals)->e->e.term->term_priority = strtol((*(D_PN(_children[1], _offset))).start_loc.s, NULL, 0);
+ return 0;}
+
+ D_Reduction d_reduction_74_dparser_gram = {2, 35, NULL, d_final_reduction_code_35_74_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_35_75_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 125 "grammar.g"
+
+ if ((D_PN(_ps, _offset)->globals)->e->kind != ELEM_TERM)
+ d_fail("ignore-case (/i) on non-terminal");
+ (D_PN(_ps, _offset)->globals)->e->e.term->ignore_case = 1;
+ return 0;}
+
+ D_Reduction d_reduction_75_dparser_gram = {1, 35, NULL, d_final_reduction_code_35_75_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_35_76_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 130 "grammar.g"
+ conditional_EBNF((D_PN(_ps, _offset)->globals)); return 0;}
+
+ D_Reduction d_reduction_76_dparser_gram = {1, 35, NULL, d_final_reduction_code_35_76_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_35_77_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 131 "grammar.g"
+ star_EBNF((D_PN(_ps, _offset)->globals)); return 0;}
+
+ D_Reduction d_reduction_77_dparser_gram = {1, 35, NULL, d_final_reduction_code_35_77_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_35_78_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 132 "grammar.g"
+ plus_EBNF((D_PN(_ps, _offset)->globals)); return 0;}
+
+ D_Reduction d_reduction_78_dparser_gram = {1, 35, NULL, d_final_reduction_code_35_78_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_79_dparser_gram = {2, 36, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_37_80_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 137 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->r->op_assoc = ASSOC_UNARY_RIGHT; return 0;}
+
+ D_Reduction d_reduction_80_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_80_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_37_81_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 138 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->r->op_assoc = ASSOC_UNARY_LEFT; return 0;}
+
+ D_Reduction d_reduction_81_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_81_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_37_82_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 139 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->r->op_assoc = ASSOC_BINARY_RIGHT; return 0;}
+
+ D_Reduction d_reduction_82_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_82_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_37_83_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 140 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->r->op_assoc = ASSOC_BINARY_LEFT; return 0;}
+
+ D_Reduction d_reduction_83_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_83_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_37_84_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 141 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->r->rule_assoc = ASSOC_UNARY_RIGHT; return 0;}
+
+ D_Reduction d_reduction_84_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_84_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_37_85_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 142 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->r->rule_assoc = ASSOC_UNARY_LEFT; return 0;}
+
+ D_Reduction d_reduction_85_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_85_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_37_86_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 143 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->r->rule_assoc = ASSOC_BINARY_RIGHT; return 0;}
+
+ D_Reduction d_reduction_86_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_86_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_37_87_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 144 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->r->rule_assoc = ASSOC_BINARY_LEFT; return 0;}
+
+ D_Reduction d_reduction_87_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_87_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_37_88_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 145 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->r->rule_assoc = ASSOC_NARY_RIGHT; return 0;}
+
+ D_Reduction d_reduction_88_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_88_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_37_89_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 146 "grammar.g"
+ (D_PN(_ps, _offset)->globals)->r->rule_assoc = ASSOC_NARY_LEFT; return 0;}
+
+ D_Reduction d_reduction_89_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_89_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_38_90_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 149 "grammar.g"
+
+ if ((D_PN(_ps, _offset)->globals)->r->op_assoc) (D_PN(_ps, _offset)->globals)->r->op_priority = strtol((*(D_PN(_children[0], _offset))).start_loc.s, NULL, 0);
+ else (D_PN(_ps, _offset)->globals)->r->rule_priority = strtol((*(D_PN(_children[0], _offset))).start_loc.s, NULL, 0);
+ return 0;}
+
+ D_Reduction d_reduction_90_dparser_gram = {1, 38, NULL, d_final_reduction_code_38_90_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_91_dparser_gram = {3, 39, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_92_dparser_gram = {2, 40, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_93_dparser_gram = {0, 40, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_94_dparser_gram = {1, 41, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_95_dparser_gram = {0, 41, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_96_dparser_gram = {1, 42, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_97_dparser_gram = {0, 42, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ int d_final_reduction_code_43_98_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 156 "grammar.g"
+
+ (D_PN(_ps, _offset)->globals)->r->speculative_code.code = dup_str((*(D_PN(_children[0], _offset))).start_loc.s + 1, (*(D_PN(_children[0], _offset))).end - 1);
+ (D_PN(_ps, _offset)->globals)->r->speculative_code.line = (*(D_PN(_children[0], _offset))).start_loc.line;
+ return 0;}
+
+ D_Reduction d_reduction_98_dparser_gram = {1, 43, NULL, d_final_reduction_code_43_98_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_44_99_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 161 "grammar.g"
+
+ (D_PN(_ps, _offset)->globals)->r->final_code.code = dup_str((*(D_PN(_children[0], _offset))).start_loc.s + 1, (*(D_PN(_children[0], _offset))).end - 1);
+ (D_PN(_ps, _offset)->globals)->r->final_code.line = (*(D_PN(_children[0], _offset))).start_loc.line;
+ return 0;}
+
+ D_Reduction d_reduction_99_dparser_gram = {1, 44, NULL, d_final_reduction_code_44_99_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ int d_final_reduction_code_45_100_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) {
+ #line 166 "grammar.g"
+
+ add_pass_code((D_PN(_ps, _offset)->globals), (D_PN(_ps, _offset)->globals)->r, (*(D_PN(_children[0], _offset))).start_loc.s, (*(D_PN(_children[0], _offset))).end, (*(D_PN(_children[2], _offset))).start_loc.s+1,
+ (*(D_PN(_children[2], _offset))).end-1, (*(D_PN(_children[0], _offset))).start_loc.line, (*(D_PN(_children[2], _offset))).start_loc.line);
+ return 0;}
+
+ D_Reduction d_reduction_100_dparser_gram = {3, 45, NULL, d_final_reduction_code_45_100_dparser_gram, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_101_dparser_gram = {3, 46, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_102_dparser_gram = {2, 47, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_103_dparser_gram = {0, 47, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_104_dparser_gram = {3, 48, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_105_dparser_gram = {2, 49, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_106_dparser_gram = {0, 49, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_107_dparser_gram = {3, 50, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_110_dparser_gram = {1, 50, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_115_dparser_gram = {2, 51, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_116_dparser_gram = {0, 51, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_117_dparser_gram = {2, 52, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_118_dparser_gram = {0, 52, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_119_dparser_gram = {2, 53, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_120_dparser_gram = {0, 53, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL};
+ D_Reduction d_reduction_121_dparser_gram = {1, 54, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_122_dparser_gram = {1, 55, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_123_dparser_gram = {1, 56, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_124_dparser_gram = {1, 57, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_125_dparser_gram = {1, 58, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_128_dparser_gram = {1, 59, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_129_dparser_gram = {1, 60, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Reduction d_reduction_130_dparser_gram = {1, 61, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL};
+ D_Shift d_shift_0_dparser_gram = { 62, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_1_dparser_gram = { 63, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_2_dparser_gram = { 64, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_3_dparser_gram = { 65, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_4_dparser_gram = { 66, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_5_dparser_gram = { 67, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_6_dparser_gram = { 68, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_7_dparser_gram = { 69, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_8_dparser_gram = { 70, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_9_dparser_gram = { 71, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_10_dparser_gram = { 72, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_11_dparser_gram = { 73, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_12_dparser_gram = { 74, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_13_dparser_gram = { 75, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_14_dparser_gram = { 76, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_15_dparser_gram = { 77, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_16_dparser_gram = { 78, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_17_dparser_gram = { 79, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_18_dparser_gram = { 80, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_19_dparser_gram = { 81, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_20_dparser_gram = { 82, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_21_dparser_gram = { 83, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_22_dparser_gram = { 84, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_23_dparser_gram = { 85, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_24_dparser_gram = { 86, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_25_dparser_gram = { 87, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_26_dparser_gram = { 88, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_27_dparser_gram = { 89, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_28_dparser_gram = { 90, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_29_dparser_gram = { 91, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_30_dparser_gram = { 92, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_31_dparser_gram = { 93, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_32_dparser_gram = { 94, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_33_dparser_gram = { 95, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_34_dparser_gram = { 96, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_35_dparser_gram = { 97, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_36_dparser_gram = { 98, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_37_dparser_gram = { 99, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_38_dparser_gram = { 100, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_39_dparser_gram = { 101, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_40_dparser_gram = { 102, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_41_dparser_gram = { 103, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_42_dparser_gram = { 104, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_43_dparser_gram = { 105, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_44_dparser_gram = { 106, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_45_dparser_gram = { 107, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_46_dparser_gram = { 108, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_47_dparser_gram = { 109, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_48_dparser_gram = { 110, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_49_dparser_gram = { 111, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_50_dparser_gram = { 112, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_51_dparser_gram = { 113, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_52_dparser_gram = { 114, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_53_dparser_gram = { 115, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_54_dparser_gram = { 116, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_55_dparser_gram = { 117, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_56_dparser_gram = { 118, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_57_dparser_gram = { 119, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_58_dparser_gram = { 120, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_59_dparser_gram = { 121, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_60_dparser_gram = { 122, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_61_dparser_gram = { 123, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_62_dparser_gram = { 124, 0, 0, 0, -1, NULL };
+ D_Shift d_shift_63_dparser_gram = { 125, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_64_dparser_gram = { 126, 0, 0, 0, 0, NULL };
+ D_Shift d_shift_65_dparser_gram = { 127, 0, 0, 0, 0, NULL };
+
+ D_Shift *d_shifts_3_dparser_gram[] = {
+ &d_shift_0_dparser_gram, &d_shift_2_dparser_gram, &d_shift_4_dparser_gram, &d_shift_6_dparser_gram, &d_shift_7_dparser_gram, &d_shift_23_dparser_gram, &d_shift_27_dparser_gram, &d_shift_49_dparser_gram, &d_shift_62_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_3_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_3_1_dparser_gram[] = {&d_shift_27_dparser_gram,0};
+ D_Shift **d_accepts_diff_3_dparser_gram[] = {
+ d_accepts_diff_3_0_dparser_gram,
+ d_accepts_diff_3_1_dparser_gram
+ };
+
+ unsigned char d_scanner_3_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,
+ };
+
+ unsigned char d_accepts_diff_3_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
+ 4,4,4,4,4,4,4,4,4,4,4,0,0,0,0,5,
+ 0,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
+ 4,4,4,4,4,4,4,4,4,4,4,6,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_0_2_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,
+ };
+
+ D_Shift *d_shift_3_2_dparser_gram[] = { &d_shift_23_dparser_gram, NULL};
+
+ unsigned char d_scanner_3_3_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 4,4,4,4,4,4,4,4,4,4,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
+ 4,4,4,4,4,4,4,4,4,4,4,0,0,0,0,4,
+ 0,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
+ 4,4,4,4,4,4,4,4,4,4,4,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_3_3_dparser_gram[] = { &d_shift_62_dparser_gram, NULL};
+
+ unsigned char d_accepts_diff_3_4_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,
+ };
+
+ unsigned char d_accepts_diff_3_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+ 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,
+ 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+ 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_3_4_dparser_gram[] = { &d_shift_27_dparser_gram, NULL};
+
+ D_Shift *d_shift_3_5_dparser_gram[] = { &d_shift_49_dparser_gram, NULL};
+
+ unsigned char d_scanner_3_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,8,0,0,9,0,0,0,0,0,0,0,0,0,0,0,
+ 10,0,0,11,12,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,13,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_9_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_10_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_11_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_12_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,18,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_13_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,19,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_14_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,20,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_15_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,21,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_16_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,22,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_17_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,23,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_18_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_19_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,25,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_20_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,26,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_21_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,27,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_22_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_23_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_3_24_dparser_gram[] = { &d_shift_7_dparser_gram, NULL};
+
+ unsigned char d_scanner_3_25_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_26_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_27_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_28_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,33,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_29_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,34,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_3_30_dparser_gram[] = { &d_shift_4_dparser_gram, NULL};
+
+ unsigned char d_scanner_3_31_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,35,0,0,
+ };
+
+ unsigned char d_scanner_3_32_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_3_33_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_3_34_dparser_gram[] = { &d_shift_6_dparser_gram, NULL};
+
+ D_Shift *d_shift_3_35_dparser_gram[] = { &d_shift_2_dparser_gram, NULL};
+
+ D_Shift *d_shift_3_36_dparser_gram[] = { &d_shift_0_dparser_gram, NULL};
+
+ D_Shift *d_shifts_4_dparser_gram[] = {
+ &d_shift_31_dparser_gram, &d_shift_49_dparser_gram, &d_shift_51_dparser_gram, &d_shift_59_dparser_gram, &d_shift_60_dparser_gram, &d_shift_61_dparser_gram, &d_shift_62_dparser_gram, &d_shift_63_dparser_gram, &d_shift_64_dparser_gram, &d_shift_65_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_4_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_4_1_dparser_gram[] = {&d_shift_59_dparser_gram,0};
+ D_Shift *d_accepts_diff_4_2_dparser_gram[] = {&d_shift_65_dparser_gram,0};
+ D_Shift **d_accepts_diff_4_dparser_gram[] = {
+ d_accepts_diff_4_0_dparser_gram,
+ d_accepts_diff_4_1_dparser_gram,
+ d_accepts_diff_4_2_dparser_gram
+ };
+
+ unsigned char d_scanner_4_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,2,3,2,2,2,2,4,5,0,2,2,2,6,2,2,
+ 7,8,8,8,8,8,8,8,8,8,2,2,2,2,2,2,
+ };
+
+ unsigned char d_scanner_4_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 2,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,10,2,0,2,11,
+ 2,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,12,2,0,2,0,
+ };
+
+ D_Shift *d_shift_4_1_dparser_gram[] = { &d_shift_59_dparser_gram, NULL};
+
+ unsigned char d_scanner_4_2_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,14,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ };
+
+ unsigned char d_scanner_4_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,15,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ };
+
+ unsigned char d_scanner_4_2_2_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ };
+
+ unsigned char d_scanner_4_3_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,17,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ };
+
+ unsigned char d_scanner_4_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,18,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ };
+
+ unsigned char d_scanner_4_3_2_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ };
+
+ D_Shift *d_shift_4_4_dparser_gram[] = { &d_shift_31_dparser_gram, NULL};
+
+ unsigned char d_scanner_4_5_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 7,8,8,8,8,8,8,8,8,8,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_4_5_dparser_gram[] = { &d_shift_59_dparser_gram, NULL};
+
+ unsigned char d_scanner_4_6_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 19,19,19,19,19,19,19,19,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_4_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0,
+ 0,0,0,0,0,20,0,0,21,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0,
+ 0,0,0,0,0,20,0,0,22,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_accepts_diff_4_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_4_6_dparser_gram[] = { &d_shift_65_dparser_gram, NULL};
+
+ unsigned char d_scanner_4_7_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 8,8,8,8,8,8,8,8,8,8,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_4_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,23,0,0,0,
+ 0,0,0,0,0,23,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,23,0,0,0,
+ 0,0,0,0,0,23,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_4_7_dparser_gram[] = { &d_shift_63_dparser_gram, NULL};
+
+ unsigned char d_scanner_4_8_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 9,9,9,9,9,9,9,9,9,9,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_4_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,0,0,0,0,9,
+ 0,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_4_9_dparser_gram[] = { &d_shift_51_dparser_gram, NULL};
+
+ D_Shift *d_shift_4_10_dparser_gram[] = { &d_shift_59_dparser_gram, NULL};
+
+ D_Shift *d_shift_4_13_dparser_gram[] = { &d_shift_61_dparser_gram, NULL};
+
+ unsigned char d_scanner_4_14_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
+ 24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
+ 24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
+ 24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
+ };
+
+ unsigned char d_scanner_4_14_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
+ 24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
+ 24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
+ 24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
+ };
+
+ D_Shift *d_shift_4_16_dparser_gram[] = { &d_shift_60_dparser_gram, NULL};
+
+ unsigned char d_scanner_4_17_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
+ 25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
+ 25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
+ 25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
+ };
+
+ unsigned char d_scanner_4_17_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
+ 25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
+ 25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
+ 25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
+ };
+
+ unsigned char d_scanner_4_18_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0,
+ 0,0,0,0,0,20,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0,
+ 0,0,0,0,0,20,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_4_18_dparser_gram[] = { &d_shift_65_dparser_gram, NULL};
+
+ D_Shift *d_shift_4_19_dparser_gram[] = { &d_shift_65_dparser_gram, NULL};
+
+ unsigned char d_scanner_4_20_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 26,26,26,26,26,26,26,26,26,26,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_4_20_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,26,26,26,26,26,26,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,26,26,26,26,26,26,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_4_22_dparser_gram[] = { &d_shift_63_dparser_gram, NULL};
+
+ unsigned char d_scanner_4_25_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,26,26,26,26,26,26,0,0,0,0,0,27,0,0,0,
+ 0,0,0,0,0,27,0,0,0,0,0,0,0,0,0,0,
+ 0,26,26,26,26,26,26,0,0,0,0,0,27,0,0,0,
+ 0,0,0,0,0,27,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_4_25_dparser_gram[] = { &d_shift_64_dparser_gram, NULL};
+
+ D_Shift *d_shift_4_26_dparser_gram[] = { &d_shift_64_dparser_gram, NULL};
+
+ D_Shift *d_shifts_5_dparser_gram[] = {
+ &d_shift_14_dparser_gram, &d_shift_15_dparser_gram, &d_shift_16_dparser_gram, &d_shift_17_dparser_gram, &d_shift_18_dparser_gram, &d_shift_19_dparser_gram, &d_shift_20_dparser_gram, &d_shift_21_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_5_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_5_dparser_gram[] = {
+ d_accepts_diff_5_0_dparser_gram
+ };
+
+ unsigned char d_scanner_5_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,2,0,0,0,0,0,0,0,0,0,0,3,0,0,0,
+ 0,0,0,4,5,0,0,6,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,9,0,0,0,10,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_5_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,13,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_9_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,17,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_10_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,18,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_11_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,19,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_12_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,20,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_13_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,21,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_14_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,22,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_15_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,23,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_16_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_17_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 25,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_18_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,26,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_19_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,27,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_20_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,
+ 0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_21_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_22_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_23_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_24_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,33,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_25_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,34,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_26_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,35,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_27_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_28_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_29_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,38,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_30_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 39,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_31_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_32_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_33_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,42,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_34_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_35_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,44,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_36_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,45,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_37_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,46,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_38_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,47,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_39_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,48,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_40_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,49,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_41_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,50,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_42_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 51,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_43_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,52,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_44_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 53,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_45_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,54,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_46_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,55,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_47_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 56,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_48_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,57,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_49_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,58,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_50_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,59,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_51_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,60,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_52_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,61,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_53_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,62,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_54_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,63,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_55_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,64,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_56_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,65,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_5_57_dparser_gram[] = { &d_shift_14_dparser_gram, NULL};
+
+ unsigned char d_scanner_5_58_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,66,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_59_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,67,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_60_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,68,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_61_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,69,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_62_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,70,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_63_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,71,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_5_64_dparser_gram[] = { &d_shift_20_dparser_gram, NULL};
+
+ unsigned char d_scanner_5_65_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,72,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_66_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,73,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_67_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,74,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_68_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,75,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_69_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,76,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_70_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,77,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_5_71_dparser_gram[] = { &d_shift_16_dparser_gram, NULL};
+
+ D_Shift *d_shift_5_72_dparser_gram[] = { &d_shift_17_dparser_gram, NULL};
+
+ unsigned char d_scanner_5_73_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,78,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_74_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,79,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_75_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,80,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_76_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,81,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_77_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,82,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_78_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,83,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_79_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_80_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_81_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,86,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_5_82_dparser_gram[] = { &d_shift_15_dparser_gram, NULL};
+
+ unsigned char d_scanner_5_83_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,87,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_84_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,88,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_5_85_dparser_gram[] = { &d_shift_19_dparser_gram, NULL};
+
+ unsigned char d_scanner_5_86_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,89,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_87_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,90,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_5_88_dparser_gram[] = { &d_shift_21_dparser_gram, NULL};
+
+ unsigned char d_scanner_5_89_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,91,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_90_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_91_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,93,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_92_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_93_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,95,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_94_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_95_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,97,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_96_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,98,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_97_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,99,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_5_98_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,100,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_5_99_dparser_gram[] = { &d_shift_18_dparser_gram, NULL};
+
+ D_Shift *d_shifts_6_dparser_gram[] = {
+ &d_shift_62_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_6_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_6_dparser_gram[] = {
+ d_accepts_diff_6_0_dparser_gram
+ };
+
+ unsigned char d_scanner_6_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+ 2,2,2,2,2,2,2,2,2,2,2,0,0,0,0,2,
+ 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+ 2,2,2,2,2,2,2,2,2,2,2,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_6_1_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 2,2,2,2,2,2,2,2,2,2,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_accepts_diff_8_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_8_dparser_gram[] = {
+ d_accepts_diff_8_0_dparser_gram
+ };
+
+ D_Shift *d_shifts_13_dparser_gram[] = {
+ &d_shift_23_dparser_gram, &d_shift_27_dparser_gram, &d_shift_62_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_13_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_13_1_dparser_gram[] = {&d_shift_27_dparser_gram,0};
+ D_Shift **d_accepts_diff_13_dparser_gram[] = {
+ d_accepts_diff_13_0_dparser_gram,
+ d_accepts_diff_13_1_dparser_gram
+ };
+
+ unsigned char d_scanner_13_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,
+ };
+
+ unsigned char d_scanner_13_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
+ 3,3,3,3,3,3,3,3,3,3,3,0,0,0,0,4,
+ 0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
+ 3,3,3,3,3,3,3,3,3,3,3,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_13_2_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 3,3,3,3,3,3,3,3,3,3,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_13_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
+ 3,3,3,3,3,3,3,3,3,3,3,0,0,0,0,3,
+ 0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
+ 3,3,3,3,3,3,3,3,3,3,3,0,0,0,0,0,
+ };
+
+ D_Shift *d_shifts_17_dparser_gram[] = {
+ &d_shift_22_dparser_gram, &d_shift_26_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_17_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_17_1_dparser_gram[] = {&d_shift_22_dparser_gram,0};
+ D_Shift **d_accepts_diff_17_dparser_gram[] = {
+ d_accepts_diff_17_0_dparser_gram,
+ d_accepts_diff_17_1_dparser_gram
+ };
+
+ unsigned char d_scanner_17_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_17_1_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,
+ };
+
+ unsigned char d_accepts_diff_17_1_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_17_1_dparser_gram[] = { &d_shift_22_dparser_gram, NULL};
+
+ unsigned char d_scanner_17_2_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,
+ };
+
+ D_Shift *d_shift_17_3_dparser_gram[] = { &d_shift_26_dparser_gram, NULL};
+
+ D_Shift *d_shifts_30_dparser_gram[] = {
+ &d_shift_1_dparser_gram, &d_shift_31_dparser_gram, &d_shift_49_dparser_gram, &d_shift_51_dparser_gram, &d_shift_59_dparser_gram, &d_shift_60_dparser_gram, &d_shift_61_dparser_gram, &d_shift_62_dparser_gram, &d_shift_63_dparser_gram, &d_shift_64_dparser_gram, &d_shift_65_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_30_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_30_1_dparser_gram[] = {&d_shift_59_dparser_gram,0};
+ D_Shift *d_accepts_diff_30_2_dparser_gram[] = {&d_shift_65_dparser_gram,0};
+ D_Shift **d_accepts_diff_30_dparser_gram[] = {
+ d_accepts_diff_30_0_dparser_gram,
+ d_accepts_diff_30_1_dparser_gram,
+ d_accepts_diff_30_2_dparser_gram
+ };
+
+ unsigned char d_scanner_30_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 2,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,10,2,0,2,11,
+ 2,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,12,2,13,2,0,
+ };
+
+ unsigned char d_scanner_30_2_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,15,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ };
+
+ unsigned char d_scanner_30_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,16,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ };
+
+ unsigned char d_scanner_30_2_2_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ };
+
+ unsigned char d_scanner_30_3_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+ 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+ 17,17,17,17,17,17,17,18,17,17,17,17,17,17,17,17,
+ 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+ };
+
+ unsigned char d_scanner_30_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+ 17,17,17,17,17,17,17,17,17,17,17,17,19,17,17,17,
+ 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+ 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+ };
+
+ unsigned char d_scanner_30_3_2_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+ 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+ 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+ 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+ };
+
+ unsigned char d_scanner_30_6_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 20,20,20,20,20,20,20,20,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_30_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,21,0,0,0,
+ 0,0,0,0,0,21,0,0,22,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,21,0,0,0,
+ 0,0,0,0,0,21,0,0,23,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_30_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,
+ 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,
+ 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_30_12_dparser_gram[] = { &d_shift_1_dparser_gram, NULL};
+
+ unsigned char d_scanner_30_18_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,
+ 26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,
+ 26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,
+ 26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,
+ };
+
+ unsigned char d_scanner_30_18_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,
+ 26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,
+ 26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,
+ 26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,
+ };
+
+ unsigned char d_scanner_30_19_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,21,0,0,0,
+ 0,0,0,0,0,21,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,21,0,0,0,
+ 0,0,0,0,0,21,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_30_21_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 27,27,27,27,27,27,27,27,27,27,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_30_21_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,27,27,27,27,27,27,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,27,27,27,27,27,27,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_30_26_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,27,27,27,27,27,27,0,0,0,0,0,28,0,0,0,
+ 0,0,0,0,0,28,0,0,0,0,0,0,0,0,0,0,
+ 0,27,27,27,27,27,27,0,0,0,0,0,28,0,0,0,
+ 0,0,0,0,0,28,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shifts_49_dparser_gram[] = {
+ &d_shift_1_dparser_gram, &d_shift_62_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_49_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_49_dparser_gram[] = {
+ d_accepts_diff_49_0_dparser_gram
+ };
+
+ unsigned char d_scanner_49_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+ 2,2,2,2,2,2,2,2,2,2,2,0,0,0,0,2,
+ 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+ 2,2,2,2,2,2,2,2,2,2,2,0,0,3,0,0,
+ };
+
+ D_Shift *d_shifts_52_dparser_gram[] = {
+ &d_shift_9_dparser_gram, &d_shift_10_dparser_gram, &d_shift_11_dparser_gram, &d_shift_12_dparser_gram, &d_shift_13_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_52_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_52_dparser_gram[] = {
+ d_accepts_diff_52_0_dparser_gram
+ };
+
+ unsigned char d_scanner_52_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,2,0,0,0,0,0,0,3,0,0,
+ 4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,
+ 0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_5_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_9_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_10_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_11_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_12_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,17,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,18,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_13_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,19,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_14_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_15_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,21,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_16_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,22,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_17_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,23,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_19_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,25,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_20_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,26,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_21_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,27,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_22_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,28,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_52_23_dparser_gram[] = { &d_shift_11_dparser_gram, NULL};
+
+ unsigned char d_scanner_52_24_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_52_26_dparser_gram[] = { &d_shift_12_dparser_gram, NULL};
+
+ unsigned char d_scanner_52_27_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_28_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,32,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_30_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,34,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_31_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,35,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_52_32_dparser_gram[] = { &d_shift_9_dparser_gram, NULL};
+
+ unsigned char d_scanner_52_33_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,36,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_52_34_dparser_gram[] = { &d_shift_10_dparser_gram, NULL};
+
+ unsigned char d_scanner_52_35_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,37,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_36_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,38,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_52_37_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,39,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_52_38_dparser_gram[] = { &d_shift_13_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_53_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_53_1_dparser_gram[] = {&d_shift_59_dparser_gram,0};
+ D_Shift *d_accepts_diff_53_2_dparser_gram[] = {&d_shift_65_dparser_gram,0};
+ D_Shift **d_accepts_diff_53_dparser_gram[] = {
+ d_accepts_diff_53_0_dparser_gram,
+ d_accepts_diff_53_1_dparser_gram,
+ d_accepts_diff_53_2_dparser_gram
+ };
+
+ D_Shift *d_shifts_55_dparser_gram[] = {
+ &d_shift_0_dparser_gram, &d_shift_2_dparser_gram, &d_shift_4_dparser_gram, &d_shift_6_dparser_gram, &d_shift_7_dparser_gram, &d_shift_49_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_55_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_55_dparser_gram[] = {
+ d_accepts_diff_55_0_dparser_gram
+ };
+
+ unsigned char d_scanner_55_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,5,0,0,6,0,0,0,0,0,0,0,0,0,0,0,
+ 7,0,0,8,9,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_5_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_11_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,17,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_12_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,18,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_15_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,21,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_16_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,22,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_18_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_19_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,25,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_20_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,26,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_22_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,27,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_23_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_24_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,29,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_25_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_28_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,
+ };
+
+ unsigned char d_scanner_55_29_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,33,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_55_30_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,34,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shifts_59_dparser_gram[] = {
+ &d_shift_31_dparser_gram, &d_shift_32_dparser_gram, &d_shift_49_dparser_gram, &d_shift_51_dparser_gram, &d_shift_59_dparser_gram, &d_shift_60_dparser_gram, &d_shift_61_dparser_gram, &d_shift_62_dparser_gram, &d_shift_63_dparser_gram, &d_shift_64_dparser_gram, &d_shift_65_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_59_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_59_1_dparser_gram[] = {&d_shift_59_dparser_gram,0};
+ D_Shift *d_accepts_diff_59_2_dparser_gram[] = {&d_shift_65_dparser_gram,0};
+ D_Shift **d_accepts_diff_59_dparser_gram[] = {
+ d_accepts_diff_59_0_dparser_gram,
+ d_accepts_diff_59_1_dparser_gram,
+ d_accepts_diff_59_2_dparser_gram
+ };
+
+ unsigned char d_scanner_59_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,2,3,2,2,2,2,4,5,6,2,2,2,7,2,2,
+ 8,9,9,9,9,9,9,9,9,9,2,2,2,2,2,2,
+ };
+
+ unsigned char d_scanner_59_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 2,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,11,2,0,2,12,
+ 2,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,13,2,0,2,0,
+ };
+
+ D_Shift *d_shift_59_5_dparser_gram[] = { &d_shift_32_dparser_gram, NULL};
+
+ unsigned char d_scanner_59_6_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 8,9,9,9,9,9,9,9,9,9,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_59_9_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 10,10,10,10,10,10,10,10,10,10,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_59_9_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,0,0,0,0,10,
+ 0,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,0,0,0,0,0,
+ };
+
+ D_Shift *d_accepts_diff_60_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_60_1_dparser_gram[] = {&d_shift_59_dparser_gram,0};
+ D_Shift *d_accepts_diff_60_2_dparser_gram[] = {&d_shift_65_dparser_gram,0};
+ D_Shift **d_accepts_diff_60_dparser_gram[] = {
+ d_accepts_diff_60_0_dparser_gram,
+ d_accepts_diff_60_1_dparser_gram,
+ d_accepts_diff_60_2_dparser_gram
+ };
+
+ D_Shift *d_shifts_61_dparser_gram[] = {
+ &d_shift_31_dparser_gram, &d_shift_49_dparser_gram, &d_shift_51_dparser_gram, &d_shift_52_dparser_gram, &d_shift_59_dparser_gram, &d_shift_60_dparser_gram, &d_shift_61_dparser_gram, &d_shift_62_dparser_gram, &d_shift_63_dparser_gram, &d_shift_64_dparser_gram, &d_shift_65_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_61_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_61_1_dparser_gram[] = {&d_shift_65_dparser_gram,0};
+ D_Shift *d_accepts_diff_61_2_dparser_gram[] = {&d_shift_59_dparser_gram,0};
+ D_Shift **d_accepts_diff_61_dparser_gram[] = {
+ d_accepts_diff_61_0_dparser_gram,
+ d_accepts_diff_61_1_dparser_gram,
+ d_accepts_diff_61_2_dparser_gram
+ };
+
+ unsigned char d_scanner_61_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 2,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,10,2,11,2,12,
+ 2,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,13,2,0,2,0,
+ };
+
+ unsigned char d_accepts_diff_61_5_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 2,2,2,2,2,2,2,2,2,2,0,0,0,0,0,0,
+ };
+
+ unsigned char d_accepts_diff_61_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_61_10_dparser_gram[] = { &d_shift_52_dparser_gram, NULL};
+
+ unsigned char d_accepts_diff_61_11_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+ 2,2,2,2,2,2,2,2,2,2,2,0,0,0,0,2,
+ 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+ 2,2,2,2,2,2,2,2,2,2,2,0,0,0,0,0,
+ };
+
+ D_Shift *d_accepts_diff_64_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_64_dparser_gram[] = {
+ d_accepts_diff_64_0_dparser_gram
+ };
+
+ D_Shift *d_shifts_72_dparser_gram[] = {
+ &d_shift_1_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_72_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_72_dparser_gram[] = {
+ d_accepts_diff_72_0_dparser_gram
+ };
+
+ unsigned char d_scanner_72_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,
+ };
+
+ D_Shift *d_accepts_diff_73_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_73_dparser_gram[] = {
+ d_accepts_diff_73_0_dparser_gram
+ };
+
+ D_Shift *d_shifts_77_dparser_gram[] = {
+ &d_shift_23_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_77_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_77_dparser_gram[] = {
+ d_accepts_diff_77_0_dparser_gram
+ };
+
+ D_Shift *d_accepts_diff_80_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_80_dparser_gram[] = {
+ d_accepts_diff_80_0_dparser_gram
+ };
+
+ D_Shift *d_shifts_92_dparser_gram[] = {
+ &d_shift_28_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_92_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_92_dparser_gram[] = {
+ d_accepts_diff_92_0_dparser_gram
+ };
+
+ unsigned char d_scanner_92_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,
+ };
+
+ D_Shift *d_shift_92_1_dparser_gram[] = { &d_shift_28_dparser_gram, NULL};
+
+ D_Shift *d_shifts_95_dparser_gram[] = {
+ &d_shift_29_dparser_gram, &d_shift_31_dparser_gram, &d_shift_49_dparser_gram, &d_shift_51_dparser_gram, &d_shift_60_dparser_gram, &d_shift_61_dparser_gram, &d_shift_62_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_95_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_95_dparser_gram[] = {
+ d_accepts_diff_95_0_dparser_gram
+ };
+
+ unsigned char d_scanner_95_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,2,0,3,0,0,4,5,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_95_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+ 6,6,6,6,6,6,6,6,6,6,6,7,0,0,0,6,
+ 0,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+ 6,6,6,6,6,6,6,6,6,6,6,8,0,0,0,0,
+ };
+
+ unsigned char d_scanner_95_1_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,10,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ };
+
+ unsigned char d_scanner_95_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,9,11,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ };
+
+ unsigned char d_scanner_95_1_2_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+ };
+
+ unsigned char d_scanner_95_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,
+ };
+
+ unsigned char d_scanner_95_3_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,14,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ };
+
+ unsigned char d_scanner_95_5_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 6,6,6,6,6,6,6,6,6,6,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_95_5_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+ 6,6,6,6,6,6,6,6,6,6,6,0,0,0,0,6,
+ 0,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+ 6,6,6,6,6,6,6,6,6,6,6,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_95_10_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ };
+
+ unsigned char d_scanner_95_14_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
+ 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
+ 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
+ 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
+ };
+
+ unsigned char d_scanner_95_14_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
+ 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
+ 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
+ 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
+ };
+
+ unsigned char d_scanner_95_18_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_95_19_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,21,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_95_20_dparser_gram[] = { &d_shift_29_dparser_gram, NULL};
+
+ D_Shift *d_shifts_99_dparser_gram[] = {
+ &d_shift_38_dparser_gram, &d_shift_39_dparser_gram, &d_shift_40_dparser_gram, &d_shift_41_dparser_gram, &d_shift_42_dparser_gram, &d_shift_43_dparser_gram, &d_shift_44_dparser_gram, &d_shift_45_dparser_gram, &d_shift_46_dparser_gram, &d_shift_47_dparser_gram, &d_shift_51_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_99_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_99_dparser_gram[] = {
+ d_accepts_diff_99_0_dparser_gram
+ };
+
+ unsigned char d_scanner_99_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,4,0,0,0,0,0,0,0,0,0,5,0,0,0,
+ 0,0,6,0,0,7,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_5_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,13,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_9_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_11_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_13_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,18,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_14_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,19,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_15_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,20,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_99_16_dparser_gram[] = { &d_shift_47_dparser_gram, NULL};
+
+ unsigned char d_scanner_99_17_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,21,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_18_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,22,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_19_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,23,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_99_20_dparser_gram[] = { &d_shift_46_dparser_gram, NULL};
+
+ unsigned char d_scanner_99_22_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,25,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_23_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,26,0,0,27,
+ 0,0,28,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_24_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,29,0,0,30,
+ 0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_26_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 33,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_27_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,34,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_29_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 36,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_30_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,37,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_31_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,38,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_32_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,39,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_33_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,40,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_34_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,41,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_35_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_36_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_38_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,45,0,0,0,
+ 0,0,46,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_39_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,47,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_40_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_41_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,49,0,0,0,
+ 0,0,50,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_42_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,51,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_99_43_dparser_gram[] = { &d_shift_43_dparser_gram, NULL};
+
+ unsigned char d_scanner_99_44_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,52,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_45_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,53,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_46_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,54,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_99_47_dparser_gram[] = { &d_shift_45_dparser_gram, NULL};
+
+ unsigned char d_scanner_99_48_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,55,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_49_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,56,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_50_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,57,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_51_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,58,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_52_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,59,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_99_53_dparser_gram[] = { &d_shift_42_dparser_gram, NULL};
+
+ unsigned char d_scanner_99_54_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,60,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_55_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,61,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_99_56_dparser_gram[] = { &d_shift_44_dparser_gram, NULL};
+
+ unsigned char d_scanner_99_57_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,62,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_58_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,63,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_59_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,64,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_99_60_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,65,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_99_61_dparser_gram[] = { &d_shift_39_dparser_gram, NULL};
+
+ unsigned char d_scanner_99_62_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,66,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_99_63_dparser_gram[] = { &d_shift_41_dparser_gram, NULL};
+
+ unsigned char d_scanner_99_64_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,67,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_99_65_dparser_gram[] = { &d_shift_38_dparser_gram, NULL};
+
+ D_Shift *d_shift_99_66_dparser_gram[] = { &d_shift_40_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_100_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_100_1_dparser_gram[] = {&d_shift_59_dparser_gram,0};
+ D_Shift *d_accepts_diff_100_2_dparser_gram[] = {&d_shift_65_dparser_gram,0};
+ D_Shift **d_accepts_diff_100_dparser_gram[] = {
+ d_accepts_diff_100_0_dparser_gram,
+ d_accepts_diff_100_1_dparser_gram,
+ d_accepts_diff_100_2_dparser_gram
+ };
+
+ D_Shift *d_shifts_123_dparser_gram[] = {
+ &d_shift_63_dparser_gram, &d_shift_64_dparser_gram, &d_shift_65_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_123_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_123_1_dparser_gram[] = {&d_shift_65_dparser_gram,0};
+ D_Shift **d_accepts_diff_123_dparser_gram[] = {
+ d_accepts_diff_123_0_dparser_gram,
+ d_accepts_diff_123_1_dparser_gram
+ };
+
+ unsigned char d_scanner_123_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,
+ 3,4,4,4,4,4,4,4,4,4,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_123_1_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 3,4,4,4,4,4,4,4,4,4,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_123_2_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 5,5,5,5,5,5,5,5,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_123_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,
+ 0,0,0,0,0,6,0,0,7,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,
+ 0,0,0,0,0,6,0,0,8,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_123_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,
+ 0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,
+ 0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_123_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,
+ 0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,
+ 0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_123_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,10,10,10,10,10,10,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,10,10,10,10,10,10,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_123_9_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,10,10,10,10,10,10,0,0,0,0,0,11,0,0,0,
+ 0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,
+ 0,10,10,10,10,10,10,0,0,0,0,0,11,0,0,0,
+ 0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shifts_125_dparser_gram[] = {
+ &d_shift_49_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_125_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_125_dparser_gram[] = {
+ d_accepts_diff_125_0_dparser_gram
+ };
+
+ D_Shift *d_accepts_diff_128_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_128_1_dparser_gram[] = {&d_shift_59_dparser_gram,0};
+ D_Shift *d_accepts_diff_128_2_dparser_gram[] = {&d_shift_65_dparser_gram,0};
+ D_Shift **d_accepts_diff_128_dparser_gram[] = {
+ d_accepts_diff_128_0_dparser_gram,
+ d_accepts_diff_128_1_dparser_gram,
+ d_accepts_diff_128_2_dparser_gram
+ };
+
+ D_Shift *d_accepts_diff_131_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_131_1_dparser_gram[] = {&d_shift_65_dparser_gram,0};
+ D_Shift *d_accepts_diff_131_2_dparser_gram[] = {&d_shift_59_dparser_gram,0};
+ D_Shift **d_accepts_diff_131_dparser_gram[] = {
+ d_accepts_diff_131_0_dparser_gram,
+ d_accepts_diff_131_1_dparser_gram,
+ d_accepts_diff_131_2_dparser_gram
+ };
+
+ D_Shift *d_shifts_132_dparser_gram[] = {
+ &d_shift_33_dparser_gram, &d_shift_34_dparser_gram, &d_shift_35_dparser_gram, &d_shift_36_dparser_gram, &d_shift_37_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_132_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_132_dparser_gram[] = {
+ d_accepts_diff_132_0_dparser_gram
+ };
+
+ unsigned char d_scanner_132_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,2,0,0,0,0,0,3,4,0,0,0,5,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,
+ };
+
+ unsigned char d_scanner_132_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_132_2_dparser_gram[] = { &d_shift_36_dparser_gram, NULL};
+
+ D_Shift *d_shift_132_3_dparser_gram[] = { &d_shift_37_dparser_gram, NULL};
+
+ D_Shift *d_shift_132_5_dparser_gram[] = { &d_shift_35_dparser_gram, NULL};
+
+ D_Shift *d_shift_132_7_dparser_gram[] = { &d_shift_34_dparser_gram, NULL};
+
+ unsigned char d_scanner_132_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ unsigned char d_scanner_132_9_1_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_shift_132_10_dparser_gram[] = { &d_shift_33_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_133_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_133_dparser_gram[] = {
+ d_accepts_diff_133_0_dparser_gram
+ };
+
+ D_Shift *d_shifts_141_dparser_gram[] = {
+ &d_shift_32_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_141_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_141_dparser_gram[] = {
+ d_accepts_diff_141_0_dparser_gram
+ };
+
+ unsigned char d_scanner_141_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ };
+
+ D_Shift *d_accepts_diff_144_0_dparser_gram[] = {0};
+ D_Shift *d_accepts_diff_144_1_dparser_gram[] = {&d_shift_65_dparser_gram,0};
+ D_Shift **d_accepts_diff_144_dparser_gram[] = {
+ d_accepts_diff_144_0_dparser_gram,
+ d_accepts_diff_144_1_dparser_gram
+ };
+
+ D_Shift *d_accepts_diff_151_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_151_dparser_gram[] = {
+ d_accepts_diff_151_0_dparser_gram
+ };
+
+ D_Shift *d_shifts_155_dparser_gram[] = {
+ &d_shift_22_dparser_gram, NULL};
+
+ D_Shift *d_accepts_diff_155_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_155_dparser_gram[] = {
+ d_accepts_diff_155_0_dparser_gram
+ };
+
+ D_Shift *d_accepts_diff_156_0_dparser_gram[] = {0};
+ D_Shift **d_accepts_diff_156_dparser_gram[] = {
+ d_accepts_diff_156_0_dparser_gram
+ };
+
+ SB_uint8 d_scanner_3_dparser_gram[37] = {
+ { NULL, {d_scanner_3_0_0_dparser_gram, d_scanner_3_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_1_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_2_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_3_dparser_gram, {d_scanner_3_3_0_dparser_gram, d_scanner_3_3_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_4_dparser_gram, {d_scanner_3_3_0_dparser_gram, d_scanner_3_3_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_5_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_6_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_7_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_8_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_9_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_10_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_11_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_12_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_13_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_14_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_15_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_16_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_17_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_18_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_19_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_20_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_21_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_22_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_23_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_24_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_25_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_26_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_27_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_28_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_29_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_30_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_31_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_32_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_33_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_34_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_35_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_36_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_3_dparser_gram[37] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_4_0_dparser_gram, d_accepts_diff_3_4_1_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_4_dparser_gram[27] = {
+ { NULL, {d_scanner_4_0_0_dparser_gram, d_scanner_4_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_10_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_4_2_0_dparser_gram, d_scanner_4_2_1_dparser_gram,
+ d_scanner_4_2_2_dparser_gram, d_scanner_4_2_2_dparser_gram}},
+ { NULL, {d_scanner_4_3_0_dparser_gram, d_scanner_4_3_1_dparser_gram,
+ d_scanner_4_3_2_dparser_gram, d_scanner_4_3_2_dparser_gram}},
+ { d_shift_4_4_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_10_dparser_gram, {d_scanner_4_5_0_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_4_6_0_dparser_gram, d_scanner_4_6_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_22_dparser_gram, {d_scanner_4_7_0_dparser_gram, d_scanner_4_7_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_3_dparser_gram, {d_scanner_4_8_0_dparser_gram, d_scanner_4_8_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_9_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_10_dparser_gram, {d_scanner_4_8_0_dparser_gram, d_scanner_4_8_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_5_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_4_2_0_dparser_gram, d_scanner_4_2_1_dparser_gram,
+ d_scanner_4_2_2_dparser_gram, d_scanner_4_2_2_dparser_gram}},
+ { d_shift_4_13_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_4_14_0_dparser_gram, d_scanner_4_14_1_dparser_gram,
+ d_scanner_4_14_1_dparser_gram, d_scanner_4_14_1_dparser_gram}},
+ { NULL, {d_scanner_4_3_0_dparser_gram, d_scanner_4_3_1_dparser_gram,
+ d_scanner_4_3_2_dparser_gram, d_scanner_4_3_2_dparser_gram}},
+ { d_shift_4_16_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_4_17_0_dparser_gram, d_scanner_4_17_1_dparser_gram,
+ d_scanner_4_17_1_dparser_gram, d_scanner_4_17_1_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_4_6_0_dparser_gram, d_scanner_4_18_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_4_20_0_dparser_gram, d_scanner_4_20_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_4_20_0_dparser_gram, d_scanner_4_20_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_22_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_4_2_0_dparser_gram, d_scanner_4_2_1_dparser_gram,
+ d_scanner_4_2_2_dparser_gram, d_scanner_4_2_2_dparser_gram}},
+ { NULL, {d_scanner_4_3_0_dparser_gram, d_scanner_4_3_1_dparser_gram,
+ d_scanner_4_3_2_dparser_gram, d_scanner_4_3_2_dparser_gram}},
+ { d_shift_4_26_dparser_gram, {d_scanner_4_20_0_dparser_gram, d_scanner_4_25_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_26_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_4_dparser_gram[27] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_4_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_4_6_1_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_4_0_dparser_gram, d_accepts_diff_3_4_1_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_5_dparser_gram[100] = {
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_1_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_2_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_3_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_4_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_5_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_6_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_7_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_8_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_9_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_10_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_11_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_12_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_13_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_14_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_15_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_16_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_17_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_18_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_19_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_20_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_21_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_22_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_23_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_24_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_25_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_26_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_27_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_28_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_29_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_30_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_31_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_32_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_33_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_34_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_35_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_36_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_37_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_38_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_39_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_40_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_41_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_42_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_43_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_44_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_45_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_46_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_47_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_48_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_49_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_50_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_51_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_52_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_53_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_54_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_55_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_56_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_5_57_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_58_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_59_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_60_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_61_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_62_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_63_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_5_64_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_65_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_66_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_67_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_68_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_69_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_70_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_5_71_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_5_72_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_73_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_74_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_75_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_76_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_77_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_78_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_79_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_80_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_81_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_5_82_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_83_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_84_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_5_85_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_86_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_87_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_5_88_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_89_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_90_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_91_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_92_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_93_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_94_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_95_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_96_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_97_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_98_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_5_99_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_5_dparser_gram[100] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_6_dparser_gram[2] = {
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_6_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_3_dparser_gram, {d_scanner_6_1_0_dparser_gram, d_scanner_6_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_6_dparser_gram[2] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_13_dparser_gram[4] = {
+ { NULL, {d_scanner_13_0_0_dparser_gram, d_scanner_13_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_2_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_3_dparser_gram, {d_scanner_13_2_0_dparser_gram, d_scanner_13_2_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_4_dparser_gram, {d_scanner_13_2_0_dparser_gram, d_scanner_13_2_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_13_dparser_gram[4] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_4_0_dparser_gram, d_accepts_diff_3_4_1_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_17_dparser_gram[4] = {
+ { NULL, {d_scanner_17_0_0_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_17_1_dparser_gram, {d_scanner_17_1_0_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_17_2_0_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_17_3_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_17_dparser_gram[4] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_17_1_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_30_dparser_gram[28] = {
+ { NULL, {d_scanner_4_0_0_dparser_gram, d_scanner_30_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_10_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_2_0_dparser_gram, d_scanner_30_2_1_dparser_gram,
+ d_scanner_30_2_2_dparser_gram, d_scanner_30_2_2_dparser_gram}},
+ { NULL, {d_scanner_30_3_0_dparser_gram, d_scanner_30_3_1_dparser_gram,
+ d_scanner_30_3_2_dparser_gram, d_scanner_30_3_2_dparser_gram}},
+ { d_shift_4_4_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_10_dparser_gram, {d_scanner_4_5_0_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_30_6_0_dparser_gram, d_scanner_30_6_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_22_dparser_gram, {d_scanner_4_7_0_dparser_gram, d_scanner_30_7_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_3_dparser_gram, {d_scanner_4_8_0_dparser_gram, d_scanner_4_8_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_9_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_10_dparser_gram, {d_scanner_4_8_0_dparser_gram, d_scanner_4_8_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_5_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_30_12_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_2_0_dparser_gram, d_scanner_30_2_1_dparser_gram,
+ d_scanner_30_2_2_dparser_gram, d_scanner_30_2_2_dparser_gram}},
+ { d_shift_4_13_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_4_17_0_dparser_gram, d_scanner_4_17_1_dparser_gram,
+ d_scanner_4_17_1_dparser_gram, d_scanner_4_17_1_dparser_gram}},
+ { NULL, {d_scanner_30_3_0_dparser_gram, d_scanner_30_3_1_dparser_gram,
+ d_scanner_30_3_2_dparser_gram, d_scanner_30_3_2_dparser_gram}},
+ { d_shift_4_16_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_18_0_dparser_gram, d_scanner_30_18_1_dparser_gram,
+ d_scanner_30_18_1_dparser_gram, d_scanner_30_18_1_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_30_6_0_dparser_gram, d_scanner_30_19_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_21_0_dparser_gram, d_scanner_30_21_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_21_0_dparser_gram, d_scanner_30_21_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_22_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_2_0_dparser_gram, d_scanner_30_2_1_dparser_gram,
+ d_scanner_30_2_2_dparser_gram, d_scanner_30_2_2_dparser_gram}},
+ { NULL, {d_scanner_30_3_0_dparser_gram, d_scanner_30_3_1_dparser_gram,
+ d_scanner_30_3_2_dparser_gram, d_scanner_30_3_2_dparser_gram}},
+ { d_shift_4_26_dparser_gram, {d_scanner_30_21_0_dparser_gram, d_scanner_30_26_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_26_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_30_dparser_gram[28] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_4_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_4_6_1_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_4_0_dparser_gram, d_accepts_diff_3_4_1_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_49_dparser_gram[3] = {
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_49_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_3_dparser_gram, {d_scanner_6_1_0_dparser_gram, d_scanner_6_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_30_12_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_49_dparser_gram[3] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_52_dparser_gram[39] = {
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_1_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_2_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_3_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_4_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_5_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_6_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_7_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_8_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_9_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_10_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_11_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_12_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_13_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_14_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_15_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_16_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_17_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_18_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_19_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_20_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_21_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_22_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_52_23_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_24_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_21_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_52_26_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_27_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_28_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_28_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_30_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_31_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_52_32_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_33_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_52_34_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_35_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_36_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_37_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_52_38_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_52_dparser_gram[39] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_55_dparser_gram[34] = {
+ { NULL, {d_scanner_55_0_0_dparser_gram, d_scanner_55_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_1_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_5_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_3_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_4_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_5_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_6_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_7_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_8_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_10_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_10_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_11_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_12_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_11_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_12_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_15_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_16_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_17_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_18_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_19_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_20_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_24_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_22_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_23_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_24_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_25_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_27_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_30_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_28_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_29_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_30_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_34_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_35_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_36_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_55_dparser_gram[34] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_59_dparser_gram[28] = {
+ { NULL, {d_scanner_59_0_0_dparser_gram, d_scanner_59_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_10_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_2_0_dparser_gram, d_scanner_30_2_1_dparser_gram,
+ d_scanner_30_2_2_dparser_gram, d_scanner_30_2_2_dparser_gram}},
+ { NULL, {d_scanner_30_3_0_dparser_gram, d_scanner_30_3_1_dparser_gram,
+ d_scanner_30_3_2_dparser_gram, d_scanner_30_3_2_dparser_gram}},
+ { d_shift_4_4_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_59_5_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_10_dparser_gram, {d_scanner_59_6_0_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_30_6_0_dparser_gram, d_scanner_30_6_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_22_dparser_gram, {d_scanner_4_8_0_dparser_gram, d_scanner_30_7_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_3_dparser_gram, {d_scanner_59_9_0_dparser_gram, d_scanner_59_9_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_9_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_10_dparser_gram, {d_scanner_59_9_0_dparser_gram, d_scanner_59_9_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_5_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_2_0_dparser_gram, d_scanner_30_2_1_dparser_gram,
+ d_scanner_30_2_2_dparser_gram, d_scanner_30_2_2_dparser_gram}},
+ { d_shift_4_13_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_4_17_0_dparser_gram, d_scanner_4_17_1_dparser_gram,
+ d_scanner_4_17_1_dparser_gram, d_scanner_4_17_1_dparser_gram}},
+ { NULL, {d_scanner_30_3_0_dparser_gram, d_scanner_30_3_1_dparser_gram,
+ d_scanner_30_3_2_dparser_gram, d_scanner_30_3_2_dparser_gram}},
+ { d_shift_4_16_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_18_0_dparser_gram, d_scanner_30_18_1_dparser_gram,
+ d_scanner_30_18_1_dparser_gram, d_scanner_30_18_1_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_30_6_0_dparser_gram, d_scanner_30_19_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_21_0_dparser_gram, d_scanner_30_21_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_21_0_dparser_gram, d_scanner_30_21_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_22_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_2_0_dparser_gram, d_scanner_30_2_1_dparser_gram,
+ d_scanner_30_2_2_dparser_gram, d_scanner_30_2_2_dparser_gram}},
+ { NULL, {d_scanner_30_3_0_dparser_gram, d_scanner_30_3_1_dparser_gram,
+ d_scanner_30_3_2_dparser_gram, d_scanner_30_3_2_dparser_gram}},
+ { d_shift_4_26_dparser_gram, {d_scanner_30_21_0_dparser_gram, d_scanner_30_26_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_26_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_59_dparser_gram[28] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_4_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_4_6_1_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_4_0_dparser_gram, d_accepts_diff_3_4_1_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_61_dparser_gram[28] = {
+ { NULL, {d_scanner_4_0_0_dparser_gram, d_scanner_61_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_10_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_2_0_dparser_gram, d_scanner_30_2_1_dparser_gram,
+ d_scanner_30_2_2_dparser_gram, d_scanner_30_2_2_dparser_gram}},
+ { NULL, {d_scanner_30_3_0_dparser_gram, d_scanner_30_3_1_dparser_gram,
+ d_scanner_30_3_2_dparser_gram, d_scanner_30_3_2_dparser_gram}},
+ { d_shift_4_4_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_10_dparser_gram, {d_scanner_4_5_0_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_30_6_0_dparser_gram, d_scanner_30_6_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_22_dparser_gram, {d_scanner_4_7_0_dparser_gram, d_scanner_30_7_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_3_dparser_gram, {d_scanner_4_8_0_dparser_gram, d_scanner_4_8_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_9_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_61_10_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_10_dparser_gram, {d_scanner_4_8_0_dparser_gram, d_scanner_4_8_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_5_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_2_0_dparser_gram, d_scanner_30_2_1_dparser_gram,
+ d_scanner_30_2_2_dparser_gram, d_scanner_30_2_2_dparser_gram}},
+ { d_shift_4_13_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_4_17_0_dparser_gram, d_scanner_4_17_1_dparser_gram,
+ d_scanner_4_17_1_dparser_gram, d_scanner_4_17_1_dparser_gram}},
+ { NULL, {d_scanner_30_3_0_dparser_gram, d_scanner_30_3_1_dparser_gram,
+ d_scanner_30_3_2_dparser_gram, d_scanner_30_3_2_dparser_gram}},
+ { d_shift_4_16_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_18_0_dparser_gram, d_scanner_30_18_1_dparser_gram,
+ d_scanner_30_18_1_dparser_gram, d_scanner_30_18_1_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_30_6_0_dparser_gram, d_scanner_30_19_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_21_0_dparser_gram, d_scanner_30_21_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_21_0_dparser_gram, d_scanner_30_21_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_22_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_30_2_0_dparser_gram, d_scanner_30_2_1_dparser_gram,
+ d_scanner_30_2_2_dparser_gram, d_scanner_30_2_2_dparser_gram}},
+ { NULL, {d_scanner_30_3_0_dparser_gram, d_scanner_30_3_1_dparser_gram,
+ d_scanner_30_3_2_dparser_gram, d_scanner_30_3_2_dparser_gram}},
+ { d_shift_4_26_dparser_gram, {d_scanner_30_21_0_dparser_gram, d_scanner_30_26_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_26_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_61_dparser_gram[28] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_61_5_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_61_6_1_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_61_5_0_dparser_gram, d_accepts_diff_61_11_1_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_72_dparser_gram[2] = {
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_72_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_30_12_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_72_dparser_gram[2] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_77_dparser_gram[2] = {
+ { NULL, {d_scanner_13_0_0_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_2_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_77_dparser_gram[2] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_92_dparser_gram[2] = {
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_92_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_92_1_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_92_dparser_gram[2] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_95_dparser_gram[21] = {
+ { NULL, {d_scanner_95_0_0_dparser_gram, d_scanner_95_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_95_1_0_dparser_gram, d_scanner_95_1_1_dparser_gram,
+ d_scanner_95_1_2_dparser_gram, d_scanner_95_1_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_95_2_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_95_3_0_dparser_gram, d_scanner_4_2_1_dparser_gram,
+ d_scanner_4_2_2_dparser_gram, d_scanner_4_2_2_dparser_gram}},
+ { d_shift_4_4_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_3_dparser_gram, {d_scanner_95_5_0_dparser_gram, d_scanner_95_5_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_9_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_5_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_95_1_0_dparser_gram, d_scanner_95_1_1_dparser_gram,
+ d_scanner_95_1_2_dparser_gram, d_scanner_95_1_2_dparser_gram}},
+ { d_shift_4_13_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_95_10_0_dparser_gram, d_scanner_4_3_2_dparser_gram,
+ d_scanner_4_3_2_dparser_gram, d_scanner_4_3_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_55_11_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_95_3_0_dparser_gram, d_scanner_4_2_1_dparser_gram,
+ d_scanner_4_2_2_dparser_gram, d_scanner_4_2_2_dparser_gram}},
+ { d_shift_4_16_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_95_14_0_dparser_gram, d_scanner_95_14_1_dparser_gram,
+ d_scanner_95_14_1_dparser_gram, d_scanner_95_14_1_dparser_gram}},
+ { NULL, {d_scanner_95_1_0_dparser_gram, d_scanner_95_1_1_dparser_gram,
+ d_scanner_95_1_2_dparser_gram, d_scanner_95_1_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_13_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_95_3_0_dparser_gram, d_scanner_4_2_1_dparser_gram,
+ d_scanner_4_2_2_dparser_gram, d_scanner_4_2_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_95_18_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_95_19_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_95_20_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_95_dparser_gram[21] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_99_dparser_gram[67] = {
+ { NULL, {d_scanner_55_0_0_dparser_gram, d_scanner_99_0_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_1_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_9_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_3_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_4_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_5_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_6_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_7_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_8_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_9_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_3_9_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_11_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_9_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_13_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_14_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_15_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_99_16_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_17_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_18_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_19_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_99_20_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_16_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_22_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_23_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_24_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_52_28_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_26_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_27_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_26_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_29_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_30_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_31_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_32_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_33_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_34_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_35_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_36_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_5_35_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_38_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_39_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_40_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_41_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_42_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_99_43_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_44_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_45_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_46_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_99_47_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_48_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_49_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_50_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_51_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_52_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_99_53_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_54_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_55_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_99_56_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_57_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_58_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_59_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_60_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_99_61_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_62_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_99_63_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_64_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_99_65_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_99_66_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_99_dparser_gram[67] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_123_dparser_gram[11] = {
+ { NULL, {d_scanner_123_0_0_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_123_1_0_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_123_2_0_dparser_gram, d_scanner_123_2_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_22_dparser_gram, {d_scanner_3_3_0_dparser_gram, d_scanner_123_3_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_123_2_0_dparser_gram, d_scanner_123_4_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_19_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_59_9_0_dparser_gram, d_scanner_123_6_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_59_9_0_dparser_gram, d_scanner_123_6_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_22_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_26_dparser_gram, {d_scanner_59_9_0_dparser_gram, d_scanner_123_9_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_4_26_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_123_dparser_gram[11] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_61_6_1_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_125_dparser_gram[2] = {
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_13_0_0_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_3_5_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_125_dparser_gram[2] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_132_dparser_gram[11] = {
+ { NULL, {d_scanner_132_0_0_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_132_1_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_132_2_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_132_3_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_3_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_132_5_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_99_4_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_132_7_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_132_8_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { NULL, {d_scanner_3_0_2_dparser_gram, d_scanner_132_9_1_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_132_10_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_132_dparser_gram[11] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_141_dparser_gram[2] = {
+ { NULL, {d_scanner_141_0_0_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_59_5_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_141_dparser_gram[2] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ SB_uint8 d_scanner_155_dparser_gram[2] = {
+ { NULL, {d_scanner_17_0_0_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}},
+ { d_shift_17_1_dparser_gram, {d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram,
+ d_scanner_3_0_2_dparser_gram, d_scanner_3_0_2_dparser_gram}}
+ };
+
+ SB_trans_uint8 d_transition_155_dparser_gram[2] = {
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}},
+ {{ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram,
+ d_accepts_diff_3_0_0_dparser_gram, d_accepts_diff_3_0_0_dparser_gram}}
+ };
+
+ unsigned char d_goto_valid_0_dparser_gram[] = {
+ 0x46, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_0_dparser_gram[] = {&d_reduction_9_dparser_gram};
+ D_Reduction *d_reductions_2_dparser_gram[] = {&d_reduction_1_dparser_gram};
+ unsigned char d_goto_valid_3_dparser_gram[] = {
+ 0x98, 0x80, 0x6, 0x0, 0x0, 0x40, 0x0, 0x42, 0x35, 0x0, 0x20, 0x2, 0x0, 0x80, 0x0, 0x10};
+ unsigned char d_goto_valid_4_dparser_gram[] = {
+ 0x0, 0x4, 0x0, 0x0, 0x0, 0x0, 0xc4, 0x3f, 0x0, 0x0, 0x0, 0x20, 0x0, 0x80, 0x2, 0xfe};
+ unsigned char d_goto_valid_5_dparser_gram[] = {
+ 0x0, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0};
+ unsigned char d_goto_valid_6_dparser_gram[] = {
+ 0x0, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10};
+ D_Reduction *d_reductions_7_dparser_gram[] = {&d_reduction_14_dparser_gram};
+ unsigned char d_goto_valid_8_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10};
+ D_Reduction *d_reductions_9_dparser_gram[] = {&d_reduction_40_dparser_gram};
+ D_Reduction *d_reductions_10_dparser_gram[] = {&d_reduction_43_dparser_gram};
+ unsigned char d_goto_valid_11_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_11_dparser_gram[] = {&d_reduction_103_dparser_gram};
+ D_Reduction *d_reductions_12_dparser_gram[] = {&d_reduction_124_dparser_gram};
+ unsigned char d_goto_valid_13_dparser_gram[] = {
+ 0x10, 0x80, 0x6, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x20, 0x2, 0x0, 0x0, 0x0, 0x10};
+ D_Reduction *d_reductions_13_dparser_gram[] = {&d_reduction_2_dparser_gram};
+ D_Reduction *d_reductions_14_dparser_gram[] = {&d_reduction_4_dparser_gram};
+ D_Reduction *d_reductions_15_dparser_gram[] = {&d_reduction_8_dparser_gram};
+ unsigned char d_goto_valid_16_dparser_gram[] = {
+ 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_16_dparser_gram[] = {&d_reduction_7_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_16_dparser_gram[] = {{ 0, 55, &d_reduction_5_dparser_gram}};
+ unsigned char d_goto_valid_17_dparser_gram[] = {
+ 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x1, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_18_dparser_gram[] = {&d_reduction_42_dparser_gram};
+ D_Reduction *d_reductions_19_dparser_gram[] = {&d_reduction_10_dparser_gram};
+ D_Reduction *d_reductions_20_dparser_gram[] = {&d_reduction_43_dparser_gram};
+ unsigned char d_goto_valid_21_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_21_dparser_gram[] = {&d_reduction_120_dparser_gram};
+ unsigned char d_goto_valid_22_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_22_dparser_gram[] = {&d_reduction_116_dparser_gram};
+ unsigned char d_goto_valid_23_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_23_dparser_gram[] = {&d_reduction_118_dparser_gram};
+ D_Reduction *d_reductions_24_dparser_gram[] = {&d_reduction_121_dparser_gram};
+ D_Reduction *d_reductions_25_dparser_gram[] = {&d_reduction_122_dparser_gram};
+ D_Reduction *d_reductions_26_dparser_gram[] = {&d_reduction_123_dparser_gram};
+ D_Reduction *d_reductions_27_dparser_gram[] = {&d_reduction_128_dparser_gram};
+ D_Reduction *d_reductions_28_dparser_gram[] = {&d_reduction_129_dparser_gram};
+ D_Reduction *d_reductions_29_dparser_gram[] = {&d_reduction_130_dparser_gram};
+ unsigned char d_goto_valid_30_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc4, 0xbf, 0x0, 0x0, 0x0, 0x20, 0x0, 0x80, 0x2, 0xfe};
+ D_Reduction *d_reductions_31_dparser_gram[] = {&d_reduction_21_dparser_gram};
+ D_Reduction *d_reductions_32_dparser_gram[] = {&d_reduction_110_dparser_gram};
+ D_Reduction *d_reductions_33_dparser_gram[] = {&d_reduction_110_dparser_gram};
+ D_Reduction *d_reductions_34_dparser_gram[] = {&d_reduction_110_dparser_gram};
+ D_Reduction *d_reductions_35_dparser_gram[] = {&d_reduction_110_dparser_gram};
+ D_Reduction *d_reductions_36_dparser_gram[] = {&d_reduction_110_dparser_gram};
+ D_Reduction *d_reductions_37_dparser_gram[] = {&d_reduction_125_dparser_gram};
+ D_Reduction *d_reductions_38_dparser_gram[] = {&d_reduction_125_dparser_gram};
+ D_Reduction *d_reductions_39_dparser_gram[] = {&d_reduction_125_dparser_gram};
+ D_Reduction *d_reductions_40_dparser_gram[] = {&d_reduction_29_dparser_gram};
+ D_Reduction *d_reductions_41_dparser_gram[] = {&d_reduction_30_dparser_gram};
+ D_Reduction *d_reductions_42_dparser_gram[] = {&d_reduction_31_dparser_gram};
+ D_Reduction *d_reductions_43_dparser_gram[] = {&d_reduction_32_dparser_gram};
+ D_Reduction *d_reductions_44_dparser_gram[] = {&d_reduction_33_dparser_gram};
+ D_Reduction *d_reductions_45_dparser_gram[] = {&d_reduction_34_dparser_gram};
+ D_Reduction *d_reductions_46_dparser_gram[] = {&d_reduction_35_dparser_gram};
+ D_Reduction *d_reductions_47_dparser_gram[] = {&d_reduction_36_dparser_gram};
+ unsigned char d_goto_valid_48_dparser_gram[] = {
+ 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_48_dparser_gram[] = {&d_reduction_19_dparser_gram};
+ unsigned char d_goto_valid_49_dparser_gram[] = {
+ 0x0, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10};
+ D_Reduction *d_reductions_50_dparser_gram[] = {&d_reduction_17_dparser_gram};
+ D_Reduction *d_reductions_51_dparser_gram[] = {&d_reduction_37_dparser_gram};
+ unsigned char d_goto_valid_52_dparser_gram[] = {
+ 0x0, 0x18, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_52_dparser_gram[] = {&d_reduction_22_dparser_gram};
+ unsigned char d_goto_valid_53_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc4, 0xbf, 0x0, 0x0, 0x0, 0x20, 0x0, 0x80, 0x2, 0xfe};
+ D_Reduction *d_reductions_54_dparser_gram[] = {&d_reduction_3_dparser_gram};
+ unsigned char d_goto_valid_55_dparser_gram[] = {
+ 0x80, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x40, 0x35, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0};
+ D_Reduction *d_reductions_55_dparser_gram[] = {&d_reduction_5_dparser_gram};
+ unsigned char d_goto_valid_56_dparser_gram[] = {
+ 0x0, 0x0, 0x48, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_56_dparser_gram[] = {&d_reduction_62_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_56_dparser_gram[] = {{ 1, 92, &d_reduction_45_dparser_gram}, { 3, 124, &d_reduction_49_dparser_gram}};
+ D_Reduction *d_reductions_57_dparser_gram[] = {&d_reduction_41_dparser_gram};
+ unsigned char d_goto_valid_58_dparser_gram[] = {
+ 0x0, 0x0, 0x48, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_58_dparser_gram[] = {&d_reduction_62_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_58_dparser_gram[] = {{ 1, 92, &d_reduction_45_dparser_gram}, { 3, 124, &d_reduction_49_dparser_gram}};
+ unsigned char d_goto_valid_59_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc4, 0x3f, 0x0, 0x0, 0x0, 0x60, 0x0, 0x80, 0x2, 0xfe};
+ unsigned char d_goto_valid_60_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc4, 0xbf, 0x0, 0x0, 0x0, 0x20, 0x0, 0x80, 0x2, 0xfe};
+ unsigned char d_goto_valid_61_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc4, 0x3f, 0x0, 0x0, 0x0, 0x20, 0x0, 0x80, 0x6, 0xfe};
+ D_Reduction *d_reductions_62_dparser_gram[] = {&d_reduction_11_dparser_gram};
+ D_Reduction *d_reductions_63_dparser_gram[] = {&d_reduction_20_dparser_gram};
+ unsigned char d_goto_valid_64_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x82, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10};
+ D_Reduction *d_reductions_65_dparser_gram[] = {&d_reduction_13_dparser_gram};
+ D_Reduction *d_reductions_66_dparser_gram[] = {&d_reduction_16_dparser_gram};
+ D_Reduction *d_reductions_67_dparser_gram[] = {&d_reduction_24_dparser_gram};
+ D_Reduction *d_reductions_68_dparser_gram[] = {&d_reduction_25_dparser_gram};
+ D_Reduction *d_reductions_69_dparser_gram[] = {&d_reduction_26_dparser_gram};
+ D_Reduction *d_reductions_70_dparser_gram[] = {&d_reduction_27_dparser_gram};
+ D_Reduction *d_reductions_71_dparser_gram[] = {&d_reduction_28_dparser_gram};
+ unsigned char d_goto_valid_72_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ unsigned char d_goto_valid_73_dparser_gram[] = {
+ 0x0, 0x18, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_73_dparser_gram[] = {&d_reduction_22_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_73_dparser_gram[] = {{ 0, 90, &d_reduction_23_dparser_gram}};
+ D_Reduction *d_reductions_74_dparser_gram[] = {&d_reduction_101_dparser_gram};
+ D_Reduction *d_reductions_75_dparser_gram[] = {&d_reduction_102_dparser_gram};
+ D_Reduction *d_reductions_76_dparser_gram[] = {&d_reduction_6_dparser_gram};
+ unsigned char d_goto_valid_77_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0};
+ unsigned char d_goto_valid_78_dparser_gram[] = {
+ 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_78_dparser_gram[] = {&d_reduction_47_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_78_dparser_gram[] = {{ 0, 92, &d_reduction_45_dparser_gram}};
+ unsigned char d_goto_valid_79_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_79_dparser_gram[] = {&d_reduction_53_dparser_gram, &d_reduction_58_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_79_dparser_gram[] = {{ 2, 124, &d_reduction_49_dparser_gram}};
+ unsigned char d_goto_valid_80_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_81_dparser_gram[] = {&d_reduction_107_dparser_gram};
+ D_Reduction *d_reductions_82_dparser_gram[] = {&d_reduction_119_dparser_gram};
+ D_Reduction *d_reductions_83_dparser_gram[] = {&d_reduction_107_dparser_gram};
+ D_Reduction *d_reductions_84_dparser_gram[] = {&d_reduction_115_dparser_gram};
+ D_Reduction *d_reductions_85_dparser_gram[] = {&d_reduction_107_dparser_gram};
+ D_Reduction *d_reductions_86_dparser_gram[] = {&d_reduction_117_dparser_gram};
+ D_Reduction *d_reductions_87_dparser_gram[] = {&d_reduction_12_dparser_gram};
+ D_Reduction *d_reductions_88_dparser_gram[] = {&d_reduction_18_dparser_gram};
+ D_Reduction *d_reductions_89_dparser_gram[] = {&d_reduction_15_dparser_gram};
+ D_Reduction *d_reductions_90_dparser_gram[] = {&d_reduction_23_dparser_gram};
+ D_Reduction *d_reductions_91_dparser_gram[] = {&d_reduction_38_dparser_gram};
+ unsigned char d_goto_valid_92_dparser_gram[] = {
+ 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_92_dparser_gram[] = {&d_reduction_45_dparser_gram};
+ unsigned char d_goto_valid_93_dparser_gram[] = {
+ 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_93_dparser_gram[] = {&d_reduction_51_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_93_dparser_gram[] = {{ 1, 124, &d_reduction_49_dparser_gram}};
+ D_Reduction *d_reductions_94_dparser_gram[] = {&d_reduction_52_dparser_gram};
+ unsigned char d_goto_valid_95_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x90, 0x2, 0x40, 0x81, 0x3, 0x0, 0x0, 0x0, 0x28, 0x0, 0x80, 0x2, 0x1c};
+ D_Reduction *d_reductions_96_dparser_gram[] = {&d_reduction_38_dparser_gram};
+ unsigned char d_goto_valid_97_dparser_gram[] = {
+ 0x0, 0x0, 0x40, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_97_dparser_gram[] = {&d_reduction_62_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_97_dparser_gram[] = {{ 0, 111, &d_reduction_48_dparser_gram}, { 3, 124, &d_reduction_49_dparser_gram}};
+ D_Reduction *d_reductions_98_dparser_gram[] = {&d_reduction_46_dparser_gram};
+ unsigned char d_goto_valid_99_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0xb0, 0xc, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x3f, 0x2, 0x0};
+ D_Reduction *d_reductions_99_dparser_gram[] = {&d_reduction_97_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_99_dparser_gram[] = {{ 0, 124, &d_reduction_49_dparser_gram}, { 2, 151, &d_reduction_91_dparser_gram}};
+ unsigned char d_goto_valid_100_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0xc4, 0x3f, 0x0, 0x0, 0x0, 0x20, 0x0, 0x80, 0x2, 0xfe};
+ unsigned char d_goto_valid_101_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_101_dparser_gram[] = {&d_reduction_73_dparser_gram};
+ unsigned char d_goto_valid_102_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_102_dparser_gram[] = {&d_reduction_106_dparser_gram};
+ D_Reduction *d_reductions_103_dparser_gram[] = {&d_reduction_57_dparser_gram};
+ unsigned char d_goto_valid_104_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_104_dparser_gram[] = {&d_reduction_56_dparser_gram, &d_reduction_70_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_104_dparser_gram[] = {{ 0, 132, &d_reduction_54_dparser_gram}};
+ unsigned char d_goto_valid_105_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_105_dparser_gram[] = {&d_reduction_61_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_105_dparser_gram[] = {{ 0, 133, &d_reduction_59_dparser_gram}};
+ D_Reduction *d_reductions_106_dparser_gram[] = {&d_reduction_72_dparser_gram};
+ D_Reduction *d_reductions_107_dparser_gram[] = {&d_reduction_71_dparser_gram};
+ D_Reduction *d_reductions_108_dparser_gram[] = {&d_reduction_63_dparser_gram};
+ D_Reduction *d_reductions_109_dparser_gram[] = {&d_reduction_64_dparser_gram};
+ D_Reduction *d_reductions_110_dparser_gram[] = {&d_reduction_65_dparser_gram};
+ D_Reduction *d_reductions_111_dparser_gram[] = {&d_reduction_48_dparser_gram};
+ D_Reduction *d_reductions_112_dparser_gram[] = {&d_reduction_80_dparser_gram};
+ D_Reduction *d_reductions_113_dparser_gram[] = {&d_reduction_81_dparser_gram};
+ D_Reduction *d_reductions_114_dparser_gram[] = {&d_reduction_82_dparser_gram};
+ D_Reduction *d_reductions_115_dparser_gram[] = {&d_reduction_83_dparser_gram};
+ D_Reduction *d_reductions_116_dparser_gram[] = {&d_reduction_84_dparser_gram};
+ D_Reduction *d_reductions_117_dparser_gram[] = {&d_reduction_85_dparser_gram};
+ D_Reduction *d_reductions_118_dparser_gram[] = {&d_reduction_86_dparser_gram};
+ D_Reduction *d_reductions_119_dparser_gram[] = {&d_reduction_87_dparser_gram};
+ D_Reduction *d_reductions_120_dparser_gram[] = {&d_reduction_88_dparser_gram};
+ D_Reduction *d_reductions_121_dparser_gram[] = {&d_reduction_89_dparser_gram};
+ D_Reduction *d_reductions_122_dparser_gram[] = {&d_reduction_50_dparser_gram};
+ unsigned char d_goto_valid_123_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe0};
+ D_Reduction *d_reductions_124_dparser_gram[] = {&d_reduction_49_dparser_gram};
+ unsigned char d_goto_valid_125_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x52, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0};
+ D_Reduction *d_reductions_125_dparser_gram[] = {&d_reduction_95_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_125_dparser_gram[] = {{ 1, 151, &d_reduction_91_dparser_gram}};
+ D_Reduction *d_reductions_126_dparser_gram[] = {&d_reduction_96_dparser_gram};
+ D_Reduction *d_reductions_127_dparser_gram[] = {&d_reduction_98_dparser_gram};
+ unsigned char d_goto_valid_128_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc4, 0xbf, 0x0, 0x0, 0x0, 0x20, 0x0, 0x80, 0x2, 0xfe};
+ D_Reduction *d_reductions_129_dparser_gram[] = {&d_reduction_69_dparser_gram};
+ unsigned char d_goto_valid_130_dparser_gram[] = {
+ 0x0, 0x0, 0x48, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_130_dparser_gram[] = {&d_reduction_62_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_130_dparser_gram[] = {{ 1, 92, &d_reduction_45_dparser_gram}, { 3, 124, &d_reduction_49_dparser_gram}};
+ unsigned char d_goto_valid_131_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc4, 0x3f, 0x0, 0x0, 0x0, 0x20, 0x0, 0x80, 0x6, 0xfe};
+ unsigned char d_goto_valid_132_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xf, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_132_dparser_gram[] = {&d_reduction_54_dparser_gram};
+ unsigned char d_goto_valid_133_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xf, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_133_dparser_gram[] = {&d_reduction_59_dparser_gram};
+ D_Reduction *d_reductions_134_dparser_gram[] = {&d_reduction_79_dparser_gram};
+ D_Reduction *d_reductions_135_dparser_gram[] = {&d_reduction_90_dparser_gram};
+ unsigned char d_goto_valid_136_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_136_dparser_gram[] = {&d_reduction_93_dparser_gram};
+ D_RightEpsilonHint d_right_epsilon_hints_136_dparser_gram[] = {{ 0, 151, &d_reduction_91_dparser_gram}};
+ D_Reduction *d_reductions_137_dparser_gram[] = {&d_reduction_94_dparser_gram};
+ D_Reduction *d_reductions_138_dparser_gram[] = {&d_reduction_99_dparser_gram};
+ D_Reduction *d_reductions_139_dparser_gram[] = {&d_reduction_66_dparser_gram};
+ D_Reduction *d_reductions_140_dparser_gram[] = {&d_reduction_68_dparser_gram};
+ unsigned char d_goto_valid_141_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x0};
+ D_Reduction *d_reductions_142_dparser_gram[] = {&d_reduction_104_dparser_gram};
+ D_Reduction *d_reductions_143_dparser_gram[] = {&d_reduction_105_dparser_gram};
+ unsigned char d_goto_valid_144_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe0};
+ D_Reduction *d_reductions_145_dparser_gram[] = {&d_reduction_75_dparser_gram};
+ D_Reduction *d_reductions_146_dparser_gram[] = {&d_reduction_76_dparser_gram};
+ D_Reduction *d_reductions_147_dparser_gram[] = {&d_reduction_77_dparser_gram};
+ D_Reduction *d_reductions_148_dparser_gram[] = {&d_reduction_78_dparser_gram};
+ D_Reduction *d_reductions_149_dparser_gram[] = {&d_reduction_55_dparser_gram};
+ D_Reduction *d_reductions_150_dparser_gram[] = {&d_reduction_60_dparser_gram};
+ unsigned char d_goto_valid_151_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10};
+ D_Reduction *d_reductions_151_dparser_gram[] = {&d_reduction_91_dparser_gram};
+ D_Reduction *d_reductions_152_dparser_gram[] = {&d_reduction_67_dparser_gram};
+ D_Reduction *d_reductions_153_dparser_gram[] = {&d_reduction_74_dparser_gram};
+ D_Reduction *d_reductions_154_dparser_gram[] = {&d_reduction_92_dparser_gram};
+ unsigned char d_goto_valid_155_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0};
+ unsigned char d_goto_valid_156_dparser_gram[] = {
+ 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0};
+ D_Reduction *d_reductions_157_dparser_gram[] = {&d_reduction_100_dparser_gram};
+ unsigned short d_gotos_dparser_gram[547] = {
+ 2,3,14,15,31,4,16,49,54,50,56,53,60,55,17,51,
+ 18,19,59,61,62,65,78,90,17,79,18,19,92,89,93,81,
+ 97,80,79,88,67,99,100,73,74,131,80,132,32,20,133,134,
+ 33,34,35,36,37,38,39,40,21,152,52,94,95,5,96,6,
+ 153,7,21,8,9,157,41,42,43,44,45,46,47,48,13,52,
+ 142,112,0,79,10,66,57,22,11,80,58,80,137,0,10,138,
+ 13,139,11,68,69,70,71,72,158,23,98,24,0,77,12,0,
+ 0,0,0,25,26,27,13,28,29,30,0,13,150,13,0,0,
+ 0,0,64,0,155,13,33,34,35,36,37,38,39,40,0,63,
+ 156,0,13,76,20,0,0,33,34,35,36,37,38,39,40,0,
+ 75,0,12,0,5,0,6,151,7,12,8,9,83,22,0,0,
+ 33,34,35,36,37,38,39,40,145,146,147,148,149,0,22,23,
+ 0,24,0,0,0,154,38,39,40,25,26,27,13,28,29,30,
+ 23,0,24,13,0,12,0,22,82,135,25,26,27,13,28,29,
+ 30,91,74,145,146,147,148,149,0,23,0,24,0,136,38,39,
+ 40,0,0,25,26,27,13,28,29,30,85,0,0,0,33,34,
+ 35,36,37,38,39,40,0,84,28,29,30,87,0,0,0,33,
+ 34,35,36,37,38,39,40,0,0,0,0,0,0,68,69,70,
+ 71,72,0,0,0,22,0,123,124,0,125,0,0,126,127,0,
+ 28,29,30,128,0,0,22,23,0,24,0,0,0,0,0,0,
+ 0,25,26,27,13,28,29,30,23,104,24,86,105,0,106,0,
+ 0,0,25,26,27,13,28,29,30,0,0,107,0,108,0,0,
+ 129,0,0,0,109,110,111,113,114,115,116,117,118,119,120,121,
+ 122,0,130,0,103,0,33,34,35,36,37,38,39,40,0,0,
+ 0,0,0,0,0,0,0,141,101,0,102,33,34,35,36,37,
+ 38,39,40,0,140,0,0,0,0,0,0,0,12,22,103,0,
+ 0,0,0,0,0,0,0,26,27,13,0,0,0,0,0,23,
+ 0,24,22,0,0,0,0,0,0,25,26,27,13,28,29,30,
+ 0,0,0,0,23,0,24,0,0,0,0,0,0,0,25,26,
+ 27,13,28,29,30,144,0,0,0,33,34,35,36,37,38,39,
+ 40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,23,0,24,143,0,0,0,0,0,0,25,26,27,13,
+ 28,29,30};
+
+ D_ErrorRecoveryHint d_error_recovery_hints_3_dparser_gram[] = {
+ { 0, 7, "}"},
+ { 0, 15, ";"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_4_dparser_gram[] = {
+ { 0, 7, "}"},
+ { 0, 50, ")"},
+ { 0, 50, "]"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_5_dparser_gram[] = {{ 1, 7, "}"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_11_dparser_gram[] = {{ 1, 46, "}"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_13_dparser_gram[] = {{ 0, 15, ";"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_17_dparser_gram[] = {{ 1, 15, ";"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_21_dparser_gram[] = {{ 1, 50, ")"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_22_dparser_gram[] = {{ 1, 50, "}"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_23_dparser_gram[] = {{ 1, 50, "]"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_48_dparser_gram[] = {{ 2, 7, "}"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_53_dparser_gram[] = {
+ { 0, 46, "}"},
+ { 0, 50, ")"},
+ { 0, 50, "]"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_55_dparser_gram[] = {{ 0, 7, "}"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_56_dparser_gram[] = {{ 2, 15, ";"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_59_dparser_gram[] = {
+ { 0, 50, ")"},
+ { 0, 50, "]"},
+ { 0, 50, "}"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_62_dparser_gram[] = {{ 3, 7, "}"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_74_dparser_gram[] = {{ 3, 46, "}"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_77_dparser_gram[] = {{ 3, 15, ";"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_81_dparser_gram[] = {{ 3, 50, ")"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_83_dparser_gram[] = {{ 3, 50, "}"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_85_dparser_gram[] = {{ 3, 50, "]"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_87_dparser_gram[] = {{ 4, 7, "}"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_91_dparser_gram[] = {{ 4, 15, ";"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_95_dparser_gram[] = {
+ { 0, 31, "}"},
+ { 0, 31, ")"},
+ { 0, 48, "]"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_99_dparser_gram[] = {{ 0, 48, "]"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_100_dparser_gram[] = {
+ { 0, 31, "}"},
+ { 0, 50, ")"},
+ { 0, 50, "]"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_101_dparser_gram[] = {{ 1, 31, ")"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_102_dparser_gram[] = {{ 1, 48, "]"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_125_dparser_gram[] = {{ 0, 46, "}"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_130_dparser_gram[] = {{ 2, 31, ")"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_131_dparser_gram[] = {
+ { 0, 48, "]"},
+ { 0, 50, ")"},
+ { 0, 50, "}"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_139_dparser_gram[] = {{ 3, 31, "}"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_141_dparser_gram[] = {{ 3, 31, ")"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_142_dparser_gram[] = {{ 3, 48, "]"}};
+ D_ErrorRecoveryHint d_error_recovery_hints_152_dparser_gram[] = {{ 4, 31, ")"}};
+
+ D_State d_states_dparser_gram[] = {
+ { d_goto_valid_0_dparser_gram, 1, { 1, d_reductions_0_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 0, NULL}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 1, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_2_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_3_dparser_gram, 1, { 0, NULL}, { 0, NULL}, { 2, d_error_recovery_hints_3_dparser_gram}, d_shifts_3_dparser_gram, NULL, (void*)d_scanner_3_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_3_dparser_gram, d_accepts_diff_3_dparser_gram, -1},
+ { d_goto_valid_4_dparser_gram, 6, { 0, NULL}, { 0, NULL}, { 3, d_error_recovery_hints_4_dparser_gram}, d_shifts_4_dparser_gram, NULL, (void*)d_scanner_4_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_4_dparser_gram, d_accepts_diff_4_dparser_gram, -1},
+ { d_goto_valid_5_dparser_gram, 6, { 0, NULL}, { 0, NULL}, { 1, d_error_recovery_hints_5_dparser_gram}, d_shifts_5_dparser_gram, NULL, (void*)d_scanner_5_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_5_dparser_gram, d_accepts_diff_5_dparser_gram, -1},
+ { d_goto_valid_6_dparser_gram, -1, { 0, NULL}, { 0, NULL}, { 1, d_error_recovery_hints_5_dparser_gram}, d_shifts_6_dparser_gram, NULL, (void*)d_scanner_6_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_6_dparser_gram, d_accepts_diff_6_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_7_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_8_dparser_gram, 46, { 0, NULL}, { 0, NULL}, { 1, d_error_recovery_hints_5_dparser_gram}, d_shifts_6_dparser_gram, NULL, (void*)d_scanner_6_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_6_dparser_gram, d_accepts_diff_6_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_9_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_10_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_11_dparser_gram, 39, { 1, d_reductions_11_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_11_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_12_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_13_dparser_gram, -9, { 1, d_reductions_13_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_13_dparser_gram}, d_shifts_13_dparser_gram, NULL, (void*)d_scanner_13_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_13_dparser_gram, d_accepts_diff_13_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_14_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_15_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_16_dparser_gram, -5, { 1, d_reductions_16_dparser_gram}, { 1, d_right_epsilon_hints_16_dparser_gram}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_17_dparser_gram, -2, { 0, NULL}, { 0, NULL}, { 1, d_error_recovery_hints_17_dparser_gram}, d_shifts_17_dparser_gram, NULL, (void*)d_scanner_17_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_17_dparser_gram, d_accepts_diff_17_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_18_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_19_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_20_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_21_dparser_gram, 41, { 1, d_reductions_21_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_21_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_22_dparser_gram, 32, { 1, d_reductions_22_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_22_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_23_dparser_gram, 32, { 1, d_reductions_23_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_23_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_24_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_25_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_26_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_27_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_28_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_29_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_30_dparser_gram, -80, { 0, NULL}, { 0, NULL}, { 3, d_error_recovery_hints_4_dparser_gram}, d_shifts_30_dparser_gram, NULL, (void*)d_scanner_30_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_30_dparser_gram, d_accepts_diff_30_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_31_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_32_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_33_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_34_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_35_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_36_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_37_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_38_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_39_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_40_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_41_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_42_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_43_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_44_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_45_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_46_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_47_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_48_dparser_gram, -12, { 1, d_reductions_48_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_48_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_49_dparser_gram, -22, { 0, NULL}, { 0, NULL}, { 1, d_error_recovery_hints_48_dparser_gram}, d_shifts_49_dparser_gram, NULL, (void*)d_scanner_49_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_49_dparser_gram, d_accepts_diff_49_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_50_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_51_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_52_dparser_gram, -28, { 1, d_reductions_52_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_48_dparser_gram}, d_shifts_52_dparser_gram, NULL, (void*)d_scanner_52_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_52_dparser_gram, d_accepts_diff_52_dparser_gram, -1},
+ { d_goto_valid_53_dparser_gram, -97, { 0, NULL}, { 0, NULL}, { 3, d_error_recovery_hints_53_dparser_gram}, d_shifts_30_dparser_gram, NULL, (void*)d_scanner_30_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_30_dparser_gram, d_accepts_diff_30_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_54_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_55_dparser_gram, -102, { 1, d_reductions_55_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_55_dparser_gram}, d_shifts_55_dparser_gram, NULL, (void*)d_scanner_55_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_55_dparser_gram, d_accepts_diff_55_dparser_gram, -1},
+ { d_goto_valid_56_dparser_gram, -3, { 1, d_reductions_56_dparser_gram}, { 2, d_right_epsilon_hints_56_dparser_gram}, { 1, d_error_recovery_hints_56_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_57_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_58_dparser_gram, -12, { 1, d_reductions_58_dparser_gram}, { 2, d_right_epsilon_hints_58_dparser_gram}, { 1, d_error_recovery_hints_56_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_59_dparser_gram, -122, { 0, NULL}, { 0, NULL}, { 3, d_error_recovery_hints_59_dparser_gram}, d_shifts_59_dparser_gram, NULL, (void*)d_scanner_59_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_59_dparser_gram, d_accepts_diff_59_dparser_gram, -1},
+ { d_goto_valid_60_dparser_gram, -200, { 0, NULL}, { 0, NULL}, { 3, d_error_recovery_hints_59_dparser_gram}, d_shifts_30_dparser_gram, NULL, (void*)d_scanner_30_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_30_dparser_gram, d_accepts_diff_30_dparser_gram, -1},
+ { d_goto_valid_61_dparser_gram, -217, { 0, NULL}, { 0, NULL}, { 3, d_error_recovery_hints_59_dparser_gram}, d_shifts_61_dparser_gram, NULL, (void*)d_scanner_61_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_61_dparser_gram, d_accepts_diff_61_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_62_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_62_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_63_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_64_dparser_gram, 28, { 0, NULL}, { 0, NULL}, { 1, d_error_recovery_hints_62_dparser_gram}, d_shifts_49_dparser_gram, NULL, (void*)d_scanner_49_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_49_dparser_gram, d_accepts_diff_49_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_65_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_62_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_66_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_67_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_68_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_69_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_70_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_71_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_72_dparser_gram, 40, { 0, NULL}, { 0, NULL}, { 1, d_error_recovery_hints_62_dparser_gram}, d_shifts_72_dparser_gram, NULL, (void*)d_scanner_72_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_72_dparser_gram, d_accepts_diff_72_dparser_gram, -1},
+ { d_goto_valid_73_dparser_gram, -214, { 1, d_reductions_73_dparser_gram}, { 1, d_right_epsilon_hints_73_dparser_gram}, { 0, NULL}, d_shifts_52_dparser_gram, NULL, (void*)d_scanner_52_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_52_dparser_gram, d_accepts_diff_52_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_74_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_74_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_75_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_76_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_77_dparser_gram, 57, { 0, NULL}, { 0, NULL}, { 1, d_error_recovery_hints_77_dparser_gram}, d_shifts_77_dparser_gram, NULL, (void*)d_scanner_77_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_77_dparser_gram, d_accepts_diff_77_dparser_gram, -1},
+ { d_goto_valid_78_dparser_gram, -10, { 1, d_reductions_78_dparser_gram}, { 1, d_right_epsilon_hints_78_dparser_gram}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_79_dparser_gram, -35, { 2, d_reductions_79_dparser_gram}, { 1, d_right_epsilon_hints_79_dparser_gram}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_80_dparser_gram, 53, { 0, NULL}, { 0, NULL}, { 1, d_error_recovery_hints_77_dparser_gram}, d_shifts_77_dparser_gram, NULL, (void*)d_scanner_77_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_77_dparser_gram, d_accepts_diff_77_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_81_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_81_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_82_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_83_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_83_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_84_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_85_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_85_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_86_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_87_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_87_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_88_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_89_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_87_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_90_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_91_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_91_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_92_dparser_gram, -16, { 1, d_reductions_92_dparser_gram}, { 0, NULL}, { 0, NULL}, d_shifts_92_dparser_gram, NULL, (void*)d_scanner_92_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_92_dparser_gram, d_accepts_diff_92_dparser_gram, -1},
+ { d_goto_valid_93_dparser_gram, -15, { 1, d_reductions_93_dparser_gram}, { 1, d_right_epsilon_hints_93_dparser_gram}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_94_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_95_dparser_gram, -301, { 0, NULL}, { 0, NULL}, { 3, d_error_recovery_hints_95_dparser_gram}, d_shifts_95_dparser_gram, NULL, (void*)d_scanner_95_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_95_dparser_gram, d_accepts_diff_95_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_96_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_91_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_97_dparser_gram, -59, { 1, d_reductions_97_dparser_gram}, { 2, d_right_epsilon_hints_97_dparser_gram}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_98_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_99_dparser_gram, -259, { 1, d_reductions_99_dparser_gram}, { 2, d_right_epsilon_hints_99_dparser_gram}, { 1, d_error_recovery_hints_99_dparser_gram}, d_shifts_99_dparser_gram, NULL, (void*)d_scanner_99_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_99_dparser_gram, d_accepts_diff_99_dparser_gram, -1},
+ { d_goto_valid_100_dparser_gram, -320, { 0, NULL}, { 0, NULL}, { 3, d_error_recovery_hints_100_dparser_gram}, d_shifts_4_dparser_gram, NULL, (void*)d_scanner_4_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_4_dparser_gram, d_accepts_diff_4_dparser_gram, -1},
+ { d_goto_valid_101_dparser_gram, -7, { 1, d_reductions_101_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_101_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_102_dparser_gram, 6, { 1, d_reductions_102_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_102_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_103_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_104_dparser_gram, -20, { 2, d_reductions_104_dparser_gram}, { 1, d_right_epsilon_hints_104_dparser_gram}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_105_dparser_gram, -18, { 1, d_reductions_105_dparser_gram}, { 1, d_right_epsilon_hints_105_dparser_gram}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_106_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_107_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_108_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_109_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_110_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_111_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_112_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_113_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_114_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_115_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_116_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_117_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_118_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_119_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_120_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_121_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_122_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_123_dparser_gram, -179, { 0, NULL}, { 0, NULL}, { 0, NULL}, d_shifts_123_dparser_gram, NULL, (void*)d_scanner_123_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_123_dparser_gram, d_accepts_diff_123_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_124_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_125_dparser_gram, -51, { 1, d_reductions_125_dparser_gram}, { 1, d_right_epsilon_hints_125_dparser_gram}, { 1, d_error_recovery_hints_125_dparser_gram}, d_shifts_125_dparser_gram, NULL, (void*)d_scanner_125_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_125_dparser_gram, d_accepts_diff_125_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_126_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_127_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_128_dparser_gram, -341, { 0, NULL}, { 0, NULL}, { 3, d_error_recovery_hints_100_dparser_gram}, d_shifts_30_dparser_gram, NULL, (void*)d_scanner_30_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_30_dparser_gram, d_accepts_diff_30_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_129_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_130_dparser_gram, -61, { 1, d_reductions_130_dparser_gram}, { 2, d_right_epsilon_hints_130_dparser_gram}, { 1, d_error_recovery_hints_130_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_131_dparser_gram, -419, { 0, NULL}, { 0, NULL}, { 3, d_error_recovery_hints_131_dparser_gram}, d_shifts_61_dparser_gram, NULL, (void*)d_scanner_61_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_61_dparser_gram, d_accepts_diff_61_dparser_gram, -1},
+ { d_goto_valid_132_dparser_gram, -89, { 1, d_reductions_132_dparser_gram}, { 0, NULL}, { 0, NULL}, d_shifts_132_dparser_gram, NULL, (void*)d_scanner_132_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_132_dparser_gram, d_accepts_diff_132_dparser_gram, -1},
+ { d_goto_valid_133_dparser_gram, -132, { 1, d_reductions_133_dparser_gram}, { 0, NULL}, { 0, NULL}, d_shifts_132_dparser_gram, NULL, (void*)d_scanner_132_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_132_dparser_gram, d_accepts_diff_132_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_134_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_135_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_136_dparser_gram, -17, { 1, d_reductions_136_dparser_gram}, { 1, d_right_epsilon_hints_136_dparser_gram}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_137_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_138_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_139_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_139_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_140_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_141_dparser_gram, 30, { 0, NULL}, { 0, NULL}, { 1, d_error_recovery_hints_141_dparser_gram}, d_shifts_141_dparser_gram, NULL, (void*)d_scanner_141_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_141_dparser_gram, d_accepts_diff_141_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_142_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_142_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_143_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_144_dparser_gram, -139, { 0, NULL}, { 0, NULL}, { 0, NULL}, d_shifts_123_dparser_gram, NULL, (void*)d_scanner_123_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_123_dparser_gram, d_accepts_diff_123_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_145_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_146_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_147_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_148_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_149_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_150_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_151_dparser_gram, -87, { 1, d_reductions_151_dparser_gram}, { 0, NULL}, { 0, NULL}, d_shifts_6_dparser_gram, NULL, (void*)d_scanner_6_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_6_dparser_gram, d_accepts_diff_6_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_152_dparser_gram}, { 0, NULL}, { 1, d_error_recovery_hints_152_dparser_gram}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_153_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { NULL, -2147483647, { 1, d_reductions_154_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1},
+ { d_goto_valid_155_dparser_gram, 15, { 0, NULL}, { 0, NULL}, { 0, NULL}, d_shifts_155_dparser_gram, NULL, (void*)d_scanner_155_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_155_dparser_gram, d_accepts_diff_155_dparser_gram, -1},
+ { d_goto_valid_156_dparser_gram, -58, { 0, NULL}, { 0, NULL}, { 1, d_error_recovery_hints_125_dparser_gram}, d_shifts_125_dparser_gram, NULL, (void*)d_scanner_125_dparser_gram, sizeof(unsigned char), 0, D_SCAN_ALL, (void*)d_transition_125_dparser_gram, d_accepts_diff_125_dparser_gram, -1},
+ { NULL, -2147483647, { 1, d_reductions_157_dparser_gram}, { 0, NULL}, { 0, NULL}, NULL, NULL, NULL, sizeof(unsigned char), 0, D_SCAN_ALL, NULL, (D_Shift***)NULL, -1}
+ };
+
+ D_Symbol d_symbols_dparser_gram[] = {
+ {D_SYMBOL_INTERNAL, "0 Start", 7},
+ {D_SYMBOL_INTERNAL, "1 Start", 7},
+ {D_SYMBOL_NTERM, "grammar", 7},
+ {D_SYMBOL_INTERNAL, "grammar.6", 9},
+ {D_SYMBOL_INTERNAL, "grammar.4", 9},
+ {D_SYMBOL_INTERNAL, "grammar.4.5", 11},
+ {D_SYMBOL_INTERNAL, "grammar.3", 9},
+ {D_SYMBOL_NTERM, "global_code", 11},
+ {D_SYMBOL_INTERNAL, "global_code.10", 14},
+ {D_SYMBOL_INTERNAL, "global_code.9", 13},
+ {D_SYMBOL_INTERNAL, "global_code.8", 13},
+ {D_SYMBOL_NTERM, "pass_types", 10},
+ {D_SYMBOL_NTERM, "pass_type", 9},
+ {D_SYMBOL_NTERM, "declarationtype", 15},
+ {D_SYMBOL_NTERM, "token_identifier", 16},
+ {D_SYMBOL_NTERM, "production", 10},
+ {D_SYMBOL_NTERM, "regex_production", 16},
+ {D_SYMBOL_NTERM, "production_name", 15},
+ {D_SYMBOL_INTERNAL, "production_name.18", 18},
+ {D_SYMBOL_NTERM, "rules", 5},
+ {D_SYMBOL_INTERNAL, "rules.21", 8},
+ {D_SYMBOL_INTERNAL, "rules.20", 8},
+ {D_SYMBOL_NTERM, "rule", 4},
+ {D_SYMBOL_INTERNAL, "rule.29", 7},
+ {D_SYMBOL_INTERNAL, "rule.28", 7},
+ {D_SYMBOL_INTERNAL, "rule.23", 7},
+ {D_SYMBOL_INTERNAL, "rule.23.27", 10},
+ {D_SYMBOL_INTERNAL, "rule.23.26", 10},
+ {D_SYMBOL_INTERNAL, "rule.23.24", 10},
+ {D_SYMBOL_INTERNAL, "rule.23.24.25", 13},
+ {D_SYMBOL_NTERM, "new_rule", 8},
+ {D_SYMBOL_NTERM, "simple_element", 14},
+ {D_SYMBOL_INTERNAL, "simple_element.32", 17},
+ {D_SYMBOL_NTERM, "element", 7},
+ {D_SYMBOL_NTERM, "new_subrule", 11},
+ {D_SYMBOL_NTERM, "element_modifier", 16},
+ {D_SYMBOL_NTERM, "rule_modifier", 13},
+ {D_SYMBOL_NTERM, "rule_assoc", 10},
+ {D_SYMBOL_NTERM, "rule_priority", 13},
+ {D_SYMBOL_NTERM, "rule_code", 9},
+ {D_SYMBOL_INTERNAL, "rule_code.42", 12},
+ {D_SYMBOL_INTERNAL, "rule_code.41", 12},
+ {D_SYMBOL_INTERNAL, "rule_code.40", 12},
+ {D_SYMBOL_NTERM, "speculative_code", 16},
+ {D_SYMBOL_NTERM, "final_code", 10},
+ {D_SYMBOL_NTERM, "pass_code", 9},
+ {D_SYMBOL_NTERM, "curly_code", 10},
+ {D_SYMBOL_INTERNAL, "curly_code.47", 13},
+ {D_SYMBOL_NTERM, "bracket_code", 12},
+ {D_SYMBOL_INTERNAL, "bracket_code.49", 15},
+ {D_SYMBOL_NTERM, "balanced_code", 13},
+ {D_SYMBOL_INTERNAL, "balanced_code.53", 16},
+ {D_SYMBOL_INTERNAL, "balanced_code.52", 16},
+ {D_SYMBOL_INTERNAL, "balanced_code.51", 16},
+ {D_SYMBOL_NTERM, "symbols", 7},
+ {D_SYMBOL_NTERM, "string", 6},
+ {D_SYMBOL_NTERM, "regex", 5},
+ {D_SYMBOL_NTERM, "identifier", 10},
+ {D_SYMBOL_NTERM, "integer", 7},
+ {D_SYMBOL_NTERM, "decimalint", 10},
+ {D_SYMBOL_NTERM, "hexint", 6},
+ {D_SYMBOL_NTERM, "octalint", 8},
+ {D_SYMBOL_STRING, "${scanner", 9},
+ {D_SYMBOL_STRING, "}", 1},
+ {D_SYMBOL_STRING, "${declare", 9},
+ {D_SYMBOL_STRING, "}", 1},
+ {D_SYMBOL_STRING, "${token", 7},
+ {D_SYMBOL_STRING, "}", 1},
+ {D_SYMBOL_STRING, "${action}", 9},
+ {D_SYMBOL_STRING, "${pass", 6},
+ {D_SYMBOL_STRING, "}", 1},
+ {D_SYMBOL_STRING, "preorder", 8},
+ {D_SYMBOL_STRING, "postorder", 9},
+ {D_SYMBOL_STRING, "manual", 6},
+ {D_SYMBOL_STRING, "for_all", 7},
+ {D_SYMBOL_STRING, "for_undefined", 13},
+ {D_SYMBOL_STRING, "tokenize", 8},
+ {D_SYMBOL_STRING, "longest_match", 13},
+ {D_SYMBOL_STRING, "whitespace", 10},
+ {D_SYMBOL_STRING, "all_matches", 11},
+ {D_SYMBOL_STRING, "set_op_priority_from_rule", 25},
+ {D_SYMBOL_STRING, "all_subparsers", 14},
+ {D_SYMBOL_STRING, "subparser", 9},
+ {D_SYMBOL_STRING, "save_parse_tree", 15},
+ {D_SYMBOL_STRING, ":", 1},
+ {D_SYMBOL_STRING, ";", 1},
+ {D_SYMBOL_STRING, ";", 1},
+ {D_SYMBOL_STRING, ";", 1},
+ {D_SYMBOL_STRING, "::=", 3},
+ {D_SYMBOL_STRING, "_", 1},
+ {D_SYMBOL_STRING, "|", 1},
+ {D_SYMBOL_STRING, "${scan", 6},
+ {D_SYMBOL_STRING, "}", 1},
+ {D_SYMBOL_STRING, "(", 1},
+ {D_SYMBOL_STRING, ")", 1},
+ {D_SYMBOL_STRING, "$term", 5},
+ {D_SYMBOL_STRING, "/i", 2},
+ {D_SYMBOL_STRING, "?", 1},
+ {D_SYMBOL_STRING, "*", 1},
+ {D_SYMBOL_STRING, "+", 1},
+ {D_SYMBOL_STRING, "$unary_op_right", 15},
+ {D_SYMBOL_STRING, "$unary_op_left", 14},
+ {D_SYMBOL_STRING, "$binary_op_right", 16},
+ {D_SYMBOL_STRING, "$binary_op_left", 15},
+ {D_SYMBOL_STRING, "$unary_right", 12},
+ {D_SYMBOL_STRING, "$unary_left", 11},
+ {D_SYMBOL_STRING, "$binary_right", 13},
+ {D_SYMBOL_STRING, "$binary_left", 12},
+ {D_SYMBOL_STRING, "$right", 6},
+ {D_SYMBOL_STRING, "$left", 5},
+ {D_SYMBOL_STRING, ":", 1},
+ {D_SYMBOL_STRING, "{", 1},
+ {D_SYMBOL_STRING, "}", 1},
+ {D_SYMBOL_STRING, "[", 1},
+ {D_SYMBOL_STRING, "]", 1},
+ {D_SYMBOL_STRING, "(", 1},
+ {D_SYMBOL_STRING, ")", 1},
+ {D_SYMBOL_STRING, "[", 1},
+ {D_SYMBOL_STRING, "]", 1},
+ {D_SYMBOL_STRING, "{", 1},
+ {D_SYMBOL_STRING, "}", 1},
+ {D_SYMBOL_REGEX, "[!~`@#$%^&*\\\\-_+=|:;\\\\\\\\<,>.?/]", 37},
+ {D_SYMBOL_REGEX, "'([^'\\\\\\\\]|\\\\\\\\[^])*'", 29},
+ {D_SYMBOL_REGEX, "\\\"([^\\\"\\\\\\\\]|\\\\\\\\[^])*\\\"", 38},
+ {D_SYMBOL_REGEX, "[a-zA-Z_][a-zA-Z_0-9]*", 22},
+ {D_SYMBOL_REGEX, "-?[1-9][0-9]*[uUlL]?", 20},
+ {D_SYMBOL_REGEX, "-?(0x|0X)[0-9a-fA-F]+[uUlL]?", 28},
+ {D_SYMBOL_REGEX, "-?0[0-7]*[uUlL]?", 16},
+ };
+
+ D_ParserTables parser_tables_dparser_gram = {
+ 158, d_states_dparser_gram, d_gotos_dparser_gram, 0, 128, d_symbols_dparser_gram, NULL, 0, NULL, 0};
Index: llvm/test/Programs/MultiSource/Applications/d/index.html
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/index.html:1.1
*** /dev/null Thu Jan 1 10:50:46 2004
--- llvm/test/Programs/MultiSource/Applications/d/index.html Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,127 ----
+ <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+ <html>
+ <head>
+ <meta http-equiv="content-type"
+ content="text/html; charset=ISO-8859-1">
+ <title>D Parser Homepage</title>
+ </head>
+ <body>
+ <div style="text-align: center;"><big style="font-weight: bold;"><big><big>DParser<br>
+ <small><small><small>(you know... 'da parser)<br>
+ </small></small></small><br>
+ </big></big></big><br>
+ <div style="text-align: left; margin-left: 40px;"><span
+ style="font-weight: bold;">Introduction<br>
+ <br>
+ </span>DParser is an simple but powerful tool for parsing. You
+ can specify the form of the text to be parsed using a combination of
+ regular expressions and grammar productions. Because of the
+ parsing technique (technically a scannerless GLR parser based on the
+ Tomita algorithm) there are no restrictions. The grammar can be
+ ambiguous, right or left recursive, have any number of null
+ productions,
+ and because there is no seperate tokenizer, can include whitespace in
+ terminals and have terminals which are prefixes of other terminals.
+ DParser handles not just well formed computer languages and data
+ files, but just about any wacky situation that occurs in the real world.<br>
+ <br>
+ <span style="font-weight: bold;">Features<br>
+ </span>
+ <ul>
+ <li>Powerful GLR parsing<br>
+ </li>
+ <li>Simple EBNF-style grammars and regular expression terminals</li>
+ <li>Priorities and associativities for token and rules</li>
+ <li>Built-in error recovery</li>
+ <li>Speculative actions (for semantic disambiguation)</li>
+ <li>Auto-building of parse tree (optionally)</li>
+ <li>Final actions as you go, or on the complete parse tree</li>
+ <li>Tree walkers and default actions (multi-pass compilation support)<br>
+ </li>
+ <li>Symbol table built for ambiguous parsing</li>
+ <li>Partial parses, recursive parsing, parsing starting with any
+ non-terminal</li>
+ <li>Whitespace can be specified as a subgrammar</li>
+ <li>External (C call interface) tokenizers and external terminal
+ scanners </li>
+ <li>Good asymptotically efficiency</li>
+ <li>Comes with ANSI-C, Python and Verilog grammars<br>
+ </li>
+ <li>Comes with full source</li>
+ <li>Portable C for easy compilation and linking<br>
+ </li>
+ <li>BSD licence, so you can included it in your application without
+ worrying about licensing<br>
+ </li>
+ </ul>
+ <span style="font-weight: bold;">Examples<br>
+ <br>
+ <a href="d/tests/ansic.test.g">ANSI
+ C grammar</a><br>
+ </span><span style="font-weight: bold;"> </span><span
+ style="font-weight: bold;"> <a
+ href="d/tests/python.test.g">Python
+ grammar</a><br>
+ </span><span style="font-weight: bold;"> </span><span
+ style="font-weight: bold;"> <a
+ href="d/verilog/verilog.g">Verilog
+ grammar</a><br>
+ </span><span style="font-weight: bold;"> </span><span
+ style="font-weight: bold;"></span><span style="font-weight: bold;"><br>
+ Documentation<br>
+ <br>
+ <span style="font-weight: bold;">
+ </span></span><span style="font-weight: bold;"><a
+ href="d/make_dparser.cat">Man page for
+ parser generator</a><br>
+ </span><span style="font-weight: bold;">
+ </span><span style="font-weight: bold;"><a
+ href="d/manual.html">Manual</a><br>
+ </span><span style="font-weight: bold;">
+ </span><span style="font-weight: bold;"><a
+ href="d/faq.html">FAQ</a><br>
+ <br>
+ </span><span style="font-weight: bold;"> Public Headers<br>
+ <br>
+ <a href="d/dparse.h">dparse.h</a>
+ - main
+ parser data structures and functions<br>
+ <a href="d/dparse_tables.h">dparse_tables.h</a>
+ - parse tables data structures<br>
+ <a href="d/dsymtab.h">dsymtab.h</a>
+ - optional symbol
+ table<br>
+ <br>
+ </span><span style="font-weight: bold;">Download<br>
+ <br>
+ <a
+ href="http://prdownloads.sourceforge.net/dparser/d-1.5-src.tar.gz">Source
+ (tar.gz)</a><br>
+ <span style="font-weight: bold;"> </span></span><span
+ style="font-weight: bold;"><a
+ href="http://sourceforge.net/project/showfiles.php?group_id=70166">Binaries
+ for Linux, FreeBSD and Windows (cygwin)</a><br>
+ <br>
+ </span><a href="http://sourceforge.net/projects/dparser/"><span
+ style="font-weight: bold;"></span></a>
+ <div style="text-align: left;"><span style="font-weight: bold;">Additional
+ Information at </span><a
+ href="http://sourceforge.net/projects/dparser/">Sourceforge</a>
+ <div style="text-align: left;">
+ <table border="1" width="100%" cellpadding="2" cellspacing="2">
+ <tbody>
+ <tr>
+ </tr>
+ </tbody>
+ </table>
+ <span style="font-weight: bold;">Contact the author: jplevyak at source
+ forge (users.sourceforge.net)</span><br>
+ <a href="http://sourceforge.net/"> <br>
+ <img src="http://sourceforge.net/sflogo.php?group_id=70166&type=5"
+ width="210" height="62" border="0" alt="SourceForge.net Logo"></a><br>
+ </div>
+ </div>
+ </div>
+ </div>
+ </body>
+ </html>
Index: llvm/test/Programs/MultiSource/Applications/d/lex.c
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/lex.c:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/lex.c Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,572 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+
+ #include "d.h"
+
+ typedef struct NFAState {
+ uint index;
+ Vec(struct NFAState*) chars[256];
+ Vec(struct NFAState*) epsilon;
+ Vec(Action*) accepts;
+ Vec(Action*) live;
+ } NFAState;
+
+ typedef struct DFAState {
+ Vec(struct NFAState*) states;
+ struct DFAState *chars[256];
+ ScanState *scan;
+ } DFAState;
+
+ typedef Vec(DFAState *) VecDFAState;
+ typedef Vec(NFAState *) VecNFAState;
+
+ typedef struct LexState {
+ uint nfa_index;
+ VecNFAState allnfas;
+ uint transitions;
+ uint scanners;
+ uint ignore_case;
+ } LexState;
+
+ static NFAState *
+ new_NFAState(LexState *ls) {
+ NFAState *n = MALLOC(sizeof(NFAState));
+ memset(n, 0, sizeof(NFAState));
+ n->index = ls->nfa_index++;
+ vec_add(&ls->allnfas, n);
+ return n;
+ }
+
+ static DFAState *
+ new_DFAState() {
+ DFAState *n = MALLOC(sizeof(DFAState));
+ memset(n, 0, sizeof(DFAState));
+ return n;
+ }
+
+ static void
+ free_DFAState(DFAState *y) {
+ vec_free(&y->states);
+ FREE(y);
+ }
+
+ static void
+ free_VecDFAState(VecDFAState *dfas) {
+ int i;
+ for (i = 0; i < dfas->n; i++)
+ free_DFAState(dfas->v[i]);
+ vec_free(dfas);
+ }
+
+ static void
+ free_NFAState(NFAState *y) {
+ int i;
+ for (i = 0; i < 256; i++)
+ vec_free(&y->chars[i]);
+ vec_free(&y->epsilon);
+ vec_free(&y->accepts);
+ FREE(y);
+ }
+
+ static void
+ free_VecNFAState(VecNFAState *nfas) {
+ int i;
+ for (i = 0; i < nfas->n; i++)
+ free_NFAState(nfas->v[i]);
+ vec_free(nfas);
+ }
+
+ static ScanState *
+ new_ScanState() {
+ ScanState *n = MALLOC(sizeof(ScanState));
+ memset(n, 0, sizeof(ScanState));
+ return n;
+ }
+
+ static int
+ nfacmp(const void *ai, const void *aj) {
+ uint32 i = (*(NFAState**)ai)->index;
+ uint32 j = (*(NFAState**)aj)->index;
+ return (i > j) ? 1 : ((i < j) ? -1 : 0);
+ }
+
+ static void
+ nfa_closure(DFAState *x) {
+ int i, j, k;
+
+ for (i = 0; i < x->states.n; i++)
+ for (j = 0; j < x->states.v[i]->epsilon.n; j++) {
+ for (k = 0; k < x->states.n; k++)
+ if (x->states.v[i]->epsilon.v[j] == x->states.v[k])
+ goto Lbreak;
+ vec_add(&x->states, x->states.v[i]->epsilon.v[j]);
+ Lbreak:;
+ }
+ qsort(x->states.v, x->states.n, sizeof(x->states.v[0]), nfacmp);
+ }
+
+ static int
+ eq_dfa_state(DFAState *x, DFAState *y) {
+ int i;
+
+ if (x->states.n != y->states.n)
+ return 0;
+ for (i = 0; i < x->states.n; i++)
+ if (x->states.v[i] != y->states.v[i])
+ return 0;
+ return 1;
+ }
+
+ static void
+ dfa_to_scanner(VecDFAState *alldfas, VecScanState *scanner) {
+ int i, j, k, highest, p;
+
+ vec_clear(scanner);
+ for (i = 0; i < alldfas->n; i++) {
+ alldfas->v[i]->scan = new_ScanState();
+ alldfas->v[i]->scan->index = i;
+ vec_add(scanner, alldfas->v[i]->scan);
+ }
+ for (i = 0; i < alldfas->n; i++) {
+ for (j = 0; j < 256; j++)
+ if (alldfas->v[i]->chars[j])
+ alldfas->v[i]->scan->chars[j] = alldfas->v[i]->chars[j]->scan;
+ highest = INT_MIN;
+ for (j = 0; j < alldfas->v[i]->states.n; j++)
+ for (k = 0; k < alldfas->v[i]->states.v[j]->accepts.n; k++) {
+ p = alldfas->v[i]->states.v[j]->accepts.v[k]->term->term_priority;
+ if (highest < p)
+ highest = p;
+ }
+ for (j = 0; j < alldfas->v[i]->states.n; j++)
+ for (k = 0; k < alldfas->v[i]->states.v[j]->accepts.n; k++) {
+ p = alldfas->v[i]->states.v[j]->accepts.v[k]->term->term_priority;
+ if (p == highest)
+ vec_add(&alldfas->v[i]->scan->accepts,
+ alldfas->v[i]->states.v[j]->accepts.v[k]);
+ }
+ }
+ }
+
+ static void
+ nfa_to_scanner(NFAState *n, Scanner *s) {
+ DFAState *x = new_DFAState(), *y;
+ VecDFAState alldfas;
+ int i, i_alldfas, i_states, i_char;
+ VecScanState *scanner = &s->states;
+
+ memset(&alldfas, 0, sizeof(alldfas));
+ vec_add(&x->states, n);
+ nfa_closure(x);
+ vec_add(&alldfas, x);
+ for (i_alldfas = 0; i_alldfas < alldfas.n; i_alldfas++) {
+ x = alldfas.v[i_alldfas];
+ for (i_char = 0; i_char < 256; i_char++) {
+ y = NULL;
+ for (i_states = 0; i_states < x->states.n; i_states++) {
+ for (i = 0; i < x->states.v[i_states]->chars[i_char].n; i++) {
+ if (!y)
+ y = new_DFAState();
+ set_add(&y->states, x->states.v[i_states]->chars[i_char].v[i]);
+ }
+ }
+ if (y) {
+ set_to_vec(&y->states);
+ nfa_closure(y);
+ for (i = 0; i < alldfas.n; i++)
+ if (eq_dfa_state(y, alldfas.v[i])) {
+ free_DFAState(y);
+ y = alldfas.v[i];
+ goto Lnext;
+ }
+ vec_add(&alldfas, y);
+ Lnext:
+ x->chars[i_char] = y;
+ }
+ }
+ }
+ dfa_to_scanner(&alldfas, scanner);
+ free_VecDFAState(&alldfas);
+ }
+
+ /* build a NFA for the regular expression */
+ static void
+ build_regex_nfa(LexState *ls, uint8 **areg, NFAState *pp, NFAState *nn) {
+ uint8 c, pc, *reg = *areg;
+ NFAState *p = pp, *s, *x, *n = nn;
+ int reversed, i;
+ uint8 mark[256];
+
+ s = p;
+ while ((c = *reg++)) {
+ switch(c) {
+ case '(':
+ build_regex_nfa(ls, ®, s, (x = new_NFAState(ls)));
+ p = s;
+ s = x;
+ break;
+ case ')':
+ goto Lreturn;
+ case '|':
+ vec_add(&s->epsilon, nn);
+ vec_add(&pp->epsilon, (s = new_NFAState(ls)));
+ break;
+ case '[':
+ if (*reg == '^') {
+ reg++;
+ reversed = 1;
+ } else
+ reversed = 0;
+ memset(mark, 0, sizeof(mark));
+ pc = UCHAR_MAX;
+ while ((c = *reg++)) {
+ switch(c) {
+ case ']':
+ goto Lsetdone;
+ case '-':
+ c = *reg++;
+ if (!c)
+ goto Lerror;
+ if (c == '\\')
+ c = *reg++;
+ if (!c)
+ goto Lerror;
+ for (;pc <= c; pc++)
+ mark[pc] = 1;
+ break;
+ case '\\':
+ c = *reg++;
+ /* fall through */
+ default:
+ pc = c;
+ mark[c] = 1;
+ break;
+ }
+ }
+ Lsetdone:
+ x = new_NFAState(ls);
+ for (i = 1; i < 256; i++)
+ if ((!reversed && mark[i]) || (reversed && !mark[i]))
+ vec_add(&s->chars[i], x);
+ p = s;
+ s = x;
+ break;
+ case '?':
+ vec_add(&p->epsilon, s);
+ break;
+ case '*':
+ vec_add(&p->epsilon, s);
+ vec_add(&s->epsilon, p);
+ break;
+ case '+':
+ vec_add(&s->epsilon, p);
+ break;
+ case '\\':
+ c = *reg++;
+ if (!c)
+ goto Lerror;
+ /* fall through */
+ default:
+ if (!ls->ignore_case || !isalpha(c))
+ vec_add(&s->chars[c], (x = new_NFAState(ls)));
+ else {
+ vec_add(&s->chars[tolower(c)], (x = new_NFAState(ls)));
+ vec_add(&s->chars[toupper(c)], x);
+ }
+ p = s;
+ s = x;
+ break;
+ }
+ }
+ Lreturn:
+ vec_add(&s->epsilon, n);
+ *areg = reg;
+ return;
+ Lerror:
+ d_fail("bad (part of) regex: %s\n", *areg);
+ }
+
+ static void
+ action_diff(VecAction *a, VecAction *b, VecAction *c) {
+ int bb = 0, cc = 0;
+ while (1) {
+ if (bb >= b->n)
+ break;
+ Lagainc:
+ if (cc >= c->n) {
+ while (bb < b->n)
+ vec_add(a, b->v[bb++]);
+ break;
+ }
+ Lagainb:
+ if (b->v[bb]->index == c->v[cc]->index) {
+ bb++;
+ cc++;
+ continue;
+ }
+ if (b->v[bb]->index < c->v[cc]->index) {
+ vec_add(a, b->v[bb++]);
+ if (bb >= b->n)
+ break;
+ goto Lagainb;
+ }
+ cc++;
+ goto Lagainc;
+ }
+ }
+
+ static void
+ action_intersect(VecAction *a, VecAction *b, VecAction *c) {
+ int bb = 0, cc = 0;
+ while (1) {
+ if (bb >= b->n)
+ break;
+ Lagainc:
+ if (cc >= c->n)
+ break;
+ Lagainb:
+ if (b->v[bb]->index == c->v[cc]->index) {
+ vec_add(a, b->v[bb++]);
+ cc++;
+ continue;
+ }
+ if (b->v[bb]->index < c->v[cc]->index) {
+ bb++;
+ if (bb >= b->n)
+ break;
+ goto Lagainb;
+ }
+ cc++;
+ goto Lagainc;
+ }
+ }
+
+ static void
+ compute_liveness(Scanner *scanner) {
+ int i, j, changed = 1;
+ ScanState *ss, *sss;
+ VecScanState *states = &scanner->states;
+
+ /* basis */
+ for (i = 0; i < states->n; i++) {
+ ss = states->v[i];
+ set_union(&ss->live, &ss->accepts);
+ }
+ while (changed) {
+ changed = 0;
+ for (i = 0; i < states->n; i++) {
+ ss = states->v[i];
+ for (j = 0; j < 256; j++) {
+ if ((sss = ss->chars[j])) {
+ if (ss != sss)
+ if (set_union(&ss->live, &sss->live))
+ changed = 1;
+ }
+ }
+ }
+ }
+ for (i = 0; i < states->n; i++) {
+ ss = states->v[i];
+ set_to_vec(&ss->live);
+ sort_VecAction(&ss->live);
+ }
+ }
+
+ static uint32
+ trans_hash_fn(ScanStateTransition *a, hash_fns_t *fns) {
+ uint h = 0;
+ int i;
+
+ if (!fns->data[0])
+ for (i = 0; i < a->live_diff.n; i++)
+ h += 3 * a->live_diff.v[i]->index;
+ for (i = 0; i < a->accepts_diff.n; i++)
+ h += 3 * a->accepts_diff.v[i]->index;
+ return h;
+ }
+
+ static int
+ trans_cmp_fn(ScanStateTransition *a, ScanStateTransition *b, hash_fns_t *fns) {
+ int i;
+
+ if (!fns->data[0])
+ if (a->live_diff.n != b->live_diff.n)
+ return 1;
+ if (a->accepts_diff.n != b->accepts_diff.n)
+ return 1;
+ if (!fns->data[0])
+ for (i = 0; i < a->live_diff.n; i++)
+ if (a->live_diff.v[i] != b->live_diff.v[i])
+ return 1;
+ for (i = 0; i < a->accepts_diff.n; i++)
+ if (a->accepts_diff.v[i] != b->accepts_diff.v[i])
+ return 1;
+ return 0;
+ }
+
+ static hash_fns_t trans_hash_fns = {
+ (hash_fn_t)trans_hash_fn,
+ (cmp_fn_t)trans_cmp_fn,
+ { 0, 0 }
+ };
+
+ static void
+ build_transitions(LexState *ls, Scanner *s) {
+ int i, j;
+ ScanState *ss;
+ ScanStateTransition *trans = NULL, *x;
+ VecScanState *states = &s->states;
+
+ #ifdef LIVE_DIFF_IN_TRANSITIONS
+ trans_hash_fns.data[0] = (void*)0;
+ #else
+ trans_hash_fns.data[0] = (void*)1;
+ #endif
+ for (i = 0; i < states->n; i++) {
+ ss = states->v[i];
+ for (j = 0; j < 256; j++) {
+ if (!trans) {
+ trans = MALLOC(sizeof(*trans));
+ memset(trans, 0, sizeof(*trans));
+ }
+ if (ss->chars[j]) {
+ action_diff(&trans->live_diff, &ss->live, &ss->chars[j]->live);
+ action_intersect(&trans->accepts_diff, &ss->accepts,
+ &trans->live_diff);
+ }
+ if ((x = set_add_fn(&s->transitions, trans, &trans_hash_fns)) == trans)
+ trans = NULL;
+ else {
+ vec_free(&trans->live_diff);
+ vec_free(&trans->accepts_diff);
+ }
+ ss->transition[j] = x;
+ }
+ }
+ j = 0;
+ set_to_vec(&s->transitions);
+ for (i = 0; i < s->transitions.n; i++)
+ s->transitions.v[i]->index = i;
+ ls->transitions += s->transitions.n;
+ }
+
+ static void
+ compute_transitions(LexState *ls, Scanner *s) {
+ compute_liveness(s);
+ build_transitions(ls, s);
+ }
+
+ static void
+ build_state_scanner(LexState *ls, State *s) {
+ NFAState *n, *nn, *nnn;
+ Action *a;
+ uint8 *c, *reg;
+ int j, one;
+
+ one = 0;
+ n = new_NFAState(ls);
+ /* first strings since they can be trivially combined as a tree */
+ for (j = 0; j < s->shift_actions.n; j++) {
+ a = s->shift_actions.v[j];
+ if (a->kind == ACTION_ACCEPT) {
+ one = 1;
+ if (!n->chars[0].n)
+ vec_add(&n->chars[0], (nnn = new_NFAState(ls)));
+ else
+ nnn = n->chars[0].v[0];
+ vec_add(&nnn->accepts, a);
+ } else if (a->kind == ACTION_SHIFT && a->term->kind == TERM_STRING) {
+ one = 1;
+ nn = n;
+ if (!a->term->ignore_case) {
+ for (c = a->term->string; *c; c++) {
+ if (!nn->chars[*c].n)
+ vec_add(&nn->chars[*c], (nnn = new_NFAState(ls)));
+ else
+ nnn = nn->chars[*c].v[0];
+ nn = nnn;
+ }
+ } else { /* use new states */
+ for (c = a->term->string; *c; c++) {
+ if (isalpha(*c)) {
+ vec_add(&nn->chars[toupper(*c)], (nnn = new_NFAState(ls)));
+ vec_add(&nn->chars[tolower(*c)], nnn);
+ } else
+ vec_add(&nn->chars[*c], (nnn = new_NFAState(ls)));
+ nn = nnn;
+ }
+ }
+ vec_add(&nn->accepts, a);
+ }
+ }
+ /* now regexes */
+ for (j = 0; j < s->shift_actions.n; j++) {
+ a = s->shift_actions.v[j];
+ if (a->kind == ACTION_SHIFT && a->term->kind == TERM_REGEX) {
+ one = 1;
+ reg = a->term->string;
+ vec_add(&n->epsilon, (nnn = new_NFAState(ls)));
+ nn = new_NFAState(ls);
+ ls->ignore_case = a->term->ignore_case;
+ build_regex_nfa(ls, ®, nnn, nn);
+ vec_add(&nn->accepts, a);
+ }
+ }
+ if (one) {
+ nfa_to_scanner(n, &s->scanner);
+ compute_transitions(ls, &s->scanner);
+ }
+ free_VecNFAState(&ls->allnfas);
+ ls->scanners++;
+ }
+
+ static LexState *
+ new_LexState() {
+ LexState *ls = MALLOC(sizeof(LexState));
+ memset(ls, 0, sizeof(LexState));
+ vec_clear(&ls->allnfas);
+ return ls;
+ }
+
+ void
+ build_scanners(Grammar *g) {
+ int i, j, k;
+ State *s;
+ LexState *ls = new_LexState();
+
+ /* detect identical scanners */
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ if (s->same_shifts)
+ continue;
+ for (j = 0; j < i; j++) {
+ if (g->states.v[j]->same_shifts)
+ continue;
+ if (g->states.v[j]->shift_actions.n != g->states.v[i]->shift_actions.n)
+ continue;
+ for (k = 0; k < g->states.v[j]->shift_actions.n; k++)
+ if (g->states.v[i]->shift_actions.v[k]->term !=
+ g->states.v[j]->shift_actions.v[k]->term)
+ break;
+ if (k >= g->states.v[j]->shift_actions.n) {
+ s->same_shifts = g->states.v[j];
+ break;
+ }
+ }
+ }
+ /* build scanners */
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ if (s->shift_actions.n) {
+ if (s->same_shifts)
+ s->scanner = s->same_shifts->scanner;
+ else
+ build_state_scanner(ls, s);
+ }
+ }
+ if (verbose_level)
+ printf("%d scanners %d transitions\n", ls->scanners, ls->transitions);
+ FREE(ls);
+ }
+
Index: llvm/test/Programs/MultiSource/Applications/d/lex.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/lex.h:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/lex.h Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,28 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+
+ #ifndef _lex_H_
+ #define _lex_H_
+
+ /* #define LIVE_DIFF_IN_TRANSITIONS */
+
+ struct Grammar;
+
+ typedef struct ScanStateTransition {
+ uint index;
+ VecAction live_diff;
+ VecAction accepts_diff;
+ } ScanStateTransition;
+
+ typedef struct ScanState {
+ uint index;
+ struct ScanState *chars[256];
+ VecAction accepts;
+ VecAction live;
+ ScanStateTransition *transition[256];
+ } ScanState;
+
+ void build_scanners(struct Grammar *g);
+
+ #endif
Index: llvm/test/Programs/MultiSource/Applications/d/lr.c
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/lr.c:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/lr.c Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,391 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+
+ #include "d.h"
+
+ #define INITIAL_ALLITEMS 3359
+
+ #define item_hash(_i) \
+ (((uint)(_i)->rule->index << 8) + \
+ ((uint)((_i)->kind != ELEM_END ? (_i)->index : (_i)->rule->elems.n)))
+
+ static int
+ insert_item(State *s, Elem *e) {
+ Item *i = e;
+ if (set_add(&s->items_hash, i)) {
+ vec_add(&s->items, i);
+ return 1;
+ }
+ return 0;
+ }
+
+ static int
+ itemcmp(const void *ai, const void *aj) {
+ uint i = item_hash(*(Item**)ai);
+ uint j = item_hash(*(Item**)aj);
+ return (i > j) ? 1 : ((i < j) ? -1 : 0);
+ }
+
+ static State *
+ new_state() {
+ State *s = MALLOC(sizeof(State));
+ memset(s, 0, sizeof(State));
+ return s;
+ }
+
+ static void
+ free_state(State *s) {
+ vec_free(&s->items);
+ vec_free(&s->items_hash);
+ FREE(s);
+ }
+
+ static State *
+ maybe_add_state(Grammar *g, State *s) {
+ int i, j;
+
+ for (i = 0; i < g->states.n; i++) {
+ if (s->hash == g->states.v[i]->hash &&
+ s->items.n == g->states.v[i]->items.n) {
+ for (j = 0; j < s->items.n; j++)
+ if (s->items.v[j] != g->states.v[i]->items.v[j])
+ goto Lcont;
+ free_state(s);
+ return g->states.v[i];
+ Lcont:;
+ }
+ }
+ s->index = g->states.n;
+ vec_add(&g->states, s);
+ return s;
+ }
+
+ static Elem *
+ next_elem(Item *i) {
+ if (i->index + 1 >= i->rule->elems.n)
+ return i->rule->end;
+ else
+ return i->rule->elems.v[i->index + 1];
+ }
+
+ static State *
+ build_closure(Grammar *g, State *s) {
+ int j, k;
+
+ for (j = 0; j < s->items.n; j++) {
+ Item *i = s->items.v[j];
+ Elem *e = i;
+ if (e->kind == ELEM_NTERM) {
+ Production *pp = e->e.nterm;
+ for (k = 0; k < e->e.nterm->rules.n; k++)
+ insert_item(s, pp->rules.v[k]->elems.v ?
+ pp->rules.v[k]->elems.v[0] : pp->rules.v[k]->end);
+ }
+ }
+ qsort(s->items.v, s->items.n, sizeof(Item*), itemcmp);
+ s->hash = 0;
+ for (j = 0; j < s->items.n; j++)
+ s->hash += item_hash(s->items.v[j]);
+ return maybe_add_state(g, s);
+ }
+
+ static Elem *
+ clone_elem(Elem *e) {
+ Elem *ee = MALLOC(sizeof(*ee));
+ memcpy(ee, e, sizeof(*ee));
+ return ee;
+ }
+
+ static void
+ add_goto(State *s, State *ss, Elem *e) {
+ Goto *g = MALLOC(sizeof(Goto));
+ g->state = ss;
+ g->elem = clone_elem(e);
+ vec_add(&s->gotos, g);
+ }
+
+ static void
+ build_state_for(Grammar *g, State *s, Elem *e) {
+ int j;
+ Item *i;
+ State *ss = NULL;
+
+ for (j = 0; j < s->items.n; j++) {
+ i = s->items.v[j];
+ if (i->kind != ELEM_END && i->kind == e->kind &&
+ i->e.term_or_nterm == e->e.term_or_nterm)
+ {
+ if (!ss) ss = new_state();
+ insert_item(ss, next_elem(i));
+ }
+ }
+ if (ss)
+ add_goto(s, build_closure(g, ss), e);
+ }
+
+ static void
+ build_new_states(Grammar *g) {
+ int i, j;
+ State *s;
+ Elem e;
+
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ for (j = 0; j < g->terminals.n; j++) {
+ e.kind = ELEM_TERM;
+ e.e.term = g->terminals.v[j];
+ build_state_for(g, s, &e);
+ }
+ for (j = 0; j < g->productions.n; j++) {
+ e.kind = ELEM_NTERM;
+ e.e.nterm = g->productions.v[j];
+ build_state_for(g, s, &e);
+ }
+ }
+ }
+
+ static void
+ build_states_for_each_production(Grammar *g) {
+ int i;
+ for (i = 0; i < g->productions.n; i++)
+ if (!g->productions.v[i]->internal && g->productions.v[i]->elem) {
+ State *s = new_state();
+ insert_item(s, g->productions.v[i]->elem);
+ g->productions.v[i]->state = build_closure(g, s);
+ }
+ }
+
+ uint
+ elem_symbol(Grammar *g, Elem *e) {
+ if (e->kind == ELEM_NTERM)
+ return e->e.nterm->index;
+ else
+ return g->productions.n + e->e.term->index;
+ }
+
+ static int
+ gotocmp(const void *aa, const void *bb) {
+ Goto *a = *(Goto **)aa, *b = *(Goto **)bb;
+ int i = a->state->index, j = b->state->index;
+ return ((i > j) ? 1 : ((i < j) ? -1 : 0));
+ }
+
+ static void
+ sort_Gotos(Grammar *g) {
+ int i;
+
+ for (i = 0; i < g->states.n; i++) {
+ VecGoto *vg = &g->states.v[i]->gotos;
+ qsort(vg->v, vg->n, sizeof(Goto*), gotocmp);
+ }
+ }
+
+ static void
+ build_LR_sets(Grammar *g) {
+ State *s = new_state();
+ insert_item(s, g->productions.v[0]->rules.v[0]->elems.v[0]);
+ build_closure(g, s);
+ build_states_for_each_production(g);
+ build_new_states(g);
+ sort_Gotos(g);
+ }
+
+ static Action *
+ new_Action(Grammar *g, int akind, Term *aterm, Rule *arule, State *astate) {
+ Action *a = MALLOC(sizeof(Action));
+ a->kind = akind;
+ a->term = aterm;
+ a->rule = arule;
+ a->state = astate;
+ a->index = g->action_count++;
+ return a;
+ }
+
+ static void
+ add_action(Grammar *g, State *s, int akind, Term *aterm,
+ Rule *arule, State *astate)
+ {
+ int i;
+ Action *a;
+
+ if (akind == ACTION_REDUCE) {
+ /* eliminate duplicates */
+ for (i = 0; i < s->reduce_actions.n; i++)
+ if (s->reduce_actions.v[i]->rule == arule)
+ return;
+ a = new_Action(g, akind, aterm, arule, astate);
+ vec_add(&s->reduce_actions, a);
+ } else {
+ /* eliminate duplicates */
+ for (i = 0; i < s->shift_actions.n; i++)
+ if (s->shift_actions.v[i]->term == aterm &&
+ s->shift_actions.v[i]->state == astate &&
+ s->shift_actions.v[i]->kind == akind)
+ return;
+ a = new_Action(g, akind, aterm, arule, astate);
+ vec_add(&s->shift_actions, a);
+ }
+ }
+
+ static void
+ init_LR(Grammar *g) {
+ g->action_count = 0;
+ }
+
+ static int
+ actioncmp(const void *aa, const void *bb) {
+ Action *a = *(Action **)aa, *b = *(Action **)bb;
+ int i, j;
+ if (a->kind == ACTION_SHIFT)
+ i = a->term->index + 1000000;
+ else
+ i = a->rule->index;
+ if (b->kind == ACTION_SHIFT)
+ j = b->term->index + 1000000;
+ else
+ j = b->rule->index;
+ return ((i > j) ? 1 : ((i < j) ? -1 : 0));
+ }
+
+ void
+ sort_VecAction(VecAction *v) {
+ qsort(v->v, v->n, sizeof(Action*), actioncmp);
+ }
+
+ static void
+ build_actions(Grammar *g) {
+ int x, y, z;
+ State *s;
+ Elem *e;
+
+ for (x = 0; x < g->states.n; x++) {
+ s = g->states.v[x];
+ for (y = 0; y < s->items.n; y++) {
+ e = s->items.v[y];
+ if (e->kind != ELEM_END) {
+ if (e->kind == ELEM_TERM) {
+ for (z = 0; z < s->gotos.n; z++) {
+ if (s->gotos.v[z]->elem->e.term == e->e.term)
+ add_action(g, s, ACTION_SHIFT,
+ e->e.term, 0, s->gotos.v[z]->state);
+ }
+ }
+ } else if (e->rule->prod->index)
+ add_action(g, s, ACTION_REDUCE, NULL, e->rule, 0);
+ else
+ s->accept = 1;
+ }
+ sort_VecAction(&s->shift_actions);
+ sort_VecAction(&s->reduce_actions);
+ }
+ }
+
+ State *
+ goto_State(State *s, Elem *e) {
+ int i;
+ for (i = 0; i < s->gotos.n; i++)
+ if (s->gotos.v[i]->elem->e.term_or_nterm == e->e.term_or_nterm)
+ return s->gotos.v[i]->state;
+ return NULL;
+ }
+
+ static Hint *
+ new_Hint(uint d, State *s, Rule *r) {
+ Hint *h = MALLOC(sizeof(*h));
+ h->depth = d;
+ h->state = s;
+ h->rule = r;
+ return h;
+ }
+
+ static int
+ hintcmp(const void *ai, const void *aj) {
+ Hint *i = *(Hint**)ai;
+ Hint *j = *(Hint**)aj;
+ return
+ (i->depth > j->depth) ? 1 : (
+ (i->depth < j->depth) ? -1 : (
+ (i->rule->index > j->rule->index) ? 1 : (
+ (i->rule->index < j->rule->index) ? -1 : 0)));
+ }
+
+ static void
+ build_right_epsilon_hints(Grammar *g) {
+ int x, y, z;
+ State *s, *ss;
+ Elem *e;
+ Rule *r;
+
+ for (x = 0; x < g->states.n; x++) {
+ s = g->states.v[x];
+ for (y = 0; y < s->items.n; y++) {
+ e = s->items.v[y];
+ r = e->rule;
+ if (e->kind != ELEM_END) {
+ for (z = e->index; z < r->elems.n; z++) {
+ if ((r->elems.v[z]->kind != ELEM_NTERM ||
+ !r->elems.v[z]->e.nterm->nullable))
+ goto Lnext;
+ }
+ ss = s;
+ for (z = e->index; z < r->elems.n; z++)
+ ss = goto_State(ss, r->elems.v[z]);
+ if (ss && r->elems.n)
+ vec_add(&s->right_epsilon_hints,
+ new_Hint(r->elems.n - e->index - 1, ss, r));
+ else /* ignore for states_for_each_productions */;
+ }
+ Lnext:;
+ }
+ if (s->right_epsilon_hints.n > 1)
+ qsort(s->right_epsilon_hints.v, s->right_epsilon_hints.n,
+ sizeof(Hint*), hintcmp);
+ }
+ }
+
+ static void
+ build_error_recovery(Grammar *g) {
+ int i, j, k, depth;
+ State *s;
+ Rule *r, *rr;
+ Elem *e, *ee;
+
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ for (j = 0; j < s->items.n; j++) {
+ r = s->items.v[j]->rule;
+ if (r->elems.n > 1 &&
+ r->elems.v[r->elems.n - 1]->kind == ELEM_TERM &&
+ r->elems.v[r->elems.n - 1]->e.term->kind == TERM_STRING)
+ {
+ depth = s->items.v[j]->index;
+ e = r->elems.v[r->elems.n - 1];
+ for (k = 0; k < s->error_recovery_hints.n; k++) {
+ rr = s->error_recovery_hints.v[k]->rule;
+ ee = rr->elems.v[rr->elems.n - 1];
+ if (e->e.term->string_len == ee->e.term->string_len &&
+ !strcmp(e->e.term->string, ee->e.term->string))
+ {
+ if (s->error_recovery_hints.v[k]->depth > depth)
+ s->error_recovery_hints.v[k]->depth = depth;
+ goto Ldone;
+ }
+ }
+ vec_add(&s->error_recovery_hints, new_Hint(depth, NULL, r));
+ Ldone:;
+ }
+ }
+ qsort(s->error_recovery_hints.v, s->error_recovery_hints.n,
+ sizeof(Hint*), hintcmp);
+ }
+ }
+
+ void
+ build_LR_tables(Grammar *g) {
+ init_LR(g);
+ build_LR_sets(g);
+ build_actions(g);
+ build_right_epsilon_hints(g);
+ build_error_recovery(g);
+ }
Index: llvm/test/Programs/MultiSource/Applications/d/lr.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/lr.h:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/lr.h Thu Jan 1 10:50:35 2004
***************
*** 0 ****
--- 1,13 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+
+ #ifndef _lr_H_
+ #define _lr_H_
+
+ void build_LR_tables(Grammar *g);
+ void sort_VecAction(VecAction *v);
+ uint elem_symbol(Grammar *g, Elem *e);
+ State *goto_State(State *s, Elem *e);
+
+ #endif
Index: llvm/test/Programs/MultiSource/Applications/d/make_dparser.1
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/make_dparser.1:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/make_dparser.1 Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,105 ----
+ .TH make_dparser 1 "Mar 2003" Unix "User Manuals"
+ .SH NAME
+ .PP
+ make_dparser \- D Parser Generator
+ .SH SYNOPSIS
+ .PP
+ .B make_dparser
+ [\fIoptions\fP] \fIgrammar\fP
+ .SH DESCRIPTION
+ .PP
+ make_dparser is a scannerless GLR parser generator based on the Tomita
+ algorithm. It is self-hosted and very easy to use. Grammars are written in a
+ natural style of EBNF and regular expressions and support both speculative and
+ final actions.
+ .SH OPTIONS
+ .PP
+ .IP "-l"
+ Toggle longest match lexical ambiguity resolution.
+ When ON the scanner only recognizing the longest matching tokens
+ in a given state. This provides an easy way to build
+ grammars for languages which use longest match lexical
+ ambiguity resolution (e.g. ANSI-C, C++). (OFF by default)
+ .IP "-T"
+ Toggle building of a tokenizer for START. When ON, instead of generating
+ a unique scanner for each state (i.e. a 'scannerless' parser),
+ generate a single scanner (tokenizer) for the entire grammar. This provides
+ an easy way to build grammars for languages which assume a
+ tokenizer (e.g. ANSI C). (OFF by default)
+ .IP "-H \fI-1/0/1\fP"
+ Write header, 0 : no, 1 : yes, -1 : only if not empty.
+ .IP "-t \fI0/1\fP"
+ Token type, 0 : #define, 1 : enum.
+ .IP "-C"
+ Toggle computing whitespace states. If 'whitespace' is
+ defined in the grammar, then use it as a subparser to
+ consume whitespace. (ON by default)
+ .IP "-A"
+ Toggle computing states for all non-terminals. Ensures that there is a unique
+ state for each non-terminal so that a subparsers can be invoked for
+ that non-terminal. (OFF by default)
+ .IP "-i \fItag\fP"
+ Tag for grammar data structures so that multiple sets of tables can
+ be included in one file/application. (defaults to 'gram')
+ .IP "-b \fIblocks\fP"
+ Number of blocks to which scanner tables are broken up into.
+ Larger numbers permit more sharing with more overhead. 4 seems to be optimal
+ for most grammars. (defaults to 4)
+ files.
+ .IP "-p"
+ Toggle setting of operator priority from rules. Setting of operator
+ priorities on operator tokens can increase the size of the tables but
+ can permit unnecessary parse stacks to be pruned earlier. (OFF by default)
+ .IP "-r"
+ Toggle use of right recursion for EBNF productions. Do not change this
+ unless you really know what you are doing. (OFF by default)
+ .IP "-L"
+ Toggle writing of line numbers. Used to debug the parsing table
+ generator itself. (ON by default)
+ .IP "-v"
+ Increase verbosity.
+ .IP "-d"
+ Increase debugging.
+ .IP "-h"
+ Display help.
+ .SH ENVIRONMENT
+ .PP
+ All the options are available through environment variables
+ with the names:
+
+ .na
+ .nh
+ D_MAKE_PARSER_HEADER,
+ D_MAKE_PARSER_TOKEN,
+ D_MAKE_PARSER_GRAMMAR_IDENT,
+ D_MAKE_PARSER_SCANNER_BLOCKS,
+ D_MAKE_PARSER_SET_PRIORITY,
+ D_MAKE_PARSER_WRITE_LINE_DIRECTIVES,
+ D_MAKE_PARSER_VERBOSE,
+ D_MAKE_PARSER_DEBUG.
+ .ad
+ .hy
+ .SH FEATURES
+ .PP
+ The features are covered in the documentation. See the README file.
+ .SH FILES
+ .PP
+ None.
+ .SH NO WARRANTIES
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ COPYRIGHT for more details.
+ .SH SEE ALSO
+ .PP
+ .BR flex (1),
+ .BR yacc (1),
+ .BR bison (1)
+ .PP
+ D Parser Home Page: http://dparser.sourceforge.net/
+ .PP
+ The BSD General Public License.
+ .SH AUTHOR
+ .PP
+ John Plevyak. Use <jplevyak at users.sourceforge.net> to contact.
+
Index: llvm/test/Programs/MultiSource/Applications/d/make_dparser.c
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/make_dparser.c:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/make_dparser.c Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,105 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+ #include "gramgram.h"
+ #include "d.h"
+
+ static void help(ArgumentState *arg_state, char *arg_unused);
+
+ static int set_op_priority_from_rule = 0;
+ static int right_recursive_BNF = 0;
+ static int states_for_whitespace = 1;
+ static int states_for_all_nterms = 0;
+ static int tokenizer = 0;
+ static int longest_match = 0;
+ static char grammar_ident[256] = "gram";
+ static int scanner_blocks = 4;
+ static int scanner_block_size;
+ static int write_line_directives = 1;
+ static int write_header = -1;
+ static int token_type = 0;
+
+ static ArgumentDescription arg_desc[] = {
+ {"longest_match", 'l', "Use Longest Match Rule for Tokens", "T",
+ &longest_match, "D_MAKE_LONGEST_MATCH", NULL},
+ {"tokenizer", 'T', "Tokenizer for START", "T", &tokenizer,
+ "D_MAKE_PARSER_TOKENIZER", NULL},
+ {"write_header", 'H', "Write Header (-1:if not empty)", "I", &write_header,
+ "D_MAKE_PARSER_HEADER", NULL},
+ {"token_type", 't', "Token Type (0:define, 1:enum)", "I", &token_type,
+ "D_MAKE_PARSER_TOKEN", NULL},
+ {"whitespace_states", 'C', "Compute Whitespace States", "T",
+ &states_for_whitespace, "D_MAKE_PARSER_WHITESPACE", NULL},
+ {"all_states", 'A', "Compute States For All NTERMs", "T",
+ &states_for_all_nterms, "D_MAKE_PARSER_ALL_NTERMS", NULL},
+ {"grammar_ident", 'i', "Grammar Identifier", "S255", grammar_ident,
+ "D_MAKE_PARSER_GRAMMAR_IDENT", NULL},
+ {"scanner_blocks", 'b', "Scanner Blocks", "I", &scanner_blocks,
+ "D_MAKE_PARSER_SCANNER_BLOCKS", NULL},
+ {"op_pri_from_rule", 'p', "Set Operator Priority From Rule", "T",
+ &set_op_priority_from_rule, "D_MAKE_PARSER_SET_PRIORITY", NULL},
+ {"right_recurse_BNF", 'r', "Use Right Recursion For */+", "T",
+ &right_recursive_BNF, "D_MAKE_PARSER_RIGHT_RECURSIVE_BNF", NULL},
+ {"write_lines", 'L', "Write #line(s)", "T",
+ &write_line_directives, "D_MAKE_PARSER_WRITE_LINE_DIRECTIVES", NULL},
+ {"verbose", 'v', "Verbose", "+", &verbose_level,
+ "D_MAKE_PARSER_VERBOSE", NULL},
+ {"debug", 'd', "Debug", "+", &debug_level,
+ "D_MAKE_PARSER_DEBUG", NULL},
+ {"help", 'h', "Help", NULL, NULL, NULL, help},
+ {0}
+ };
+
+ static ArgumentState arg_state = {
+ 0, 0,
+ "program",
+ arg_desc
+ };
+
+ extern D_ParserTables parser_tables_dparser_gram;
+
+ static void
+ help(ArgumentState *arg_state, char *arg_unused) {
+ char ver[30];
+ d_version(ver);
+ fprintf(stderr, "D Make Parser Version %s ", ver);
+ fprintf(stderr, "Copyright (c) 2002-2003 John Plevyak\n");
+ usage(arg_state, arg_unused);
+ }
+
+ int
+ main(int argc, char *argv[]) {
+ char *grammar_pathname;
+ Grammar *g;
+
+ process_args(&arg_state, argv);
+ if (arg_state.nfile_arguments != 1)
+ help(&arg_state, NULL);
+ grammar_pathname = arg_state.file_argument[0];
+ g = new_D_Grammar(grammar_pathname);
+ /* grammar construction options */
+ g->set_op_priority_from_rule = set_op_priority_from_rule;
+ g->right_recursive_BNF = right_recursive_BNF;
+ g->states_for_whitespace = states_for_whitespace;
+ g->states_for_all_nterms = states_for_all_nterms;
+ g->tokenizer = tokenizer;
+ g->longest_match = longest_match;
+ /* grammar writing options */
+ strcpy(g->grammar_ident, grammar_ident);
+ g->scanner_blocks = scanner_blocks;
+ g->scanner_block_size = scanner_block_size;
+ g->write_line_directives = write_line_directives;
+ g->write_header = write_header;
+ g->token_type = token_type;
+
+ if (parse_grammar(g, &parser_tables_dparser_gram, sizeof(ParseNode_User)) < 0)
+ d_fail("unable to parse grammar '%s'", grammar_pathname);
+ if (build_grammar(g) < 0)
+ d_fail("unable to load grammar '%s'", grammar_pathname);
+ if (write_ctables(g) < 0)
+ d_fail("unable to write C tables '%s'", grammar_pathname);
+ free_D_Grammar(g);
+ return 0;
+ }
+
+
Index: llvm/test/Programs/MultiSource/Applications/d/make_dparser.cat
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/make_dparser.cat:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/make_dparser.cat Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,103 ----
+ make_dparser(1) User Manuals make_dparser(1)
+
+
+
+ NAME
+ make_dparser - D Parser Generator
+
+ SYNOPSIS
+ make_dparser [options] grammar
+
+ DESCRIPTION
+ make_dparser is a scannerless GLR parser generator based on the Tomita
+ algorithm. It is self-hosted and very easy to use. Grammars are written
+ in a natural style of EBNF and regular expressions and support both
+ speculative and final actions.
+
+ OPTIONS
+ -l Toggle longest match lexical ambiguity resolution. When ON the
+ scanner only recognizing the longest matching tokens in a given
+ state. This provides an easy way to build grammars for languages
+ which use longest match lexical ambiguity resolution (e.g. ANSI-
+ C, C++). (OFF by default)
+
+ -T Toggle building of a tokenizer for START. When ON, instead of
+ generating a unique scanner for each state (i.e. a 'scannerless'
+ parser), generate a single scanner (tokenizer) for the entire
+ grammar. This provides an easy way to build grammars for lan-
+ guages which assume a tokenizer (e.g. ANSI C). (OFF by default)
+
+ -H -1/0/1
+ Write header, 0 : no, 1 : yes, -1 : only if not empty.
+
+ -t 0/1 Token type, 0 : #define, 1 : enum.
+
+ -C Toggle computing whitespace states. If 'whitespace' is defined
+ in the grammar, then use it as a subparser to consume whites-
+ pace. (ON by default)
+
+ -A Toggle computing states for all non-terminals. Ensures that
+ there is a unique state for each non-terminal so that a sub-
+ parsers can be invoked for that non-terminal. (OFF by default)
+
+ -i tag Tag for grammar data structures so that multiple sets of tables
+ can be included in one file/application. (defaults to 'gram')
+
+ -b blocks
+ Number of blocks to which scanner tables are broken up into.
+ Larger numbers permit more sharing with more overhead. 4 seems
+ to be optimal for most grammars. (defaults to 4) files.
+
+ -p Toggle setting of operator priority from rules. Setting of
+ operator priorities on operator tokens can increase the size of
+ the tables but can permit unnecessary parse stacks to be pruned
+ earlier. (OFF by default)
+
+ -r Toggle use of right recursion for EBNF productions. Do not
+ change this unless you really know what you are doing. (OFF by
+ default)
+
+ -L Toggle writing of line numbers. Used to debug the parsing table
+ generator itself. (ON by default)
+
+ -v Increase verbosity.
+
+ -d Increase debugging.
+
+ -h Display help.
+
+ ENVIRONMENT
+ All the options are available through environment variables with the
+ names:
+
+ D_MAKE_PARSER_HEADER, D_MAKE_PARSER_TOKEN, D_MAKE_PARSER_GRAMMAR_IDENT,
+ D_MAKE_PARSER_SCANNER_BLOCKS, D_MAKE_PARSER_SET_PRIORITY,
+ D_MAKE_PARSER_WRITE_LINE_DIRECTIVES, D_MAKE_PARSER_VERBOSE,
+ D_MAKE_PARSER_DEBUG.
+
+ FEATURES
+ The features are covered in the documentation. See the README file.
+
+ FILES
+ None.
+
+ NO WARRANTIES
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of MER-
+ CHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the COPYRIGHT
+ for more details.
+
+ SEE ALSO
+ flex(1), yacc(1), bison(1)
+
+ D Parser Home Page: http://dparser.sourceforge.net/
+
+ The BSD General Public License.
+
+ AUTHOR
+ John Plevyak. Use <jplevyak at users.sourceforge.net> to contact.
+
+
+
+
+ Unix Mar 2003 make_dparser(1)
Index: llvm/test/Programs/MultiSource/Applications/d/manual.html
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/manual.html:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/manual.html Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,788 ----
+ <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+ <html>
+ <head>
+ <meta http-equiv="content-type"
+ content="text/html; charset=ISO-8859-1">
+ <title>manual.html</title>
+ </head>
+ <body>
+ <div style="text-align: center;"> <big><big><span
+ style="font-weight: bold;">DParser Manual<br>
+ </span></big></big>
+ <div style="text-align: left;"><big><br>
+ <br>
+ <span style="font-weight: bold;">Contents</span><br>
+ </big>
+ <ol>
+ <li>Installation</li>
+ <li>Getting Started</li>
+ <li>Comments<br>
+ </li>
+ <li>Productions</li>
+ <li>Global Code<br>
+ </li>
+ <li>Terminals</li>
+ <ol>
+ <li>Strings</li>
+ <li>Regular Expressions</li>
+ <li>External (C) scanners</li>
+ <li>Tokenizers</li>
+ <li>Longest Match<br>
+ </li>
+ </ol>
+ <li>Priorities and Associativity</li>
+ <ol>
+ <li>Token Priorities</li>
+ <li>Operator Priorities</li>
+ <li>Rule Priorities</li>
+ </ol>
+ <li>Actions</li>
+ <ol>
+ <li>Speculative Actions</li>
+ <li>Final Actions</li>
+ <li>Embedded<br>
+ </li>
+ <li>Pass Actions<br>
+ </li>
+ <li>Default Actions<br>
+ </li>
+ </ol>
+ <li>Attributes and Action Specifiers</li>
+ <ol>
+ <li>Global State</li>
+ <li>Parse Nodes</li>
+ <li>Misc</li>
+ </ol>
+ <li>Symbol Table</li>
+ <li>Whitespace</li>
+ <li>Ambiguities</li>
+ <li>Error Recovery</li>
+ <li>Parsing Options<br>
+ </li>
+ <li>Grammar Grammar<br>
+ </li>
+ </ol>
+ <span style="font-weight: bold;">1. Installation</span><br>
+ <br>
+ To build:
+ 'gmake'
+ (only available with source code package)<br>
+ <br>
+ To test: 'gmake
+ test' (only
+ available with source code package)<br>
+ <br>
+ To install, 'gmake install' (binary or source code
+ packages)<br>
+ <br>
+ <span style="font-weight: bold;">2. Getting Started<span
+ style="font-weight: bold;"></span><span style="font-weight: bold;"></span></span><span
+ style="font-weight: bold;"></span><br>
+ <br>
+ 2.1. Create your grammar, for example, in the file "my.g":<br>
+ <br>
+ E: E '+' E | "[abc]";<br>
+ <br>
+ 2.2. Convert grammar into parsing tables:<br>
+ <br>
+ % make_dparser -g my.g<br>
+ <br>
+ 2.3. Create a driver program, for example, in the file
+ "my.c": <br>
+ <br>
+ #include <stdio.h><br>
+ #include <dparse.h><br>
+ extern D_ParserTables parser_tables_gram;<br>
+ int<br>
+ main(int argc, char *argv[]) {<br>
+ char s[256], *ss;<br>
+ D_Parser *p = new_D_Parser(&parser_tables_gram, 0);<br>
+ if (fgets(s,255,stdin) && dparse(p, s, strlen(s))
+ && !p->syntax_errors)<br>
+ printf("success\n");<br>
+ else<br>
+ printf("failure\n");<br>
+ }<br>
+ <br>
+ 2.4. Compile:<br>
+ <br>
+ % cc -I/usr/local/include my.c my.g.d_parser.c -L/usr/local/lib
+ -ldparse<br>
+ <br>
+ 2.5. Run:<br>
+ <br>
+ % a.out<br>
+ a=<br>
+ syntax error, '' line 1<br>
+ failure<br>
+ %<br>
+ <br>
+ % a.out<br>
+ a+b<br>
+ success<br>
+ %<br>
+ <br>
+ We'll come back to this example later.<br>
+ <br>
+ <span style="font-weight: bold;">3. Comments</span><br>
+ <br>
+ Grammars can include C/C++ style comments.<br>
+ <br>
+ EXAMPLE<br>
+ <br>
+ // My first grammar<br>
+ E: E '+' E | "[abc]";<br>
+ /* is this right? */<br>
+ <br>
+ <span style="font-weight: bold;">4. Productions</span><br>
+ <br>
+ 4.1. The first production is the root of your grammar (what you
+ will be trying to parse).<br>
+ 4.2. Productions start with the non-terminal being defined
+ followed by a colon ':', a set of right hand sides seperated by '|'
+ (or)
+ consisting of elements (non-terminals or terminals).<br>
+ 4.3. Elements can be grouped with parens '(', and the normal
+ regular expression symbols can be used ('+' '*' '?' '|').<br>
+ <br>
+ EXAMPLE<br>
+ <br>
+ program: statements+ | comment* (function | procedure)?;<br>
+ <br>
+ 4.4. <span style="font-weight: bold;">NOTE:</span> Instead of
+ using '[' ']' for optional elements we use the more familar and
+ consistent '?' operator. The square brackets are reserved for
+ speculative actions (below).<br>
+ <br>
+ <span style="font-weight: bold;">5. Global Code</span><br>
+ <br>
+ Global (or static) C code can be intermixed with productions by
+ surrounding the code with brackets '{'.<br>
+ <br>
+ EXAMPLE<br>
+ <br>
+ { void dr_s() { printf("Dr. S\n"); }<br>
+ S: 'the' 'cat' 'and' 'the' 'hat' { dr_s(); } | T;<br>
+ { void twain() { printf("Mark Twain\n"); }<br>
+ T: 'Huck' 'Finn' { twain(); };<br>
+ <br>
+ <span style="font-weight: bold;">6. Terminals</span><br>
+ <br>
+ 6.1. Strings terminals are surrounded with single quotes.
+ For example:<br>
+ <br>
+ <span style="font-weight: bold;"></span>block: '{' statements* '}';<br>
+ whileblock: 'while' '(' expression ')' block;<br>
+ <br>
+ 6.2. Regular expressions are surrounded with double quotes.
+ For example:<br>
+ <br>
+ hexint: "(0x|0X)[0-9a-fA-F]+[uUlL]?";<br>
+ <br>
+ <span style="font-weight: bold;">NOTE: </span>only the simple
+ regular expression operators are currently supported (v1.3). This
+ include parens, square parens, ranges, and '*', '+', '?'. If you
+ need something more, request a feature or implement it yourself; the
+ code is in scan.c.<br>
+ <br>
+ 6.3. External (C) Scanners<br>
+ <br>
+ There are two types of external scanners, those which read a
+ single terminal, and those which are global (called for every
+ terminal).
+ Here is an example of a scanner for a single terminal.
+ Notice how it can be mixed with regular string terminals.<br>
+ <br>
+ {<br>
+ extern char *ops;<br>
+ extern void *ops_cache;<br>
+ int ops_scan(char *ops, void *ops_cache, char **as,<br>
+ int *col, int *line, unsigned short *op_assoc, int
+ *op_priority);<br>
+ }<br>
+ <br>
+ X: '1' (${scan ops_scan(ops, ops_cache)} '2')*;<br>
+ <br>
+ The user provides the 'ops_scan' function. This example is
+ from tests/g4.test.g in the source distribution.<br>
+ <br>
+ The second type of scanner is a global scanner:<br>
+ <br>
+ {<br>
+ #include "g7.test.g.d_parser.h"<br>
+ int myscanner(char **s, int *col, int *line, unsigned short *symbol,<br>
+ int *term_priority, unsigned short
+ *op_assoc, int *op_priority)<br>
+ {<br>
+ if (**s == 'a') {<br>
+ (*s)++;<br>
+ *symbol = A;<br>
+ return 1;<br>
+ } else if (**s == 'b') {<br>
+ (*s)++;<br>
+ *symbol = BB;<br>
+ return 1;<br>
+ } else if (**s == 'c') {<br>
+ (*s)++;<br>
+ *symbol = CCC;<br>
+ return 1;<br>
+ } else if (**s == 'd') {<br>
+ (*s)++;<br>
+ *symbol = DDDD;<br>
+ return 1;<br>
+ } else<br>
+ return 0;<br>
+ }<br>
+ ${scanner myscanner}<br>
+ ${token A BB CCC DDDD}<br>
+ <br>
+ S: A (BB CCC)+ SS;<br>
+ SS: DDDD;<br>
+ <br>
+ Notice how the you need to include the header file generated by <span
+ style="font-weight: bold;">make_dparser</span> which contains the
+ token
+ definitions.<br>
+ <br>
+ 6.4. Tokenizers<br>
+ <br>
+ Tokenizers are non-context sensitive global scanners which
+ produce only one token for any given input string. Some
+ programming languages (for example <span style="font-weight: bold;">C</span>)
+ are easier to specify using a tokenizer because (for example) reserved
+ words can be handled simply by lowering the terminal priority for
+ identifiers.<br>
+ <br>
+ EXAMPLE:<br>
+ <br>
+ S : 'if' '(' S ')' S ';' | 'do' S 'while' '(' S ')' ';' | ident;<br>
+ ident: "[a-z]+" $term -1;<br>
+ <br>
+ The sentence: <span style="font-weight: bold;">if ( while ) a;</span>
+ is legal because <span style="font-weight: bold;">while</span> cannot
+ appear at the start of <span style="font-weight: bold;">S</span> and
+ so
+ it doesn't conflict with the parsing of <span
+ style="font-weight: bold;">while</span>
+ as an <span style="font-weight: bold;">ident</span> in that position.
+ However, if a tokenizer is specified, all tokens will be possible
+ at each position and the sentense will produce a syntax error.<br>
+ <br>
+ <span style="font-weight: bold;">DParser</span> provides two
+ ways to specify tokenizers: globally as an option (-T) to <span
+ style="font-weight: bold;">make_dparser</span> and locally with a
+ ${declare tokenize ...} specifier (see the ANSI C grammar for an
+ example). The ${declare tokenize ...} declartion allows a
+ tokenizer to be specified over a subset of the parsing states so that
+ (for example) ANSI C could be a subgrammar of another larger grammar.
+ Currently the parse states are not split so that the productions
+ for the substates must be disjoint.<br>
+ <br>
+ 6.5 Longest Match<br>
+ <br>
+ Longest match lexical ambiguity resolution is a technique used
+ by seperate phase lexers to help decide (along<br>
+ with lexical priorities) which single token to select for a given input
+ string. It is used in the definition of ANSI-C, but not in C++
+ because of a snafu in the definition of templates whereby templates of
+ templates (List<List <Int>>) can end with the right shift
+ token ('>>"). Since <span style="font-weight: bold;">DParser</span>
+ does not have a seperate lexical phase, it does not require longest
+ match disambiguation, but provides it as an option.<br>
+ <br>
+ There are two ways to specify longest match disabiguation:
+ globally as an option (-l) to <span style="font-weight: bold;">make_dparser</span>
+ or locally with with a ${declare ... longest_match}. If global
+ longest match disambiguation is <span style="font-weight: bold;">ON</span>,
+ it can be locally disabled with {$declare ... all_matches} . As
+ with Tokenizers above, local declarations operate on disjoint subsets
+ of
+ parsing states.<br>
+ <br>
+ <span style="font-weight: bold;">7. Priorities and Associativity<br>
+ <br>
+ </span> Priorities can very from MININT to MAXINT and are
+ specified as integers. Associativity can take the values:<br>
+ <br>
+ assoc : '$unary_op_right' | '$unary_op_left' | '$binary_op_right'<br>
+ |
+ '$binary_op_left' | '$unary_right' | '$unary_left'<br>
+ |
+ '$binary_right' | '$binary_left' | '$right' | '$left' ;<br>
+ <br>
+ 7.1. Token Prioritites<br>
+ <br>
+ Currently (v1.0) the automatically generated scanners use the <span
+ style="font-style: italic;">longest match</span> rule so that, for
+ example:<br>
+ <br>
+ OP: '>' | '>>';<br>
+ <br>
+ will match the string '>>' only as '>>' instead of
+ ambiguously as either '>' or '>>'. A planned feature is
+ to make this optional.<br>
+ <br>
+ Termininal priorities apply after the longest match string has
+ been found and the terminal with the highest priority is selected.<br>
+ They are introduced after a terminal by the specifier <span
+ style="font-weight: bold;">$term</span>. We saw an example of
+ token priorities with the definition of <span
+ style="font-weight: bold;">ident</span>.<br>
+ <br>
+ EXAMPLE:<br>
+ <br>
+ S : 'if' '(' S ')' S ';' | 'do' S 'while' '(' S ')' ';' | ident;<br>
+ ident: "[a-z]+" $term -1;<br>
+ <br>
+ 7.2. Operator Priorities<br>
+ <br>
+ Operator priorities specify the priority of a operator symbol
+ (either a terminal or a non-terminal). This corresponds to the <span
+ style="font-style: italic;">yacc</span> or <span
+ style="font-style: italic;">bison</span> <span
+ style="font-weight: bold;">%left</span> etc. declaration.
+ However, since <span style="font-weight: bold;">DParser</span>
+ is
+ doesn't require a global tokenizer, operator priorities and
+ associativities are specified on the reduction which creates the token.
+ Moreover, the associativity includes the operator usage as well
+ since it cannot be infered from rule context. Possible operator
+ associativies are:<br>
+ <br>
+ operator_assoc : '$unary_op_right' | '$unary_op_left' |
+ '$binary_op_right'<br>
+ |
+ '$binary_op_left' | '$unary_right' | '$unary_left'<br>
+ |
+ '$binary_right' | '$binary_left';<br>
+ <br>
+ EXAMPLE:<br>
+ <br>
+ E: ident op ident;<br>
+ ident: '[a-z]+';<br>
+ <span style="font-weight: bold;"></span>op: '*' $binary_op_left 2 |<br>
+ '+' $binary_op_left 1;<br>
+ <br>
+ 7.3. Rule Priorities<br>
+ <br>
+ Rule priorities specify the priority of the reduction itself and
+ have the possible associativies:<br>
+ <br>
+ rule_assoc: '$right' | '$left';<br>
+ <br>
+ Rule and operator priorities can be intermixed and are
+ interpreted at run time (<span style="font-weight: bold;">not</span>
+ when
+ the tables are built). This make it possible for user-defined
+ scanners to return the associativities and priorities of tokens.<br>
+ <br>
+ <span style="font-weight: bold;">8. Actions<br>
+ <br>
+ </span> Actions are the bits of code which run when a reduction
+ occurs.<br>
+ <br>
+ EXAMPLE<br>
+ <br>
+ S: this | that;<br>
+ this: 'this' { printf("got this\n"); };<br>
+ that: 'that' { printf("got that\n"); };<br>
+ <br>
+ 8.1 Speculative Action<br>
+ <br>
+ Speculative actions occur when the reduction takes place during
+ the speculative parsing process. It is possible<br>
+ that the reduction will not be part of the final parse or that it will
+ occur a different number of times. For example:<br>
+ <br>
+ S: this | that;<br>
+ this: hi 'mom';<br>
+ that: ho 'dad';<br>
+ ho: 'hello' [ printf("ho\n"); ];<br>
+ hi: 'hello' [ printf("hi\n"); ];<br>
+ <br>
+ Will print both 'hi' and 'ho' when given the input 'hello dad' because
+ at the time hello is reduced, the following token is not known.<br>
+ <br>
+ 8.2 Final Actions<br>
+ <br>
+ Final actions occur only when the reduction must be part of any
+ legal final parse (committed). It is possible to do final actions
+ during parsing or delay them till the entire parse tree is constructed
+ (see Options). Final actions are executed in order and in number
+ according the the single final unambiguous parse.<br>
+ <br>
+ S: A S 'b' | 'x';<br>
+ A: [ printf("speculative e-reduce A\n"); ] <br>
+ { printf("final e-reduce A\n"); };<br>
+ <br>
+ On input:<br>
+ <br>
+ xbbb<br>
+ <br>
+ Will produce:<br>
+ <br>
+ speculative e-reduce A<br>
+ final e-reduce A<br>
+ final e-reduce A<br>
+ final e-reduce A<br>
+ <br>
+ 8.3 Embedded Actions<br>
+ <br>
+ Actions can be embedded into rule. These actions are executed
+ as if they were replaced with a synthetic production with a single null
+ rule containing the actions. For example:<br>
+ <br>
+ S: A { printf("X"); } B;<br>
+ A: 'a' { printf("a"); };<br>
+ B: 'b' { printf("b"); };<br>
+ <br>
+ On input:<br>
+ <br>
+ ab<br>
+ <br>
+ Will produce:<br>
+ <br>
+ aXb<br>
+ <br>
+ 8.4 Pass Actions<br>
+ <br>
+ <span style="font-weight: bold;">DParser</span> supports
+ multiple pass compilation. The passes are declared at the top of
+ the grammar, and the actions are associated with individual rules.<br>
+ <br>
+ EXAMPLE<br>
+ <br>
+ ${pass sym for_all postorder}<br>
+ ${pass gen for_all postorder}<br>
+ <br>
+ translation_unit: statement*;<br>
+ <br>
+ statement<br>
+ : expression ';' {<br>
+ d_pass(${parser}, &$n, ${pass sym});<br>
+ d_pass(${parser}, &$n, ${pass gen});<br>
+ }<br>
+ ;<br>
+ <br>
+ expression : integer<br>
+ gen: { printf("gen integer\n"); }<br>
+ sym: { printf("sym integer\n"); }<br>
+ | expression '+' expression $right 2<br>
+ sym: { printf("sym +\n"); }<br>
+ ;<br>
+ <br>
+ A pass name then a colon indicate that the following action is
+ associated with a particular pass. Passes can be either <span
+ style="font-weight: bold;">for_all</span> or <span
+ style="font-weight: bold;">for_undefined</span> (which means that the
+ automatic traversal only applies to rules without actions defined for
+ this pass). Furthermore, passes can be <span
+ style="font-weight: bold;">postorder</span>, <span
+ style="font-weight: bold;">preorder</span>, and <span
+ style="font-weight: bold;">manual</span> (you have to call <span
+ style="font-weight: bold;">d_pass</span> yourself). Passes can
+ be initiated in the final action of any rule.<br>
+ <br>
+ 8.5 Default Actions<br>
+ <br>
+ The special production "<span style="font-weight: bold;">_</span>"
+ can be defined with a single rule whose actions become the default when
+ no other action is specified. Default actions can be specified
+ for speculative, final and pass actions and apply to each seperately.<br>
+ <br>
+ EXAMPLE<br>
+ <br>
+ _: { printf("final action"); }<br>
+ gen: { printf("default gen action"); }<br>
+ sym: { printf("default sym action"); }<br>
+ ;<br>
+ <span style="font-weight: bold;"></span><br>
+ <span style="font-weight: bold;">9. Attributes and Action Specifiers</span><br>
+ <br>
+ 9.1. Global State (<span style="font-weight: bold;">$g</span>)<br>
+ <br>
+ Global state is declared by <span style="font-weight: bold;">define</span>'ing<span
+ style="font-weight: bold;"> D_ParseNodeGlobals</span> (see the ANSI C
+ grammar for a similar declaration for symbols). Global state can be
+ accessed in any action with <span style="font-weight: bold;">$g</span>.
+ Because <span style="font-weight: bold;">DParser</span> handles
+ ambiguous parsing global state can be accessed on different speculative
+ parses. In the future automatic splitting of global state may be
+ implemented (if there is demand). Currently, the global state can be
+ copied and assigned to <span style="font-weight: bold;">$g</span> to
+ ensure that the changes made only effect subsequent speculative parses
+ derived from the particular parse.<br>
+ <br>
+ EXAMPLE<br>
+ <br>
+ [ $g = copy_globals($g);<br>
+ $g->my_variable = 1;<br>
+ ]<br>
+ <br>
+ The symbol table (Section 10) can be used to manage state
+ information safely for different speculative parses.<br>
+ <br>
+ 9.2. Parse Node State<br>
+ <br>
+ Each parse node includes a set of system state variables and can
+ have a set of user-defined state variables. User defined parse
+ node state is declared by <span style="font-weight: bold;">define</span>'ing<span
+ style="font-weight: bold;"> D_ParseNodeUser</span>. Parse node
+ state is accessed with:<br>
+ <br>
+ <span style="font-weight: bold;">$#</span> - number of child nodes<br>
+ <span style="font-weight: bold;">$$</span> - user parse node
+ state
+ for parent node (non-terminal defined by the production)<br>
+ <span style="font-weight: bold;">$X</span> (where X is a number)
+ -
+ the user parse node state of element X of the production<br>
+ <span style="font-weight: bold;">$nX</span> - the system parse
+ node state of element X of the production<br>
+ <br>
+ The system parse node state is defined in <span
+ style="font-weight: bold;">dparse.h</span> which is installed with <span
+ style="font-weight: bold;">DParser</span>. It contains such
+ information as the symbol, the location of the parsed string, and
+ pointers to the start and end of the parsed string.<br>
+ <br>
+ 9.3. Misc<br>
+ <br>
+ <span style="font-weight: bold;">${scope}</span> - the current
+ symbol table scope<br>
+ <span style="font-weight: bold;">${reject}</span> - in
+ speculative actions permits the current parse to be rejected<br>
+ <br>
+ <span style="font-weight: bold;">10. Symbol Table</span><br>
+ <br>
+ <span style="font-weight: bold;"></span> The symbol table can be
+ updated down different speculative paths while sharing the bulk of the
+ data. It defines the following functions in the file (dsymtab.h):<br>
+ <br>
+ struct D_Scope *new_D_Scope(struct D_Scope *st);<br>
+ struct D_Scope *enter_D_Scope(struct D_Scope *current, struct D_Scope
+ *scope);<br>
+ D_Sym *NEW_D_SYM(struct D_Scope *st, char *name, char *end);<br>
+ D_Sym *find_D_Sym(struct D_Scope *st, char *name, char *end);<br>
+ D_Sym *UPDATE_D_SYM(struct D_Scope *st, D_Sym *sym);<br>
+ D_Sym *current_D_Sym(struct D_Scope *st, D_Sym *sym);<br>
+ D_Sym *find_D_Sym_in_Scope(struct D_Scope *st, char *name, char *end);<br>
+ <br>
+ 'new_D_Scope' creates a new scope below 'st' or NULL for a 'top level'
+ scope. 'enter_D_Scope' returns to a previous scoping level.
+ NOTE: do not simply assign ${scope} to a previous scope as any updated
+ symbol information will be lost. 'commit_D_Scope' can be used in
+ final actions to compress the update list for the top level scope and
+ improve efficiency.<br>
+ <br>
+ 'find_D_Sym' finds the most current version of a symbol in a given
+ scope. 'UPDATE_D_SYM' updates the value of symbol (creates a
+ difference record on the current speculative parse path).
+ 'current_D_Sym' is used to retrive the current version of a symbol, the
+ pointer to which may have been stored in some other attribute or
+ variable. Symbols with the same name should not be created in the
+ same scope. The function 'find_D_Sym_in_Scope' is provided to
+ detect this case. <br>
+ <br>
+ User data can be attached to symbols by <span
+ style="font-weight: bold;">define</span>'ing <span
+ style="font-weight: bold;">D_UserSym</span>. See the ANSI C
+ grammar for an example. <br>
+ <br>
+ Here is a full example of scope usage (from tests/g29.test.g):<br>
+ <br>
+ <span style="font-family: monospace;">#include <stdio.h><br>
+ <br>
+ typedef struct My_Sym {<br>
+ int value;<br>
+ } My_Sym;<br>
+ #define D_UserSym My_Sym<br>
+ typedef struct My_ParseNode {<br>
+ int value;<br>
+ struct D_Scope *scope;<br>
+ } My_ParseNode;<br>
+ #define D_ParseNode_User My_ParseNode<br>
+ }<br>
+ <br>
+ translation_unit: statement*;<br>
+ <br>
+ statement <br>
+ : expression ';' <br>
+ { printf("%d\n", $0.value); }<br>
+ | '{' new_scope statement* '}'<br>
+ [ ${scope} = enter_D_Scope(${scope}, $n0.scope); ]<br>
+ { ${scope} = commit_D_Scope(${scope}); }<br>
+ ;<br>
+ <br>
+ new_scope: [ ${scope} = new_D_Scope(${scope}); ];<br>
+ <br>
+ expression <br>
+ : identifier ':' expression <br>
+ [ <br>
+ D_Sym *s;<br>
+ if (find_D_Sym_in_Scope(${scope}, $n0.start_loc.s,
+ $n0.end))<br>
+ printf("duplicate identifier line %d\n",
+ $n0.start_loc.line);<br>
+ s = NEW_D_SYM(${scope}, $n0.start_loc.s, $n0.end);<br>
+ s->user.value = $2.value;<br>
+ $$.value = s->user.value;<br>
+ ]<br>
+ | identifier '=' expression<br>
+ [ D_Sym *s = find_D_Sym(${scope}, $n0.start_loc.s, $n0.end);<br>
+ s = UPDATE_D_SYM(${scope}, s);<br>
+ s->user.value = $2.value;<br>
+ $$.value = s->user.value;<br>
+ ]<br>
+ | integer <br>
+ [ $$.value = atoi($n0.start_loc.s); ]<br>
+ | identifier <br>
+ [ D_Sym *s = find_D_Sym(${scope}, $n0.start_loc.s, $n0.end);<br>
+ if (s)<br>
+ $$.value = s->user.value;<br>
+ ]<br>
+ | expression '+' expression<br>
+ [ $$.value = $0.value + $1.value; ]<br>
+ ;<br>
+ <br>
+ integer: "-?([0-9]|0(x|X))[0-9]*(u|U|b|B|w|W|L|l)*" $term -1;<br>
+ identifier: "[a-zA-Z_][a-zA-Z_0-9]*";<br>
+ <br>
+ </span> <br>
+ <span style="font-weight: bold;">11. Whitespace</span><br>
+ <br>
+ Whitespace can be specified two ways: C function which can be
+ user-defined, or as a subgrammar. The default whitespace parser
+ is
+ compatible with C/C++ #line directives and comments. It can be
+ replaced with any user specified function as a parsing option (see
+ Options).<br>
+ <br>
+ Additionally, if the (optionally) reserved production <span
+ style="font-weight: bold;">whitespace</span> is defined, the
+ subgrammar
+ it defines will be used to consume whitespace for the main grammar.
+ This subgrammar can include normal actions.<br>
+ <br>
+ EXAMPLE<br>
+ <br>
+ <span style="font-weight: bold;"></span>S: 'a' 'b' 'c';<br>
+ whitespace: "[ \t\n]*";<br>
+ <br>
+ Whitespace can be accessed on a per parse node basis using the
+ functions: <span style="font-weight: bold;">d_ws_before</span> and <span
+ style="font-weight: bold;">d_ws_after</span>, which return the start
+ of the whitespace before <span style="font-weight: bold;">start_loc.s</span>
+ and after <span style="font-weight: bold;">end</span> respectively. <br>
+ <br>
+ <span style="font-weight: bold;">12. Ambiguities<br>
+ </span> <br>
+ Ambiguities are resolved automatically based on priorities and
+ associativities. In addition, when the other resolution
+ techniques
+ fail, user defined ambiguity resolution is possible. The default
+ ambiguity handler produces a fatal error on an unresolved
+ ambiguity. This behavior can be replaced with a user defined
+ resolvers the signature of which is provided in <span
+ style="font-weight: bold;">dparse.h</span>.<br>
+ <br>
+ If the <span style="font-weight: bold;">verbose_level</span>
+ flag is set, the default ambiguity handler will print out parenthesized
+ versions of the ambiguous parse trees. This may be of some
+ assistence in disambiguating a grammar.<br>
+ <br>
+ <span style="font-weight: bold;">13. Error Recovery<br>
+ <br>
+ DParser</span> implements an error recovery scheme appropriate
+ to
+ scannerless parsers. I haven't had time to investigate all the
+ prior work in this area, so I am not sure if it is novel. Suffice
+ for now that it is optional and works well with C/C++ like grammars.<br>
+ <br>
+ <span style="font-weight: bold;">14. Parsing Options</span><br>
+ <br>
+ Parser are instantiated with the function <span
+ style="font-style: italic;">new_D_Parser<span
+ style="font-weight: bold;">. </span></span> The resulting data
+ structure contains a number of user configurable options (see <span
+ style="font-weight: bold;">dparser.h</span>). These are provided
+ reasonable default values and include:<br>
+ <ul>
+ <li><span style="font-weight: bold;">initial_globals</span> - the
+ initial global variables accessable through <span
+ style="font-weight: bold;">$g</span></li>
+ <li><span style="font-weight: bold;"></span><span
+ style="font-weight: bold;">initial_skip_space_fn</span> - the initial
+ whitespace function</li>
+ <li><span style="font-family: monospace;"></span><span
+ style="font-weight: bold;">initial_scope</span> - the initial symbol
+ table scope</li>
+ <li><span style="font-weight: bold;"></span><span
+ style="font-weight: bold;">syntax_error_fn</span> - the function
+ called
+ on a syntax error</li>
+ <li><span style="font-weight: bold;">ambiguity_fn</span> - the
+ function called on an unresolved ambiguity</li>
+ <li><span style="font-weight: bold;">loc</span> - the initial
+ location
+ (set on an error).</li>
+ </ul>
+ In addtion, there are the following user configurables:<br>
+ <ul>
+ <li><span style="font-weight: bold;">sizeof_user_parse_node</span> -
+ the sizeof <span style="font-weight: bold;">D_ParseNodeUser</span></li>
+ <li><span style="font-weight: bold;">save_parse_tree</span> - whether
+ or not the parse tree should be save once the final actions have been
+ executed</li>
+ <li><span style="font-style: italic;"></span><span
+ style="font-weight: bold;">dont_fixup_internal_productions</span> - to
+ not convert the Kleene star into a variable number of children from a
+ tree of reductions</li>
+ <li><span style="font-weight: bold;">dont_merge_epsilon_trees</span>
+ -
+ to not automatically remove ambiguities which result from trees of
+ epsilon reductions without actions</li>
+ <li><span style="font-weight: bold;">dont_use_eagerness_for_disambiguation</span>
+ - do not use the rule that the longest parse which reduces to the same
+ token should be used to disambiguate parses. This rule is used to
+ handle the case (<span style="font-weight: bold;">if then else?</span>)
+ relatively cleanly.</li>
+ <li><span style="font-weight: bold;">dont_use_height_for_disambiguation</span>
+ - do not use the rule that the least deep parse which reduces to the
+ same token should be used to disabiguate parses. This rule is
+ used
+ to handle recursive grammars relatiively cleanly.</li>
+ <li><span style="font-weight: bold;">dont_compare_stacks</span> -
+ disables comparing stacks to handle certain exponential cases during
+ ambiguous operator priority resolution. This feature is
+ relatively
+ new, and this disables the new code.<br>
+ </li>
+ <li><span style="font-weight: bold;">commit_actions_interval</span> -
+ how often to commit final actions (0 is immediate, MAXINT is
+ essentially
+ not till the end of parsing)</li>
+ <li><span style="font-weight: bold;"></span><span
+ style="font-weight: bold;">error_recovery</span> - whether or not to
+ use error recovery (defaults ON)</li>
+ </ul>
+ An the following result values:<br>
+ <ul>
+ <li><span style="font-weight: bold;">syntax_errors</span> - how many
+ syntax errors (if <span style="font-weight: bold;">error_recovery</span>
+ was on)</li>
+ </ul>
+ This final value should be checked to see if parse was successful.<br>
+ <br>
+ <span style="font-weight: bold;">15. Grammar Grammar</span><br>
+ <br>
+ <span style="font-weight: bold;">DParser</span> is fully
+ self-hosted (would you trust a parser generator which wasn't?).
+ The grammar grammar is <a href="grammar.g">here (Grammar Grammar)</a>.
+ <span style="font-weight: bold;"></span><br>
+ <span style="font-weight: bold;"></span><br>
+ <span style="font-weight: bold;"><br>
+ </span><big><big><span style="font-weight: bold;"></span></big></big></div>
+ </div>
+ </body>
+ </html>
Index: llvm/test/Programs/MultiSource/Applications/d/parse.c
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/parse.c:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/parse.c Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,2077 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+
+ #include "d.h"
+
+ /* tunables */
+ #define DEFAULT_COMMIT_ACTIONS_INTERVAL 100
+ #define PNODE_HASH_INITIAL_SIZE_INDEX 10
+ #define SNODE_HASH_INITIAL_SIZE_INDEX 8
+ #define ERROR_RECOVERY_QUEUE_SIZE 10000
+
+ #define GOTO_STATE(_p, _pn, _ps) \
+ ((_p)->t->goto_table[(_pn)->parse_node.symbol - \
+ (_ps)->state->goto_table_offset] - 1)
+ #define GOTO_STATE_INDEX(_p, _symbol, _si) \
+ ((_p)->t->goto_table[(_symbol) - (_p)->t->state[_si].goto_table_offset] - 1)
+ #define is_unreduced_epsilon_PNode(_pn) \
+ (is_epsilon_PNode(_pn) && ((_pn)->reduction && (_pn)->reduction->final_code))
+
+ #ifndef USE_GC
+ static void free_SNode(struct Parser *p, struct SNode *s);
+ #define ref_pn(_pn) do { (_pn)->refcount++; } while (0)
+ #define ref_sn(_sn) do { (_sn)->refcount++; } while (0)
+ #define unref_pn(_p, _pn) do { if (!--(_pn)->refcount) free_PNode(_p, _pn); } while (0)
+ #define unref_sn(_p, _sn) do { if (!--(_sn)->refcount) free_SNode(_p, _sn); } while (0)
+ #else
+ #define ref_pn(_pn)
+ #define ref_sn(_sn)
+ #define unref_pn(_p, _pn)
+ #define unref_sn(_p, _sn)
+ #endif
+
+ typedef Stack(struct PNode*) StackPNode;
+ typedef Stack(struct SNode*) StackSNode;
+ typedef Stack(int) StackInt;
+
+ static int exhaustive_parse(Parser *p, int state);
+
+ void
+ print_paren(PNode *p) {
+ int i;
+ char *c;
+ if (!p->error_recovery) {
+ if (p->children.n) {
+ if (p->children.n > 1)
+ printf("(");
+ for (i = 0; i < p->children.n; i++)
+ print_paren(p->children.v[i]);
+ if (p->children.n > 1)
+ printf(")");
+ } else if (p->parse_node.start_loc.s != p->parse_node.end_skip) {
+ printf(" ");
+ for (c = p->parse_node.start_loc.s; c < p->parse_node.end_skip; c++)
+ printf("%c", *c);
+ printf(" ");
+ }
+ }
+ }
+
+ void
+ xprint_paren(Parser *pp, PNode *p) {
+ int i;
+ char *c;
+ if (!p->error_recovery) {
+ printf("[%s]", pp->t->symbols[p->parse_node.symbol].name);
+ if (p->children.n) {
+ printf("(");
+ for (i = 0; i < p->children.n; i++)
+ xprint_paren(pp, p->children.v[i]);
+ printf(")");
+ } else if (p->parse_node.start_loc.s != p->parse_node.end_skip) {
+ printf(" ");
+ for (c = p->parse_node.start_loc.s; c < p->parse_node.end_skip; c++)
+ printf("%c", *c);
+ printf(" ");
+ }
+ }
+ }
+
+ void xpp(Parser *pp, PNode *p) { xprint_paren(pp, p); printf("\n"); }
+ void pp(PNode *p) { print_paren(p); printf("\n"); }
+
+ #define D_ParseNode_to_PNode(_apn) \
+ ((PNode*)D_PN(_apn, -(int)&((PNode*)(NULL))->parse_node))
+
+ #define PNode_to_D_ParseNode(_apn) \
+ ((D_ParseNode*)&((PNode*)(_apn))->parse_node)
+
+ D_ParseNode *
+ d_get_child(D_ParseNode *apn, int child) {
+ PNode *pn = D_ParseNode_to_PNode(apn);
+ if (child < 0 || child >= pn->children.n)
+ return NULL;
+ return &pn->children.v[child]->parse_node;
+ }
+
+ int
+ d_get_number_of_children(D_ParseNode *apn) {
+ PNode *pn = D_ParseNode_to_PNode(apn);
+ return pn->children.n;
+ }
+
+ D_ParseNode *
+ d_find_in_tree(D_ParseNode *apn, int symbol) {
+ PNode *pn = D_ParseNode_to_PNode(apn);
+ D_ParseNode *res;
+ int i;
+
+ if (pn->parse_node.symbol == symbol)
+ return apn;
+ for (i = 0; i < pn->children.n; i++)
+ if ((res = d_find_in_tree(&pn->children.v[i]->parse_node, symbol)))
+ return res;
+ return NULL;
+ }
+
+ char *
+ d_ws_before(D_Parser *ap, D_ParseNode *apn) {
+ PNode *pn = D_ParseNode_to_PNode(apn);
+ return pn->ws_before;
+ }
+
+ char *
+ d_ws_after(D_Parser *ap, D_ParseNode *apn) {
+ PNode *pn = D_ParseNode_to_PNode(apn);
+ return pn->ws_after;
+ }
+
+ #define SNODE_HASH(_s, _sc, _g) ((((uint)(_s)) << 12) + (((uint)(_sc))) + ((uint)(_g)))
+
+ SNode *
+ find_SNode(Parser *p, uint state, D_Scope *sc, void *g) {
+ SNodeHash *ph = &p->snode_hash;
+ SNode *sn;
+ uint h = SNODE_HASH(state, sc, g);
+ if (ph->v)
+ for (sn = ph->v[h % ph->m]; sn; sn = sn->bucket_next)
+ if (sn->state - p->t->state == state &&
+ sn->initial_scope == sc &&
+ sn->initial_globals == g)
+ return sn;
+ return NULL;
+ }
+
+ void
+ insert_SNode_internal(Parser *p, SNode *sn) {
+ SNodeHash *ph = &p->snode_hash;
+ uint h = SNODE_HASH(sn->state - p->t->state, sn->initial_scope, sn->initial_globals), i;
+ SNode *t;
+
+ if (ph->n + 1 > ph->m) {
+ SNode **v = ph->v;
+ int m = ph->m;
+ ph->i++;
+ ph->m = prime2[ph->i];
+ ph->v = (SNode**)MALLOC(ph->m * sizeof(*ph->v));
+ memset(ph->v, 0, ph->m * sizeof(*ph->v));
+ for (i = 0; i < m; i++)
+ while ((t = v[i])) {
+ v[i] = v[i]->bucket_next;
+ insert_SNode_internal(p, t);
+ }
+ FREE(v);
+ }
+ sn->bucket_next = ph->v[h % ph->m];
+ ph->v[h % ph->m] = sn;
+ ph->n++;
+ }
+
+ static void
+ insert_SNode(Parser *p, SNode *sn) {
+ insert_SNode_internal(p, sn);
+ ref_sn(sn);
+ sn->all_next = p->snode_hash.all;
+ p->snode_hash.all = sn;
+ }
+
+ static SNode *
+ new_SNode(Parser *p, D_State *state, d_loc_t *loc, D_Scope *sc, void *g) {
+ SNode *sn = p->free_snodes;
+ if (!sn)
+ sn = MALLOC(sizeof *sn);
+ else
+ p->free_snodes = sn->all_next;
+ sn->depth = 0;
+ vec_clear(&sn->zns);
+ #ifndef USE_GC
+ sn->refcount = 0;
+ #endif
+ sn->all_next = 0;
+ p->states++;
+ sn->state = state;
+ sn->initial_scope = sc;
+ sn->initial_globals = g;
+ sn->loc = *loc;
+ insert_SNode(p, sn);
+ if (sn->state->accept) {
+ if (!p->accept) {
+ ref_sn(sn);
+ p->accept = sn;
+ } else if (sn->loc.s > p->accept->loc.s) {
+ ref_sn(sn);
+ unref_sn(p, p->accept);
+ p->accept = sn;
+ }
+ }
+ return sn;
+ }
+
+ static ZNode *
+ new_ZNode(Parser *p, PNode *pn) {
+ ZNode *z = p->free_znodes;
+ if (!z)
+ z = MALLOC(sizeof *z);
+ else
+ p->free_znodes = znode_next(z);
+ z->pn = pn;
+ vec_clear(&z->sns);
+ return z;
+ }
+
+ static void
+ free_PNode(Parser *p, PNode *pn) {
+ PNode *amb;
+ int i;
+ if (p->user.free_node_fn)
+ p->user.free_node_fn(&pn->parse_node);
+ for (i = 0; i < pn->children.n; i++)
+ unref_pn(p, pn->children.v[i]);
+ vec_free(&pn->children);
+ if ((amb = pn->ambiguities)) {
+ pn->ambiguities = NULL;
+ free_PNode(p, amb);
+ }
+ if (pn->latest != pn)
+ unref_pn(p, pn->latest);
+ pn->all_next = p->free_pnodes;
+ p->free_pnodes = pn;
+ #ifdef TRACK_PNODES
+ if (pn->xprev)
+ pn->xprev->xnext = pn->xnext;
+ else
+ p->xall = pn->xnext;
+ if (pn->xnext)
+ pn->xnext->xprev = pn->xprev;
+ pn->xprev = NULL;
+ pn->xnext = NULL;
+ #endif
+ }
+
+ #ifndef USE_GC
+ static void
+ free_ZNode(Parser *p, ZNode *z, SNode *s) {
+ int i;
+ unref_pn(p, z->pn);
+ for (i = 0; i < z->sns.n; i++)
+ if (s != z->sns.v[i])
+ unref_sn(p, z->sns.v[i]);
+ vec_free(&z->sns);
+ znode_next(z) = p->free_znodes;
+ p->free_znodes = z;
+ }
+
+ static void
+ free_SNode(Parser *p, struct SNode *s) {
+ int i;
+ for (i = 0; i < s->zns.n; i++)
+ if (s->zns.v[i])
+ free_ZNode(p, s->zns.v[i], s);
+ vec_free(&s->zns);
+ s->all_next = p->free_snodes;
+ p->free_snodes = s;
+ }
+ #endif
+
+ #define PNODE_HASH(_si, _ei, _s, _sc, _g) \
+ ((((uint)_si) << 8) + (((uint)_ei) << 16) + (((uint)_s)) + (((uint)_sc)) + (((uint)_g)))
+
+ PNode *
+ find_PNode(Parser *p, char *start, char *end_skip, int symbol, D_Scope *sc, void *g) {
+ PNodeHash *ph = &p->pnode_hash;
+ PNode *pn;
+ uint h = PNODE_HASH(start, end_skip, symbol, sc, g);
+ if (ph->v)
+ for (pn = ph->v[h % ph->m]; pn; pn = pn->bucket_next)
+ if (pn->parse_node.symbol == symbol &&
+ pn->parse_node.start_loc.s == start &&
+ pn->parse_node.end_skip == end_skip &&
+ pn->initial_scope == sc &&
+ pn->initial_globals == g)
+ return pn;
+ return NULL;
+ }
+
+ void
+ insert_PNode_internal(Parser *p, PNode *pn) {
+ PNodeHash *ph = &p->pnode_hash;
+ uint h = PNODE_HASH(pn->parse_node.start_loc.s, pn->parse_node.end_skip,
+ pn->parse_node.symbol, pn->initial_scope, pn->initial_globals), i;
+ PNode *t;
+
+ if (ph->n + 1 > ph->m) {
+ PNode **v = ph->v;
+ int m = ph->m;
+ ph->i++;
+ ph->m = prime2[ph->i];
+ ph->v = (PNode**)MALLOC(ph->m * sizeof(*ph->v));
+ memset(ph->v, 0, ph->m * sizeof(*ph->v));
+ for (i = 0; i < m; i++)
+ while ((t = v[i])) {
+ v[i] = v[i]->bucket_next;
+ insert_PNode_internal(p, t);
+ }
+ FREE(v);
+ }
+ pn->bucket_next = ph->v[h % ph->m];
+ ph->v[h % ph->m] = pn;
+ ph->n++;
+ }
+
+ static void
+ insert_PNode(Parser *p, PNode *pn) {
+ insert_PNode_internal(p, pn);
+ ref_pn(pn);
+ pn->all_next = p->pnode_hash.all;
+ p->pnode_hash.all = pn;
+ }
+
+ static void
+ free_old_nodes(Parser *p) {
+ int i;
+ uint h;
+ PNode *pn = p->pnode_hash.all, *tpn, **lpn;
+ SNode *sn = p->snode_hash.all, *tsn, **lsn;
+ while (sn) {
+ h = SNODE_HASH(sn->state - p->t->state, sn->initial_scope, sn->initial_globals);
+ lsn = &p->snode_hash.v[h % p->snode_hash.m];
+ tsn = sn; sn = sn->all_next;
+ while (*lsn != tsn) lsn = &(*lsn)->bucket_next;
+ *lsn = (*lsn)->bucket_next;
+ }
+ sn = p->snode_hash.last_all;
+ while (sn) {
+ tsn = sn; sn = sn->all_next;
+ unref_sn(p, tsn);
+ }
+ p->snode_hash.last_all = p->snode_hash.all;
+ p->snode_hash.all = NULL;
+ while (pn) {
+ for (i = 0; i < pn->children.n; i++) {
+ if (pn->children.v[i] != pn->children.v[i]->latest) {
+ ref_pn(pn->children.v[i]->latest);
+ unref_pn(p, pn->children.v[i]);
+ pn->children.v[i] = pn->children.v[i]->latest;
+ }
+ }
+ h = PNODE_HASH(pn->parse_node.start_loc.s, pn->parse_node.end_skip,
+ pn->parse_node.symbol, pn->initial_scope, pn->initial_globals);
+ lpn = &p->pnode_hash.v[h % p->pnode_hash.m];
+ tpn = pn; pn = pn->all_next;
+ while (*lpn != tpn) lpn = &(*lpn)->bucket_next;
+ *lpn = (*lpn)->bucket_next;
+ unref_pn(p, tpn);
+ }
+ p->pnode_hash.n = 0;
+ p->pnode_hash.all = NULL;
+ }
+
+ static void
+ alloc_parser_working_data(Parser *p) {
+ p->pnode_hash.i = PNODE_HASH_INITIAL_SIZE_INDEX;
+ p->pnode_hash.m = prime2[p->pnode_hash.i];
+ p->pnode_hash.v =
+ (PNode**)MALLOC(p->pnode_hash.m * sizeof(*p->pnode_hash.v));
+ memset(p->pnode_hash.v, 0, p->pnode_hash.m * sizeof(*p->pnode_hash.v));
+ p->snode_hash.i = SNODE_HASH_INITIAL_SIZE_INDEX;
+ p->snode_hash.m = prime2[p->snode_hash.i];
+ p->snode_hash.v =
+ (SNode**)MALLOC(p->snode_hash.m * sizeof(*p->snode_hash.v));
+ memset(p->snode_hash.v, 0, p->snode_hash.m * sizeof(*p->snode_hash.v));
+ p->shift_results = MALLOC(p->t->nsymbols * sizeof(ShiftResult));
+ }
+
+ static void
+ free_parser_working_data(Parser *p) {
+ int i;
+
+ free_old_nodes(p);
+ free_old_nodes(p); /* to catch SNodes saved for error repair */
+ if (p->pnode_hash.v)
+ FREE(p->pnode_hash.v);
+ if (p->snode_hash.v)
+ FREE(p->snode_hash.v);
+ memset(&p->pnode_hash, 0, sizeof(p->pnode_hash));
+ memset(&p->snode_hash, 0, sizeof(p->snode_hash));
+ while (p->reductions_todo) {
+ Reduction *r = p->free_reductions->next;
+ unref_sn(p, p->reductions_todo->snode);
+ FREE(p->free_reductions); p->free_reductions = r;
+ }
+ while (p->shifts_todo) {
+ Shift *s = p->free_shifts->next;
+ unref_sn(p, p->shifts_todo->snode);
+ FREE(p->free_shifts); p->free_shifts = s;
+ }
+ while (p->free_reductions) {
+ Reduction *r = p->free_reductions->next;
+ FREE(p->free_reductions); p->free_reductions = r;
+ }
+ while (p->free_shifts) {
+ Shift *s = p->free_shifts->next;
+ FREE(p->free_shifts); p->free_shifts = s;
+ }
+ while (p->free_pnodes) {
+ PNode *pn = p->free_pnodes->all_next;
+ FREE(p->free_pnodes); p->free_pnodes = pn;
+ }
+ while (p->free_znodes) {
+ ZNode *zn = znode_next(p->free_znodes);
+ FREE(p->free_znodes); p->free_znodes = zn;
+ }
+ while (p->free_snodes) {
+ SNode *sn = p->free_snodes->all_next;
+ FREE(p->free_snodes); p->free_snodes = sn;
+ }
+ for (i = 0; i < p->error_reductions.n; i++)
+ FREE(p->error_reductions.v[i]);
+ vec_free(&p->error_reductions);
+ if (p->whitespace_parser)
+ free_parser_working_data(p->whitespace_parser);
+ FREE(p->shift_results);
+ p->shift_results = NULL;
+ }
+
+ static int
+ znode_depth(ZNode *z) {
+ int i, d = 0;
+ if (!z)
+ return INT_MAX;
+ for (i = 0; i < z->sns.n; i++)
+ d = d < z->sns.v[i]->depth ? z->sns.v[i]->depth : d;
+ return d;
+ }
+
+ static Reduction *
+ add_Reduction(Parser *p, ZNode *z, SNode *sn, D_Reduction *reduction) {
+ Reduction *x, **l = &p->reductions_todo;
+ int d = znode_depth(z), dd;
+ for (x = p->reductions_todo; x; l = &x->next, x = x->next) {
+ if (sn->loc.s < x->snode->loc.s)
+ break;
+ dd = znode_depth(x->znode);
+ if ((sn->loc.s == x->snode->loc.s && d >= dd)) {
+ if (d == dd)
+ while (x) {
+ if (sn == x->snode && z == x->znode && reduction == x->reduction)
+ return NULL;
+ x = x->next;
+ }
+ break;
+ }
+ }
+ {
+ Reduction *r = p->free_reductions;
+ if (!r)
+ r = MALLOC(sizeof *r);
+ else
+ p->free_reductions = r->next;
+ r->znode = z;
+ r->snode = sn;
+ r->new_snode = NULL;
+ ref_sn(sn);
+ r->reduction = reduction;
+ r->next = *l;
+ *l = r;
+ return r;
+ }
+ }
+
+ static void
+ add_Shift(Parser *p, SNode *snode) {
+ Shift *x, **l = &p->shifts_todo;
+ Shift *s = p->free_shifts;
+ if (!s)
+ s = MALLOC(sizeof *s);
+ else
+ p->free_shifts = s->next;
+ s->snode = snode;
+ ref_sn(s->snode);
+ for (x = p->shifts_todo; x; l = &x->next, x = x->next)
+ if (snode->loc.s <= x->snode->loc.s) break;
+ s->next = *l;
+ *l = s;
+ }
+
+ static SNode *
+ add_SNode(Parser *p, D_State *state, d_loc_t *loc, D_Scope *sc, void *g) {
+ int i;
+ SNode *sn = find_SNode(p, state - p->t->state, sc, g);
+ if (sn)
+ return sn;
+ sn = new_SNode(p, state, loc, sc, g);
+ if (sn->state->shifts)
+ add_Shift(p, sn);
+ for (i = 0; i < sn->state->reductions.n; i++)
+ if (!sn->state->reductions.v[i]->nelements)
+ add_Reduction(p, 0, sn, sn->state->reductions.v[i]);
+ return sn;
+ }
+
+ static int
+ reduce_actions(Parser *p, PNode *pn, D_Reduction *r) {
+ int i, height = 0;
+ PNode *c;
+
+ for (i = 0; i < pn->children.n; i++) {
+ c = pn->children.v[i];
+ if (c->op_assoc) {
+ pn->assoc = c->op_assoc;
+ pn->priority = c->op_priority;
+ }
+ if (c->height >= height)
+ height = c->height + 1;
+ }
+ pn->op_assoc = r->op_assoc;
+ pn->op_priority = r->op_priority;
+ pn->height = height;
+ if (r->rule_assoc) {
+ pn->assoc = r->rule_assoc;
+ pn->priority = r->rule_priority;
+ }
+ if (r->speculative_code)
+ return r->speculative_code(
+ pn, (void**)&pn->children.v[0], pn->children.n,
+ (int)&((PNode*)(NULL))->parse_node, (D_Parser*)p);
+ return 0;
+ }
+
+ #define x 666 /* impossible */
+ static int child_table[4][3][6] = {
+ {
+ /* binary parent, child on left */
+ /* priority of child vs parent, or = with child|parent associativity
+ > < =LL =LR =RL =RR
+ */
+ { 1, 0, 1, 1, 0, 0}, /* binary child */
+ { 1, 1, 1, 1, x, x}, /* left unary child */
+ { 1, 0, x, x, 1, 1} /* right unary child */
+ },
+ { /* binary parent, child on right */
+ { 1, 0, 0, 0, 1, 1}, /* binary child */
+ { 1, 0, 1, 1, x, x}, /* left unary child */
+ { 1, 1, x, x, 1, 1} /* right unary child */
+ },
+ { /* left unary parent */
+ { 1, 0, 0, x, 0, x}, /* binary child */
+ { 1, 0, 1, x, x, x}, /* left unary child */
+ { 1, 1, x, x, 1, x} /* right unary child */
+ },
+ { /* right unary parent */
+ { 1, 0, x, 0, x, 0}, /* binary child */
+ { 1, 1, x, 1, x, x}, /* left unary child */
+ { 1, 0, x, x, x, 1} /* right unary child */
+ }
+ };
+ #undef x
+
+ /* returns 1 if legal for child reduction and illegal for child shift */
+ static int
+ check_child(int ppri, AssocKind passoc, int cpri, AssocKind cassoc,
+ int left, int right)
+ {
+ int p = IS_BINARY_NARY_ASSOC(passoc) ? (right ? 1 : 0) :
+ (passoc == ASSOC_UNARY_LEFT ? 2 : 3);
+ int c = IS_BINARY_NARY_ASSOC(cassoc) ? 0 :
+ (cassoc == ASSOC_UNARY_LEFT ? 1 : 2);
+ int r =
+ cpri > ppri ? 0 : (
+ cpri < ppri ? 1 : ( 2 + (
+ (IS_RIGHT_ASSOC(cassoc) ? 2 : 0) +
+ (IS_RIGHT_ASSOC(passoc) ? 1 : 0))));
+ return child_table[p][c][r];
+ }
+
+ /* check assoc/priority legality, 0 is OK, -1 is bad */
+ static int
+ check_assoc_priority(PNode *pn0, PNode *pn1, PNode *pn2) {
+ if (!IS_UNARY_BINARY_ASSOC(pn0->op_assoc)) {
+ if (IS_UNARY_BINARY_ASSOC(pn1->op_assoc)) { /* second token is operator */
+ /* check expression pn0 (child of pn1) */
+ if (pn0->assoc) {
+ if (!check_child(pn1->op_priority, pn1->op_assoc,
+ pn0->priority, pn0->assoc, 0, 1))
+ return -1;
+ }
+ }
+ } else { /* pn0 is an operator */
+ if (pn1->op_assoc) {
+ /* check pn0 (child of operator pn1) */
+ if (!check_child(pn1->op_priority, pn1->op_assoc,
+ pn0->op_priority, pn0->op_assoc, 0, 1))
+ return -1;
+ } else if (pn2) {
+ /* check pn0 (child of operator pn2) */
+ if (pn2->op_assoc &&
+ !check_child(pn2->op_priority, pn2->op_assoc,
+ pn0->op_priority, pn0->op_assoc, 0, 1))
+ return -1;
+ }
+ /* check expression pn1 (child of pn0) */
+ if (pn1->assoc) {
+ if (!check_child(pn0->op_priority, pn0->op_assoc,
+ pn1->priority, pn1->assoc, 1, 0))
+ return -1;
+ }
+ }
+ return 0;
+ }
+
+ /* check to see if a path is legal with respect to
+ the associativity and priority of its operators */
+ static int
+ check_path_priorities_internal(VecZNode *path) {
+ int i = 0, j, k, jj, kk, one = 0;
+ ZNode *z, *zz, *zzz;
+ PNode *pn0, *pn1;
+
+ if (path->n < i + 1)
+ return 0;
+ pn0 = path->v[i]->pn;
+ if (!pn0->op_assoc) { /* deal with top expression directly */
+ i = 1;
+ if (path->n < i + 1)
+ return 0;
+ pn1 = path->v[i]->pn;
+ if (!pn1->op_assoc)
+ return 0;
+ if (pn0->assoc) {
+ if (!check_child(pn1->op_priority, pn1->op_assoc,
+ pn0->priority, pn0->assoc, 0, 1))
+ return -1;
+ }
+ pn0 = pn1;
+ }
+ if (path->n > i + 1) { /* entirely in the path */
+ pn1 = path->v[i + 1]->pn;
+ if (path->n > i + 2)
+ return check_assoc_priority(pn0, pn1, path->v[i + 2]->pn);
+ else { /* one level from the stack beyond the path */
+ z = path->v[i + 1];
+ for (k = 0; k < z->sns.n; k++)
+ for (j = 0; j < z->sns.v[k]->zns.n; j++) {
+ one = 1;
+ zz = z->sns.v[k]->zns.v[j];
+ if (zz && !check_assoc_priority(pn0, pn1, zz->pn))
+ return 0;
+ }
+ if (!one)
+ return check_assoc_priority(pn0, pn1, NULL);
+ }
+ } else { /* two levels from the stack beyond the path */
+ z = path->v[i];
+ for (k = 0; k < z->sns.n; k++)
+ for (j = 0; j < z->sns.v[k]->zns.n; j++) {
+ zz = z->sns.v[k]->zns.v[j];
+ if (zz)
+ for (kk = 0; kk < zz->sns.n; kk++)
+ for (jj = 0; jj < zz->sns.v[kk]->zns.n; jj++) {
+ one = 1;
+ zzz = zz->sns.v[kk]->zns.v[jj];
+ if (zzz && !check_assoc_priority(pn0, zz->pn, zzz->pn))
+ return 0;
+ }
+ }
+ return 0;
+ }
+ return -1;
+ }
+
+ /* avoid cases without operator priorities */
+ #define check_path_priorities(_p) ((_p)->n > 1 && \
+ ((_p)->v[0]->pn->op_assoc || (_p)->v[1]->pn->op_assoc) && \
+ check_path_priorities_internal(_p))
+
+ static int
+ cmp_priorities(int xpri[], int xn, int ypri[], int yn) {
+ int i = 0;
+
+ while (i < xn && i < yn) {
+ if (xpri[i] > ypri[i])
+ return -1;
+ if (xpri[i] < ypri[i])
+ return 1;
+ i++;
+ }
+ return 0;
+ }
+
+ static void
+ intsort(int *xp, int n) {
+ int again = 1, i, t;
+ while (again) {
+ again = 0;
+ for (i = 0; i < n - 1; i++) {
+ if (xp[i] > xp[i+1]) {
+ t = xp[i];
+ xp[i] = xp[i + 1];
+ xp[i + 1] = t;
+ again = 1;
+ }
+ }
+ }
+ }
+
+ /* sort by deepest, then by address */
+ static void
+ priority_insert(StackPNode *psx, PNode *x) {
+ PNode *t, **start, **cur;
+
+ stack_push(psx, x);
+ start = psx->start;
+ cur = psx->cur;
+ for (;cur > start + 1;cur--) {
+ if (cur[-1]->height > cur[-2]->height)
+ continue;
+ if (cur[-1]->height == cur[-2]->height && cur[-1] > cur[-2])
+ continue;
+ t = cur[-1];
+ cur[-1] = cur[-2];
+ cur[-2] = t;
+ }
+ }
+
+ static void
+ get_exp_all(PNode *x, StackInt *psx) {
+ int i;
+
+ if (x->assoc)
+ stack_push(psx, x->priority);
+ for (i = 0; i < x->children.n; i++)
+ get_exp_all(x->children.v[i]->latest, psx);
+ }
+
+ static void
+ get_exp_one(PNode *x, StackPNode *psx, StackInt *isx) {
+ int i;
+
+ if (!IS_NARY_ASSOC(x->assoc))
+ priority_insert(psx, x);
+ else {
+ stack_push(isx, x->priority);
+ for (i = 0; i < x->children.n; i++)
+ if (x->children.v[i]->assoc)
+ get_exp_one(x->children.v[i], psx, isx);
+ }
+ }
+
+ static void
+ get_exp_one_down(PNode *x, StackPNode *psx, StackInt *isx) {
+ int i;
+
+ stack_push(isx, x->priority);
+ for (i = 0; i < x->children.n; i++)
+ if (x->children.v[i]->assoc)
+ get_exp_one(x->children.v[i], psx, isx);
+ }
+
+ /* get the set of priorities for unshared nodes,
+ eliminating shared subtrees via priority queues */
+ static void
+ get_unshared_priorities(StackPNode *psx, StackPNode *psy,
+ StackInt *isx, StackInt *isy)
+ {
+ StackPNode *psr;
+ PNode *t;
+
+ while (1) {
+ if (is_stack_empty(psx)) {
+ psr = psy;
+ break;
+ } else if (is_stack_empty(psy)) {
+ psr = psx;
+ break;
+ }
+ if (stack_head(psx)->height > stack_head(psy)->height)
+ psr = psx;
+ else if (stack_head(psx)->height < stack_head(psy)->height)
+ psr = psy;
+ else if (stack_head(psx) > stack_head(psy))
+ psr = psx;
+ else if (stack_head(psx) < stack_head(psy))
+ psr = psy;
+ else {
+ (void)stack_pop(psx);
+ (void)stack_pop(psy);
+ continue;
+ }
+ t = stack_pop(psr);
+ if (psr == psx)
+ get_exp_one_down(t, psx, isx);
+ else
+ get_exp_one_down(t, psy, isy);
+ }
+ while (!is_stack_empty(psr)) {
+ t = stack_pop(psr);
+ if (psr == psx)
+ get_exp_all(t, isx);
+ else
+ get_exp_all(t, isy);
+ }
+ return;
+ }
+
+ static int
+ cmp_eagerness(PNode *x, PNode *y) {
+ int i, n;
+ char *xx, *yy;
+
+ n = x->children.n < y->children.n ? x->children.n : y->children.n;
+ for (i = 0; i < n; i++) {
+ xx = x->children.v[i]->parse_node.end_skip;
+ yy = y->children.v[i]->parse_node.end_skip;
+ /* if the child is a symbol, the end_skip of the last child
+ will not equal that of the entire parse tree */
+ xx = i == x->children.n - 1 ? x->parse_node.end_skip : xx;
+ yy = i == y->children.n - 1 ? y->parse_node.end_skip : yy;
+ if (xx > yy)
+ return -1;
+ if (xx < yy)
+ return 1;
+ }
+ return 0;
+ }
+
+ static int
+ cmp_pnodes(Parser *p, PNode *x, PNode *y) {
+ StackPNode psx, psy;
+ StackInt isx, isy;
+ int r = 0;
+
+ if (x->assoc && y->assoc) {
+ /* simple case */
+ if (!IS_NARY_ASSOC(x->assoc) && !IS_NARY_ASSOC(y->assoc)) {
+ if (x->priority > y->priority)
+ return -1;
+ if (x->priority < y->priority)
+ return 1;
+ }
+ /* compare the priorities of operators in two trees
+ while eliminating common subtrees for efficiency. */
+ stack_clear(&psx); stack_clear(&psy); stack_clear(&isx); stack_clear(&isy);
+ get_exp_one(x, &psx, &isx);
+ get_exp_one(y, &psy, &isy);
+ get_unshared_priorities(&psx, &psy, &isx, &isy);
+ intsort(isx.start, stack_depth(&isx));
+ intsort(isy.start, stack_depth(&isy));
+ r = cmp_priorities(isx.start, stack_depth(&isx),
+ isy.start, stack_depth(&isy));
+ stack_free(&psx); stack_free(&psy); stack_free(&isx); stack_free(&isy);
+ if (r)
+ return r;
+ }
+ if (!p->user.dont_use_eagerness_for_disambiguation)
+ if ((r = cmp_eagerness(x, y)))
+ return r;
+ if (!p->user.dont_use_height_for_disambiguation) {
+ if (x->height < y->height)
+ return -1;
+ if (x->height > y->height)
+ return 1;
+ }
+ return r;
+ }
+
+ static char *
+ find_ws_before(Parser *p, ZNode *zn) {
+ while (zn && is_epsilon_PNode(zn->pn)) {
+ zn = zn->sns.n ? (zn->sns.v[0]->zns.n ? zn->sns.v[0]->zns.v[0] : NULL) : NULL;
+ }
+ if (zn)
+ return zn->pn->parse_node.end;
+ else
+ return p->start;
+ }
+
+ static PNode *
+ make_PNode(Parser *p, int symbol, d_loc_t *start_loc, char *e, PNode *pn,
+ D_Reduction *r, VecZNode *path, D_Shift *sh)
+ {
+ int i, l = sizeof(PNode) - sizeof(d_voidp) + p->user.sizeof_user_parse_node;
+ PNode *new_pn = p->free_pnodes;
+ if (!new_pn)
+ new_pn = MALLOC(l);
+ else
+ p->free_pnodes = new_pn->all_next;
+ p->pnodes++;
+ memset(new_pn, 0, l);
+ #ifdef TRACK_PNODES
+ new_pn->xnext = p->xall;
+ if (p->xall)
+ p->xall->xprev = new_pn;
+ p->xall = new_pn;
+ #endif
+ new_pn->parse_node.symbol = symbol;
+ new_pn->parse_node.start_loc = *start_loc;
+ if (!r || !path) { /* end of last parse node of path for non-epsilon reductions */
+ new_pn->parse_node.end = e;
+ new_pn->ws_before = e;
+ } else {
+ new_pn->parse_node.end = pn->parse_node.end;
+ new_pn->ws_before = find_ws_before(p, path->v[path->n-1]->sns.v[0]->zns.v[0]);
+ }
+ new_pn->parse_node.end_skip = e;
+ new_pn->shift = sh;
+ new_pn->reduction = r;
+ new_pn->parse_node.scope = pn->parse_node.scope;
+ new_pn->initial_scope = new_pn->parse_node.scope;
+ new_pn->parse_node.globals = pn->parse_node.globals;
+ new_pn->initial_globals = new_pn->parse_node.globals;
+ new_pn->parse_node.white_space = pn->parse_node.white_space;
+ new_pn->latest = new_pn;
+ new_pn->ws_after = e;
+ if (sh) {
+ new_pn->op_assoc = sh->op_assoc;
+ new_pn->op_priority = sh->op_priority;
+ if (sh->speculative_code)
+ if (sh->speculative_code(
+ pn, (void**)&pn->children.v[0], pn->children.n,
+ (int)&((PNode*)(NULL))->parse_node, (D_Parser*)p))
+ {
+ free_PNode(p, new_pn);
+ return NULL;
+ }
+ } else if (r) {
+ if (path)
+ for (i = path->n - 1; i >= 0; i--) {
+ PNode *latest = path->v[i]->pn->latest;
+ vec_add(&new_pn->children, latest);
+ ref_pn(latest);
+ }
+ if (reduce_actions(p, new_pn, r)) {
+ free_PNode(p, new_pn);
+ return NULL;
+ }
+ if (path && path->n > 1) {
+ int n = path->n;
+ for (i = 0; i < n; i += n-1) {
+ PNode *child = new_pn->children.v[i];
+ if (child->assoc &&
+ !check_child(new_pn->priority, new_pn->assoc,
+ child->priority, child->assoc, i == 0, i == n - 1))
+ {
+ free_PNode(p, new_pn);
+ return NULL;
+ }
+ }
+ }
+ }
+ return new_pn;
+ }
+
+ static int
+ PNode_equal(PNode *pn, D_Reduction *r, VecZNode *path, D_Shift *sh) {
+ int i, n = pn->children.n;
+ if (sh)
+ return sh == pn->shift;
+ if (r != pn->reduction)
+ return 0;
+ if (!path && !n)
+ return 1;
+ if (n == path->n) {
+ for (i = 0; i < n; i++) {
+ if (pn->children.v[i]->latest != path->v[n - i - 1]->pn->latest)
+ return 0;
+ }
+ return 1;
+ }
+ return 0;
+ }
+
+ /* find/create PNode */
+ static PNode *
+ add_PNode(Parser *p, int symbol, d_loc_t *start_loc, char *e, PNode *pn,
+ D_Reduction *r, VecZNode *path, D_Shift *sh)
+ {
+ PNode *old_pn = find_PNode(p, start_loc->s, e, symbol, pn->initial_scope, pn->initial_globals),
+ *new_pn;
+ if (old_pn && PNode_equal(old_pn, r, path, sh))
+ return old_pn;
+ new_pn = make_PNode(p, symbol, start_loc, e, pn, r, path, sh);
+ if (!old_pn) {
+ old_pn = new_pn;
+ if (!new_pn)
+ return NULL;
+ insert_PNode(p, new_pn);
+ goto Lreturn;
+ }
+ if (!new_pn)
+ goto Lreturn;
+ p->compares++;
+ switch (cmp_pnodes(p, new_pn, old_pn)) {
+ case 0:
+ new_pn->ambiguities = old_pn->ambiguities;
+ old_pn->ambiguities = new_pn;
+ break;
+ case -1:
+ insert_PNode(p, new_pn);
+ old_pn->latest = new_pn;
+ ref_pn(new_pn);
+ old_pn = new_pn;
+ break;
+ case 1:
+ free_PNode(p, new_pn);
+ break;
+ }
+ Lreturn:
+ return old_pn;
+ }
+
+ /* The set of znodes associated with a state can be very large
+ because of cascade reductions (for example, large expression trees).
+ Use an adaptive data structure starting with a short list and
+ then falling back to a direct map hash table.
+ */
+
+ static void set_add_znode(VecZNode *v, ZNode *z);
+
+ static void
+ set_union_znode(VecZNode *v, VecZNode *vv) {
+ int i;
+ for (i = 0; i < vv->n; i++)
+ if (vv->v[i])
+ set_add_znode(v, vv->v[i]);
+ }
+
+ static ZNode *
+ set_find_znode(VecZNode *v, PNode *pn) {
+ uint i, j, n = v->n, h;
+ if (n <= INTEGRAL_VEC_SIZE) {
+ for (i = 0; i < n; i++)
+ if (v->v[i]->pn == pn)
+ return v->v[i];
+ return NULL;
+ }
+ h = ((uint)pn) % n;
+ for (i = h, j = 0;
+ i < v->n && j < SET_MAX_SEQUENTIAL;
+ i = ((i + 1) % n), j++)
+ {
+ if (!v->v[i])
+ return NULL;
+ else if (v->v[i]->pn == pn)
+ return v->v[i];
+ }
+ return NULL;
+ }
+
+ static void
+ set_add_znode_hash(VecZNode *v, ZNode *z) {
+ VecZNode vv;
+ int i, j, n = v->n;
+ if (n) {
+ uint h = ((uint)z->pn) % n;
+ for (i = h, j = 0;
+ i < v->n && j < SET_MAX_SEQUENTIAL;
+ i = ((i + 1) % n), j++)
+ {
+ if (!v->v[i]) {
+ v->v[i] = z;
+ return;
+ }
+ }
+ }
+ if (!n) {
+ vv.v = NULL;
+ v->i = INITIAL_SET_SIZE_INDEX;
+ } else {
+ vv.v = (void*)v->v;
+ vv.n = v->n;
+ v->i = v->i + 2;
+ }
+ v->n = prime2[v->i];
+ v->v = MALLOC(v->n * sizeof(void *));
+ memset(v->v, 0, v->n * sizeof(void *));
+ if (vv.v) {
+ set_union_znode(v, &vv);
+ FREE(vv.v);
+ }
+ set_add_znode(v, z);
+ }
+
+ static void
+ set_add_znode(VecZNode *v, ZNode *z) {
+ VecZNode vv;
+ int i, n = v->n;
+ if (n < INTEGRAL_VEC_SIZE) {
+ vec_add(v, z);
+ return;
+ }
+ if (n == INTEGRAL_VEC_SIZE) {
+ vv = *v;
+ vec_clear(v);
+ for (i = 0; i < n; i++)
+ set_add_znode_hash(v, vv.v[i]);
+ }
+ set_add_znode_hash(v, z);
+ }
+
+ static SNode *
+ goto_PNode(Parser *p, d_loc_t *loc, PNode *pn, SNode *ps) {
+ SNode *new_ps, *pre_ps;
+ ZNode *z = NULL;
+ D_State *state;
+ int i, j, k, state_index;
+
+ if (!IS_BIT_SET(ps->state->goto_valid, pn->parse_node.symbol))
+ return NULL;
+ state_index = GOTO_STATE(p, pn, ps);
+ state = &p->t->state[state_index];
+ new_ps = add_SNode(p, state, loc, pn->initial_scope, pn->initial_globals);
+ new_ps->last_pn = pn;
+ DBG(printf("goto %d (%s) -> %d %X\n",
+ ps->state - p->t->state,
+ p->t->symbols[pn->parse_node.symbol].name,
+ state_index, (uint)new_ps));
+ if (ps != new_ps && new_ps->depth < ps->depth + 1)
+ new_ps->depth = ps->depth + 1;
+ /* find/create ZNode */
+ z = set_find_znode(&new_ps->zns, pn);
+ if (!z) { /* not found */
+ set_add_znode(&new_ps->zns, (z = new_ZNode(p, pn)));
+ ref_pn(pn);
+ for (j = 0; j < new_ps->state->reductions.n; j++)
+ if (new_ps->state->reductions.v[j]->nelements)
+ add_Reduction(p, z, new_ps, new_ps->state->reductions.v[j]);
+ if (!pn->shift)
+ for (j = 0; j < new_ps->state->right_epsilon_hints.n; j++) {
+ D_RightEpsilonHint *h = &new_ps->state->right_epsilon_hints.v[j];
+ pre_ps = find_SNode(p, h->preceeding_state, new_ps->initial_scope, new_ps->initial_globals);
+ if (!pre_ps) continue;
+ for (k = 0; k < pre_ps->zns.n; k++)
+ if (pre_ps->zns.v[k]) {
+ Reduction *r =
+ add_Reduction(p, pre_ps->zns.v[k], pre_ps, h->reduction);
+ if (r) {
+ r->new_snode = new_ps;
+ r->new_depth = h->depth;
+ }
+ }
+ }
+ }
+ for (i = 0; i < z->sns.n; i++)
+ if (z->sns.v[i] == ps) break;
+ if (i >= z->sns.n) { /* not found */
+ vec_add(&z->sns, ps);
+ if (new_ps != ps)
+ ref_sn(ps);
+ }
+ return new_ps;
+ }
+
+ static void
+ parse_whitespace(D_Parser *ap, d_loc_t *loc, void **p_globals) {
+ Parser *pp = ((Parser*)ap)->whitespace_parser;
+ pp->start = loc->s;
+ if (!exhaustive_parse(pp, ((Parser *)ap)->t->whitespace_state)) {
+ if (pp->accept) {
+ *loc = pp->accept->loc;
+ unref_sn(pp, pp->accept);
+ pp->accept = NULL;
+ }
+ }
+ }
+
+ static void
+ shift_one(Parser *p, Shift *s) {
+ int i, nshifts = 0;
+ d_loc_t loc, skip_loc;
+ D_WhiteSpaceFn skip_fn = NULL;
+ PNode *new_pn;
+ D_State *state = s->snode->state;
+ ShiftResult *r;
+
+ loc = s->snode->loc;
+ skip_loc.s = NULL;
+ p->scans++;
+ if (state->scanner_code) {
+ p->code_shift.term_priority = 0;
+ p->code_shift.op_assoc = 0;
+ p->shift_results[nshifts].loc = loc;
+ if ((state->scanner_code(
+ &p->shift_results[nshifts].loc.s,
+ &p->shift_results[nshifts].loc.col,
+ &p->shift_results[nshifts].loc.line,
+ &p->code_shift.symbol, &p->code_shift.term_priority,
+ &p->code_shift.op_assoc, &p->code_shift.op_priority)))
+ {
+ p->shift_results[nshifts++].shift = &p->code_shift;
+ }
+ }
+ if (state->scanner_table)
+ nshifts += scan_buffer(&loc, state, &p->shift_results[nshifts]);
+ for (i = 0; i < nshifts ;i++) {
+ r = &p->shift_results[i];
+ p->shifts++;
+ DBG(printf("shift %d %X %d (%s)\n",
+ s->snode->state - p->t->state, (uint)s->snode, r->shift->symbol,
+ p->t->symbols[r->shift->symbol].name));
+ new_pn = add_PNode(p, r->shift->symbol, &s->snode->loc, r->loc.s,
+ s->snode->last_pn, NULL, NULL, r->shift);
+ if (new_pn) {
+ if (!skip_loc.s || skip_loc.s != r->loc.s || skip_fn != new_pn->parse_node.white_space) {
+ skip_loc = r->loc;
+ skip_fn = new_pn->parse_node.white_space;
+ new_pn->parse_node.white_space(
+ (D_Parser*)p, &skip_loc, (void**)&new_pn->parse_node.globals);
+ skip_loc.previous_col = s->snode->loc.col >= 0 ? s->snode->loc.col :
+ s->snode->loc.previous_col;
+ new_pn->ws_before = find_ws_before(p, s->snode->zns.v[0]);
+ new_pn->ws_after = skip_loc.s;
+ }
+ goto_PNode(p, &skip_loc, new_pn, s->snode);
+ }
+ }
+ unref_sn(p, s->snode);
+ s->next = p->free_shifts;
+ p->free_shifts = s;
+ }
+
+ static VecZNode path1; /* static first path for speed */
+
+ static VecZNode *
+ new_VecZNode(VecVecZNode *paths, int n, int parent) {
+ int i;
+ VecZNode *pv;
+
+ if (!paths->n)
+ pv = &path1;
+ else
+ pv = MALLOC(sizeof *pv);
+ vec_clear(pv);
+ if (parent >= 0)
+ for (i = 0; i < n; i++)
+ vec_add(pv, paths->v[parent]->v[i]);
+ return pv;
+ }
+
+ static void
+ build_paths_internal(ZNode *z, VecVecZNode *paths, int parent,
+ int n, int n_to_go)
+ {
+ int j, k, l;
+
+ vec_add(paths->v[parent], z);
+ if (n_to_go <= 1)
+ return;
+ for (k = 0; k < z->sns.n; k++)
+ for (j = 0, l = 0; j < z->sns.v[k]->zns.n; j++) {
+ if (z->sns.v[k]->zns.v[j]) {
+ if (k + l) {
+ vec_add(paths, new_VecZNode(paths, n - (n_to_go - 1), parent));
+ parent = paths->n - 1;
+ }
+ build_paths_internal(z->sns.v[k]->zns.v[j], paths, parent,
+ n, n_to_go - 1);
+ l++;
+ }
+ }
+ }
+
+ static void
+ build_paths(ZNode *z, VecVecZNode *paths, int nchildren_to_go) {
+ if (!nchildren_to_go)
+ return;
+ vec_add(paths, new_VecZNode(paths, 0, -1));
+ build_paths_internal(z, paths, 0, nchildren_to_go, nchildren_to_go);
+ }
+
+ static void
+ free_paths(VecVecZNode *paths) {
+ int i;
+ vec_free(&path1);
+ for (i = 1; i < paths->n; i++) {
+ vec_free(paths->v[i]);
+ FREE(paths->v[i]);
+ }
+ vec_free(paths);
+ }
+
+ static void
+ reduce_one(Parser *p, Reduction *r) {
+ SNode *sn = r->snode;
+ PNode *pn, *last_pn;
+ ZNode *first_z;
+ int i, j, n = r->reduction->nelements;
+ VecVecZNode paths;
+ VecZNode *path;
+
+ if (!r->znode) { /* epsilon reduction */
+ if ((pn = add_PNode(p, r->reduction->symbol, &sn->loc,
+ sn->loc.s, sn->last_pn, r->reduction, 0, 0)))
+ goto_PNode(p, &sn->loc, pn, sn);
+ } else {
+ DBG(printf("reduce %d %X %d\n", r->snode->state - p->t->state, (uint)sn, n));
+ vec_clear(&paths);
+ build_paths(r->znode, &paths, n);
+ for (i = 0; i < paths.n; i++) {
+ path = paths.v[i];
+ if (r->new_snode) { /* prune paths by new right epsilon node */
+ for (j = 0; j < path->v[r->new_depth]->sns.n; j++)
+ if (path->v[r->new_depth]->sns.v[j] == r->new_snode)
+ break;
+ if (j >= path->v[r->new_depth]->sns.n)
+ continue;
+ }
+ if (check_path_priorities(path))
+ continue;
+ p->reductions++;
+ last_pn = path->v[0]->pn;
+ first_z = path->v[n - 1];
+ pn = add_PNode(p, r->reduction->symbol,
+ &first_z->pn->parse_node.start_loc,
+ sn->loc.s, last_pn, r->reduction, path, NULL);
+ if (pn)
+ for (j = 0; j < first_z->sns.n; j++)
+ goto_PNode(p, &sn->loc, pn, first_z->sns.v[j]);
+ }
+ free_paths(&paths);
+ }
+ unref_sn(p, sn);
+ r->next = p->free_reductions;
+ p->free_reductions = r;
+ }
+
+ static int
+ VecSNode_equal(VecSNode *vsn1, VecSNode *vsn2) {
+ int i, j;
+ if (vsn1->n != vsn2->n)
+ return 0;
+ for (i = 0; i < vsn1->n; i++) {
+ for (j = 0; j < vsn2->n; j++) {
+ if (vsn1->v[i] == vsn2->v[j])
+ break;
+ }
+ if (j >= vsn2->n)
+ return 0;
+ }
+ return 1;
+ }
+
+ static ZNode *
+ binary_op_ZNode(SNode *sn) {
+ ZNode *z;
+ if (sn->zns.n != 1)
+ return NULL;
+ z = sn->zns.v[0];
+ if (z->pn->op_assoc == ASSOC_UNARY_RIGHT) {
+ if (z->sns.n != 1)
+ return NULL;
+ sn = z->sns.v[0];
+ if (sn->zns.n != 1)
+ return NULL;
+ z = sn->zns.v[0];
+ }
+ if (!IS_BINARY_ASSOC(z->pn->op_assoc))
+ return NULL;
+ return z;
+ }
+
+ static char *spaces = " ";
+ static void
+ print_stack(Parser *p, SNode *s, int indent) {
+ int i,j;
+
+ printf("%d", s->state - p->t->state);
+ indent += 2;
+ for (i = 0; i < s->zns.n; i++) {
+ if (!s->zns.v[i])
+ continue;
+ if (s->zns.n > 1)
+ printf("\n%s[", &spaces[99-indent]);
+ printf("(%s:", p->t->symbols[s->zns.v[i]->pn->parse_node.symbol].name);
+ print_paren(s->zns.v[i]->pn);
+ printf(")");
+ for (j = 0; j < s->zns.v[i]->sns.n; j++) {
+ if (s->zns.v[i]->sns.n > 1)
+ printf("\n%s[", &spaces[98-indent]);
+ print_stack(p, s->zns.v[i]->sns.v[j], indent);
+ if (s->zns.v[i]->sns.n > 1)
+ printf("]");
+ }
+ if (s->zns.n > 1)
+ printf("]");
+ }
+ }
+
+ /* compare two stacks with operators on top of identical substacks
+ eliminating the stack with the lower priority binary operator
+ - used to eliminate unnecessary stacks created by the
+ (empty) application binary operator
+ */
+ static void
+ cmp_stacks(Parser *p) {
+ char *pos;
+ Shift *a, *b, **al, **bl;
+ ZNode *az, *bz;
+
+ pos = p->shifts_todo->snode->loc.s;
+ DBG({
+ int i = 0;
+ for (al = &p->shifts_todo, a = *al; a && a->snode->loc.s == pos;
+ al = &a->next, a = a->next)
+ {
+ if (++i < 2) printf("\n");
+ print_stack(p, a->snode, 0);
+ printf("\n");
+ }});
+ for (al = &p->shifts_todo, a = *al; a && a->snode->loc.s == pos;
+ al = &a->next, a = a->next)
+ {
+ if (!(az = binary_op_ZNode(a->snode)))
+ continue;
+ for (bl = &a->next, b = a->next; b && b->snode->loc.s == pos;
+ bl = &b->next, b = b->next) {
+ if (!(bz = binary_op_ZNode(b->snode)))
+ continue;
+ if (!VecSNode_equal(&az->sns, &bz->sns))
+ continue;
+ if ((a->snode->state->reduces_to != b->snode->state - p->t->state) &&
+ (b->snode->state->reduces_to != a->snode->state - p->t->state))
+ continue;
+ if (az->pn->op_priority > bz->pn->op_priority) {
+ DBG(printf("DELETE ");
+ print_stack(p, b->snode, 0);
+ printf("\n"));
+ *bl = b->next;
+ unref_sn(p, b->snode);
+ FREE(b);
+ b = *bl;
+ break;
+ }
+ if (az->pn->op_priority < bz->pn->op_priority) {
+ DBG(printf("DELETE ");
+ print_stack(p, a->snode, 0);
+ printf("\n"));
+ *al = a->next;
+ unref_sn(p, a->snode);
+ FREE(a);
+ a = *al;
+ goto Lbreak2;
+ }
+ }
+ Lbreak2:;
+ }
+ }
+
+ static void
+ free_ParseTreeBelow(Parser *p, PNode *pn) {
+ int i;
+ PNode *amb;
+
+ for (i = 0; i < pn->children.n; i++)
+ unref_pn(p, pn->children.v[i]);
+ vec_free(&pn->children);
+ if ((amb = pn->ambiguities)) {
+ pn->ambiguities = NULL;
+ free_PNode(p, amb);
+ }
+ }
+
+ void
+ free_D_ParseTreeBelow(D_Parser *p, D_ParseNode *dpn) {
+ free_ParseTreeBelow((Parser*)p, DPN_TO_PN(dpn));
+ }
+
+ D_ParseNode *
+ ambiguity_count_fn(D_Parser *pp, int n, D_ParseNode **v) {
+ Parser *p = (Parser*)pp;
+ p->ambiguities += n - 1;
+ return v[0];
+ }
+
+ D_ParseNode *
+ ambiguity_abort_fn(D_Parser *pp, int n, D_ParseNode **v) {
+ int i;
+ if (verbose_level) {
+ for (i = 0; i < n; i++) {
+ print_paren(D_ParseNode_to_PNode(v[i]));
+ printf("\n");
+ }
+ }
+ d_fail("unresolved ambiguity line %d file %s", v[0]->start_loc.line,
+ v[0]->start_loc.pathname);
+ return v[0];
+ }
+
+ static int
+ final_actionless(PNode *pn) {
+ int i;
+ if (pn->reduction && pn->reduction->final_code)
+ return 0;
+ for (i = 0; i < pn->children.n; i++)
+ if (!final_actionless(pn->children.v[i]))
+ return 0;
+ return 1;
+ }
+
+ static PNode *
+ resolve_ambiguities(Parser *p, PNode *pn) {
+ PNode *amb;
+ D_ParseNode *res;
+ int efa;
+ Vec(D_ParseNode*) pns;
+
+ vec_clear(&pns);
+ efa = is_epsilon_PNode(pn) && final_actionless(pn);
+ vec_add(&pns, &pn->parse_node);
+ for (amb = pn->ambiguities; amb; amb = amb->ambiguities) {
+ if (!p->user.dont_merge_epsilon_trees)
+ if (efa && is_epsilon_PNode(amb) && final_actionless(amb))
+ continue;
+ vec_add(&pns, &amb->parse_node);
+ }
+ if (pns.n == 1) {
+ res = pns.v[0];
+ goto Ldone;
+ }
+ res = p->user.ambiguity_fn((D_Parser *)p, pns.n, pns.v);
+ Ldone:
+ vec_free(&pns);
+ return D_ParseNode_to_PNode(res);
+ }
+
+ static void
+ fixup_internal_symbol(Parser *p, PNode *pn, int ichild) {
+ PNode *child = pn->children.v[ichild];
+ int j, n, pnn;
+ n = child->children.n, pnn = pn->children.n;
+ if (pn == child)
+ d_fail("circular parse: unable to fixup internal symbol");
+ if (n == 0) {
+ for (j = ichild; j < pnn - 1; j++)
+ pn->children.v[j] = pn->children.v[j + 1];
+ pn->children.n--;
+ } else if (n == 1) {
+ ref_pn(child->children.v[0]);
+ pn->children.v[ichild] = child->children.v[0];
+ } else {
+ for (j = 0; j < n - 1; j++) /* expand children vector */
+ vec_add(&pn->children, NULL);
+ for (j = pnn - 1; j >= ichild + 1; j--) /* move to new places */
+ pn->children.v[j - 1 + n] = pn->children.v[j];
+ for (j = 0; j < n; j++) {
+ ref_pn(child->children.v[j]);
+ pn->children.v[ichild + j] = child->children.v[j];
+ }
+ }
+ unref_pn(p, child);
+ }
+
+ #define is_symbol_internal(_p, _pn) \
+ ((_p)->t->symbols[(_pn)->parse_node.symbol].kind == D_SYMBOL_INTERNAL)
+
+ static PNode *
+ commit_tree(Parser *p, PNode *pn) {
+ int i, n, fixup = 0, internal;
+
+ if (pn->evaluated)
+ return pn;
+ if (!is_unreduced_epsilon_PNode(pn))
+ pn->evaluated = 1;
+ if (pn->ambiguities)
+ pn = resolve_ambiguities(p, pn);
+ internal = is_symbol_internal(p, pn);
+ fixup = !p->user.dont_fixup_internal_productions && internal;
+ for (i = 0; i < pn->children.n; i++) {
+ pn->children.v[i] = commit_tree(p, pn->children.v[i]);
+ n = pn->children.v[i]->children.n;
+ if (fixup && is_symbol_internal(p, pn->children.v[i])) {
+ fixup_internal_symbol(p, pn, i);
+ i -= 1;
+ continue;
+ }
+ }
+ if (pn->reduction && pn->reduction->final_code)
+ pn->reduction->final_code(
+ pn, (void**)&pn->children.v[0], pn->children.n,
+ (int)&((PNode*)(NULL))->parse_node, (D_Parser*)p);
+ if (pn->evaluated) {
+ if (!p->user.save_parse_tree && !internal)
+ free_ParseTreeBelow(p, pn);
+ }
+ return pn;
+ }
+
+ static int
+ commit_stack(Parser *p, SNode *sn) {
+ int res = 0;
+ if (sn->zns.n != 1)
+ return -1;
+ if (sn->zns.v[0]->sns.n > 1)
+ return -2;
+ if (is_unreduced_epsilon_PNode(sn->zns.v[0]->pn)) /* wait till reduced */
+ return -3;
+ if (sn->zns.v[0]->sns.n)
+ if ((res = commit_stack(p, sn->zns.v[0]->sns.v[0])) < 0)
+ return res;
+ sn->zns.v[0]->pn = commit_tree(p, sn->zns.v[0]->pn);
+ return res;
+ }
+
+ static char *
+ find_substr(char *str, char *s) {
+ int len = strlen(s);
+ if (len == 1) {
+ while (*str && *str != *s) str++;
+ if (*str == *s)
+ return str + 1;
+ } else
+ while (*str) {
+ if (!strncmp(s, str, len))
+ return str + len;
+ str++;
+ }
+ return NULL;
+ }
+
+ static void
+ syntax_error_report_fn(struct D_Parser *p) {
+ char *fn = d_dup_pathname_str(p->loc.pathname);
+ fprintf(stderr, "syntax error, '%s' line %d\n", fn, p->loc.line);
+ FREE(fn);
+ }
+
+ static void
+ update_line(char *s, char *e, int *line) {
+ for (;s < e; s++) if (*s == '\n') (*line)++;
+ }
+
+ static int
+ error_recovery(Parser *p) {
+ SNode *sn, *best_sn = NULL;
+ char *best_s = NULL, *ss, *s;
+ int i, j, head = 0, tail = 0, res = 1;
+ D_ErrorRecoveryHint *best_er = NULL;
+ SNode **q = MALLOC(ERROR_RECOVERY_QUEUE_SIZE * sizeof(SNode*));
+ PNode *best_pn;
+
+ if (!p->snode_hash.last_all)
+ return res;
+ p->user.loc = p->snode_hash.last_all->loc;
+ if (!p->user.error_recovery)
+ return res;
+ if (p->user.loc.line > p->last_syntax_error_line) {
+ p->last_syntax_error_line = p->user.loc.line;
+ p->user.syntax_errors++;
+ p->user.syntax_error_fn((D_Parser*)p);
+ }
+ for (sn = p->snode_hash.last_all; sn; sn = sn->all_next) {
+ if (tail < ERROR_RECOVERY_QUEUE_SIZE - 1)
+ q[tail++] = sn;
+ }
+ s = p->snode_hash.last_all->loc.s;
+ while (tail > head) {
+ sn = q[head++];
+ if (sn->state->error_recovery_hints.n) {
+ for (i = 0; i < sn->state->error_recovery_hints.n; i++) {
+ D_ErrorRecoveryHint *er = &sn->state->error_recovery_hints.v[i];
+ if ((ss = find_substr(s, er->string))) {
+ if (!best_sn || ss < best_s ||
+ (best_sn && ss == best_s &&
+ (best_sn->depth < sn->depth ||
+ (best_sn->depth == sn->depth &&
+ best_er->depth < er->depth))))
+ {
+ best_sn = sn;
+ best_s = ss;
+ best_er = er;
+ }
+ }
+ }
+ }
+ for (i = 0; i < sn->zns.n; i++)
+ if (sn->zns.v[i])
+ for (j = 0; j < sn->zns.v[i]->sns.n; j++) {
+ if (tail < ERROR_RECOVERY_QUEUE_SIZE - 1)
+ q[tail++] = sn->zns.v[i]->sns.v[j];
+ }
+ }
+ if (best_sn) {
+ D_Reduction *rr = MALLOC(sizeof(*rr));
+ Reduction *r = MALLOC(sizeof(*r));
+ d_loc_t best_loc = p->user.loc;
+ PNode *new_pn;
+ SNode *new_sn;
+ ZNode *z;
+
+ memset(rr, 0, sizeof(*rr));
+ vec_add(&p->error_reductions, rr);
+ rr->nelements = best_er->depth + 1;
+ rr->symbol = best_er->symbol;
+ update_line(best_loc.s, best_s, &best_loc.line);
+ best_loc.s = best_s;
+ best_pn = best_sn->zns.v[0]->pn;
+ best_pn->parse_node.white_space(
+ (D_Parser*)p, &best_loc, (void**)&best_pn->parse_node.globals);
+ ref_sn(best_sn);
+ new_pn = add_PNode(p, 0, &p->user.loc, best_loc.s, best_pn, 0, 0, 0);
+ new_sn = new_SNode(p, best_sn->state, &best_loc, new_pn->initial_scope, new_pn->initial_globals);
+ new_sn->last_pn = new_pn;
+ set_add_znode(&new_sn->zns, (z = new_ZNode(p, new_pn)));
+ ref_pn(new_pn);
+ vec_add(&z->sns, best_sn);
+ r->znode = z;
+ r->snode = new_sn;
+ ref_sn(best_sn);
+ r->reduction = rr;
+ r->new_snode = NULL;
+ r->next = NULL;
+ free_old_nodes(p);
+ reduce_one(p, r);
+ for (i = 0; i < p->t->nstates; i++)
+ for (sn = p->snode_hash.v[i]; sn; sn = sn->bucket_next)
+ for (j = 0; j < sn->zns.n; j++)
+ if ((z = sn->zns.v[j]))
+ if (z->pn->reduction == rr) {
+ z->pn->evaluated = 1;
+ z->pn->error_recovery = 1;
+ }
+ if (p->shifts_todo || p->reductions_todo)
+ res = 0;
+ }
+ FREE(q);
+ return res;
+ }
+
+ #define PASS_CODE_FOUND(_p, _pn) ((_pn)->reduction && (_pn)->reduction->npass_code > (_p)->index && \
+ (_pn)->reduction->pass_code[(_p)->index])
+
+ static void
+ pass_call(Parser *p, D_Pass *pp, PNode *pn) {
+ if (PASS_CODE_FOUND(pp, pn))
+ pn->reduction->pass_code[pp->index](
+ pn, (void**)&pn->children.v[0], pn->children.n,
+ (int)&((PNode*)(NULL))->parse_node, (D_Parser*)p);
+ }
+
+ static void
+ pass_preorder(Parser *p, D_Pass *pp, PNode *pn) {
+ int found = PASS_CODE_FOUND(pp, pn), i;
+ pass_call(p, pp, pn);
+ if ((pp->kind & D_PASS_FOR_ALL) ||
+ ((pp->kind & D_PASS_FOR_UNDEFINED) && !found))
+ for (i = 0; i < pn->children.n; i++)
+ pass_preorder(p, pp, pn->children.v[i]);
+ }
+
+ static void
+ pass_postorder(Parser *p, D_Pass *pp, PNode *pn) {
+ int found = PASS_CODE_FOUND(pp, pn), i;
+ if ((pp->kind & D_PASS_FOR_ALL) ||
+ ((pp->kind & D_PASS_FOR_UNDEFINED) && !found))
+ for (i = 0; i < pn->children.n; i++)
+ pass_postorder(p, pp, pn->children.v[i]);
+ pass_call(p, pp, pn);
+ }
+
+ void
+ d_pass(D_Parser *ap, D_ParseNode *apn, int pass_number) {
+ PNode *pn = D_ParseNode_to_PNode(apn);
+ Parser *p = (Parser*)ap;
+ D_Pass *pp;
+
+ if (pass_number >= p->t->npasses)
+ d_fail("bad pass number: %d\n", pass_number);
+ pp = &p->t->passes[pass_number];
+ if (pp->kind & D_PASS_MANUAL)
+ pass_call(p, pp, pn);
+ else if (pp->kind & D_PASS_PRE_ORDER)
+ pass_preorder(p, pp, pn);
+ else if (pp->kind & D_PASS_POST_ORDER)
+ pass_postorder(p, pp, pn);
+ }
+
+ static int
+ exhaustive_parse(Parser *p, int state) {
+ Reduction *r;
+ Shift *s;
+ char *pos, *epos = NULL;
+ PNode *pn, tpn;
+ SNode *sn;
+ ZNode *z;
+ int progress = 0, ready = 0;
+ d_loc_t loc;
+
+ pos = p->user.loc.s = p->start;
+ loc = p->user.loc;
+ p->user.initial_white_space_fn((D_Parser*)p, &loc, &p->user.initial_globals);
+ /* initial state */
+ sn = add_SNode(p, &p->t->state[state], &loc, p->top_scope, p->user.initial_globals);
+ memset(&tpn, 0, sizeof(tpn));
+ tpn.parse_node.white_space = p->user.initial_white_space_fn;
+ tpn.parse_node.globals = p->user.initial_globals;
+ tpn.initial_scope = tpn.parse_node.scope = p->top_scope;
+ tpn.parse_node.end = loc.s;
+ pn = add_PNode(p, 0, &loc, loc.s, &tpn, 0, 0, 0);
+ sn->last_pn = pn;
+ set_add_znode(&sn->zns, (z = new_ZNode(p, pn)));
+ ref_pn(pn);
+ while (1) {
+ /* reduce all */
+ while (p->reductions_todo) {
+ pos = p->reductions_todo->snode->loc.s;
+ if (p->shifts_todo && p->shifts_todo->snode->loc.s < pos)
+ break;
+ if (pos > epos) {
+ epos = pos;
+ free_old_nodes(p);
+ }
+ for (;(r = p->reductions_todo) && r->snode->loc.s == pos;) {
+ p->reductions_todo = p->reductions_todo->next;
+ reduce_one(p, r);
+ }
+ }
+ /* done? */
+ if (!p->shifts_todo) {
+ if (p->accept &&
+ (p->accept->loc.s == p->end || p->user.partial_parses))
+ return 0;
+ else {
+ if (error_recovery(p))
+ return 1;
+ continue;
+ }
+ } else if (!p->user.dont_compare_stacks && p->shifts_todo->next)
+ cmp_stacks(p);
+ /* shift all */
+ pos = p->shifts_todo->snode->loc.s;
+ if (pos > epos) {
+ epos = pos;
+ free_old_nodes(p);
+ }
+ progress++;
+ ready = progress > p->user.commit_actions_interval;
+ if (ready && !p->shifts_todo->next) {
+ commit_stack(p, p->shifts_todo->snode);
+ ready = progress = 0;
+ }
+ for (; (s = p->shifts_todo) && s->snode->loc.s == pos;) {
+ p->shifts_todo = p->shifts_todo->next;
+ shift_one(p, s);
+ }
+ if (ready && p->reductions_todo && !p->reductions_todo->next) {
+ commit_stack(p, p->reductions_todo->snode);
+ progress = 0;
+ }
+ }
+ }
+
+ /* doesn't include nl */
+ char _wspace[256] = {
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 0 /* zero padded */
+ };
+
+ #define wspace(_x) (_wspace[(unsigned char)_x])
+
+ static void
+ white_space(D_Parser *p, d_loc_t *loc, void **p_user_globals) {
+ int rec = 0;
+ char *s = loc->s, *scol;
+
+ if (p->loc.s == s)
+ scol = s;
+ else
+ scol = 0;
+ if (*s == '#' && loc->previous_col == 0) {
+ Ldirective:
+ {
+ char *save = s;
+ s++;
+ while (wspace(*s)) s++;
+ if (!strncmp("line", s, 4)) {
+ if (wspace(s[4])) {
+ s += 5;
+ while (wspace(*s)) s++;
+ }
+ }
+ if (isdigit(*s)) {
+ loc->line = atoi(s) - 1;
+ while (isdigit(*s)) s++;
+ while (wspace(*s)) s++;
+ if (*s == '"')
+ loc->pathname = s;
+ } else {
+ s = save;
+ goto Ldone;
+ }
+ }
+ while (*s && *s != '\n') s++;
+ }
+ Lmore:
+ while (wspace(*s)) s++;
+ if (*s == '\n') {
+ loc->line++;
+ scol = s + 1;
+ s++;
+ if (*s == '#')
+ goto Ldirective;
+ else
+ goto Lmore;
+ }
+ if (s[0] == '/') {
+ if (s[1] == '/') {
+ while (*s && *s != '\n') { s++; }
+ loc->line++;
+ s++;
+ goto Lmore;
+ }
+ if (s[1] == '*') {
+ s += 2;
+ LnestComment:
+ rec++;
+ LmoreComment:
+ while (*s) {
+ if (s[0] == '*' && s[1] == '/') {
+ s += 2;
+ rec--;
+ if (!rec)
+ goto Lmore;
+ goto LmoreComment;
+ }
+ if (s[0] == '/' && s[1] == '*') {
+ s += 2;
+ goto LnestComment;
+ }
+ if (*s == '\n') {
+ loc->line++;
+ scol = s + 1;
+ }
+ s++;
+ }
+ }
+ }
+ Ldone:
+ if (scol)
+ loc->col = s - scol;
+ else
+ loc->col = -1;
+ loc->s = s;
+ return;
+ }
+
+ void null_white_space(D_Parser *p, d_loc_t *loc, void **p_globals) { }
+
+ D_Parser *
+ new_D_Parser(D_ParserTables *t, int sizeof_ParseNode_User) {
+ Parser *p = MALLOC(sizeof(Parser));
+ memset(p, 0, sizeof(Parser));
+ p->t = t;
+ p->user.loc.line = 1;
+ p->user.sizeof_user_parse_node = sizeof_ParseNode_User;
+ p->user.commit_actions_interval = DEFAULT_COMMIT_ACTIONS_INTERVAL;
+ p->user.syntax_error_fn = syntax_error_report_fn;
+ p->user.ambiguity_fn = ambiguity_abort_fn;
+ p->user.error_recovery = 1;
+ p->user.save_parse_tree = t->save_parse_tree;
+ if (p->t->default_white_space)
+ p->user.initial_white_space_fn = p->t->default_white_space;
+ else if (p->t->whitespace_state)
+ p->user.initial_white_space_fn = parse_whitespace;
+ else
+ p->user.initial_white_space_fn = white_space;
+ return (D_Parser*)p;
+ }
+
+ void
+ free_D_Parser(D_Parser *ap) {
+ Parser *p = (Parser *)ap;
+ if (p->top_scope && !p->user.initial_scope)
+ free_D_Scope(p->top_scope, 0);
+ if (p->whitespace_parser)
+ free_D_Parser((D_Parser*)p->whitespace_parser);
+ FREE(ap);
+ }
+
+ void
+ free_D_ParseNode(D_Parser * p, D_ParseNode *dpn) {
+ if (dpn != NO_DPN) {
+ unref_pn((Parser*)p, DPN_TO_PN(dpn));
+ free_parser_working_data((Parser*)p);
+ }
+ #ifdef TRACK_PNODES
+ if (((Parser*)p)->xall)
+ printf("tracked pnodes\n");
+ #endif
+ }
+
+ Parser *
+ new_subparser(Parser *p) {
+ Parser * pp = (Parser *)new_D_Parser(p->t, p->user.sizeof_user_parse_node);
+ pp->end = p->end;
+ pp->pinterface1 = p->pinterface1;
+ alloc_parser_working_data(pp);
+ return pp;
+ }
+
+ static void
+ initialize_whitespace_parser(Parser *p) {
+ if (p->t->whitespace_state) {
+ p->whitespace_parser = new_subparser(p);
+ p->whitespace_parser->user.initial_white_space_fn = null_white_space;
+ p->whitespace_parser->user.error_recovery = 0;
+ p->whitespace_parser->user.partial_parses = 1;
+ }
+ }
+
+ D_ParseNode *
+ dparse(D_Parser *ap, char *buf, int buf_len) {
+ int r;
+ Parser *p = (Parser *)ap;
+ SNode *ps;
+ PNode *pn;
+ D_ParseNode *res = NULL;
+
+ p->states = p->scans = p->shifts = p->reductions = p->compares = 0;
+ p->start = buf;
+ p->end = buf + buf_len;
+
+ initialize_whitespace_parser(p);
+ alloc_parser_working_data(p);
+ if (p->user.initial_scope)
+ p->top_scope = p->user.initial_scope;
+ else {
+ if (p->top_scope)
+ free_D_Scope(p->top_scope, 0);
+ p->top_scope = new_D_Scope(NULL);
+ p->top_scope->kind = SCOPE_SEQUENTIAL;
+ }
+ r = exhaustive_parse(p, p->user.start_state);
+ if (!r) {
+ ps = p->accept;
+ if (ps->zns.n != 1 || ps->zns.v[0]->pn->children.n != 1)
+ d_fail("internal error: bad final reduction");
+ pn = ps->zns.v[0]->pn->latest->children.v[0];
+ pn = commit_tree(p, pn);
+ if (verbose_level) {
+ printf(
+ "%d states %d scans %d shifts %d reductions "
+ "%d compares %d ambiguities\n",
+ p->states, p->scans, p->shifts, p->reductions,
+ p->compares, p->ambiguities);
+ if (p->user.save_parse_tree) {
+ if (verbose_level > 1)
+ xprint_paren(p, pn);
+ else
+ print_paren(pn);
+ printf("\n");
+ }
+ }
+ if (p->user.save_parse_tree) {
+ ref_pn(pn);
+ res = &pn->parse_node;
+ } else
+ res = NO_DPN;
+ unref_sn(p, p->accept);
+ p->accept = NULL;
+ } else
+ p->accept = NULL;
+ free_parser_working_data(p);
+ return res;
+ }
+
Index: llvm/test/Programs/MultiSource/Applications/d/parse.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/parse.h:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/parse.h Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,151 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+ #ifndef _parse_H_
+ #define _parse_H_
+
+ #define NO_DPN ((D_ParseNode*)0x1)
+ #define DPN_TO_PN(_dpn) \
+ ((PNode *)(((char*)dpn)-(int)(&((PNode*)0)->parse_node)))
+ #define is_epsilon_PNode(_pn) \
+ ((_pn)->parse_node.start_loc.s == (_pn)->parse_node.end)
+
+ /* #define TRACK_PNODES 1 */
+
+ struct PNode;
+ struct SNode;
+ struct ZNode;
+ struct Parser;
+
+ typedef Vec(struct ZNode*) VecZNode;
+ typedef Vec(VecZNode *) VecVecZNode;
+ typedef Vec(struct SNode*) VecSNode;
+ typedef Vec(struct PNode*) VecPNode;
+
+ typedef struct PNodeHash {
+ struct PNode **v;
+ uint i; /* size index (power of 2) */
+ uint m; /* max size (highest prime < i ** 2) */
+ uint n; /* size */
+ struct PNode *all;
+ } PNodeHash;
+
+ typedef struct SNodeHash {
+ struct SNode **v;
+ uint i; /* size index (power of 2) */
+ uint m; /* max size (highest prime < i ** 2) */
+ uint n; /* size */
+ struct SNode *all;
+ struct SNode *last_all;
+ } SNodeHash;
+
+ typedef struct Reduction {
+ struct ZNode *znode;
+ struct SNode *snode;
+ struct D_Reduction *reduction;
+ struct SNode *new_snode;
+ int new_depth;
+ struct Reduction *next;
+ } Reduction;
+
+ typedef struct Shift {
+ struct SNode *snode;
+ struct Shift *next;
+ } Shift;
+
+ typedef struct Parser {
+ D_Parser user;
+ /* string to parse */
+ char *start, *end;
+ struct D_ParserTables *t;
+ /* statistics */
+ int states, pnodes, scans, shifts, reductions, compares, ambiguities;
+ /* parser state */
+ PNodeHash pnode_hash;
+ SNodeHash snode_hash;
+ Reduction *reductions_todo;
+ Shift *shifts_todo;
+ D_Scope *top_scope;
+ struct SNode *accept;
+ int last_syntax_error_line;
+ /* memory management */
+ Reduction *free_reductions;
+ Shift *free_shifts;
+ int live_pnodes;
+ struct PNode *free_pnodes;
+ struct SNode *free_snodes;
+ struct ZNode *free_znodes;
+ Vec(D_Reduction *) error_reductions;
+ ShiftResult *shift_results;
+ D_Shift code_shift;
+ /* comments */
+ struct Parser *whitespace_parser;
+ /* interface support */
+ void *pinterface1;
+ #ifdef TRACK_PNODES
+ struct PNode *xall;
+ #endif
+ } Parser;
+
+ /*
+ Parse Node - the 'symbol' and the constructed parse subtrees.
+ */
+ typedef struct PNode {
+ AssocKind assoc;
+ int priority;
+ AssocKind op_assoc;
+ int op_priority;
+ D_Reduction *reduction;
+ D_Shift *shift;
+ #ifndef USE_GC
+ uint32 refcount;
+ #endif
+ VecPNode children;
+ uint height; /* max tree height */
+ uint8 evaluated;
+ uint8 error_recovery;
+ struct PNode *all_next;
+ struct PNode *bucket_next;
+ struct PNode *ambiguities;
+ struct PNode *latest; /* latest version of this PNode */
+ char *ws_before;
+ char *ws_after;
+ D_Scope *initial_scope;
+ void *initial_globals;
+ D_ParseNode parse_node; /* public fields */
+ #ifdef TRACK_PNODES
+ struct PNode *xnext;
+ struct PNode *xprev;
+ #endif
+ } PNode;
+
+ /*
+ State Node - the 'state'.
+ */
+ typedef struct SNode {
+ D_State *state;
+ D_Scope *initial_scope;
+ void *initial_globals;
+ d_loc_t loc;
+ uint depth; /* max stack depth (less loops) */
+ PNode *last_pn;
+ VecZNode zns;
+ #ifndef USE_GC
+ uint32 refcount;
+ #endif
+ struct SNode *bucket_next;
+ struct SNode *all_next;
+ } SNode;
+
+ /*
+ (Z)Symbol Node - holds one of the symbols associated with a state.
+ */
+ typedef struct ZNode {
+ PNode *pn;
+ VecSNode sns;
+ } ZNode;
+ #define znode_next(_z) (*(ZNode**)&((_z)->pn))
+
+ D_ParseNode * ambiguity_count_fn(D_Parser *pp, int n, D_ParseNode **v);
+
+ #endif
Index: llvm/test/Programs/MultiSource/Applications/d/parser_tests
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/parser_tests:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/parser_tests Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,39 ----
+ #!/bin/tcsh
+
+ cp BUILD_VERSION Makefile *.c *.h tests
+ cd tests
+ $MAKE -s make_dparser
+ set failed = 0
+ foreach g (*.test.g)
+ rm -f sample_parser
+ if (-e $g.flags) then
+ set flags = `cat $g.flags`
+ else
+ set flags =
+ endif
+ ./make_dparser $flags $g
+ $MAKE -s sample_parser SAMPLE_GRAMMAR=$g:t
+ foreach t ( $g.[0-9] $g.[0-9][0-9] )
+ if (-e $t.flags) then
+ set flags = `cat $t.flags`
+ else
+ set flags =
+ endif
+ ./sample_parser $flags -v $t >&! $t.out
+ diff $t.out $t.check
+ if ($?) then
+ echo $t "******** FAILED ********"
+ set failed = `expr $failed + 1`
+ else
+ echo $t "PASSED"
+ endif
+ end
+ end
+ echo "---------------------------------------"
+ if (! $failed) then
+ echo "ALL tests PASSED"
+ else
+ echo "********" $failed "test(s) FAILED *********"
+ endif
+ rm -f sample_parser BUILD_VERSION Makefile *.c *.h *.o make_dparser libdparse.a
+ cd ..
Index: llvm/test/Programs/MultiSource/Applications/d/sample.g.d_parser.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/sample.g.d_parser.h:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/sample.g.d_parser.h Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,20 ----
+ #ifndef _gram_h
+ #define _gram_h
+ #define D_SYMBOL_program 2
+ #define D_SYMBOL_statement 4
+ #define D_SYMBOL_definition 5
+ #define D_SYMBOL_external 6
+ #define D_SYMBOL_external_type 11
+ #define D_SYMBOL_expression 12
+ #define D_SYMBOL_constant 17
+ #define D_SYMBOL_strings 18
+ #define D_SYMBOL_binary_operator 20
+ #define D_SYMBOL_pre_operator 21
+ #define D_SYMBOL_post_operator 22
+ #define D_SYMBOL_builtin_types 23
+ #define D_SYMBOL_character 24
+ #define D_SYMBOL_string 25
+ #define D_SYMBOL_integer 26
+ #define D_SYMBOL_float 27
+ #define D_SYMBOL_identifier 28
+ #endif
Index: llvm/test/Programs/MultiSource/Applications/d/scan.c
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/scan.c:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/scan.c Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,152 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+
+ #include "d.h"
+
+ int
+ scan_buffer(d_loc_t *loc, D_State *parse_state, ShiftResult *results) {
+ char *s = loc->s, *scol = 0;
+ int col = loc->col, collast = col, line = loc->line;
+ int nresults = 0, i, j;
+ D_Shift **shift = NULL;
+
+ if (parse_state->scan_kind != D_SCAN_LONGEST) {
+ /* all matches */
+ SB_uint8 *st = (SB_uint8*)parse_state->scanner_table;
+ SB_trans_uint8 *tst = (SB_trans_uint8*)parse_state->transition_table;
+ uint8 state = 0, last = state;
+ uint8 c;
+ uint32 sb, so;
+ c = (uint8)*s++;
+ while ((state = st[state].scanner_block[(sb = (c >> SCANNER_BLOCK_SHIFT))]
+ [(so = c & SCANNER_BLOCK_MASK)]))
+ {
+ state -= 1;
+ if (st[state].shift) {
+ last = state;
+ loc->s = s; collast = col; loc->line = line;
+ shift = parse_state->accepts_diff[tst[state].scanner_block[sb][so]];
+ for (; *shift; shift++) {
+ results[nresults].loc = *loc;
+ results[nresults++].shift = *shift;
+ }
+ }
+ if (c == '\n') { line++; col = 0; scol = s; } else col++;
+ c = (uint8)*s++;
+ }
+ loc->col = scol ? s - scol : -1;
+ shift = st[last].shift;
+ if (shift) {
+ loc->line = line;
+ for (; *shift; shift++) {
+ results[nresults].loc = *loc;
+ results[nresults++].shift = *shift;
+ }
+ }
+ if (nresults && parse_state->scan_kind == D_SCAN_MIXED) {
+ char *end = results[nresults-1].loc.s;
+ int longest = 0;
+ for (i = nresults - 1; i >= 0; i--) {
+ if (results[i].shift->shift_kind == D_SCAN_LONGEST)
+ longest = 1;
+ if (results[i].loc.s < end)
+ break;
+ }
+ if (!longest) {
+ /* only keep non-longest */
+ for (j = i; j >= 0; j--)
+ if (results[j].shift->shift_kind != D_SCAN_LONGEST) {
+ if (i != j)
+ results[i] = results[j];
+ i--;
+ }
+ nresults = nresults - i - 1;
+ if (i != -1)
+ memmove(&results[0], &results[i + 1], nresults * sizeof(results[0]));
+ } else {
+ /* keep only 'longest' */
+ i = 0;
+ for (j = 0; j < nresults; j++)
+ if (results[j].loc.s == end) {
+ if (i != j)
+ results[i] = results[j];
+ i++;
+ }
+ nresults = i;
+ }
+ }
+ return nresults;
+ } else {
+ /* longest match only */
+ switch (parse_state->scanner_size) {
+ case 1: {
+ SB_uint8 *st = (SB_uint8*)parse_state->scanner_table;
+ uint8 state = 0, last = state;
+ uint8 c;
+ c = (uint8)*s++;
+ while ((state = st[state].scanner_block[c >> SCANNER_BLOCK_SHIFT]
+ [c & SCANNER_BLOCK_MASK]))
+ {
+ state -= 1;
+ if (st[state].shift) {
+ last = state;
+ loc->s = s; collast = col; loc->line = line;
+ }
+ if (c == '\n') { line++; col = 0; scol = s; } else col++;
+ c = (uint8)*s++;
+ }
+ shift = st[last].shift;
+ break;
+ }
+ case 2: {
+ SB_uint16 *st = (SB_uint16*)parse_state->scanner_table;
+ uint16 state = 0, last = state;
+ uint8 c;
+ c = (uint8)*s++;
+ while ((state = st[state].scanner_block[c >> SCANNER_BLOCK_SHIFT]
+ [c & SCANNER_BLOCK_MASK]))
+ {
+ state -= 1;
+ if (st[state].shift) {
+ last = state;
+ loc->s = s; collast = col; loc->line = line;
+ }
+ if (c == '\n') { line++; col = 0; scol = s; } else col++;
+ c = (uint8)*s++;
+ }
+ shift = st[last].shift;
+ break;
+ }
+ case 4: {
+ SB_uint32 *st = (SB_uint32*)parse_state->scanner_table;
+ uint32 state = 0, last = state;
+ uint8 c;
+ c = (uint8)*s++;
+ while ((state = st[state].scanner_block[c >> SCANNER_BLOCK_SHIFT]
+ [c & SCANNER_BLOCK_MASK]))
+ {
+ state -= 1;
+ if (st[state].shift) {
+ last = state;
+ loc->s = s; collast = col; loc->line = line;
+ }
+ if (c == '\n') { line++; col = 0; scol = s; } else col++;
+ c = (uint8)*s++;
+ }
+ shift = st[last].shift;
+ break;
+ }
+ }
+ loc->col = scol ? s - scol : -1;
+ if (shift) {
+ loc->line = line;
+ for (; *shift; shift++) {
+ results[nresults].loc = *loc;
+ results[nresults++].shift = *shift;
+ }
+ }
+ return nresults;
+ }
+ }
+
Index: llvm/test/Programs/MultiSource/Applications/d/scan.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/scan.h:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/scan.h Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,17 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+
+ #ifndef _scan_H_
+ #define _scan_H_
+
+ #include "d.h"
+
+ typedef struct ShiftResult {
+ D_Shift *shift;
+ d_loc_t loc;
+ } ShiftResult;
+
+ int scan_buffer(d_loc_t *loc, D_State *st, ShiftResult *result);
+
+ #endif
Index: llvm/test/Programs/MultiSource/Applications/d/symtab.c
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/symtab.c:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/symtab.c Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,324 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+ #include "d.h"
+
+ #define INITIAL_SYMHASH_SIZE 3137
+
+ typedef struct D_SymHash {
+ int index;
+ int grow;
+ Vec(D_Sym*) syms;
+ } D_SymHash;
+
+ /*
+ How this works. In a normal symbol table there is simply
+ a stack of scopes representing the scoping structure of
+ the program. Because of speculative parsing, this symbol table
+ also has a tree of all 'updates' representing different
+ views of the state of scoped variables by each speculative
+ parse state. Periodically, when the parse state collapses
+ to a single state (we are nolonger speculating), these changes
+ are can be 'committed' and the changes pushed into the top
+ level hash table.
+
+ All D_Scope's except the top level just have a 'll' of symbols, the
+ top level has a 'hash'.
+
+ 'updates' is a list of changes to symbols in other scopes. It is
+ searched to find the current version of a symbol with respect to the
+ speculative parse path represented by D_Scope.
+
+ 'up' points to the enclosing scope, it isn't used much.
+
+ 'up_updates' is the prior scope in speculative parsing, it is used find
+ the next D_Scope to look in for 'updates' after the current one has been
+ searched.
+
+ 'down' and 'down_next' are used to hold enclosing scopes, or in the
+ case of the top level, sibling scopes (created by commmit).
+ */
+
+
+ static void
+ symhash_add(D_SymHash *sh, D_Sym *s) {
+ uint i, h = s->hash % sh->syms.n, n;
+ D_Sym **v = sh->syms.v, *x;
+ Vec(D_Sym*) vv, tv;
+
+ sh->index++;
+ s->next = v[h];
+ v[h] = s;
+
+ if (sh->index > sh->grow) {
+ vv.v = sh->syms.v;
+ vv.n = sh->syms.n;
+ sh->syms.n = sh->grow;
+ sh->grow = sh->grow * 2 + 1;
+ sh->syms.v = MALLOC(sh->syms.n * sizeof(void *));
+ memset(sh->syms.v, 0, sh->syms.n * sizeof(void *));
+ v = sh->syms.v;
+ n = sh->syms.n;
+ vec_clear(&tv);
+ for (i = 0; i < vv.n; i++)
+ /* use temporary to preserve order */
+ while (vv.v[i]) {
+ x = vv.v[i];
+ vv.v[i] = x->next;
+ vec_add(&tv, x);
+ }
+ while (tv.v[i]) {
+ x = tv.v[i];
+ tv.v[i] = x->next;
+ h = x->hash % n;
+ x->next = v[h];
+ v[h] = x;
+ }
+ FREE(vv.v);
+ }
+ }
+
+ static D_SymHash *
+ new_D_SymHash() {
+ D_SymHash *sh = MALLOC(sizeof(D_SymHash));
+ memset(sh, 0, sizeof(D_SymHash));
+ sh->grow = INITIAL_SYMHASH_SIZE * 2 + 1;
+ sh->syms.n = INITIAL_SYMHASH_SIZE;
+ sh->syms.v = MALLOC(sh->syms.n * sizeof(void *));
+ memset(sh->syms.v, 0, sh->syms.n * sizeof(void *));
+ return sh;
+ }
+
+ static void
+ free_D_SymHash(D_SymHash *sh) {
+ int i;
+ D_Sym *sym;
+ for (i = 0; i < sh->syms.n; i++)
+ for (; sh->syms.v[i]; sh->syms.v[i] = sym) {
+ sym = sh->syms.v[i]->next;
+ free_D_Sym(sh->syms.v[i]);
+ }
+ FREE(sh->syms.v);
+ FREE(sh);
+ }
+
+ D_Scope *
+ new_D_Scope(D_Scope *parent) {
+ D_Scope *st = MALLOC(sizeof(D_Scope));
+ memset(st, 0, sizeof(D_Scope));
+ if (parent) {
+ st->kind = parent->kind;
+ st->search = parent;
+ st->up = parent;
+ st->up_updates = parent;
+ st->down_next = parent->down;
+ parent->down = st;
+ } else
+ st->hash = new_D_SymHash();
+ return st;
+ }
+
+ D_Scope *
+ enter_D_Scope(D_Scope *current, D_Scope *scope) {
+ D_Scope *st = MALLOC(sizeof(D_Scope)), *parent = scope->up;
+ memset(st, 0, sizeof(D_Scope));
+ st->up = parent;
+ st->kind = scope->kind;
+ st->search = scope;
+ st->up_updates = current;
+ st->down_next = current->down;
+ current->down = st;
+ return st;
+ }
+
+ void
+ free_D_Scope(D_Scope *st, int force) {
+ D_Scope *s;
+ D_Sym *sym;
+ for (; st->down; st->down = s) {
+ s = st->down->down_next;
+ free_D_Scope(st->down, 0);
+ }
+ if (st->owned_by_user && !force)
+ return;
+ if (st->hash)
+ free_D_SymHash(st->hash);
+ else
+ for (; st->ll; st->ll = sym) {
+ sym = st->ll->next;
+ free_D_Sym(st->ll);
+ }
+ for (; st->updates; st->updates = sym) {
+ sym = st->updates->next;
+ free_D_Sym(st->updates);
+ }
+ FREE(st);
+ }
+
+ static void
+ commit_ll(D_Scope *st, D_SymHash *sh) {
+ D_Sym *sym;
+ if (st->search) {
+ commit_ll(st->search, sh);
+ for (; st->ll; st->ll = sym) {
+ sym = st->ll->next;
+ symhash_add(sh, st->ll);
+ }
+ }
+ }
+
+ /* make direct links to the latest update */
+ static void
+ commit_update(D_Scope *st, D_SymHash *sh) {
+ int i;
+ D_Sym *s;
+
+ for (i = 0; i < sh->syms.n; i++)
+ for (s = sh->syms.v[i]; s; s = s->next)
+ s->update_of = current_D_Sym(st, s);
+ }
+
+ /* currently only commit the top level scope */
+ D_Scope *
+ commit_D_Scope(D_Scope *st) {
+ D_Scope *x = st;
+ if (st->up)
+ return st;
+ while (x->search) x = x->search;
+ commit_ll(st, x->hash);
+ commit_update(st, x->hash);
+ return x;
+ }
+
+ D_Sym *
+ new_D_Sym(D_Scope *st, char *name, char *end, int sizeof_D_Sym) {
+ int len = end - name;
+ D_Sym *s = MALLOC(sizeof_D_Sym);
+ memset(s, 0, sizeof_D_Sym);
+ s->name = name;
+ s->len = len;
+ s->hash = strhashl(name, len);
+ if (st->hash) {
+ symhash_add(st->hash, s);
+ } else {
+ s->next = st->ll;
+ st->ll = s;
+ }
+ return s;
+ }
+
+ void
+ free_D_Sym(D_Sym *s) {
+ FREE(s);
+ }
+
+ D_Sym *
+ current_D_Sym(D_Scope *st, D_Sym *sym) {
+ D_Scope *sc;
+ D_Sym *uu;
+
+ if (sym->update_of) sym = sym->update_of;
+ /* return the last update */
+ for (sc = st; sc; sc = sc->up_updates) {
+ for (uu = sc->updates; uu; uu = uu->next)
+ if (uu->update_of == sym)
+ return uu;
+ }
+ return sym;
+ }
+
+ D_Sym *
+ find_sym_internal(D_Scope *top, D_Scope *cur, char *name, int len, uint h) {
+ D_Sym *ll;
+
+ if (!cur)
+ return NULL;
+ if (cur->hash)
+ ll = cur->hash->syms.v[h % cur->hash->syms.n];
+ else
+ ll = cur->ll;
+ while (ll) {
+ if (ll->hash == h && ll->len == len && !strncmp(ll->name, name, len))
+ break;
+ ll = ll->next;
+ }
+ if (!ll) {
+ if (cur->search)
+ return find_sym_internal(top, cur->search, name, len, h);
+ return ll;
+ }
+ return current_D_Sym(top, ll);
+ }
+
+ D_Sym *
+ find_D_Sym(D_Scope *st, char *name, char *end) {
+ int len = end - name;
+ uint h = strhashl(name, len);
+ return find_sym_internal(st, st, name, len, h);
+ }
+
+ D_Sym *
+ find_D_Sym_in_Scope(D_Scope *st, char *name, char *end) {
+ D_Sym *ll;
+ int len = end - name;
+ uint h = strhashl(name, len);
+ for (;st ; st = st->search) {
+ if (st->hash)
+ ll = st->hash->syms.v[h % st->hash->syms.n];
+ else
+ ll = st->ll;
+ while (ll) {
+ if (ll->hash == h && ll->len == len && !strncmp(ll->name, name, len))
+ return ll;
+ ll = ll->next;
+ }
+ if (!st->search || st->search->up != st->up)
+ break;
+ }
+ return NULL;
+ }
+
+ D_Sym *
+ update_D_Sym(D_Scope *st, D_Sym *sym, int sizeof_D_Sym) {
+ D_Sym *s;
+
+ sym = current_D_Sym(st, sym);
+ s = MALLOC(sizeof_D_Sym);
+ memcpy(s, sym, sizeof(D_Sym));
+ if (sym->update_of) sym = sym->update_of;
+ s->update_of = sym;
+ s->next = st->updates;
+ st->updates = s;
+ return s;
+ }
+
+ void
+ print_sym(D_Sym *s) {
+ char *c = (char*)MALLOC(s->len + 1);
+ memcpy(c, s->name, s->len);
+ s->name[s->len] = 0;
+ printf("%s, ", c);
+ FREE(c);
+ }
+
+ void
+ print_scope(D_Scope *st) {
+ printf("SCOPE %X: ", (int)st);
+ printf(" owned: %d, kind: %d, ", st->owned_by_user, st->kind);
+ if (st->ll) printf(" LL\n");
+ if (st->hash) printf(" HASH\n");
+ if (st->hash) {
+ int i;
+ for (i = 0; i < st->hash->syms.n; i++)
+ if (st->hash->syms.v[i])
+ print_sym(st->hash->syms.v[i]);
+ } else {
+ D_Sym *ll = st->ll;
+ while (ll) {
+ print_sym(ll);
+ ll = ll->next;
+ }
+ }
+ printf("\n\n");
+ if (st->search) print_scope(st->search);
+ }
Index: llvm/test/Programs/MultiSource/Applications/d/util.c
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/util.c:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/util.c Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,365 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+
+ #include "d.h"
+
+ uint prime2[] = {
+ 1, 3, 7, 13, 31, 61, 127, 251, 509, 1021, 2039, 4093, 8191,
+ 16381, 32749, 65521, 131071, 262139, 524287, 1048573, 2097143,
+ 4194301, 8388593, 16777213, 33554393, 67108859, 134217689,
+ 268435399, 536870909
+ };
+
+ int verbose_level = 0;
+ int debug_level = 0;
+ int test_level = 0;
+
+ char *
+ d_dup_pathname_str(char *s) {
+ char *e = s;
+ if (!s)
+ return strdup("");
+ if (*e == '"') {
+ e++; while (*e && *e != '"') e++;
+ return dup_str(s + 1, e);
+ } else
+ return dup_str(s, s+strlen(s));
+ }
+
+ char *
+ dup_str(char *s, char *e) {
+ int l = e-s;
+ char *ss = (char*)MALLOC(l+1);
+ memcpy(ss, s, l);
+ ss[l] = 0;
+ return ss;
+ }
+
+ uint
+ strhashl(char *s, int l) {
+ uint h = 0, g;
+ int i = 0;
+
+ for (;i < l;i++,s++) {
+ h = (h << 4) + *s;
+ if ((g = h & 0xf0000000))
+ h = (h ^ (g >> 24)) ^ g;
+ }
+ return h;
+ }
+
+ int
+ buf_read(char *pathname, char **buf, int *len) {
+ struct stat sb;
+ int fd;
+
+ *buf = 0;
+ *len = 0;
+ fd = open(pathname, O_RDONLY);
+ if (fd <= 0)
+ return -1;
+ memset(&sb, 0, sizeof(sb));
+ fstat(fd, &sb);
+ *len = sb.st_size;
+ *buf = (char*)MALLOC(*len + 2);
+ (*buf)[*len] = 0; /* terminator */
+ (*buf)[*len + 1] = 0; /* sentinal */
+ read(fd, *buf, *len);
+ close(fd);
+ return *len;
+ }
+
+ char *
+ sbuf_read(char *pathname) {
+ char *buf;
+ int len;
+
+ if (buf_read(pathname, &buf, &len) < 0)
+ return NULL;
+ return buf;
+ }
+
+ void
+ d_fail(char *str, ...) {
+ char nstr[256];
+ va_list ap;
+ va_start(ap, str);
+ snprintf(nstr, 255, "fail: %s\n", str);
+ vfprintf(stderr, nstr, ap);
+ va_end(ap);
+ exit(1);
+ }
+
+ void
+ vec_add_internal(void *v, void *elem) {
+ AbstractVec *av = (AbstractVec*)v;
+ if (!av->n) {
+ av->v = av->e;
+ } else if (av->v == av->e) {
+ av->v = (void**)MALLOC(INITIAL_VEC_SIZE * sizeof(void *));
+ memcpy(av->v, av->e, av->n * sizeof(void *));
+ } else
+ if ((av->n & (INITIAL_VEC_SIZE - 1)) == 0) {
+ int l = av->n, nl = (1 + INITIAL_VEC_SHIFT);
+ l = l >> INITIAL_VEC_SHIFT;
+ while (!(l&1)) { l = l >> 1; nl++; }
+ l = l >> 1;
+ if (!av->n || !l) {
+ nl = 1 << nl;
+ av->v = (void**)REALLOC(av->v, nl * sizeof(void *));
+ }
+ }
+ av->v[av->n++] = elem;
+ }
+
+ int
+ vec_eq(void *v, void *vv) {
+ AbstractVec *av = (AbstractVec*)v;
+ AbstractVec *avv = (AbstractVec*)vv;
+ uint i;
+
+ if (av->n != avv->n)
+ return 0;
+ for (i = 0; i < av->n; i++)
+ if (av->v[i] != avv->v[i])
+ return 0;
+ return 1;
+ }
+
+ void *
+ stack_push_internal(AbstractStack *s, void *elem) {
+ int n = s->cur - s->start;
+ if (s->start == s->initial) {
+ s->cur = (void**)MALLOC(n * 2 * sizeof(void*));
+ memcpy(s->cur, s->start, n * sizeof(void*));
+ } else
+ s->cur = (void**)REALLOC(s->start, n * 2 * sizeof(void*));
+ s->end = s->start = s->cur;
+ s->cur += n;
+ s->end += n * 2;
+ *s->cur++ = elem;
+ return elem;
+ }
+
+ int
+ set_add(void *av, void *t) {
+ AbstractVec *v = (AbstractVec*)av, vv;
+ int j, n = v->n;
+ uint i;
+ if (n) {
+ uint h = ((uint)t);
+ h = h % n;
+ for (i = h, j = 0;
+ i < v->n && j < SET_MAX_SEQUENTIAL;
+ i = ((i + 1) % n), j++)
+ {
+ if (!v->v[i]) {
+ v->v[i] = t;
+ return 1;
+ } else if (v->v[i] == t)
+ return 0;
+ }
+ }
+ if (!n) {
+ vv.v = NULL;
+ v->i = INITIAL_SET_SIZE_INDEX;
+ } else {
+ vv.v = v->v;
+ vv.n = v->n;
+ v->i = v->i + 1;
+ }
+ v->n = prime2[v->i];
+ v->v = (void**)MALLOC(v->n * sizeof(void *));
+ memset(v->v, 0, v->n * sizeof(void *));
+ if (vv.v) {
+ set_union(av, &vv);
+ FREE(vv.v);
+ }
+ return set_add(v, t);
+ }
+
+ void *
+ set_add_fn(void *av, void *t, hash_fns_t *fns) {
+ AbstractVec *v = (AbstractVec*)av, vv;
+ uint32 tt = fns->hash_fn(t, fns);
+ int j, n = v->n;
+ uint i;
+ if (n) {
+ uint h = tt % n;
+ for (i = h, j = 0;
+ i < v->n && j < SET_MAX_SEQUENTIAL;
+ i = ((i + 1) % n), j++)
+ {
+ if (!v->v[i]) {
+ v->v[i] = t;
+ return t;
+ } else {
+ if (!fns->cmp_fn(v->v[i], t, fns))
+ return v->v[i];
+ }
+ }
+ }
+ if (!n) {
+ vv.v = NULL;
+ v->i = INITIAL_SET_SIZE_INDEX;
+ } else {
+ vv.v = v->v;
+ vv.n = v->n;
+ v->i = v->i + 1;
+ }
+ v->n = prime2[v->i];
+ v->v = (void**)MALLOC(v->n * sizeof(void *));
+ memset(v->v, 0, v->n * sizeof(void *));
+ if (vv.v) {
+ set_union_fn(av, &vv, fns);
+ FREE(vv.v);
+ }
+ return set_add_fn(v, t, fns);
+ }
+
+ int
+ set_union(void *av, void *avv) {
+ AbstractVec *vv = (AbstractVec*)avv;
+ uint i, changed = 0;
+
+ for (i = 0; i < vv->n; i++)
+ if (vv->v[i])
+ changed = set_add(av, vv->v[i]) || changed;
+ return changed;
+ }
+
+ void
+ set_union_fn(void *av, void *avv, hash_fns_t *fns) {
+ AbstractVec *vv = (AbstractVec*)avv;
+ uint i;
+
+ for (i = 0; i < vv->n; i++)
+ if (vv->v[i])
+ set_add_fn(av, vv->v[i], fns);
+ }
+
+ void
+ set_to_vec(void *av) {
+ AbstractVec *v = (AbstractVec*)av, vv;
+ uint i;
+
+ vv.n = v->n;
+ vv.v = v->v;
+ if (v->v == v->e) {
+ memcpy(vv.e, v->e, sizeof(v->e));
+ vv.v = vv.e;
+ }
+ v->n = 0;
+ v->v = 0;
+ for (i = 0; i < vv.n; i++)
+ if (vv.v[i])
+ vec_add_internal(v, vv.v[i]);
+ FREE(vv.v);
+ }
+
+ void
+ int_list_diff(int *a, int *b, int *c) {
+ while (1) {
+ if (*b < 0)
+ break;
+ Lagainc:
+ if (*c < 0) {
+ while (*b >= 0)
+ *a++ = *b++;
+ break;
+ }
+ Lagainb:
+ if (*b == *c) {
+ b++;
+ c++;
+ continue;
+ }
+ if (*b < *c) {
+ *a++ = *b++;
+ if (*b < 0)
+ break;
+ goto Lagainb;
+ }
+ if (*c < *b) {
+ c++;
+ goto Lagainc;
+ }
+ }
+ *a++ = -1;
+ }
+
+ void
+ int_list_intersect(int *a, int *b, int *c) {
+ while (1) {
+ if (*b < 0)
+ break;
+ Lagainc:
+ if (*c < 0)
+ break;
+ Lagainb:
+ if (*b == *c) {
+ *a++ = *b++;
+ c++;
+ continue;
+ }
+ if (*b < *c) {
+ b++;
+ if (*b < 0)
+ break;
+ goto Lagainb;
+ }
+ if (*c < *b) {
+ c++;
+ goto Lagainc;
+ }
+ }
+ *a++ = -1;
+ }
+
+ int *
+ int_list_dup(int *aa) {
+ int *a = aa, *b, *bb;
+ while (*a != -1) { a++; }
+ bb = b = (int*)MALLOC((a - aa + 1) * sizeof(int));
+ a = aa;
+ while (*a != -1) { *b++ = *a++; }
+ *b++ = -1;
+ return bb;
+ }
+
+ #define ESC(_c) *ss++ = '\\'; *ss++ = _c; break;
+ char *
+ escape_string(char *s) {
+ char *ss = (char*)MALLOC((strlen(s) + 1) * 4), *sss = ss;
+ for (; *s; s++) {
+ switch (*s) {
+ case '\b': ESC('b');
+ case '\f': ESC('f');
+ case '\n': ESC('n');
+ case '\r': ESC('r');
+ case '\t': ESC('t');
+ case '\v': ESC('v');
+ case '\a': ESC('a');
+ case '\\':
+ case '\"':
+ *ss++ = '\\';
+ *ss++ = *s; break;
+
+ default:
+ if (isprint(*s)) {
+ *ss++ = *s;
+ } else {
+ *ss++ = '\\';
+ *ss++ = 'x';
+ *ss++ = tohex2(*s);
+ *ss++ = tohex1(*s);
+ }
+ break;
+ }
+ }
+ *ss = 0;
+ return sss;
+ }
+
+ void d_free(void *x) { FREE(x); }
Index: llvm/test/Programs/MultiSource/Applications/d/util.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/util.h:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/util.h Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,127 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+
+ #define INITIAL_SET_SIZE_INDEX 2
+
+ #define INITIAL_VEC_SHIFT 3
+ #define INITIAL_VEC_SIZE (1 << INITIAL_VEC_SHIFT)
+ #define INITIAL_VEC_SIZE (1 << INITIAL_VEC_SHIFT)
+ #define INTEGRAL_VEC_SIZE 3
+ #define INTEGRAL_STACK_SIZE 8
+ #define TRICK_VEC_SIZE (INITIAL_VEC_SIZE - INTEGRAL_VEC_ELEMENTS)
+
+ #define SET_MAX_SEQUENTIAL 5
+
+ #define IS_BIT_SET(_v, _s) ((_v)[(_s) / 8] & 1 << ((_s) % 8))
+ #define SET_BIT(_v, _s) (_v)[(_s) / 8] |= (1 << ((_s) %8))
+
+ typedef struct AbstractVec {
+ uint n;
+ uint i; /* size index for use with sets */
+ void **v;
+ void *e[INTEGRAL_VEC_SIZE];
+ } AbstractVec;
+ #define Vec(_x) struct { \
+ uint n; \
+ uint i; \
+ _x *v; \
+ _x e[INTEGRAL_VEC_SIZE]; \
+ }
+
+ typedef struct AbstractStack {
+ void **start;
+ void **end;
+ void **cur;
+ void *initial[INTEGRAL_STACK_SIZE];
+ } AbstractStack;
+ #define Stack(_x) struct { \
+ _x *start; _x *end; _x *cur; _x initial[INTEGRAL_STACK_SIZE]; \
+ }
+
+ #define vec_move(_a, _b) do { \
+ (_a)->n = (_b)->n; \
+ if ((_b)->v == (_b)->e) { \
+ memcpy(&(_a)->e[0], &(_b)->e[0], sizeof((_a)->e)); \
+ (_a)->v = (_a)->e; \
+ } else (_a)->v = (_b)->v; \
+ vec_clear(_b); \
+ } while (0)
+
+ struct hash_fns_t;
+ typedef uint32 (*hash_fn_t)(void *, struct hash_fns_t*);
+ typedef int (*cmp_fn_t)(void *, void *, struct hash_fns_t*);
+ typedef struct hash_fns_t {
+ hash_fn_t hash_fn;
+ cmp_fn_t cmp_fn;
+ void *data[2];
+ } hash_fns_t;
+
+ #define vec_add(_v, _i) do { \
+ if (!(_v)->v) { \
+ ((_v)->v = (_v)->e)[(_v)->n++] = (_i); \
+ break; \
+ } else if ((_v)->v == ((_v)->e)) { \
+ if (((_v)->n < INTEGRAL_VEC_SIZE)) { \
+ (_v)->v[(_v)->n++] = (_i); \
+ break; \
+ } \
+ } else if ((_v)->n & (INITIAL_VEC_SIZE - 1)) { \
+ (_v)->v[(_v)->n++] = (_i); \
+ break; \
+ } \
+ vec_add_internal((_v), _i); \
+ } while (0)
+ void vec_add_internal(void *v, void *elem);
+ int vec_eq(void *v, void *vv);
+ int set_add(void *v, void *t);
+ int set_union(void *v, void *vv);
+ void *set_add_fn(void *v, void *t, hash_fns_t *fns);
+ void set_union_fn(void *v, void *vv, hash_fns_t *fns);
+ void set_to_vec(void *av);
+ #define vec_clear(_v) do { (_v)->n = 0; (_v)->v = 0; } while(0)
+ #define vec_free(_v) do { \
+ if ((_v)->v && (_v)->v != (_v)->e) FREE((_v)->v); vec_clear(_v); } while(0)
+
+ #define stack_clear(_s) do { \
+ (_s)->start = (_s)->cur = (_s)->end = (_s)->initial; \
+ (_s)->end += INTEGRAL_STACK_SIZE; \
+ } \
+ while(0)
+ #define stack_free(_s) do { \
+ if ((_s)->start != (_s)->initial) FREE((_s)->start); \
+ stack_clear(_s); \
+ } while(0)
+ #define stack_head(_s) ((_s)->cur[-1])
+ #define is_stack_empty(_s) ((_s)->cur == (_s)->start)
+ #define stack_empty(_s) ((_s)->cur = (_s)->start)
+ #define stack_depth(_s) ((_s)->cur - (_s)->start)
+ #define stack_pop(_s) (*--((_s)->cur))
+ #define stack_push(_s, _x) ((_s)->cur == (_s)->end ? \
+ stack_push_internal((AbstractStack*)((_s)), (void*)_x) : \
+ (void*)(*((_s)->cur)++ = (_x)))
+ void * stack_push_internal(AbstractStack*, void*);
+
+ int buf_read(char *pathname, char **buf, int *len);
+ char *sbuf_read(char *pathname);
+
+ #define STREQ(_x,_n,_s) \
+ ((_n == sizeof(_s)-1) && !strncasecmp(_x,_s,sizeof(_s)-1))
+
+ void d_fail(char *str, ...);
+ char *dup_str(char *str, char *end);
+ uint strhashl(char *s, int len);
+ void d_free(void *);
+
+ void int_list_diff(int *a, int *b, int *c);
+ void int_list_intersect(int *a, int *b, int *c);
+ int *int_list_dup(int *aa);
+
+ char *escape_string(char *s);
+
+ extern uint prime2[];
+ extern int verbose_level;
+ extern int debug_level;
+ extern int test_level;
+
+
Index: llvm/test/Programs/MultiSource/Applications/d/version.c
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/version.c:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/version.c Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,12 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+ #include "d.h"
+
+ void
+ d_version(char *v) {
+ v += sprintf(v, "%d.%d", D_MAJOR_VERSION, D_MINOR_VERSION);
+ if (D_BUILD_VERSION)
+ v += sprintf(v, ".%d", D_BUILD_VERSION);
+ }
+
Index: llvm/test/Programs/MultiSource/Applications/d/write_ctables.c
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/write_ctables.c:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/write_ctables.c Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,1106 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+ #include "d.h"
+
+ typedef struct ScannerBlock {
+ int state_index;
+ int scanner_index;
+ int block_index;
+ ScanState **chars;
+ ScanStateTransition **transitions;
+ } ScannerBlock;
+ typedef Vec(ScannerBlock*) VecScannerBlock;
+ typedef Vec(State *) VecState;
+
+ static int
+ scanner_size(State *s) {
+ if (s->scanner.states.n < 255 && s->scanner.transitions.n < 255)
+ return 1;
+ if (s->scanner.states.n < 32384 && s->scanner.transitions.n < 32384)
+ return 2;
+ return 4;
+ }
+
+ static char *
+ make_type(int i) {
+ switch (i) {
+ case 1: return "unsigned char";
+ case 2: return "unsigned short";
+ case 4: return "unsigned int";
+ default: d_fail("bad case"); return "";
+ }
+ }
+
+ static char *
+ scanner_type(State *s) {
+ return make_type(scanner_size(s));
+ }
+
+ static char *
+ make_u_type(int i) {
+ switch (i) {
+ case 1: return "uint8";
+ case 2: return "uint16";
+ case 4: return "uint32";
+ default: d_fail("bad case"); return "";
+ }
+ }
+
+ static char *
+ scanner_u_type(State *s) {
+ return make_u_type(scanner_size(s));
+ }
+
+ static uint32
+ scanner_block_hash_fn(ScannerBlock *b, hash_fns_t *fns) {
+ uint32 hash = 0;
+ int i, block_size = (int)fns->data[0];
+ ScanState **sb = b->chars;
+
+ for (i = 0; i < block_size; i++) {
+ hash *= 17;
+ hash += sb[i] ? sb[i]->index + 2 : 1;
+ }
+ return hash;
+ }
+
+ static int
+ scanner_block_cmp_fn(ScannerBlock *a, ScannerBlock *b, hash_fns_t *fns) {
+ int i, block_size = (int)fns->data[0];
+ ScanState **sa = a->chars;
+ ScanState **sb = b->chars;
+
+ for (i = 0; i < block_size; i++) {
+ if (sa[i] == sb[i])
+ continue;
+ if (!sa[i] || !sb[i])
+ return 1;
+ if (sa[i]->index != sb[i]->index)
+ return 1;
+ }
+ return 0;
+ }
+
+ hash_fns_t
+ scanner_block_fns = {
+ (hash_fn_t)scanner_block_hash_fn,
+ (cmp_fn_t)scanner_block_cmp_fn,
+ {0, 0}
+ };
+
+ static uint32
+ trans_scanner_block_hash_fn(ScannerBlock *b, hash_fns_t *fns) {
+ uint32 hash = 0;
+ int i, block_size = (int)fns->data[0];
+ ScanStateTransition **sb = b->transitions;
+
+ for (i = 0; i < block_size; i++) {
+ hash *= 3;
+ hash += sb[i] ? sb[i]->index + 1 : 0;
+ }
+ return hash;
+ }
+
+ static int
+ trans_scanner_block_cmp_fn(ScannerBlock *a, ScannerBlock *b, hash_fns_t *fns) {
+ int i, block_size = (int)fns->data[0];
+ ScanStateTransition **sa = a->transitions;
+ ScanStateTransition **sb = b->transitions;
+
+ for (i = 0; i < block_size; i++) {
+ if (sa[i] == sb[i])
+ continue;
+ if (!sa[i] || !sb[i])
+ return 1;
+ if (sa[i]->index != sb[i]->index)
+ return 1;
+ }
+ return 0;
+ }
+
+ hash_fns_t
+ trans_scanner_block_fns = {
+ (hash_fn_t)trans_scanner_block_hash_fn,
+ (cmp_fn_t)trans_scanner_block_cmp_fn,
+ {0, 0}
+ };
+
+ static uint32
+ shift_hash_fn(Action *sa, hash_fns_t *fns) {
+ return sa->term->index;
+ }
+
+ static int
+ shift_cmp_fn(Action *sa, Action *sb, hash_fns_t *fns) {
+ return sa->term->index != sb->term->index;
+ }
+
+ hash_fns_t
+ shift_fns = {
+ (hash_fn_t)shift_hash_fn,
+ (cmp_fn_t)shift_cmp_fn,
+ {0, 0}
+ };
+
+ static void
+ write_scanner_data_as_C(FILE *fp, Grammar *g, char *tag) {
+ State *s;
+ ScannerBlock *vsblock, *xv, *yv;
+ VecScannerBlock scanner_block_hash[4], *pscanner_block_hash;
+ VecScannerBlock trans_scanner_block_hash[4], *ptrans_scanner_block_hash;
+ VecAction shift_hash;
+ int nvsblocks, ivsblock, i, j, k, x, xx;
+ Action *a;
+ VecScanState *ss;
+ char speculative_code[256];
+ Term *t;
+
+ /* shift_actions */
+ for (i = 0; i < g->terminals.n; i++) {
+ t = g->terminals.v[i];
+ if (t->regex_production && t->regex_production->rules.v[0]->speculative_code.code)
+ sprintf(speculative_code, "d_speculative_reduction_code_%d_%d_%s",
+ t->regex_production->index, t->regex_production->rules.v[0]->index, tag);
+ else
+ strcpy(speculative_code, "NULL");
+ fprintf(fp,
+ "D_Shift d_shift_%d_%s = { %d, %d, %d, %d, %d, %s };\n",
+ i, tag,
+ g->terminals.v[i]->index + g->productions.n,
+ g->terminals.v[i]->scan_kind,
+ g->terminals.v[i]->op_assoc,
+ g->terminals.v[i]->op_priority,
+ g->terminals.v[i]->term_priority,
+ speculative_code);
+ }
+ fprintf(fp,"\n");
+ /* scanners */
+ nvsblocks = 0;
+ for (i = 0; i < g->states.n; i++)
+ nvsblocks += g->states.v[i]->scanner.states.n * g->scanner_blocks;
+ vsblock = MALLOC((nvsblocks ? nvsblocks : 1) * sizeof(ScannerBlock));
+ for (i = 0; i < 4; i++) {
+ vec_clear(&scanner_block_hash[i]);
+ vec_clear(&trans_scanner_block_hash[i]);
+ }
+ scanner_block_fns.data[0] = (void*)g->scanner_block_size;
+ scanner_block_fns.data[1] = (void*)g;
+ trans_scanner_block_fns.data[0] = (void*)g->scanner_block_size;
+ trans_scanner_block_fns.data[1] = (void*)g;
+ /* shift */
+ vec_clear(&shift_hash);
+ ivsblock = 0;
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ ss = &s->scanner.states;
+ /* build shifts */
+ if (s->shift_actions.n && !s->same_shifts) {
+ fprintf(fp, "D_Shift *d_shifts_%d_%s[] = {\n", i, tag);
+ for (j = 0; j < s->shift_actions.n; j++) {
+ a = s->shift_actions.v[j];
+ fprintf(fp, "&d_shift_%d_%s%s", a->term->index, tag,
+ j == s->shift_actions.n - 1 ? ", NULL" : ", ");
+ }
+ fprintf(fp, "};\n\n");
+ }
+ /* build accepts differences */
+ for (j = 0; j < s->scanner.transitions.n; j++) {
+ VecAction *va = &s->scanner.transitions.v[j]->accepts_diff;
+ fprintf(fp, "D_Shift *d_accepts_diff_%d_%d_%s[] = {",
+ i, j, tag);
+ for (k = 0; k < va->n; k++)
+ fprintf(fp, "&d_shift_%d_%s,", va->v[k]->term->index, tag);
+ fprintf(fp, "0};\n");
+ }
+ if (s->scanner.transitions.n) {
+ fprintf(fp, "D_Shift **d_accepts_diff_%d_%s[] = {\n", i, tag);
+ for (j = 0; j < s->scanner.transitions.n; j++) {
+ fprintf(fp, "d_accepts_diff_%d_%d_%s%s",
+ i, j, tag, j == s->scanner.transitions.n - 1 ? "\n" : ",\n");
+ }
+ fprintf(fp, "};\n\n");
+ }
+ /* build scanner_block_hash */
+ pscanner_block_hash = &scanner_block_hash[scanner_size(s)-1];
+ ptrans_scanner_block_hash = &trans_scanner_block_hash[scanner_size(s)-1];
+ for (j = 0; j < ss->n; j++) {
+ if (!s->same_shifts) {
+ for (k = 0; k < g->scanner_blocks; k++) {
+ vsblock[ivsblock].state_index = s->index;
+ vsblock[ivsblock].scanner_index = j;
+ vsblock[ivsblock].block_index = k;
+ vsblock[ivsblock].chars =
+ (void*)&ss->v[j]->chars[k * g->scanner_block_size];
+ vsblock[ivsblock].transitions =
+ (void*)&ss->v[j]->transition[k * g->scanner_block_size];
+ xv = &vsblock[ivsblock];
+ ivsblock++;
+ assert(ivsblock <= nvsblocks);
+ /* output state scanner blocks */
+ yv = set_add_fn(pscanner_block_hash, xv, &scanner_block_fns);
+ if (xv == yv) {
+ fprintf(fp,
+ "%s d_scanner_%d_%d_%d_%s[SCANNER_BLOCK_SIZE] = {\n",
+ scanner_type(s), i, j, k, tag);
+ for (x = 0; x < g->scanner_block_size; x++) {
+ xx = x + k * g->scanner_block_size;
+ fprintf(fp, "%d", ss->v[j]->chars[xx] ?
+ ss->v[j]->chars[xx]->index + 1 : 0);
+ if (x != g->scanner_block_size) fprintf(fp, ",");
+ if (x % 16 == 15) fprintf(fp, "\n");
+ }
+ fprintf(fp, "};\n\n");
+ }
+ if (s->scan_kind != D_SCAN_LONGEST) {
+ /* output accept_diff scanner blocks */
+ yv = set_add_fn(ptrans_scanner_block_hash, xv,
+ &trans_scanner_block_fns);
+ if (xv == yv) {
+ fprintf(fp,
+ "%s d_accepts_diff_%d_%d_%d_%s[SCANNER_BLOCK_SIZE] = {\n",
+ scanner_type(s), i, j, k, tag);
+ for (x = 0; x < g->scanner_block_size; x++) {
+ xx = x + k * g->scanner_block_size;
+ fprintf(fp, "%d", ss->v[j]->transition[xx]->index);
+ if (x != g->scanner_block_size) fprintf(fp, ",");
+ if (x % 16 == 15) fprintf(fp, "\n");
+ }
+ fprintf(fp, "};\n\n");
+ }
+ }
+ }
+ /* output shifts */
+ if (ss->v[j]->accepts.n) {
+ for (k = 0; k < ss->v[j]->accepts.n; k++) {
+ Action *a = ss->v[j]->accepts.v[k], *aa;
+ char tmp[256];
+ sprintf(tmp, "d_shift_%d_%d_%s", i, j, tag);
+ if (ss->v[j]->accepts.n == 1) {
+ a->temp_string = strdup(tmp);
+ aa = set_add_fn(&shift_hash, a, &shift_fns);
+ if (aa != a)
+ continue;
+ }
+ /* output shifts */
+ if (!k)
+ fprintf(fp, "D_Shift *%s[] = { ", tmp);
+ fprintf(fp, "&d_shift_%d_%s%s",
+ a->term->index, tag, k == ss->v[j]->accepts.n - 1 ?
+ ", NULL};\n\n" : ", ");
+ }
+ }
+ }
+ }
+ }
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ ss = &s->scanner.states;
+ ivsblock = 0;
+ if (ss->n && !s->same_shifts) {
+ /* output scanner state transition tables */
+ fprintf(fp, "SB_%s d_scanner_%d_%s[%d] = {\n",
+ scanner_u_type(s), i, tag, ss->n);
+ pscanner_block_hash = &scanner_block_hash[scanner_size(s)-1];
+ for (j = 0; j < ss->n; j++) {
+ Action *a;
+ if (ss->v[j]->accepts.n) {
+ a = ss->v[j]->accepts.v[0];
+ if (ss->v[j]->accepts.n == 1) {
+ a = set_add_fn(&shift_hash, a, &shift_fns);
+ fprintf(fp, "{ %s, {", a->temp_string);
+ } else
+ fprintf(fp, "{ d_shift_%d_%d_%s, {", i, j, tag);
+ } else
+ fprintf(fp, "{ NULL, {");
+ for (k = 0; k < g->scanner_blocks; k++) {
+ ScannerBlock vs;
+ vs.state_index = s->index;
+ vs.scanner_index = j;
+ vs.block_index = k;
+ vs.chars = (void*)&ss->v[j]->chars[k * g->scanner_block_size];
+ vs.transitions =
+ (void*)&ss->v[j]->transition[k * g->scanner_block_size];
+ xv = &vs;
+ yv = set_add_fn(pscanner_block_hash, xv, &scanner_block_fns);
+ assert(yv != xv);
+ fprintf(fp, "d_scanner_%d_%d_%d_%s",
+ yv->state_index, yv->scanner_index,
+ yv->block_index, tag);
+ if (k != g->scanner_blocks-1) {
+ fprintf(fp, ", ");
+ if ((k % 2) == 1) fprintf(fp,"\n ");
+ }
+ }
+ if (j != ss->n-1)
+ fprintf(fp, "}},\n");
+ else
+ fprintf(fp, "}}\n");
+ }
+ fprintf(fp, "};\n\n");
+ if (s->scan_kind != D_SCAN_LONGEST) {
+ /* output scanner accepts diffs tables */
+ fprintf(fp, "SB_trans_%s d_transition_%d_%s[%d] = {\n",
+ scanner_u_type(s), i, tag, ss->n);
+ ptrans_scanner_block_hash =
+ &trans_scanner_block_hash[scanner_size(s)-1];
+ for (j = 0; j < ss->n; j++) {
+ fprintf(fp, "{{ ");
+ for (k = 0; k < g->scanner_blocks; k++) {
+ ScannerBlock vs;
+ vs.state_index = s->index;
+ vs.scanner_index = j;
+ vs.block_index = k;
+ vs.chars = (void*)&ss->v[j]->chars[k * g->scanner_block_size];
+ vs.transitions =
+ (void*)&ss->v[j]->transition[k * g->scanner_block_size];
+ xv = &vs;
+ yv = set_add_fn(ptrans_scanner_block_hash, xv,
+ &trans_scanner_block_fns);
+ assert(yv != xv);
+ fprintf(fp, "d_accepts_diff_%d_%d_%d_%s",
+ yv->state_index, yv->scanner_index,
+ yv->block_index, tag);
+ if (k != g->scanner_blocks-1) {
+ fprintf(fp, ", ");
+ if ((k % 2) == 1) fprintf(fp,"\n ");
+ }
+ }
+ if (j != ss->n-1)
+ fprintf(fp, "}},\n");
+ else
+ fprintf(fp, "}}\n");
+ }
+ fprintf(fp, "};\n\n");
+ }
+ }
+ }
+ for (i = 0; i < 4; i++)
+ vec_free(&scanner_block_hash[i]);
+ FREE(vsblock);
+ }
+
+ #define reduction_index(_r) \
+ ((_r)->same_reduction ? (_r)->same_reduction->index : (_r)->index)
+
+ static void
+ write_goto_data_as_C(FILE *fp, Grammar *g, char *tag) {
+ Vec(int) vgoto;
+ State *s;
+ uint8 *goto_valid = NULL;
+ int i, j, x, again, lowest, nvalid_bytes, sym, lowest_sym;
+
+ nvalid_bytes = ((g->productions.n + g->terminals.n) + 7) / 8;
+ goto_valid = MALLOC(nvalid_bytes);
+ vec_clear(&vgoto);
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ if (s->gotos.n) {
+ /* check for goto on token */
+ for (j = 0; j < s->gotos.n; j++)
+ if (s->gotos.v[j]->elem->kind == ELEM_TERM &&
+ s->gotos.v[j]->elem->e.term->kind == TERM_TOKEN)
+ s->goto_on_token = 1;
+ /* find lowest goto, set valid bits */
+ memset(goto_valid, 0, nvalid_bytes);
+ lowest = 0;
+ lowest_sym = elem_symbol(g, s->gotos.v[0]->elem);
+ SET_BIT(goto_valid, lowest_sym);
+ for (j = 1; j < s->gotos.n; j++) {
+ sym = elem_symbol(g, s->gotos.v[j]->elem);
+ SET_BIT(goto_valid, sym);
+ if (sym < lowest_sym) {
+ lowest = j;
+ lowest_sym = sym;
+ }
+ }
+ /* insert into vgoto */
+ again = 1;
+ while (again) {
+ again = 0;
+ for (j = 0; j < s->gotos.n; j++) {
+ x = elem_symbol(g, s->gotos.v[j]->elem);
+ x -= lowest_sym;
+ while (vgoto.n <= x)
+ vec_add(&vgoto, 0);
+ if (vgoto.v[x]) {
+ again = 1;
+ /* undo the damage */
+ for (--j;j >= 0;j--) {
+ x = elem_symbol(g, s->gotos.v[j]->elem);
+ x -= lowest_sym;
+ vgoto.v[x] = 0;
+ }
+ lowest_sym--;
+ break;
+ } else
+ vgoto.v[x] = s->gotos.v[j]->state->index + 1;
+ }
+ }
+ s->goto_table_offset = lowest_sym;
+ /* valid bits */
+ fprintf(fp, "unsigned char d_goto_valid_%d_%s[] = {\n", i, tag);
+ for (j = 0; j < nvalid_bytes; j++)
+ fprintf(fp, "0x%x%s", goto_valid[j],
+ j == nvalid_bytes - 1 ? "" : ", ");
+ fprintf(fp, "};\n");
+ } else
+ s->goto_table_offset = -INT_MAX;
+ /* reduce_actions */
+ if (s->reduce_actions.n) {
+ fprintf(fp, "D_Reduction *d_reductions_%d_%s[] = {", i, tag);
+ for (j = 0; j < s->reduce_actions.n; j++)
+ fprintf(fp, "&d_reduction_%d_%s%s",
+ reduction_index(s->reduce_actions.v[j]->rule), tag,
+ j == s->reduce_actions.n - 1 ? "" : ", ");
+ fprintf(fp, "};\n");
+ }
+ /* modified_reduce_actions */
+ if (s->right_epsilon_hints.n) {
+ fprintf(fp, "D_RightEpsilonHint d_right_epsilon_hints_%d_%s[] = {",
+ i, tag);
+ for (j = 0; j < s->right_epsilon_hints.n; j++) {
+ fprintf(fp, "{ %d, %d, &d_reduction_%d_%s}%s",
+ s->right_epsilon_hints.v[j]->depth,
+ s->right_epsilon_hints.v[j]->state->index,
+ reduction_index(s->right_epsilon_hints.v[j]->rule), tag,
+ j == s->right_epsilon_hints.n - 1 ? "" : ", ");
+ }
+ fprintf(fp, "};\n");
+ }
+ }
+ /* gotos */
+ if (vgoto.n) {
+ fprintf(fp, "unsigned short d_gotos_%s[%d] = {\n", tag, vgoto.n);
+ for (j = 0; j < vgoto.n; j++) {
+ fprintf(fp, "%d", vgoto.v[j]);
+ if (j != vgoto.n - 1) fprintf(fp, ",");
+ if (j % 16 == 15) fprintf(fp, "\n");
+ }
+ fprintf(fp, "};\n\n");
+ } else
+ fprintf(fp, "unsigned short d_gotos_%s[1] = {0};\n", tag);
+ }
+
+ static void
+ write_scanner_code_as_C(FILE *fp, Grammar *g, char *tag) {
+ int i, j, l;
+ Action *a;
+ State *s;
+
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ for (j = 0; j < s->shift_actions.n; j++) {
+ a = s->shift_actions.v[j];
+ if (a->kind == ACTION_SHIFT && a->term->kind == TERM_CODE) {
+ if (!s->scanner_code) {
+ s->scanner_code = 1;
+ fprintf(fp, "int d_scan_code_%d_%s(char **as, int *col, int *line,"
+ "unsigned short *symbol, int *term_priority,"
+ "unsigned char *op_assoc, int *op_priority) {\n"
+ " int res;\n",
+ i, tag);
+ }
+ fprintf(fp, " if ((res = ");
+ l = strlen(a->term->string);
+ if (a->term->string[l - 1] == ')') {
+ fwrite(a->term->string, l - 1, 1, fp);
+ fprintf(fp, ", ");
+ } else
+ fprintf(fp, "%s(", a->term->string);
+ fprintf(fp, "as, col, line, op_assoc, op_priority))) {\n"
+ " *symbol = %d;\n"
+ " *term_priority = %d;\n"
+ " return res;\n"
+ " }\n",
+ a->term->index + g->productions.n,
+ a->term->term_priority);
+ }
+ }
+ if (s->scanner_code)
+ fprintf(fp, " return 0;\n}\n\n");
+ }
+ }
+
+ static int
+ find_symbol(Grammar *g, char *s, char *e, int kind) {
+ while (*s && isspace(*s)) s++;
+ if (e > s) {
+ if (kind == D_SYMBOL_NTERM) {
+ Production *p;
+ if ((p = lookup_production(g, s, e-s)))
+ return p->index;
+ } else if (kind == D_SYMBOL_STRING) {
+ int i;
+ int found = -1;
+ for (i = 0; i < g->terminals.n;i++)
+ if (g->terminals.v[i]->kind == TERM_STRING &&
+ g->terminals.v[i]->string_len == (e-s) &&
+ !strncmp(s, g->terminals.v[i]->string, e-s)) {
+ if (found > 0) {
+ d_fail("attempt to find symbol for non-unique string '%s'\n",
+ g->terminals.v[i]->string);
+ } else
+ found = i;
+ }
+ if (found > 0)
+ return found + g->productions.n;
+ }
+ }
+ return -1;
+ }
+
+ static void
+ write_code_as_C(FILE *fp, Grammar *g, Rule *r, char *code,
+ int line, char *pathname)
+ {
+ char *c;
+
+ fprintf(fp, "{\n");
+ if (g->write_line_directives)
+ fprintf(fp, "#line %d \"%s\"\n", line, pathname);
+ c = code;
+ while (*c) {
+ if (*c == '$') {
+ c++;
+ if (*c == '#') {
+ fprintf(fp, "(_n_children)");
+ c++;
+ } else if (*c == 'g') {
+ fprintf(fp, "(D_PN(_ps, _offset)->globals)");
+ c++;
+ } else if (*c == 'n') {
+ ++c;
+ if (isdigit(*c)) {
+ int n = atoi(c);
+ fprintf(fp, "(*(D_PN(_children[%d], _offset)))", n);
+ if (n > r->elems.n-1)
+ d_fail("$nXXXX greater than number of children at line %d", line);
+ while (isdigit(*c)) c++;
+ } else
+ fprintf(fp, "(*(D_PN(_ps, _offset)))");
+ } else if (*c == '$') {
+ fprintf(fp, "(D_PN(_ps, _offset)->user)");
+ c++;
+ } else if (isdigit(*c)) {
+ int n = atoi(c);
+ fprintf(fp, "(D_PN(_children[%d], _offset)->user)", n);
+ while (isdigit(*c)) c++;
+ } else if (*c == '{') {
+ char *e = ++c, *a;
+ while (*e && *e != '}' && !isspace(*e)) e++;
+ a = e;
+ if (isspace(*a)) a++;
+ while (*a && *a != '}') a++;
+ if (STREQ(c, e-c, "reject")) {
+ fprintf(fp, " return -1 ");
+ } else if (STREQ(c, e-c, "free_below")) {
+ fprintf(fp, " free_D_ParseTreeBelow(_parser, (D_PN(_ps, _offset)))");
+ } else if (STREQ(c, e-c, "scope")) {
+ fprintf(fp, "(D_PN(_ps, _offset)->scope)");
+ } else if (STREQ(c, e-c, "parser")) {
+ fprintf(fp, "_parser");
+ } else if (STREQ(c, e-c, "nterm")) {
+ fprintf(fp, "%d", find_symbol(g, e, a, D_SYMBOL_NTERM));
+ } else if (STREQ(c, e-c, "string")) {
+ fprintf(fp, "%d", find_symbol(g, e, a, D_SYMBOL_STRING));
+ } else if (STREQ(c, e-c, "pass")) {
+ D_Pass *p = find_pass(g, e, a);
+ if (!p)
+ d_fail("unknown pass '%s' line %d", dup_str(e, a), line);
+ fprintf(fp, "%d", p->index);
+ } else
+ d_fail("bad $ escape in code line %u\n", line);
+ c = a + 1;
+ } else
+ d_fail("bad $ escape in code line %u\n", line);
+ } else {
+ fputc(*c, fp);
+ c++;
+ }
+ }
+ fprintf(fp, " return 0;");
+ fprintf(fp, "}\n\n");
+ }
+
+ static void
+ write_global_code_as_C(FILE *fp, Grammar *g, char *tag) {
+ int i;
+ char *c;
+
+ for (i = 0; i < g->ncode; i++) {
+ if (g->write_line_directives)
+ fprintf(fp, "#line %d \"%s\"\n", g->code[i].line, g->pathname);
+ c = g->code[i].code;
+ while (*c) {
+ if (*c == '$') {
+ c++;
+ if (*c == '{') {
+ char *e = ++c, *a;
+ while (*e && *e != '}' && !isspace(*e)) ++e;
+ a = e;
+ if (isspace(*a)) ++a;
+ while (*a && *a != '}') a++;
+ if (STREQ(c, e-c, "nterm")) {
+ fprintf(fp, "%d", find_symbol(g, e, a, D_SYMBOL_NTERM));
+ } else if (STREQ(c, e-c, "string")) {
+ fprintf(fp, "%d", find_symbol(g, e, a, D_SYMBOL_STRING));
+ } else
+ d_fail("bad $ escape in code line %u\n", g->code[i].line + i);
+ c = a + 1;
+ }
+ else
+ d_fail("bad $ escape in code line %u\n", g->code[i].line + i);
+ } else {
+ fputc(*c, fp);
+ c++;
+ }
+ }
+ fprintf(fp, "\n");
+ }
+ }
+
+ static char * reduction_args = "(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser)";
+
+ static void
+ write_reductions_as_C(FILE *fp, Grammar *g, char *tag) {
+ int i, j, k, l, pmax;
+ Production *p, *pdefault;
+ Rule *r, *rdefault = NULL;
+ char final_code[256], speculative_code[256], pass_code[256];
+
+ pdefault = lookup_production(g, "_", 1);
+ if (pdefault) {
+ rdefault = pdefault->rules.v[0];
+ fprintf(fp, "int d_speculative_reduction_code_%d_%d_%s%s;\n",
+ rdefault->prod->index, rdefault->index, tag, reduction_args);
+ fprintf(fp, "int d_final_reduction_code_%d_%d_%s%s;\n",
+ rdefault->prod->index, rdefault->index, tag, reduction_args);
+ fprintf(fp, "extern D_ReductionCode d_pass_code_%d_%d_%s[];\n",
+ rdefault->prod->index, rdefault->index, tag);
+ for (i = 0; i < rdefault->pass_code.n; i++)
+ fprintf(fp, "int d_pass_code_%d_%d_%d_%s%s;\n",
+ i, rdefault->prod->index, rdefault->index, tag, reduction_args);
+ }
+ for (i = 0; i < g->productions.n; i++) {
+ p = g->productions.v[i];
+ for (j = p->rules.n - 1; j >= 0; j--) {
+ r = p->rules.v[j];
+ for (k = 0; k < j; k++)
+ if (r->elems.n == p->rules.v[k]->elems.n &&
+ r->speculative_code.code == p->rules.v[k]->speculative_code.code &&
+ r->final_code.code == p->rules.v[k]->final_code.code &&
+ r->op_priority == p->rules.v[k]->op_priority &&
+ r->op_assoc == p->rules.v[k]->op_assoc &&
+ r->rule_priority == p->rules.v[k]->rule_priority &&
+ r->rule_assoc == p->rules.v[k]->rule_assoc &&
+ r->action_index == p->rules.v[k]->action_index)
+ {
+ if (r->pass_code.n != p->rules.v[k]->pass_code.n)
+ continue;
+ for (l = 0; l < r->pass_code.n; l++) {
+ if (!r->pass_code.v[l] && !p->rules.v[k]->pass_code.v[l])
+ continue;
+ if (!r->pass_code.v[l] || !p->rules.v[k]->pass_code.v[l])
+ goto Lcontinue;
+ if (r->pass_code.v[l]->code != p->rules.v[k]->pass_code.v[l]->code)
+ goto Lcontinue;
+ }
+ r->same_reduction = p->rules.v[k];
+ break;
+ Lcontinue:;
+ }
+ }
+ for (j = 0; j < p->rules.n; j++) {
+ r = p->rules.v[j];
+ if (r->same_reduction)
+ continue;
+ if (r->speculative_code.code) {
+ fprintf(fp, "int d_speculative_reduction_code_%d_%d_%s%s ",
+ r->prod->index, r->index, tag, reduction_args);
+ write_code_as_C(fp, g, r, r->speculative_code.code, r->speculative_code.line, g->pathname);
+ }
+ if (r->final_code.code) {
+ fprintf(fp, "int d_final_reduction_code_%d_%d_%s%s ",
+ r->prod->index, r->index, tag, reduction_args);
+ write_code_as_C(fp, g, r, r->final_code.code, r->final_code.line, g->pathname);
+ }
+ for (k = 0; k < r->pass_code.n; k++) {
+ if (r->pass_code.v[k]) {
+ fprintf(fp, "int d_pass_code_%d_%d_%d_%s%s ",
+ k, r->prod->index, r->index, tag, reduction_args);
+ write_code_as_C(fp, g, r, r->pass_code.v[k]->code, r->pass_code.v[k]->line, g->pathname);
+ }
+ }
+ if (r->speculative_code.code)
+ sprintf(speculative_code, "d_speculative_reduction_code_%d_%d_%s",
+ r->prod->index, r->index, tag);
+ else if (rdefault && rdefault->speculative_code.code)
+ sprintf(speculative_code, "d_speculative_reduction_code_%d_%d_%s",
+ rdefault->prod->index, rdefault->index, tag);
+ else
+ strcpy(speculative_code, "NULL");
+ if (r->final_code.code)
+ sprintf(final_code, "d_final_reduction_code_%d_%d_%s", r->prod->index, r->index, tag);
+ else if (rdefault && rdefault->final_code.code)
+ sprintf(final_code, "d_final_reduction_code_%d_%d_%s",
+ rdefault->prod->index, rdefault->index, tag);
+ else
+ strcpy(final_code, "NULL");
+ pmax = r->pass_code.n;
+ if (r->pass_code.n || (rdefault && rdefault->pass_code.n)) {
+ if (rdefault && rdefault->pass_code.n > pmax)
+ pmax = rdefault->pass_code.n;
+ if (!r->pass_code.n)
+ sprintf(pass_code, "d_pass_code_%d_%d_%s",
+ rdefault->prod->index, rdefault->index, tag);
+ else {
+ sprintf(pass_code, "d_pass_code_%d_%d_%s",
+ r->prod->index, r->index, tag);
+ fprintf(fp, "D_ReductionCode %s[] = {", pass_code);
+ for (k = 0; k < pmax; k++) {
+ if (r->pass_code.n > k && r->pass_code.v[k])
+ fprintf(fp, "d_pass_code_%d_%d_%d_%s%s", k, r->prod->index, r->index, tag,
+ k < pmax-1 ? ", " : "");
+ else
+ if (rdefault && rdefault->pass_code.n > k && rdefault->pass_code.v[k])
+ fprintf(fp, "d_pass_code_%d_%d_%d_%s%s", k, rdefault->prod->index,
+ rdefault->index, tag, k < pmax-1 ? ", " : "");
+ else
+ fprintf(fp, "NULL%s", k < pmax-1 ? ", " : "");
+ }
+ fprintf(fp, "};\n\n");
+ }
+ } else
+ strcpy(pass_code, "NULL");
+ fprintf(fp, "D_Reduction d_reduction_%d_%s = ", r->index, tag);
+ fprintf(fp, "{%d, %d, %s, %s, %d, %d, %d, %d, %d, %d, %s};\n",
+ r->elems.n, r->prod->index,
+ speculative_code, final_code,
+ r->op_assoc, r->rule_assoc,
+ r->op_priority, r->rule_priority,
+ r->prod->internal ? -1 : r->action_index,
+ pmax, pass_code);
+ }
+ }
+ }
+
+ static uint32
+ er_hint_hash_fn(State *a, hash_fns_t *fns) {
+ VecHint *sa = &a->error_recovery_hints;
+ uint32 hash = 0, i;
+ Term *ta;
+
+ for (i = 0; i < sa->n; i++) {
+ ta = sa->v[i]->rule->elems.v[sa->v[i]->rule->elems.n - 1]->e.term;
+ hash += (sa->v[i]->depth + 1) * 13;
+ hash += strhashl(ta->string, ta->string_len);
+ if (sa->v[i]->rule)
+ hash += sa->v[i]->rule->prod->index * 10007;
+ }
+ return hash;
+ }
+
+ static int
+ er_hint_cmp_fn(State *a, State *b, hash_fns_t *fns) {
+ int i;
+ VecHint *sa = &a->error_recovery_hints, *sb = &b->error_recovery_hints;
+ Term *ta, *tb;
+ if (sa->n != sb->n)
+ return 1;
+ for (i = 0; i < sa->n; i++) {
+ ta = sa->v[i]->rule->elems.v[sa->v[i]->rule->elems.n - 1]->e.term;
+ tb = sb->v[i]->rule->elems.v[sb->v[i]->rule->elems.n - 1]->e.term;
+ if (sa->v[i]->depth != sb->v[i]->depth ||
+ strcmp(ta->string, tb->string) ||
+ sa->v[i]->rule->prod->index != sb->v[i]->rule->prod->index)
+ return 1;
+ }
+ return 0;
+ }
+
+ hash_fns_t
+ er_hint_hash_fns = {
+ (hash_fn_t)er_hint_hash_fn,
+ (cmp_fn_t)er_hint_cmp_fn,
+ {0, 0}
+ };
+
+ static void
+ write_error_data_as_C(FILE *fp, Grammar *g, VecState *er_hash, char *tag) {
+ int i, j;
+ State *s;
+ Term *t;
+ State *h;
+ char *ss;
+
+ if (g->states.n) {
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ if (s->error_recovery_hints.n) {
+ h = set_add_fn(er_hash, s, &er_hint_hash_fns);
+ if (h == s) {
+ fprintf(fp,
+ "D_ErrorRecoveryHint d_error_recovery_hints_%d_%s[] = {%s",
+ i, tag, s->error_recovery_hints.n > 1 ? "\n" : "");
+ for (j = 0; j < s->error_recovery_hints.n; j++) {
+ t = s->error_recovery_hints.v[j]->rule->elems.v[
+ s->error_recovery_hints.v[j]->rule->elems.n - 1]->e.term;
+ ss = escape_string(t->string);
+ fprintf(fp, "{ %d, %d, \"%s\"}%s",
+ s->error_recovery_hints.v[j]->depth,
+ s->error_recovery_hints.v[j]->rule->prod->index,
+ ss,
+ j == s->error_recovery_hints.n - 1 ? "" : ",\n");
+ FREE(ss);
+ }
+ fprintf(fp, "};\n");
+ }
+ }
+ }
+ }
+ }
+
+ static char *scan_kind_strings[] = {"D_SCAN_ALL", "D_SCAN_LONGEST", "D_SCAN_MIXED", NULL};
+
+ static void
+ write_state_data_as_C(FILE *fp, Grammar *g, VecState *er_hash, char *tag) {
+ int i;
+ State *s, *h;
+
+ fprintf(fp, "\nD_State d_states_%s[] = ", tag);
+ if (g->states.n) {
+ fprintf(fp, "{\n");
+ for (i = 0; i < g->states.n; i++) {
+ s = g->states.v[i];
+ fprintf(fp, "{ ");
+ if (s->gotos.n)
+ fprintf(fp,"d_goto_valid_%d_%s, ", i, tag);
+ else
+ fprintf(fp,"NULL, ");
+ fprintf(fp,"%d, ", s->goto_table_offset);
+ if (s->reduce_actions.n)
+ fprintf(fp, "{ %d, d_reductions_%d_%s}, ", s->reduce_actions.n,
+ i, tag);
+ else
+ fprintf(fp, "{ 0, NULL}, ");
+ if (s->right_epsilon_hints.n)
+ fprintf(fp, "{ %d, d_right_epsilon_hints_%d_%s}, ",
+ s->right_epsilon_hints.n, i, tag);
+ else
+ fprintf(fp, "{ 0, NULL}, ");
+ if (s->error_recovery_hints.n) {
+ h = set_add_fn(er_hash, s, &er_hint_hash_fns);
+ fprintf(fp, "{ %d, d_error_recovery_hints_%d_%s}, ",
+ s->error_recovery_hints.n, h->index, tag);
+ } else
+ fprintf(fp, "{ 0, NULL}, ");
+ if (s->shift_actions.n)
+ fprintf(fp, "d_shifts_%d_%s, ",
+ s->same_shifts ? s->same_shifts->index : i, tag);
+ else if (s->scanner_code || (g->scanner.code && s->goto_on_token))
+ fprintf(fp, "D_SHIFTS_CODE, ");
+ else
+ fprintf(fp, "NULL, ");
+ if (g->scanner.code) {
+ if (s->goto_on_token)
+ fprintf(fp, "%s, ", g->scanner.code);
+ else
+ fprintf(fp, "NULL, ");
+ } else if (s->scanner_code)
+ fprintf(fp, "d_scan_code_%d_%s, ", i, tag);
+ else
+ fprintf(fp, "NULL, ");
+ if (s->scanner.states.n)
+ fprintf(fp, "(void*)d_scanner_%d_%s, ",
+ s->same_shifts ? s->same_shifts->index : i, tag);
+ else
+ fprintf(fp, "NULL, ");
+ fprintf(fp, "sizeof(%s), ", scanner_type(s));
+ fprintf(fp, s->accept ? "1, " : "0, ");
+ fprintf(fp, "%s, ", scan_kind_strings[s->scan_kind]);
+ if (s->scan_kind != D_SCAN_LONGEST && s->scanner.states.n)
+ fprintf(fp, "(void*)d_transition_%d_%s, ",
+ s->same_shifts ? s->same_shifts->index : i, tag);
+ else
+ fprintf(fp, "NULL, ");
+ if (s->scan_kind != D_SCAN_LONGEST && s->scanner.states.n)
+ fprintf(fp, "d_accepts_diff_%d_%s, ",
+ s->same_shifts ? s->same_shifts->index : i, tag);
+ else
+ fprintf(fp, "(D_Shift***)NULL, ");
+ if (s->reduces_to)
+ fprintf(fp, "%d", s->reduces_to->index);
+ else
+ fprintf(fp, "-1");
+ fprintf(fp, "}%s\n", i == g->states.n - 1 ? "" : ",");
+ }
+ fprintf(fp, "};\n\n");
+ } else
+ fprintf(fp, "{{0, {0, NULL}, 0, NULL}};\n\n");
+ }
+
+ static int
+ write_header_as_C(Grammar *g, char *base_pathname, char *tag) {
+ char pathname[FILENAME_MAX];
+ int i, tokens = 0, states = 0, col;
+ FILE *hfp;
+
+ for (i = 0; i < g->terminals.n; i++)
+ if (g->terminals.v[i]->kind == TERM_TOKEN)
+ tokens = 1;
+ if (g->states_for_all_nterms)
+ states = 1;
+ else
+ for (i = 0; i < g->productions.n; i++)
+ if (state_for_declaration(g, i))
+ states = 1;
+ if (g->write_header > 0 || (g->write_header < 0 && (tokens || states))) {
+ strcpy(pathname, base_pathname);
+ strcat(pathname, ".d_parser.h");
+ hfp = fopen(pathname, "w");
+ if (!hfp)
+ d_fail("unable to open `%s` for write\n", pathname);
+ fprintf(hfp, "#ifndef _%s_h\n", tag);
+ fprintf(hfp, "#define _%s_h\n", tag);
+ if (tokens) {
+ if (!g->token_type) {
+ for (i = 0; i < g->terminals.n; i++)
+ if (g->terminals.v[i]->kind == TERM_TOKEN)
+ fprintf(hfp, "#define %s \t%d\n",
+ g->terminals.v[i]->string,
+ g->terminals.v[i]->index + g->productions.n);
+ } else {
+ fprintf(hfp, "enum D_Tokens_%s {\n", tag);
+ col = 0;
+ for (i = 0; i < g->terminals.n; i++) {
+ if (g->terminals.v[i]->kind == TERM_TOKEN) {
+ col += g->terminals.v[i]->string_len + 7;
+ if (col > 70) { printf("\n"); col = 0; }
+ fprintf(hfp, "%s = %d%s",
+ g->terminals.v[i]->string,
+ g->terminals.v[i]->index + g->productions.n,
+ i == g->terminals.n-1 ? "" : ", ");
+ }
+ }
+ fprintf(hfp, "\n};\n");
+ }
+ }
+ if (states) {
+ for (i = 0; i < g->productions.n; i++)
+ if (!g->productions.v[i]->internal && g->productions.v[i]->elem)
+ fprintf(hfp, "#define D_START_STATE_%s \t%d\n",
+ g->productions.v[i]->name, g->productions.v[i]->state->index);
+ }
+ fprintf(hfp, "#endif\n");
+ fclose(hfp);
+ return 1;
+ }
+ return 0;
+ }
+
+ static char *d_internal[] = {"D_SYMBOL_NTERM", "D_SYMBOL_INTERNAL"};
+ static char *d_symbol[] = {
+ "D_SYMBOL_STRING", "D_SYMBOL_REGEX", "D_SYMBOL_CODE", "D_SYMBOL_TOKEN" };
+ static void
+ write_symbol_data_as_C(FILE *fp, Grammar *g, char *tag) {
+ int i;
+ fprintf(fp, "D_Symbol d_symbols_%s[] = {\n", tag);
+ for (i = 0; i < g->productions.n; i++)
+ fprintf(fp, "{%s, \"%s\", %d},\n",
+ d_internal[g->productions.v[i]->internal ? 1 : 0],
+ g->productions.v[i]->name,
+ g->productions.v[i]->name_len);
+ for (i = 0; i < g->terminals.n; i++) {
+ char *s = escape_string(g->terminals.v[i]->string); /* so it is a string */
+ char *ss = escape_string(s); /* so it is printable */
+ fprintf(fp, "{%s, \"%s\", %d},\n", d_symbol[g->terminals.v[i]->kind],
+ ss, (int) strlen(ss));
+ FREE(s);
+ FREE(ss);
+ }
+ fprintf(fp, "};\n\n");
+ }
+
+ static void
+ write_passes_as_C(FILE *fp, Grammar *g, char *tag) {
+ int i;
+ if (g->passes.n) {
+ fprintf(fp, "D_Pass d_passes_%s[] = {\n", tag);
+ for (i = 0; i < g->passes.n; i++) {
+ D_Pass *p = g->passes.v[i];
+ fprintf(fp, "{\"%s\", %d, 0x%X, %d}%s\n",
+ p->name, p->name_len, p->kind, p->index,
+ i < g->passes.n-1 ? ", " : "");
+ }
+ fprintf(fp, "};\n\n");
+ }
+ }
+
+ void
+ write_parser_tables_as_C(Grammar *g, char *base_pathname, char *tag) {
+ char pathname[FILENAME_MAX];
+ FILE *fp;
+ int whitespace_production = 0, header;
+ VecState er_hash;
+ Production *p;
+
+ vec_clear(&er_hash);
+
+ strcpy(pathname, base_pathname);
+ strcat(pathname, ".d_parser.c");
+ fp = fopen(pathname, "w");
+ if (!fp)
+ d_fail("unable to open `%s` for write\n", pathname);
+
+ header = write_header_as_C(g, base_pathname, tag);
+
+ write_global_code_as_C(fp, g, tag);
+ fprintf(fp, "#include \"dparse.h\"\n");
+ if (header)
+ fprintf(fp, "#include \"%s.d_parser.h\"\n", base_pathname);
+ fprintf(fp, "\n");
+
+ write_reductions_as_C(fp, g, tag);
+ write_scanner_data_as_C(fp, g, tag);
+ write_scanner_code_as_C(fp, g, tag);
+ write_goto_data_as_C(fp, g, tag);
+ write_error_data_as_C(fp, g, &er_hash, tag);
+ write_state_data_as_C(fp, g, &er_hash, tag);
+ write_symbol_data_as_C(fp, g, tag);
+ write_passes_as_C(fp, g, tag);
+
+ if ((p = lookup_production(g, "whitespace", sizeof("whitespace")-1)))
+ whitespace_production = p->state->index;
+
+ fprintf(fp, "D_ParserTables parser_tables_%s = {\n", tag);
+ fprintf(fp, "%d, ", g->states.n);
+ fprintf(fp, "d_states_%s, ", tag);
+ fprintf(fp, "d_gotos_%s, ", tag);
+ fprintf(fp, "%d, ", whitespace_production);
+ fprintf(fp, "%d, ", g->productions.n + g->terminals.n);
+ fprintf(fp, "d_symbols_%s, ", tag);
+ if (g->default_white_space)
+ fprintf(fp, "%s, ", g->default_white_space);
+ else
+ fprintf(fp, "NULL, ");
+ fprintf(fp, "%d, ", g->passes.n);
+ if (g->passes.n)
+ fprintf(fp, "d_passes_%s, ", tag);
+ else
+ fprintf(fp, "NULL, ");
+ if (g->save_parse_tree)
+ fprintf(fp, "1");
+ else
+ fprintf(fp, "0");
+ fprintf(fp, "};\n");
+ fclose(fp);
+ }
+
+ int
+ write_ctables(Grammar *g) {
+ g->scanner_block_size = 256/g->scanner_blocks;
+ write_parser_tables_as_C(g, g->pathname,
+ *g->grammar_ident ? g->grammar_ident : NULL);
+ return 0;
+ }
Index: llvm/test/Programs/MultiSource/Applications/d/write_ctables.h
diff -c /dev/null llvm/test/Programs/MultiSource/Applications/d/write_ctables.h:1.1
*** /dev/null Thu Jan 1 10:50:47 2004
--- llvm/test/Programs/MultiSource/Applications/d/write_ctables.h Thu Jan 1 10:50:36 2004
***************
*** 0 ****
--- 1,5 ----
+ /*
+ Copyright 2002-2003 John Plevyak, All Rights Reserved
+ */
+
+ int write_ctables(Grammar *g);
More information about the llvm-commits
mailing list