1## -*- tcl -*- 2## 3## Critcl-based C/PARAM implementation of the parsing 4## expression grammar 5## 6## PEG 7## 8## Generated from file 3_peg_itself 9## for user aku 10## 11# # ## ### ##### ######## ############# ##################### 12## Requirements 13 14package require Tcl 8.4 15package require critcl 16# @sak notprovided pt_parse_peg_c 17package provide pt_parse_peg_c 1 18 19# Note: The implementation of the PARAM virtual machine 20# underlying the C/PARAM code used below is inlined 21# into the generated parser, allowing for direct access 22# and manipulation of the RDE state, instead of having 23# to dispatch through the Tcl interpreter. 24 25# # ## ### ##### ######## ############# ##################### 26## 27 28namespace eval ::pt::parse { 29 # # ## ### ##### ######## ############# ##################### 30 ## Supporting code for the main command. 31 32 catch { 33 critcl::cheaders -g 34 critcl::debug memory symbols 35 } 36 37 # # ## ### ###### ######## ############# 38 ## RDE runtime, inlined, and made static. 39 40 # This is the C code for the RDE, i.e. the implementation 41 # of pt::rde. Only the low-level engine is imported, the 42 # Tcl interface layer is ignored. This generated parser 43 # provides its own layer for that. 44 45 critcl::ccode { 46 /* -*- c -*- */ 47 48 #include <string.h> 49 #define SCOPE static 50 51#line 1 "rde_critcl/util.h" 52 53 #ifndef _RDE_UTIL_H 54 #define _RDE_UTIL_H 1 55 #ifndef SCOPE 56 #define SCOPE 57 #endif 58 #define ALLOC(type) (type *) ckalloc (sizeof (type)) 59 #define NALLOC(n,type) (type *) ckalloc ((n) * sizeof (type)) 60 #undef RDE_DEBUG 61 #define RDE_DEBUG 1 62 #undef RDE_TRACE 63 #ifdef RDE_DEBUG 64 #define STOPAFTER(x) { static int count = (x); count --; if (!count) { Tcl_Panic ("stop"); } } 65 #define XSTR(x) #x 66 #define STR(x) XSTR(x) 67 #define RANGEOK(i,n) ((0 <= (i)) && (i < (n))) 68 #define ASSERT(x,msg) if (!(x)) { Tcl_Panic (msg " (" #x "), in file " __FILE__ " @line " STR(__LINE__));} 69 #define ASSERT_BOUNDS(i,n) ASSERT (RANGEOK(i,n),"array index out of bounds: " STR(i) " >= " STR(n)) 70 #else 71 #define STOPAFTER(x) 72 #define ASSERT(x,msg) 73 #define ASSERT_BOUNDS(i,n) 74 #endif 75 #ifdef RDE_TRACE 76 SCOPE void trace_enter (const char* fun); 77 SCOPE void trace_return (const char *pat, ...); 78 SCOPE void trace_printf (const char *pat, ...); 79 #define ENTER(fun) trace_enter (fun) 80 #define RETURN(format,x) trace_return (format,x) ; return x 81 #define RETURNVOID trace_return ("%s","(void)") ; return 82 #define TRACE0(x) trace_printf0 x 83 #define TRACE(x) trace_printf x 84 #else 85 #define ENTER(fun) 86 #define RETURN(f,x) return x 87 #define RETURNVOID return 88 #define TRACE0(x) 89 #define TRACE(x) 90 #endif 91 #endif 92 93 94#line 1 "rde_critcl/stack.h" 95 96 #ifndef _RDE_DS_STACK_H 97 #define _RDE_DS_STACK_H 1 98 typedef void (*RDE_STACK_CELL_FREE) (void* cell); 99 typedef struct RDE_STACK_* RDE_STACK; 100 static const int RDE_STACK_INITIAL_SIZE = 256; 101 #endif 102 103 104#line 1 "rde_critcl/tc.h" 105 106 #ifndef _RDE_DS_TC_H 107 #define _RDE_DS_TC_H 1 108 typedef struct RDE_TC_* RDE_TC; 109 #endif 110 111 112#line 1 "rde_critcl/param.h" 113 114 #ifndef _RDE_DS_PARAM_H 115 #define _RDE_DS_PARAM_H 1 116 typedef struct RDE_PARAM_* RDE_PARAM; 117 typedef struct ERROR_STATE { 118 int refCount; 119 long int loc; 120 RDE_STACK msg; 121 } ERROR_STATE; 122 typedef struct NC_STATE { 123 long int CL; 124 long int ST; 125 Tcl_Obj* SV; 126 ERROR_STATE* ER; 127 } NC_STATE; 128 #endif 129 130 131#line 1 "rde_critcl/util.c" 132 133 #ifdef RDE_TRACE 134 typedef struct F_STACK { 135 const char* str; 136 struct F_STACK* down; 137 } F_STACK; 138 static F_STACK* top = 0; 139 static int level = 0; 140 static void 141 push (const char* str) 142 { 143 F_STACK* new = ALLOC (F_STACK); 144 new->str = str; 145 new->down = top; 146 top = new; 147 level += 4; 148 } 149 static void 150 pop (void) 151 { 152 F_STACK* next = top->down; 153 level -= 4; 154 ckfree ((char*)top); 155 top = next; 156 } 157 static void 158 indent (void) 159 { 160 int i; 161 for (i = 0; i < level; i++) { 162 fwrite(" ", 1, 1, stdout); 163 fflush (stdout); 164 } 165 if (top) { 166 fwrite(top->str, 1, strlen(top->str), stdout); 167 fflush (stdout); 168 } 169 fwrite(" ", 1, 1, stdout); 170 fflush (stdout); 171 } 172 SCOPE void 173 trace_enter (const char* fun) 174 { 175 push (fun); 176 indent(); 177 fwrite("ENTER\n", 1, 6, stdout); 178 fflush (stdout); 179 } 180 static char msg [1024*1024]; 181 SCOPE void 182 trace_return (const char *pat, ...) 183 { 184 int len; 185 va_list args; 186 indent(); 187 fwrite("RETURN = ", 1, 9, stdout); 188 fflush (stdout); 189 va_start(args, pat); 190 len = vsprintf(msg, pat, args); 191 va_end(args); 192 msg[len++] = '\n'; 193 msg[len] = '\0'; 194 fwrite(msg, 1, len, stdout); 195 fflush (stdout); 196 pop(); 197 } 198 SCOPE void 199 trace_printf (const char *pat, ...) 200 { 201 int len; 202 va_list args; 203 indent(); 204 va_start(args, pat); 205 len = vsprintf(msg, pat, args); 206 va_end(args); 207 msg[len++] = '\n'; 208 msg[len] = '\0'; 209 fwrite(msg, 1, len, stdout); 210 fflush (stdout); 211 } 212 SCOPE void 213 trace_printf0 (const char *pat, ...) 214 { 215 int len; 216 va_list args; 217 va_start(args, pat); 218 len = vsprintf(msg, pat, args); 219 va_end(args); 220 msg[len++] = '\n'; 221 msg[len] = '\0'; 222 fwrite(msg, 1, len, stdout); 223 fflush (stdout); 224 } 225 #endif 226 227 228#line 1 "rde_critcl/stack.c" 229 230 typedef struct RDE_STACK_ { 231 long int max; 232 long int top; 233 RDE_STACK_CELL_FREE freeCellProc; 234 void** cell; 235 } RDE_STACK_; 236 237 SCOPE RDE_STACK 238 rde_stack_new (RDE_STACK_CELL_FREE freeCellProc) 239 { 240 RDE_STACK s = ALLOC (RDE_STACK_); 241 s->cell = NALLOC (RDE_STACK_INITIAL_SIZE, void*); 242 s->max = RDE_STACK_INITIAL_SIZE; 243 s->top = 0; 244 s->freeCellProc = freeCellProc; 245 return s; 246 } 247 SCOPE void 248 rde_stack_del (RDE_STACK s) 249 { 250 if (s->freeCellProc && s->top) { 251 long int i; 252 for (i=0; i < s->top; i++) { 253 ASSERT_BOUNDS(i,s->max); 254 s->freeCellProc ( s->cell [i] ); 255 } 256 } 257 ckfree ((char*) s->cell); 258 ckfree ((char*) s); 259 } 260 SCOPE void 261 rde_stack_push (RDE_STACK s, void* item) 262 { 263 if (s->top >= s->max) { 264 long int new = s->max ? (2 * s->max) : RDE_STACK_INITIAL_SIZE; 265 void** cell = (void**) ckrealloc ((char*) s->cell, new * sizeof(void*)); 266 ASSERT (cell,"Memory allocation failure for RDE stack"); 267 s->max = new; 268 s->cell = cell; 269 } 270 ASSERT_BOUNDS(s->top,s->max); 271 s->cell [s->top] = item; 272 s->top ++; 273 } 274 SCOPE void* 275 rde_stack_top (RDE_STACK s) 276 { 277 ASSERT_BOUNDS(s->top-1,s->max); 278 return s->cell [s->top - 1]; 279 } 280 SCOPE void 281 rde_stack_pop (RDE_STACK s, long int n) 282 { 283 ASSERT (n >= 0, "Bad pop count"); 284 if (n == 0) return; 285 if (s->freeCellProc) { 286 while (n) { 287 s->top --; 288 ASSERT_BOUNDS(s->top,s->max); 289 s->freeCellProc ( s->cell [s->top] ); 290 n --; 291 } 292 } else { 293 s->top -= n; 294 } 295 } 296 SCOPE void 297 rde_stack_trim (RDE_STACK s, long int n) 298 { 299 ASSERT (n >= 0, "Bad trimsize"); 300 if (s->freeCellProc) { 301 while (s->top > n) { 302 s->top --; 303 ASSERT_BOUNDS(s->top,s->max); 304 s->freeCellProc ( s->cell [s->top] ); 305 } 306 } else { 307 s->top = n; 308 } 309 } 310 SCOPE void 311 rde_stack_drop (RDE_STACK s, long int n) 312 { 313 ASSERT (n >= 0, "Bad pop count"); 314 if (n == 0) return; 315 s->top -= n; 316 } 317 SCOPE void 318 rde_stack_move (RDE_STACK dst, RDE_STACK src) 319 { 320 ASSERT (dst->freeCellProc == src->freeCellProc, "Ownership mismatch"); 321 322 while (src->top > 0) { 323 src->top --; 324 ASSERT_BOUNDS(src->top,src->max); 325 rde_stack_push (dst, src->cell [src->top] ); 326 } 327 } 328 SCOPE void 329 rde_stack_get (RDE_STACK s, long int* cn, void*** cc) 330 { 331 *cn = s->top; 332 *cc = s->cell; 333 } 334 SCOPE long int 335 rde_stack_size (RDE_STACK s) 336 { 337 return s->top; 338 } 339 340 341#line 1 "rde_critcl/tc.c" 342 343 typedef struct RDE_TC_ { 344 int max; 345 int num; 346 char* str; 347 RDE_STACK off; 348 } RDE_TC_; 349 350 SCOPE RDE_TC 351 rde_tc_new (void) 352 { 353 RDE_TC tc = ALLOC (RDE_TC_); 354 tc->max = RDE_STACK_INITIAL_SIZE; 355 tc->num = 0; 356 tc->str = NALLOC (RDE_STACK_INITIAL_SIZE, char); 357 tc->off = rde_stack_new (NULL); 358 return tc; 359 } 360 SCOPE void 361 rde_tc_del (RDE_TC tc) 362 { 363 rde_stack_del (tc->off); 364 ckfree (tc->str); 365 ckfree ((char*) tc); 366 } 367 SCOPE long int 368 rde_tc_size (RDE_TC tc) 369 { 370 return rde_stack_size (tc->off); 371 } 372 SCOPE void 373 rde_tc_clear (RDE_TC tc) 374 { 375 tc->num = 0; 376 rde_stack_trim (tc->off, 0); 377 } 378 SCOPE char* 379 rde_tc_append (RDE_TC tc, char* string, long int len) 380 { 381 long int base = tc->num; 382 long int off = tc->num; 383 char* ch; 384 int clen; 385 Tcl_UniChar uni; 386 if (len < 0) { 387 len = strlen (ch); 388 } 389 390 if ((tc->num + len) >= tc->max) { 391 int new = len + (tc->max ? (2 * tc->max) : RDE_STACK_INITIAL_SIZE); 392 char* str = ckrealloc (tc->str, new * sizeof(char)); 393 ASSERT (str,"Memory allocation failure for token character array"); 394 tc->max = new; 395 tc->str = str; 396 } 397 tc->num += len; 398 ASSERT_BOUNDS(tc->num,tc->max); 399 ASSERT_BOUNDS(off,tc->max); 400 ASSERT_BOUNDS(off+len-1,tc->max); 401 ASSERT_BOUNDS(off+len-1,tc->num); 402 memcpy (tc->str + off, string, len); 403 404 ch = string; 405 while (ch < (string + len)) { 406 ASSERT_BOUNDS(off,tc->num); 407 rde_stack_push (tc->off, (void*) off); 408 clen = Tcl_UtfToUniChar (ch, &uni); 409 off += clen; 410 ch += clen; 411 } 412 return tc->str + base; 413 } 414 SCOPE void 415 rde_tc_get (RDE_TC tc, int at, char** ch, long int* len) 416 { 417 long int oc, off, top, end; 418 long int* ov; 419 rde_stack_get (tc->off, &oc, (void***) &ov); 420 ASSERT_BOUNDS(at,oc); 421 off = ov [at]; 422 if ((at+1) == oc) { 423 end = tc->num; 424 } else { 425 end = ov [at+1]; 426 } 427 TRACE (("rde_tc_get (RDE_TC %p, @ %d) => %d.[%d ... %d]/%d",tc,at,end-off,off,end-1,tc->num)); 428 ASSERT_BOUNDS(off,tc->num); 429 ASSERT_BOUNDS(end-1,tc->num); 430 *ch = tc->str + off; 431 *len = end - off; 432 } 433 SCOPE void 434 rde_tc_get_s (RDE_TC tc, int at, int last, char** ch, long int* len) 435 { 436 long int oc, off, top, end; 437 long int* ov; 438 rde_stack_get (tc->off, &oc, (void***) &ov); 439 ASSERT_BOUNDS(at,oc); 440 ASSERT_BOUNDS(last,oc); 441 off = ov [at]; 442 if ((last+1) == oc) { 443 end = tc->num; 444 } else { 445 end = ov [last+1]; 446 } 447 TRACE (("rde_tc_get_s (RDE_TC %p, @ %d .. %d) => %d.[%d ... %d]/%d",tc,at,last,end-off,off,end-1,tc->num)); 448 ASSERT_BOUNDS(off,tc->num); 449 ASSERT_BOUNDS(end-1,tc->num); 450 *ch = tc->str + off; 451 *len = end - off; 452 } 453 454 455#line 1 "rde_critcl/param.c" 456 457 typedef struct RDE_PARAM_ { 458 Tcl_Channel IN; 459 Tcl_Obj* readbuf; 460 char* CC; 461 long int CC_len; 462 RDE_TC TC; 463 long int CL; 464 RDE_STACK LS; 465 ERROR_STATE* ER; 466 RDE_STACK ES; 467 long int ST; 468 Tcl_Obj* SV; 469 Tcl_HashTable NC; 470 471 RDE_STACK ast ; 472 RDE_STACK mark ; 473 474 long int numstr; 475 char** string; 476 477 ClientData clientData; 478 } RDE_PARAM_; 479 typedef int (*UniCharClass) (int); 480 typedef enum test_class_id { 481 tc_alnum, 482 tc_alpha, 483 tc_ascii, 484 tc_ddigit, 485 tc_digit, 486 tc_graph, 487 tc_lower, 488 tc_printable, 489 tc_punct, 490 tc_space, 491 tc_upper, 492 tc_wordchar, 493 tc_xdigit 494 } test_class_id; 495 static void ast_node_free (void* n); 496 static void error_state_free (void* es); 497 static void error_set (RDE_PARAM p, int s); 498 static void nc_clear (RDE_PARAM p); 499 static int UniCharIsAscii (int character); 500 static int UniCharIsHexDigit (int character); 501 static int UniCharIsDecDigit (int character); 502 static void test_class (RDE_PARAM p, UniCharClass class, test_class_id id); 503 static int er_int_compare (const void* a, const void* b); 504 #define SV_INIT(p) \ 505 p->SV = NULL; \ 506 TRACE (("SV_INIT (%p => %p)", (p), (p)->SV)) 507 #define SV_SET(p,newsv) \ 508 if (((p)->SV) != (newsv)) { \ 509 TRACE (("SV_CLEAR/set (%p => %p)", (p), (p)->SV)); \ 510 if ((p)->SV) { \ 511 Tcl_DecrRefCount ((p)->SV); \ 512 } \ 513 (p)->SV = (newsv); \ 514 TRACE (("SV_SET (%p => %p)", (p), (p)->SV)); \ 515 if ((p)->SV) { \ 516 Tcl_IncrRefCount ((p)->SV); \ 517 } \ 518 } 519 #define SV_CLEAR(p) \ 520 TRACE (("SV_CLEAR (%p => %p)", (p), (p)->SV)); \ 521 if ((p)->SV) { \ 522 Tcl_DecrRefCount ((p)->SV); \ 523 } \ 524 (p)->SV = NULL 525 #define ER_INIT(p) \ 526 p->ER = NULL; \ 527 TRACE (("ER_INIT (%p => %p)", (p), (p)->ER)) 528 #define ER_CLEAR(p) \ 529 error_state_free ((p)->ER); \ 530 (p)->ER = NULL 531 SCOPE RDE_PARAM 532 rde_param_new (long int nstr, char** strings) 533 { 534 RDE_PARAM p; 535 ENTER ("rde_param_new"); 536 TRACE (("\tINT %d strings @ %p", nstr, strings)); 537 p = ALLOC (RDE_PARAM_); 538 p->numstr = nstr; 539 p->string = strings; 540 p->readbuf = Tcl_NewObj (); 541 Tcl_IncrRefCount (p->readbuf); 542 TRACE (("\tTcl_Obj* readbuf %p used %d", p->readbuf,p->readbuf->refCount)); 543 Tcl_InitHashTable (&p->NC, TCL_ONE_WORD_KEYS); 544 p->IN = NULL; 545 p->CL = -1; 546 p->ST = 0; 547 ER_INIT (p); 548 SV_INIT (p); 549 p->CC = NULL; 550 p->CC_len = 0; 551 p->TC = rde_tc_new (); 552 p->ES = rde_stack_new (error_state_free); 553 p->LS = rde_stack_new (NULL); 554 p->ast = rde_stack_new (ast_node_free); 555 p->mark = rde_stack_new (NULL); 556 RETURN ("%p", p); 557 } 558 SCOPE void 559 rde_param_del (RDE_PARAM p) 560 { 561 ENTER ("rde_param_del"); 562 TRACE (("RDE_PARAM %p",p)); 563 ER_CLEAR (p); TRACE (("\ter_clear")); 564 SV_CLEAR (p); TRACE (("\tsv_clear")); 565 nc_clear (p); TRACE (("\tnc_clear")); 566 Tcl_DeleteHashTable (&p->NC); TRACE (("\tnc hashtable delete")); 567 rde_tc_del (p->TC); TRACE (("\ttc clear")); 568 rde_stack_del (p->ES); TRACE (("\tes clear")); 569 rde_stack_del (p->LS); TRACE (("\tls clear")); 570 rde_stack_del (p->ast); TRACE (("\tast clear")); 571 rde_stack_del (p->mark); TRACE (("\tmark clear")); 572 TRACE (("\tTcl_Obj* readbuf %p used %d", p->readbuf,p->readbuf->refCount)); 573 Tcl_DecrRefCount (p->readbuf); 574 ckfree ((char*) p); 575 RETURNVOID; 576 } 577 SCOPE void 578 rde_param_reset (RDE_PARAM p, Tcl_Channel chan) 579 { 580 ENTER ("rde_param_reset"); 581 TRACE (("RDE_PARAM %p",p)); 582 TRACE (("Tcl_Channel %p",chan)); 583 p->IN = chan; 584 p->CL = -1; 585 p->ST = 0; 586 p->CC = NULL; 587 p->CC_len = 0; 588 ER_CLEAR (p); 589 SV_CLEAR (p); 590 nc_clear (p); 591 rde_tc_clear (p->TC); 592 rde_stack_trim (p->ES, 0); 593 rde_stack_trim (p->LS, 0); 594 rde_stack_trim (p->ast, 0); 595 rde_stack_trim (p->mark, 0); 596 TRACE (("\tTcl_Obj* readbuf %p used %d", p->readbuf,p->readbuf->refCount)); 597 RETURNVOID; 598 } 599 SCOPE void 600 rde_param_update_strings (RDE_PARAM p, long int nstr, char** strings) 601 { 602 ENTER ("rde_param_update_strings"); 603 TRACE (("RDE_PARAM %p", p)); 604 TRACE (("INT %d strings", nstr)); 605 p->numstr = nstr; 606 p->string = strings; 607 RETURNVOID; 608 } 609 SCOPE void 610 rde_param_data (RDE_PARAM p, char* buf, long int len) 611 { 612 (void) rde_tc_append (p->TC, buf, len); 613 } 614 SCOPE void 615 rde_param_clientdata (RDE_PARAM p, ClientData clientData) 616 { 617 p->clientData = clientData; 618 } 619 static void 620 nc_clear (RDE_PARAM p) 621 { 622 Tcl_HashSearch hs; 623 Tcl_HashEntry* he; 624 Tcl_HashTable* tablePtr; 625 for(he = Tcl_FirstHashEntry(&p->NC, &hs); 626 he != NULL; 627 he = Tcl_FirstHashEntry(&p->NC, &hs)) { 628 Tcl_HashSearch hsc; 629 Tcl_HashEntry* hec; 630 tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (he); 631 for(hec = Tcl_FirstHashEntry(tablePtr, &hsc); 632 hec != NULL; 633 hec = Tcl_NextHashEntry(&hsc)) { 634 NC_STATE* scs = Tcl_GetHashValue (hec); 635 error_state_free (scs->ER); 636 if (scs->SV) { Tcl_DecrRefCount (scs->SV); } 637 ckfree ((char*) scs); 638 } 639 Tcl_DeleteHashTable (tablePtr); 640 ckfree ((char*) tablePtr); 641 Tcl_DeleteHashEntry (he); 642 } 643 } 644 SCOPE ClientData 645 rde_param_query_clientdata (RDE_PARAM p) 646 { 647 return p->clientData; 648 } 649 SCOPE void 650 rde_param_query_amark (RDE_PARAM p, long int* mc, long int** mv) 651 { 652 rde_stack_get (p->mark, mc, (void***) mv); 653 } 654 SCOPE void 655 rde_param_query_ast (RDE_PARAM p, long int* ac, Tcl_Obj*** av) 656 { 657 rde_stack_get (p->ast, ac, (void***) av); 658 } 659 SCOPE const char* 660 rde_param_query_in (RDE_PARAM p) 661 { 662 return p->IN 663 ? Tcl_GetChannelName (p->IN) 664 : ""; 665 } 666 SCOPE const char* 667 rde_param_query_cc (RDE_PARAM p, long int* len) 668 { 669 *len = p->CC_len; 670 return p->CC; 671 } 672 SCOPE int 673 rde_param_query_cl (RDE_PARAM p) 674 { 675 return p->CL; 676 } 677 SCOPE const ERROR_STATE* 678 rde_param_query_er (RDE_PARAM p) 679 { 680 return p->ER; 681 } 682 SCOPE Tcl_Obj* 683 rde_param_query_er_tcl (RDE_PARAM p, const ERROR_STATE* er) 684 { 685 Tcl_Obj* res; 686 if (!er) { 687 688 res = Tcl_NewStringObj ("", 0); 689 } else { 690 Tcl_Obj* ov [2]; 691 Tcl_Obj** mov; 692 long int mc, i, j; 693 long int* mv; 694 int lastid; 695 const char* msg; 696 rde_stack_get (er->msg, &mc, (void***) &mv); 697 698 qsort (mv, mc, sizeof (long int), er_int_compare); 699 700 mov = NALLOC (mc, Tcl_Obj*); 701 lastid = -1; 702 for (i=0, j=0; i < mc; i++) { 703 ASSERT_BOUNDS (i,mc); 704 if (mv [i] == lastid) continue; 705 lastid = mv [i]; 706 ASSERT_BOUNDS(mv[i],p->numstr); 707 msg = p->string [mv[i]]; 708 ASSERT_BOUNDS (j,mc); 709 mov [j] = Tcl_NewStringObj (msg, -1); 710 j++; 711 } 712 713 ov [0] = Tcl_NewIntObj (er->loc); 714 ov [1] = Tcl_NewListObj (j, mov); 715 res = Tcl_NewListObj (2, ov); 716 ckfree ((char*) mov); 717 } 718 return res; 719 } 720 SCOPE void 721 rde_param_query_es (RDE_PARAM p, long int* ec, ERROR_STATE*** ev) 722 { 723 rde_stack_get (p->ES, ec, (void***) ev); 724 } 725 SCOPE void 726 rde_param_query_ls (RDE_PARAM p, long int* lc, long int** lv) 727 { 728 rde_stack_get (p->LS, lc, (void***) lv); 729 } 730 SCOPE Tcl_HashTable* 731 rde_param_query_nc (RDE_PARAM p) 732 { 733 return &p->NC; 734 } 735 SCOPE int 736 rde_param_query_st (RDE_PARAM p) 737 { 738 return p->ST; 739 } 740 SCOPE Tcl_Obj* 741 rde_param_query_sv (RDE_PARAM p) 742 { 743 TRACE (("SV_QUERY %p => (%p)", (p), (p)->SV)); \ 744 return p->SV; 745 } 746 SCOPE long int 747 rde_param_query_tc_size (RDE_PARAM p) 748 { 749 return rde_tc_size (p->TC); 750 } 751 SCOPE void 752 rde_param_query_tc_get_s (RDE_PARAM p, long int at, long int last, char** ch, long int* len) 753 { 754 rde_tc_get_s (p->TC, at, last, ch, len); 755 } 756 SCOPE const char* 757 rde_param_query_string (RDE_PARAM p, long int id) 758 { 759 TRACE (("rde_param_query_string (RDE_PARAM %p, %d/%d)", p, id, p->numstr)); 760 ASSERT_BOUNDS(id,p->numstr); 761 return p->string [id]; 762 } 763 SCOPE void 764 rde_param_i_ast_pop_discard (RDE_PARAM p) 765 { 766 rde_stack_pop (p->mark, 1); 767 } 768 SCOPE void 769 rde_param_i_ast_pop_rewind (RDE_PARAM p) 770 { 771 long int trim = (long int) rde_stack_top (p->mark); 772 ENTER ("rde_param_i_ast_pop_rewind"); 773 TRACE (("RDE_PARAM %p",p)); 774 rde_stack_pop (p->mark, 1); 775 rde_stack_trim (p->ast, (int) trim); 776 TRACE (("SV = (%p rc%d '%s')", 777 p->SV, 778 p->SV ? p->SV->refCount : -1, 779 p->SV ? Tcl_GetString (p->SV) : "")); 780 RETURNVOID; 781 } 782 SCOPE void 783 rde_param_i_ast_rewind (RDE_PARAM p) 784 { 785 long int trim = (long int) rde_stack_top (p->mark); 786 ENTER ("rde_param_i_ast_rewind"); 787 TRACE (("RDE_PARAM %p",p)); 788 rde_stack_trim (p->ast, (int) trim); 789 TRACE (("SV = (%p rc%d '%s')", 790 p->SV, 791 p->SV ? p->SV->refCount : -1, 792 p->SV ? Tcl_GetString (p->SV) : "")); 793 RETURNVOID; 794 } 795 SCOPE void 796 rde_param_i_ast_push (RDE_PARAM p) 797 { 798 rde_stack_push (p->mark, (void*) rde_stack_size (p->ast)); 799 } 800 SCOPE void 801 rde_param_i_ast_value_push (RDE_PARAM p) 802 { 803 ENTER ("rde_param_i_ast_value_push"); 804 TRACE (("RDE_PARAM %p",p)); 805 ASSERT(p->SV,"Unable to push undefined semantic value"); 806 TRACE (("rde_param_i_ast_value_push %p => (%p)/%d", p, p->SV, )); 807 TRACE (("SV = (%p rc%d '%s')", p->SV, p->SV->refCount, Tcl_GetString (p->SV))); 808 rde_stack_push (p->ast, p->SV); 809 Tcl_IncrRefCount (p->SV); 810 RETURNVOID; 811 } 812 static void 813 ast_node_free (void* n) 814 { 815 Tcl_DecrRefCount ((Tcl_Obj*) n); 816 } 817 SCOPE void 818 rde_param_i_error_clear (RDE_PARAM p) 819 { 820 ER_CLEAR (p); 821 } 822 SCOPE void 823 rde_param_i_error_nonterminal (RDE_PARAM p, int s) 824 { 825 long int pos; 826 if (!p->ER) return; 827 pos = 1 + (long int) rde_stack_top (p->LS); 828 if (p->ER->loc != pos) return; 829 error_set (p, s); 830 p->ER->loc = pos; 831 } 832 SCOPE void 833 rde_param_i_error_pop_merge (RDE_PARAM p) 834 { 835 ERROR_STATE* top = (ERROR_STATE*) rde_stack_top (p->ES); 836 837 if (top == p->ER) { 838 rde_stack_pop (p->ES, 1); 839 return; 840 } 841 842 if (!top) { 843 rde_stack_pop (p->ES, 1); 844 return; 845 } 846 847 if (!p->ER) { 848 rde_stack_drop (p->ES, 1); 849 p->ER = top; 850 851 return; 852 } 853 854 if (top->loc < p->ER->loc) { 855 rde_stack_pop (p->ES, 1); 856 return; 857 } 858 859 if (top->loc > p->ER->loc) { 860 rde_stack_drop (p->ES, 1); 861 error_state_free (p->ER); 862 p->ER = top; 863 864 return; 865 } 866 867 rde_stack_move (p->ER->msg, top->msg); 868 rde_stack_pop (p->ES, 1); 869 } 870 SCOPE void 871 rde_param_i_error_push (RDE_PARAM p) 872 { 873 rde_stack_push (p->ES, p->ER); 874 if (p->ER) { p->ER->refCount ++; } 875 } 876 static void 877 error_set (RDE_PARAM p, int s) 878 { 879 error_state_free (p->ER); 880 p->ER = ALLOC (ERROR_STATE); 881 p->ER->refCount = 1; 882 p->ER->loc = p->CL; 883 p->ER->msg = rde_stack_new (NULL); 884 ASSERT_BOUNDS(s,p->numstr); 885 rde_stack_push (p->ER->msg, (void*) s); 886 } 887 static void 888 error_state_free (void* esx) 889 { 890 ERROR_STATE* es = esx; 891 if (!es) return; 892 es->refCount --; 893 if (es->refCount > 0) return; 894 rde_stack_del (es->msg); 895 ckfree ((char*) es); 896 } 897 SCOPE void 898 rde_param_i_loc_pop_discard (RDE_PARAM p) 899 { 900 rde_stack_pop (p->LS, 1); 901 } 902 SCOPE void 903 rde_param_i_loc_pop_rewind (RDE_PARAM p) 904 { 905 p->CL = (long int) rde_stack_top (p->LS); 906 rde_stack_pop (p->LS, 1); 907 } 908 SCOPE void 909 rde_param_i_loc_push (RDE_PARAM p) 910 { 911 rde_stack_push (p->LS, (void*) p->CL); 912 } 913 SCOPE void 914 rde_param_i_loc_rewind (RDE_PARAM p) 915 { 916 p->CL = (long int) rde_stack_top (p->LS); 917 } 918 SCOPE void 919 rde_param_i_input_next (RDE_PARAM p, int m) 920 { 921 int leni; 922 char* ch; 923 ASSERT_BOUNDS(m,p->numstr); 924 p->CL ++; 925 if (p->CL < rde_tc_size (p->TC)) { 926 927 rde_tc_get (p->TC, p->CL, &p->CC, &p->CC_len); 928 ASSERT_BOUNDS (p->CC_len, TCL_UTF_MAX); 929 p->ST = 1; 930 ER_CLEAR (p); 931 return; 932 } 933 if (!p->IN || 934 Tcl_Eof (p->IN) || 935 (Tcl_ReadChars (p->IN, p->readbuf, 1, 0) <= 0)) { 936 937 p->ST = 0; 938 error_set (p, m); 939 return; 940 } 941 942 ch = Tcl_GetStringFromObj (p->readbuf, &leni); 943 ASSERT_BOUNDS (leni, TCL_UTF_MAX); 944 p->CC = rde_tc_append (p->TC, ch, leni); 945 p->CC_len = leni; 946 p->ST = 1; 947 ER_CLEAR (p); 948 } 949 SCOPE void 950 rde_param_i_status_fail (RDE_PARAM p) 951 { 952 p->ST = 0; 953 } 954 SCOPE void 955 rde_param_i_status_ok (RDE_PARAM p) 956 { 957 p->ST = 1; 958 } 959 SCOPE void 960 rde_param_i_status_negate (RDE_PARAM p) 961 { 962 p->ST = !p->ST; 963 } 964 SCOPE int 965 rde_param_i_symbol_restore (RDE_PARAM p, int s) 966 { 967 NC_STATE* scs; 968 Tcl_HashEntry* hPtr; 969 Tcl_HashTable* tablePtr; 970 971 hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); 972 if (!hPtr) { return 0; } 973 tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); 974 hPtr = Tcl_FindHashEntry (tablePtr, (char*) s); 975 if (!hPtr) { return 0; } 976 977 scs = Tcl_GetHashValue (hPtr); 978 p->CL = scs->CL; 979 p->ST = scs->ST; 980 error_state_free (p->ER); 981 p->ER = scs->ER; 982 if (p->ER) { p->ER->refCount ++; } 983 TRACE (("SV_RESTORE (%p) '%s'",scs->SV, scs->SV ? Tcl_GetString (scs->SV):"")); 984 SV_SET (p, scs->SV); 985 return 1; 986 } 987 SCOPE void 988 rde_param_i_symbol_save (RDE_PARAM p, int s) 989 { 990 long int at = (long int) rde_stack_top (p->LS); 991 NC_STATE* scs; 992 Tcl_HashEntry* hPtr; 993 Tcl_HashTable* tablePtr; 994 int isnew; 995 ENTER ("rde_param_i_symbol_save"); 996 TRACE (("RDE_PARAM %p",p)); 997 TRACE (("INT %d",s)); 998 999 hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew); 1000 if (isnew) { 1001 tablePtr = ALLOC (Tcl_HashTable); 1002 Tcl_InitHashTable (tablePtr, TCL_ONE_WORD_KEYS); 1003 Tcl_SetHashValue (hPtr, tablePtr); 1004 } else { 1005 tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); 1006 } 1007 hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew); 1008 if (isnew) { 1009 1010 scs = ALLOC (NC_STATE); 1011 scs->CL = p->CL; 1012 scs->ST = p->ST; 1013 TRACE (("SV_CACHE (%p '%s')", p->SV, p->SV ? Tcl_GetString(p->SV) : "")); 1014 scs->SV = p->SV; 1015 if (scs->SV) { Tcl_IncrRefCount (scs->SV); } 1016 scs->ER = p->ER; 1017 if (scs->ER) { scs->ER->refCount ++; } 1018 Tcl_SetHashValue (hPtr, scs); 1019 } else { 1020 1021 scs = (NC_STATE*) Tcl_GetHashValue (hPtr); 1022 scs->CL = p->CL; 1023 scs->ST = p->ST; 1024 TRACE (("SV_CACHE/over (%p '%s')", p->SV, p->SV ? Tcl_GetString(p->SV) : "" )); 1025 if (scs->SV) { Tcl_DecrRefCount (scs->SV); } 1026 scs->SV = p->SV; 1027 if (scs->SV) { Tcl_IncrRefCount (scs->SV); } 1028 error_state_free (scs->ER); 1029 scs->ER = p->ER; 1030 if (scs->ER) { scs->ER->refCount ++; } 1031 } 1032 TRACE (("SV = (%p rc%d '%s')", 1033 p->SV, 1034 p->SV ? p->SV->refCount : -1, 1035 p->SV ? Tcl_GetString (p->SV) : "")); 1036 RETURNVOID; 1037 } 1038 SCOPE void 1039 rde_param_i_test_alnum (RDE_PARAM p) 1040 { 1041 test_class (p, Tcl_UniCharIsAlnum, tc_alnum); 1042 } 1043 SCOPE void 1044 rde_param_i_test_alpha (RDE_PARAM p) 1045 { 1046 test_class (p, Tcl_UniCharIsAlpha, tc_alpha); 1047 } 1048 SCOPE void 1049 rde_param_i_test_ascii (RDE_PARAM p) 1050 { 1051 test_class (p, UniCharIsAscii, tc_ascii); 1052 } 1053 SCOPE void 1054 rde_param_i_test_char (RDE_PARAM p, char* c, int msg) 1055 { 1056 ASSERT_BOUNDS(msg,p->numstr); 1057 p->ST = Tcl_UtfNcmp (p->CC, c, 1) == 0; 1058 if (p->ST) { 1059 ER_CLEAR (p); 1060 } else { 1061 error_set (p, msg); 1062 p->CL --; 1063 } 1064 } 1065 SCOPE void 1066 rde_param_i_test_ddigit (RDE_PARAM p) 1067 { 1068 test_class (p, UniCharIsDecDigit, tc_ddigit); 1069 } 1070 SCOPE void 1071 rde_param_i_test_digit (RDE_PARAM p) 1072 { 1073 test_class (p, Tcl_UniCharIsDigit, tc_digit); 1074 } 1075 SCOPE void 1076 rde_param_i_test_graph (RDE_PARAM p) 1077 { 1078 test_class (p, Tcl_UniCharIsGraph, tc_graph); 1079 } 1080 SCOPE void 1081 rde_param_i_test_lower (RDE_PARAM p) 1082 { 1083 test_class (p, Tcl_UniCharIsLower, tc_lower); 1084 } 1085 SCOPE void 1086 rde_param_i_test_print (RDE_PARAM p) 1087 { 1088 test_class (p, Tcl_UniCharIsPrint, tc_printable); 1089 } 1090 SCOPE void 1091 rde_param_i_test_punct (RDE_PARAM p) 1092 { 1093 test_class (p, Tcl_UniCharIsPunct, tc_punct); 1094 } 1095 SCOPE void 1096 rde_param_i_test_range (RDE_PARAM p, char* s, char* e, int msg) 1097 { 1098 ASSERT_BOUNDS(msg,p->numstr); 1099 p->ST = 1100 (Tcl_UtfNcmp (s, p->CC, 1) <= 0) && 1101 (Tcl_UtfNcmp (p->CC, e, 1) <= 0); 1102 if (p->ST) { 1103 ER_CLEAR (p); 1104 } else { 1105 error_set (p, msg); 1106 p->CL --; 1107 } 1108 } 1109 SCOPE void 1110 rde_param_i_test_space (RDE_PARAM p) 1111 { 1112 test_class (p, Tcl_UniCharIsSpace, tc_space); 1113 } 1114 SCOPE void 1115 rde_param_i_test_upper (RDE_PARAM p) 1116 { 1117 test_class (p, Tcl_UniCharIsUpper, tc_upper); 1118 } 1119 SCOPE void 1120 rde_param_i_test_wordchar (RDE_PARAM p) 1121 { 1122 test_class (p, Tcl_UniCharIsWordChar, tc_wordchar); 1123 } 1124 SCOPE void 1125 rde_param_i_test_xdigit (RDE_PARAM p) 1126 { 1127 test_class (p, UniCharIsHexDigit, tc_xdigit); 1128 } 1129 static void 1130 test_class (RDE_PARAM p, UniCharClass class, test_class_id id) 1131 { 1132 Tcl_UniChar ch; 1133 Tcl_UtfToUniChar(p->CC, &ch); 1134 ASSERT_BOUNDS(id,p->numstr); 1135 p->ST = !!class (ch); 1136 1137 if (p->ST) { 1138 ER_CLEAR (p); 1139 } else { 1140 error_set (p, id); 1141 p->CL --; 1142 } 1143 } 1144 static int 1145 UniCharIsAscii (int character) 1146 { 1147 return (character >= 0) && (character < 0x80); 1148 } 1149 static int 1150 UniCharIsHexDigit (int character) 1151 { 1152 return (character >= 0) && (character < 0x80) && isxdigit(character); 1153 } 1154 static int 1155 UniCharIsDecDigit (int character) 1156 { 1157 return (character >= 0) && (character < 0x80) && isdigit(character); 1158 } 1159 SCOPE void 1160 rde_param_i_value_clear (RDE_PARAM p) 1161 { 1162 SV_CLEAR (p); 1163 } 1164 SCOPE void 1165 rde_param_i_value_leaf (RDE_PARAM p, int s) 1166 { 1167 Tcl_Obj* newsv; 1168 Tcl_Obj* ov [3]; 1169 long int pos = 1 + (long int) rde_stack_top (p->LS); 1170 ASSERT_BOUNDS(s,p->numstr); 1171 ov [0] = Tcl_NewStringObj (p->string[s], -1); 1172 ov [1] = Tcl_NewIntObj (pos); 1173 ov [2] = Tcl_NewIntObj (p->CL); 1174 newsv = Tcl_NewListObj (3, ov); 1175 TRACE (("rde_param_i_value_leaf => '%s'",Tcl_GetString (newsv))); 1176 SV_SET (p, newsv); 1177 } 1178 SCOPE void 1179 rde_param_i_value_reduce (RDE_PARAM p, int s) 1180 { 1181 Tcl_Obj* newsv; 1182 int oc, i, j; 1183 Tcl_Obj** ov; 1184 long int ac; 1185 Tcl_Obj** av; 1186 long int pos = 1 + (long int) rde_stack_top (p->LS); 1187 long int mark = (long int) rde_stack_top (p->mark); 1188 long int asize = rde_stack_size (p->ast); 1189 long int new = asize - mark; 1190 ASSERT (new >= 0, "Bad number of elements to reduce"); 1191 ov = NALLOC (3+new, Tcl_Obj*); 1192 ASSERT_BOUNDS(s,p->numstr); 1193 ov [0] = Tcl_NewStringObj (p->string[s], -1); 1194 ov [1] = Tcl_NewIntObj (pos); 1195 ov [2] = Tcl_NewIntObj (p->CL); 1196 rde_stack_get (p->ast, &ac, (void***) &av); 1197 for (i = 3, j = mark; j < asize; i++, j++) { 1198 ASSERT_BOUNDS (i, 3+new); 1199 ASSERT_BOUNDS (j, ac); 1200 ov [i] = av [j]; 1201 } 1202 ASSERT (i == 3+new, "Reduction result incomplete"); 1203 newsv = Tcl_NewListObj (3+new, ov); 1204 TRACE (("rde_param_i_value_reduce => '%s'",Tcl_GetString (newsv))); 1205 SV_SET (p, newsv); 1206 ckfree ((char*) ov); 1207 } 1208 static int 1209 er_int_compare (const void* a, const void* b) 1210 { 1211 long int ai = *((long int*) a); 1212 long int bi = *((long int*) b); 1213 if (ai < bi) { return -1; } 1214 if (ai > bi) { return 1; } 1215 return 0; 1216 } 1217 SCOPE int 1218 rde_param_i_symbol_start (RDE_PARAM p, int s) 1219 { 1220 if (rde_param_i_symbol_restore (p, s)) { 1221 if (p->ST) { 1222 rde_stack_push (p->ast, p->SV); 1223 Tcl_IncrRefCount (p->SV); 1224 } 1225 return 1; 1226 } 1227 rde_stack_push (p->LS, (void*) p->CL); 1228 return 0; 1229 } 1230 SCOPE int 1231 rde_param_i_symbol_start_d (RDE_PARAM p, int s) 1232 { 1233 if (rde_param_i_symbol_restore (p, s)) { 1234 if (p->ST) { 1235 rde_stack_push (p->ast, p->SV); 1236 Tcl_IncrRefCount (p->SV); 1237 } 1238 return 1; 1239 } 1240 rde_stack_push (p->LS, (void*) p->CL); 1241 rde_stack_push (p->mark, (void*) rde_stack_size (p->ast)); 1242 return 0; 1243 } 1244 SCOPE int 1245 rde_param_i_symbol_void_start (RDE_PARAM p, int s) 1246 { 1247 if (rde_param_i_symbol_restore (p, s)) return 1; 1248 rde_stack_push (p->LS, (void*) p->CL); 1249 return 0; 1250 } 1251 SCOPE int 1252 rde_param_i_symbol_void_start_d (RDE_PARAM p, int s) 1253 { 1254 if (rde_param_i_symbol_restore (p, s)) return 1; 1255 rde_stack_push (p->LS, (void*) p->CL); 1256 rde_stack_push (p->mark, (void*) rde_stack_size (p->ast)); 1257 return 0; 1258 } 1259 SCOPE void 1260 rde_param_i_symbol_done_d_reduce (RDE_PARAM p, int s, int m) 1261 { 1262 if (p->ST) { 1263 rde_param_i_value_reduce (p, s); 1264 } else { 1265 SV_CLEAR (p); 1266 } 1267 rde_param_i_symbol_save (p, s); 1268 rde_param_i_error_nonterminal (p, m); 1269 rde_param_i_ast_pop_rewind (p); 1270 rde_stack_pop (p->LS, 1); 1271 if (p->ST) { 1272 rde_stack_push (p->ast, p->SV); 1273 Tcl_IncrRefCount (p->SV); 1274 } 1275 } 1276 SCOPE void 1277 rde_param_i_symbol_done_leaf (RDE_PARAM p, int s, int m) 1278 { 1279 if (p->ST) { 1280 rde_param_i_value_leaf (p, s); 1281 } else { 1282 SV_CLEAR (p); 1283 } 1284 rde_param_i_symbol_save (p, s); 1285 rde_param_i_error_nonterminal (p, m); 1286 rde_stack_pop (p->LS, 1); 1287 if (p->ST) { 1288 rde_stack_push (p->ast, p->SV); 1289 Tcl_IncrRefCount (p->SV); 1290 } 1291 } 1292 SCOPE void 1293 rde_param_i_symbol_done_d_leaf (RDE_PARAM p, int s, int m) 1294 { 1295 if (p->ST) { 1296 rde_param_i_value_leaf (p, s); 1297 } else { 1298 SV_CLEAR (p); 1299 } 1300 rde_param_i_symbol_save (p, s); 1301 rde_param_i_error_nonterminal (p, m); 1302 rde_param_i_ast_pop_rewind (p); 1303 rde_stack_pop (p->LS, 1); 1304 if (p->ST) { 1305 rde_stack_push (p->ast, p->SV); 1306 Tcl_IncrRefCount (p->SV); 1307 } 1308 } 1309 SCOPE void 1310 rde_param_i_symbol_done_void (RDE_PARAM p, int s, int m) 1311 { 1312 SV_CLEAR (p); 1313 rde_param_i_symbol_save (p, s); 1314 rde_param_i_error_nonterminal (p, m); 1315 rde_stack_pop (p->LS, 1); 1316 } 1317 SCOPE void 1318 rde_param_i_symbol_done_d_void (RDE_PARAM p, int s, int m) 1319 { 1320 SV_CLEAR (p); 1321 rde_param_i_symbol_save (p, s); 1322 rde_param_i_error_nonterminal (p, m); 1323 rde_param_i_ast_pop_rewind (p); 1324 rde_stack_pop (p->LS, 1); 1325 } 1326 SCOPE void 1327 rde_param_i_next_char (RDE_PARAM p, char* c, int m) 1328 { 1329 rde_param_i_input_next (p, m); 1330 if (!p->ST) return; 1331 rde_param_i_test_char (p, c, m); 1332 } 1333 SCOPE void 1334 rde_param_i_next_range (RDE_PARAM p, char* s, char* e, int m) 1335 { 1336 rde_param_i_input_next (p, m); 1337 if (!p->ST) return; 1338 rde_param_i_test_range (p, s, e, m); 1339 } 1340 SCOPE void 1341 rde_param_i_next_alnum (RDE_PARAM p, int m) 1342 { 1343 rde_param_i_input_next (p, m); 1344 if (!p->ST) return; 1345 rde_param_i_test_alnum (p); 1346 } 1347 SCOPE void 1348 rde_param_i_next_alpha (RDE_PARAM p, int m) 1349 { 1350 rde_param_i_input_next (p, m); 1351 if (!p->ST) return; 1352 rde_param_i_test_alpha (p); 1353 } 1354 SCOPE void 1355 rde_param_i_next_ascii (RDE_PARAM p, int m) 1356 { 1357 rde_param_i_input_next (p, m); 1358 if (!p->ST) return; 1359 rde_param_i_test_ascii (p); 1360 } 1361 SCOPE void 1362 rde_param_i_next_ddigit (RDE_PARAM p, int m) 1363 { 1364 rde_param_i_input_next (p, m); 1365 if (!p->ST) return; 1366 rde_param_i_test_ddigit (p); 1367 } 1368 SCOPE void 1369 rde_param_i_next_digit (RDE_PARAM p, int m) 1370 { 1371 rde_param_i_input_next (p, m); 1372 if (!p->ST) return; 1373 rde_param_i_test_digit (p); 1374 } 1375 SCOPE void 1376 rde_param_i_next_graph (RDE_PARAM p, int m) 1377 { 1378 rde_param_i_input_next (p, m); 1379 if (!p->ST) return; 1380 rde_param_i_test_graph (p); 1381 } 1382 SCOPE void 1383 rde_param_i_next_lower (RDE_PARAM p, int m) 1384 { 1385 rde_param_i_input_next (p, m); 1386 if (!p->ST) return; 1387 rde_param_i_test_lower (p); 1388 } 1389 SCOPE void 1390 rde_param_i_next_print (RDE_PARAM p, int m) 1391 { 1392 rde_param_i_input_next (p, m); 1393 if (!p->ST) return; 1394 rde_param_i_test_print (p); 1395 } 1396 SCOPE void 1397 rde_param_i_next_punct (RDE_PARAM p, int m) 1398 { 1399 rde_param_i_input_next (p, m); 1400 if (!p->ST) return; 1401 rde_param_i_test_punct (p); 1402 } 1403 SCOPE void 1404 rde_param_i_next_space (RDE_PARAM p, int m) 1405 { 1406 rde_param_i_input_next (p, m); 1407 if (!p->ST) return; 1408 rde_param_i_test_space (p); 1409 } 1410 SCOPE void 1411 rde_param_i_next_upper (RDE_PARAM p, int m) 1412 { 1413 rde_param_i_input_next (p, m); 1414 if (!p->ST) return; 1415 rde_param_i_test_upper (p); 1416 } 1417 SCOPE void 1418 rde_param_i_next_wordchar (RDE_PARAM p, int m) 1419 { 1420 rde_param_i_input_next (p, m); 1421 if (!p->ST) return; 1422 rde_param_i_test_wordchar (p); 1423 } 1424 SCOPE void 1425 rde_param_i_next_xdigit (RDE_PARAM p, int m) 1426 { 1427 rde_param_i_input_next (p, m); 1428 if (!p->ST) return; 1429 rde_param_i_test_xdigit (p); 1430 } 1431 SCOPE void 1432 rde_param_i_notahead_start_d (RDE_PARAM p) 1433 { 1434 rde_stack_push (p->LS, (void*) p->CL); 1435 rde_stack_push (p->mark, (void*) rde_stack_size (p->ast)); 1436 } 1437 SCOPE void 1438 rde_param_i_notahead_exit_d (RDE_PARAM p) 1439 { 1440 if (p->ST) { 1441 rde_param_i_ast_pop_rewind (p); 1442 } else { 1443 rde_stack_pop (p->mark, 1); 1444 } 1445 p->CL = (long int) rde_stack_top (p->LS); 1446 rde_stack_pop (p->LS, 1); 1447 p->ST = !p->ST; 1448 } 1449 SCOPE void 1450 rde_param_i_notahead_exit (RDE_PARAM p) 1451 { 1452 p->CL = (long int) rde_stack_top (p->LS); 1453 rde_stack_pop (p->LS, 1); 1454 p->ST = !p->ST; 1455 } 1456 SCOPE void 1457 rde_param_i_state_push_2 (RDE_PARAM p) 1458 { 1459 1460 rde_stack_push (p->LS, (void*) p->CL); 1461 rde_stack_push (p->ES, p->ER); 1462 if (p->ER) { p->ER->refCount ++; } 1463 } 1464 SCOPE void 1465 rde_param_i_state_push_void (RDE_PARAM p) 1466 { 1467 rde_stack_push (p->LS, (void*) p->CL); 1468 ER_CLEAR (p); 1469 rde_stack_push (p->ES, p->ER); 1470 1471 } 1472 SCOPE void 1473 rde_param_i_state_push_value (RDE_PARAM p) 1474 { 1475 rde_stack_push (p->mark, (void*) rde_stack_size (p->ast)); 1476 rde_stack_push (p->LS, (void*) p->CL); 1477 ER_CLEAR (p); 1478 rde_stack_push (p->ES, p->ER); 1479 1480 } 1481 SCOPE void 1482 rde_param_i_state_merge_ok (RDE_PARAM p) 1483 { 1484 rde_param_i_error_pop_merge (p); 1485 if (!p->ST) { 1486 p->ST = 1; 1487 p->CL = (long int) rde_stack_top (p->LS); 1488 } 1489 rde_stack_pop (p->LS, 1); 1490 } 1491 SCOPE void 1492 rde_param_i_state_merge_void (RDE_PARAM p) 1493 { 1494 rde_param_i_error_pop_merge (p); 1495 if (!p->ST) { 1496 p->CL = (long int) rde_stack_top (p->LS); 1497 } 1498 rde_stack_pop (p->LS, 1); 1499 } 1500 SCOPE void 1501 rde_param_i_state_merge_value (RDE_PARAM p) 1502 { 1503 rde_param_i_error_pop_merge (p); 1504 if (!p->ST) { 1505 long int trim = (long int) rde_stack_top (p->mark); 1506 rde_stack_trim (p->ast, (int) trim); 1507 p->CL = (long int) rde_stack_top (p->LS); 1508 } 1509 rde_stack_pop (p->mark, 1); 1510 rde_stack_pop (p->LS, 1); 1511 } 1512 SCOPE int 1513 rde_param_i_kleene_close (RDE_PARAM p) 1514 { 1515 int stop = !p->ST; 1516 rde_param_i_error_pop_merge (p); 1517 if (stop) { 1518 p->ST = 1; 1519 p->CL = (long int) rde_stack_top (p->LS); 1520 } 1521 rde_stack_pop (p->LS, 1); 1522 return stop; 1523 } 1524 SCOPE int 1525 rde_param_i_kleene_abort (RDE_PARAM p) 1526 { 1527 int stop = !p->ST; 1528 if (stop) { 1529 p->CL = (long int) rde_stack_top (p->LS); 1530 } 1531 rde_stack_pop (p->LS, 1); 1532 return stop; 1533 } 1534 SCOPE int 1535 rde_param_i_seq_void2void (RDE_PARAM p) 1536 { 1537 rde_param_i_error_pop_merge (p); 1538 if (p->ST) { 1539 rde_stack_push (p->ES, p->ER); 1540 if (p->ER) { p->ER->refCount ++; } 1541 return 0; 1542 } else { 1543 p->CL = (long int) rde_stack_top (p->LS); 1544 rde_stack_pop (p->LS, 1); 1545 return 1; 1546 } 1547 } 1548 SCOPE int 1549 rde_param_i_seq_void2value (RDE_PARAM p) 1550 { 1551 rde_param_i_error_pop_merge (p); 1552 if (p->ST) { 1553 rde_stack_push (p->mark, (void*) rde_stack_size (p->ast)); 1554 rde_stack_push (p->ES, p->ER); 1555 if (p->ER) { p->ER->refCount ++; } 1556 return 0; 1557 } else { 1558 p->CL = (long int) rde_stack_top (p->LS); 1559 rde_stack_pop (p->LS, 1); 1560 return 1; 1561 } 1562 } 1563 SCOPE int 1564 rde_param_i_seq_value2value (RDE_PARAM p) 1565 { 1566 rde_param_i_error_pop_merge (p); 1567 if (p->ST) { 1568 rde_stack_push (p->ES, p->ER); 1569 if (p->ER) { p->ER->refCount ++; } 1570 return 0; 1571 } else { 1572 long int trim = (long int) rde_stack_top (p->mark); 1573 rde_stack_pop (p->mark, 1); 1574 rde_stack_trim (p->ast, (int) trim); 1575 p->CL = (long int) rde_stack_top (p->LS); 1576 rde_stack_pop (p->LS, 1); 1577 return 1; 1578 } 1579 } 1580 SCOPE int 1581 rde_param_i_bra_void2void (RDE_PARAM p) 1582 { 1583 rde_param_i_error_pop_merge (p); 1584 if (p->ST) { 1585 rde_stack_pop (p->LS, 1); 1586 } else { 1587 p->CL = (long int) rde_stack_top (p->LS); 1588 rde_stack_push (p->ES, p->ER); 1589 if (p->ER) { p->ER->refCount ++; } 1590 } 1591 return p->ST; 1592 } 1593 SCOPE int 1594 rde_param_i_bra_void2value (RDE_PARAM p) 1595 { 1596 rde_param_i_error_pop_merge (p); 1597 if (p->ST) { 1598 rde_stack_pop (p->LS, 1); 1599 } else { 1600 rde_stack_push (p->mark, (void*) rde_stack_size (p->ast)); 1601 p->CL = (long int) rde_stack_top (p->LS); 1602 rde_stack_push (p->ES, p->ER); 1603 if (p->ER) { p->ER->refCount ++; } 1604 } 1605 return p->ST; 1606 } 1607 SCOPE int 1608 rde_param_i_bra_value2void (RDE_PARAM p) 1609 { 1610 rde_param_i_error_pop_merge (p); 1611 if (p->ST) { 1612 rde_stack_pop (p->mark, 1); 1613 rde_stack_pop (p->LS, 1); 1614 } else { 1615 long int trim = (long int) rde_stack_top (p->mark); 1616 rde_stack_pop (p->mark, 1); 1617 rde_stack_trim (p->ast, (int) trim); 1618 p->CL = (long int) rde_stack_top (p->LS); 1619 rde_stack_push (p->ES, p->ER); 1620 if (p->ER) { p->ER->refCount ++; } 1621 } 1622 return p->ST; 1623 } 1624 SCOPE int 1625 rde_param_i_bra_value2value (RDE_PARAM p) 1626 { 1627 rde_param_i_error_pop_merge (p); 1628 if (p->ST) { 1629 rde_stack_pop (p->mark, 1); 1630 rde_stack_pop (p->LS, 1); 1631 } else { 1632 long int trim = (long int) rde_stack_top (p->mark); 1633 rde_stack_trim (p->ast, (int) trim); 1634 p->CL = (long int) rde_stack_top (p->LS); 1635 rde_stack_push (p->ES, p->ER); 1636 if (p->ER) { p->ER->refCount ++; } 1637 } 1638 return p->ST; 1639 } 1640 SCOPE void 1641 rde_param_i_next_str (RDE_PARAM p, char* str, int m) 1642 { 1643 int at = p->CL; 1644 while (*str) { 1645 rde_param_i_input_next (p, m); 1646 if (!p->ST) { 1647 p->CL = at; 1648 return; 1649 } 1650 rde_param_i_test_char (p, str, m); 1651 if (!p->ST) { 1652 p->CL = at; 1653 return; 1654 } 1655 str = Tcl_UtfNext (str); 1656 } 1657 } 1658 SCOPE void 1659 rde_param_i_next_class (RDE_PARAM p, char* class, int m) 1660 { 1661 rde_param_i_input_next (p, m); 1662 if (!p->ST) return; 1663 while (*class) { 1664 p->ST = Tcl_UtfNcmp (p->CC, class, 1) == 0; 1665 if (p->ST) { 1666 ER_CLEAR (p); 1667 return; 1668 } 1669 class = Tcl_UtfNext (class); 1670 } 1671 error_set (p, m); 1672 p->CL --; 1673 } 1674 1675 1676 } 1677 1678 # # ## ### ###### ######## ############# 1679 ## BEGIN of GENERATED CODE. DO NOT EDIT. 1680 1681 critcl::ccode { 1682 /* -*- c -*- */ 1683 1684 /* 1685 * Declaring the parse functions 1686 */ 1687 1688 static void sequence_4 (RDE_PARAM p); 1689 static void sym_ALNUM (RDE_PARAM p); 1690 static void sequence_9 (RDE_PARAM p); 1691 static void sym_ALPHA (RDE_PARAM p); 1692 static void sequence_14 (RDE_PARAM p); 1693 static void sym_AND (RDE_PARAM p); 1694 static void sym_APOSTROPH (RDE_PARAM p); 1695 static void sequence_21 (RDE_PARAM p); 1696 static void sym_ASCII (RDE_PARAM p); 1697 static void choice_26 (RDE_PARAM p); 1698 static void sequence_29 (RDE_PARAM p); 1699 static void sym_Attribute (RDE_PARAM p); 1700 static void choice_37 (RDE_PARAM p); 1701 static void sym_Char (RDE_PARAM p); 1702 static void sequence_44 (RDE_PARAM p); 1703 static void sym_CharOctalFull (RDE_PARAM p); 1704 static void optional_50 (RDE_PARAM p); 1705 static void sequence_52 (RDE_PARAM p); 1706 static void sym_CharOctalPart (RDE_PARAM p); 1707 static void sequence_57 (RDE_PARAM p); 1708 static void sym_CharSpecial (RDE_PARAM p); 1709 static void notahead_61 (RDE_PARAM p); 1710 static void sequence_64 (RDE_PARAM p); 1711 static void sym_CharUnescaped (RDE_PARAM p); 1712 static void optional_72 (RDE_PARAM p); 1713 static void sequence_74 (RDE_PARAM p); 1714 static void optional_76 (RDE_PARAM p); 1715 static void sequence_78 (RDE_PARAM p); 1716 static void optional_80 (RDE_PARAM p); 1717 static void sequence_82 (RDE_PARAM p); 1718 static void sym_CharUnicode (RDE_PARAM p); 1719 static void notahead_87 (RDE_PARAM p); 1720 static void sequence_90 (RDE_PARAM p); 1721 static void kleene_92 (RDE_PARAM p); 1722 static void sequence_96 (RDE_PARAM p); 1723 static void sym_Class (RDE_PARAM p); 1724 static void sequence_101 (RDE_PARAM p); 1725 static void sym_CLOSE (RDE_PARAM p); 1726 static void sym_CLOSEB (RDE_PARAM p); 1727 static void sequence_108 (RDE_PARAM p); 1728 static void sym_COLON (RDE_PARAM p); 1729 static void notahead_113 (RDE_PARAM p); 1730 static void sequence_116 (RDE_PARAM p); 1731 static void kleene_118 (RDE_PARAM p); 1732 static void sequence_121 (RDE_PARAM p); 1733 static void sym_COMMENT (RDE_PARAM p); 1734 static void sequence_126 (RDE_PARAM p); 1735 static void sym_CONTROL (RDE_PARAM p); 1736 static void sym_DAPOSTROPH (RDE_PARAM p); 1737 static void sequence_133 (RDE_PARAM p); 1738 static void sym_DDIGIT (RDE_PARAM p); 1739 static void optional_137 (RDE_PARAM p); 1740 static void sequence_143 (RDE_PARAM p); 1741 static void sym_Definition (RDE_PARAM p); 1742 static void sequence_148 (RDE_PARAM p); 1743 static void sym_DIGIT (RDE_PARAM p); 1744 static void sequence_153 (RDE_PARAM p); 1745 static void sym_DOT (RDE_PARAM p); 1746 static void sequence_158 (RDE_PARAM p); 1747 static void sym_END (RDE_PARAM p); 1748 static void notahead_162 (RDE_PARAM p); 1749 static void sym_EOF (RDE_PARAM p); 1750 static void sym_EOL (RDE_PARAM p); 1751 static void sequence_170 (RDE_PARAM p); 1752 static void kleene_172 (RDE_PARAM p); 1753 static void sequence_174 (RDE_PARAM p); 1754 static void sym_Expression (RDE_PARAM p); 1755 static void sequence_180 (RDE_PARAM p); 1756 static void sym_Final (RDE_PARAM p); 1757 static void kleene_186 (RDE_PARAM p); 1758 static void sequence_190 (RDE_PARAM p); 1759 static void sym_Grammar (RDE_PARAM p); 1760 static void sequence_195 (RDE_PARAM p); 1761 static void sym_GRAPH (RDE_PARAM p); 1762 static void sequence_201 (RDE_PARAM p); 1763 static void sym_Header (RDE_PARAM p); 1764 static void choice_206 (RDE_PARAM p); 1765 static void choice_210 (RDE_PARAM p); 1766 static void kleene_212 (RDE_PARAM p); 1767 static void sequence_214 (RDE_PARAM p); 1768 static void sym_Ident (RDE_PARAM p); 1769 static void sequence_219 (RDE_PARAM p); 1770 static void sym_Identifier (RDE_PARAM p); 1771 static void sequence_224 (RDE_PARAM p); 1772 static void sym_IS (RDE_PARAM p); 1773 static void sequence_229 (RDE_PARAM p); 1774 static void sym_LEAF (RDE_PARAM p); 1775 static void notahead_234 (RDE_PARAM p); 1776 static void sequence_237 (RDE_PARAM p); 1777 static void kleene_239 (RDE_PARAM p); 1778 static void sequence_243 (RDE_PARAM p); 1779 static void notahead_247 (RDE_PARAM p); 1780 static void sequence_250 (RDE_PARAM p); 1781 static void kleene_252 (RDE_PARAM p); 1782 static void sequence_256 (RDE_PARAM p); 1783 static void choice_258 (RDE_PARAM p); 1784 static void sym_Literal (RDE_PARAM p); 1785 static void sequence_263 (RDE_PARAM p); 1786 static void sym_LOWER (RDE_PARAM p); 1787 static void sequence_268 (RDE_PARAM p); 1788 static void sym_NOT (RDE_PARAM p); 1789 static void sequence_273 (RDE_PARAM p); 1790 static void sym_OPEN (RDE_PARAM p); 1791 static void sym_OPENB (RDE_PARAM p); 1792 static void sequence_280 (RDE_PARAM p); 1793 static void sym_PEG (RDE_PARAM p); 1794 static void sequence_285 (RDE_PARAM p); 1795 static void sym_PLUS (RDE_PARAM p); 1796 static void choice_290 (RDE_PARAM p); 1797 static void optional_292 (RDE_PARAM p); 1798 static void sequence_295 (RDE_PARAM p); 1799 static void sym_Prefix (RDE_PARAM p); 1800 static void sequence_316 (RDE_PARAM p); 1801 static void choice_321 (RDE_PARAM p); 1802 static void sym_Primary (RDE_PARAM p); 1803 static void sequence_326 (RDE_PARAM p); 1804 static void sym_PRINTABLE (RDE_PARAM p); 1805 static void sequence_331 (RDE_PARAM p); 1806 static void sym_PUNCT (RDE_PARAM p); 1807 static void sequence_336 (RDE_PARAM p); 1808 static void sym_QUESTION (RDE_PARAM p); 1809 static void sequence_342 (RDE_PARAM p); 1810 static void choice_345 (RDE_PARAM p); 1811 static void sym_Range (RDE_PARAM p); 1812 static void sequence_350 (RDE_PARAM p); 1813 static void sym_SEMICOLON (RDE_PARAM p); 1814 static void poskleene_354 (RDE_PARAM p); 1815 static void sym_Sequence (RDE_PARAM p); 1816 static void sequence_359 (RDE_PARAM p); 1817 static void sym_SLASH (RDE_PARAM p); 1818 static void sequence_364 (RDE_PARAM p); 1819 static void sym_SPACE (RDE_PARAM p); 1820 static void sequence_369 (RDE_PARAM p); 1821 static void sym_STAR (RDE_PARAM p); 1822 static void sym_StartExpr (RDE_PARAM p); 1823 static void choice_381 (RDE_PARAM p); 1824 static void optional_383 (RDE_PARAM p); 1825 static void sequence_385 (RDE_PARAM p); 1826 static void sym_Suffix (RDE_PARAM p); 1827 static void sym_TO (RDE_PARAM p); 1828 static void sequence_392 (RDE_PARAM p); 1829 static void sym_UPPER (RDE_PARAM p); 1830 static void sequence_397 (RDE_PARAM p); 1831 static void sym_VOID (RDE_PARAM p); 1832 static void choice_402 (RDE_PARAM p); 1833 static void kleene_404 (RDE_PARAM p); 1834 static void sym_WHITESPACE (RDE_PARAM p); 1835 static void sequence_409 (RDE_PARAM p); 1836 static void sym_WORDCHAR (RDE_PARAM p); 1837 static void sequence_414 (RDE_PARAM p); 1838 static void sym_XDIGIT (RDE_PARAM p); 1839 1840 /* 1841 * Precomputed table of strings (symbols, error messages, etc.). 1842 */ 1843 1844 static char const* p_string [170] = { 1845 /* 0 = */ "str '<alnum>'", 1846 /* 1 = */ "n ALNUM", 1847 /* 2 = */ "ALNUM", 1848 /* 3 = */ "str '<alpha>'", 1849 /* 4 = */ "n ALPHA", 1850 /* 5 = */ "ALPHA", 1851 /* 6 = */ "t &", 1852 /* 7 = */ "n AND", 1853 /* 8 = */ "AND", 1854 /* 9 = */ "t '", 1855 /* 10 = */ "n APOSTROPH", 1856 /* 11 = */ "APOSTROPH", 1857 /* 12 = */ "str '<ascii>'", 1858 /* 13 = */ "n ASCII", 1859 /* 14 = */ "ASCII", 1860 /* 15 = */ "n Attribute", 1861 /* 16 = */ "Attribute", 1862 /* 17 = */ "n Char", 1863 /* 18 = */ "Char", 1864 /* 19 = */ "t \134", 1865 /* 20 = */ ".. 0 2", 1866 /* 21 = */ ".. 0 7", 1867 /* 22 = */ "n CharOctalFull", 1868 /* 23 = */ "CharOctalFull", 1869 /* 24 = */ "n CharOctalPart", 1870 /* 25 = */ "CharOctalPart", 1871 /* 26 = */ "cl 'nrt'\42\133\135\134'", 1872 /* 27 = */ "n CharSpecial", 1873 /* 28 = */ "CharSpecial", 1874 /* 29 = */ "dot", 1875 /* 30 = */ "n CharUnescaped", 1876 /* 31 = */ "CharUnescaped", 1877 /* 32 = */ "str '\134u'", 1878 /* 33 = */ "xdigit", 1879 /* 34 = */ "n CharUnicode", 1880 /* 35 = */ "CharUnicode", 1881 /* 36 = */ "n Class", 1882 /* 37 = */ "Class", 1883 /* 38 = */ "t \51", 1884 /* 39 = */ "n CLOSE", 1885 /* 40 = */ "CLOSE", 1886 /* 41 = */ "t \135", 1887 /* 42 = */ "n CLOSEB", 1888 /* 43 = */ "CLOSEB", 1889 /* 44 = */ "t :", 1890 /* 45 = */ "n COLON", 1891 /* 46 = */ "COLON", 1892 /* 47 = */ "t #", 1893 /* 48 = */ "n COMMENT", 1894 /* 49 = */ "COMMENT", 1895 /* 50 = */ "str '<control>'", 1896 /* 51 = */ "n CONTROL", 1897 /* 52 = */ "CONTROL", 1898 /* 53 = */ "t \42", 1899 /* 54 = */ "n DAPOSTROPH", 1900 /* 55 = */ "DAPOSTROPH", 1901 /* 56 = */ "str '<ddigit>'", 1902 /* 57 = */ "n DDIGIT", 1903 /* 58 = */ "DDIGIT", 1904 /* 59 = */ "n Definition", 1905 /* 60 = */ "Definition", 1906 /* 61 = */ "str '<digit>'", 1907 /* 62 = */ "n DIGIT", 1908 /* 63 = */ "DIGIT", 1909 /* 64 = */ "t .", 1910 /* 65 = */ "n DOT", 1911 /* 66 = */ "DOT", 1912 /* 67 = */ "str 'END'", 1913 /* 68 = */ "n END", 1914 /* 69 = */ "END", 1915 /* 70 = */ "n EOF", 1916 /* 71 = */ "EOF", 1917 /* 72 = */ "cl '\n\r'", 1918 /* 73 = */ "n EOL", 1919 /* 74 = */ "EOL", 1920 /* 75 = */ "n Expression", 1921 /* 76 = */ "Expression", 1922 /* 77 = */ "n Final", 1923 /* 78 = */ "Final", 1924 /* 79 = */ "n Grammar", 1925 /* 80 = */ "Grammar", 1926 /* 81 = */ "str '<graph>'", 1927 /* 82 = */ "n GRAPH", 1928 /* 83 = */ "GRAPH", 1929 /* 84 = */ "n Header", 1930 /* 85 = */ "Header", 1931 /* 86 = */ "cl '_:'", 1932 /* 87 = */ "alpha", 1933 /* 88 = */ "alnum", 1934 /* 89 = */ "n Ident", 1935 /* 90 = */ "Ident", 1936 /* 91 = */ "n Identifier", 1937 /* 92 = */ "Identifier", 1938 /* 93 = */ "str '<-'", 1939 /* 94 = */ "n IS", 1940 /* 95 = */ "IS", 1941 /* 96 = */ "str 'leaf'", 1942 /* 97 = */ "n LEAF", 1943 /* 98 = */ "LEAF", 1944 /* 99 = */ "n Literal", 1945 /* 100 = */ "Literal", 1946 /* 101 = */ "str '<lower>'", 1947 /* 102 = */ "n LOWER", 1948 /* 103 = */ "LOWER", 1949 /* 104 = */ "t !", 1950 /* 105 = */ "n NOT", 1951 /* 106 = */ "NOT", 1952 /* 107 = */ "t \50", 1953 /* 108 = */ "n OPEN", 1954 /* 109 = */ "OPEN", 1955 /* 110 = */ "t \133", 1956 /* 111 = */ "n OPENB", 1957 /* 112 = */ "OPENB", 1958 /* 113 = */ "str 'PEG'", 1959 /* 114 = */ "n PEG", 1960 /* 115 = */ "PEG", 1961 /* 116 = */ "t +", 1962 /* 117 = */ "n PLUS", 1963 /* 118 = */ "PLUS", 1964 /* 119 = */ "n Prefix", 1965 /* 120 = */ "Prefix", 1966 /* 121 = */ "n Primary", 1967 /* 122 = */ "Primary", 1968 /* 123 = */ "str '<print>'", 1969 /* 124 = */ "n PRINTABLE", 1970 /* 125 = */ "PRINTABLE", 1971 /* 126 = */ "str '<punct>'", 1972 /* 127 = */ "n PUNCT", 1973 /* 128 = */ "PUNCT", 1974 /* 129 = */ "t ?", 1975 /* 130 = */ "n QUESTION", 1976 /* 131 = */ "QUESTION", 1977 /* 132 = */ "n Range", 1978 /* 133 = */ "Range", 1979 /* 134 = */ "t \73", 1980 /* 135 = */ "n SEMICOLON", 1981 /* 136 = */ "SEMICOLON", 1982 /* 137 = */ "n Sequence", 1983 /* 138 = */ "Sequence", 1984 /* 139 = */ "t /", 1985 /* 140 = */ "n SLASH", 1986 /* 141 = */ "SLASH", 1987 /* 142 = */ "str '<space>'", 1988 /* 143 = */ "n SPACE", 1989 /* 144 = */ "SPACE", 1990 /* 145 = */ "t *", 1991 /* 146 = */ "n STAR", 1992 /* 147 = */ "STAR", 1993 /* 148 = */ "n StartExpr", 1994 /* 149 = */ "StartExpr", 1995 /* 150 = */ "n Suffix", 1996 /* 151 = */ "Suffix", 1997 /* 152 = */ "t -", 1998 /* 153 = */ "n TO", 1999 /* 154 = */ "TO", 2000 /* 155 = */ "str '<upper>'", 2001 /* 156 = */ "n UPPER", 2002 /* 157 = */ "UPPER", 2003 /* 158 = */ "str 'void'", 2004 /* 159 = */ "n VOID", 2005 /* 160 = */ "VOID", 2006 /* 161 = */ "space", 2007 /* 162 = */ "n WHITESPACE", 2008 /* 163 = */ "WHITESPACE", 2009 /* 164 = */ "str '<wordchar>'", 2010 /* 165 = */ "n WORDCHAR", 2011 /* 166 = */ "WORDCHAR", 2012 /* 167 = */ "str '<xdigit>'", 2013 /* 168 = */ "n XDIGIT", 2014 /* 169 = */ "XDIGIT" 2015 }; 2016 2017 /* 2018 * Grammar Start Expression 2019 */ 2020 2021 static void MAIN (RDE_PARAM p) { 2022 sym_Grammar (p); 2023 return; 2024 } 2025 2026 /* 2027 * leaf Symbol 'ALNUM' 2028 */ 2029 2030 static void sym_ALNUM (RDE_PARAM p) { 2031 /* 2032 * x 2033 * "<alnum>" 2034 * (WHITESPACE) 2035 */ 2036 2037 if (rde_param_i_symbol_start (p, 2)) return ; 2038 sequence_4 (p); 2039 rde_param_i_symbol_done_leaf (p, 2, 1); 2040 return; 2041 } 2042 2043 static void sequence_4 (RDE_PARAM p) { 2044 /* 2045 * x 2046 * "<alnum>" 2047 * (WHITESPACE) 2048 */ 2049 2050 rde_param_i_state_push_void (p); 2051 rde_param_i_next_str (p, "<alnum>", 0); 2052 if (rde_param_i_seq_void2void(p)) return; 2053 sym_WHITESPACE (p); 2054 rde_param_i_state_merge_void (p); 2055 return; 2056 } 2057 2058 /* 2059 * leaf Symbol 'ALPHA' 2060 */ 2061 2062 static void sym_ALPHA (RDE_PARAM p) { 2063 /* 2064 * x 2065 * "<alpha>" 2066 * (WHITESPACE) 2067 */ 2068 2069 if (rde_param_i_symbol_start (p, 5)) return ; 2070 sequence_9 (p); 2071 rde_param_i_symbol_done_leaf (p, 5, 4); 2072 return; 2073 } 2074 2075 static void sequence_9 (RDE_PARAM p) { 2076 /* 2077 * x 2078 * "<alpha>" 2079 * (WHITESPACE) 2080 */ 2081 2082 rde_param_i_state_push_void (p); 2083 rde_param_i_next_str (p, "<alpha>", 3); 2084 if (rde_param_i_seq_void2void(p)) return; 2085 sym_WHITESPACE (p); 2086 rde_param_i_state_merge_void (p); 2087 return; 2088 } 2089 2090 /* 2091 * leaf Symbol 'AND' 2092 */ 2093 2094 static void sym_AND (RDE_PARAM p) { 2095 /* 2096 * x 2097 * '&' 2098 * (WHITESPACE) 2099 */ 2100 2101 if (rde_param_i_symbol_start (p, 8)) return ; 2102 sequence_14 (p); 2103 rde_param_i_symbol_done_leaf (p, 8, 7); 2104 return; 2105 } 2106 2107 static void sequence_14 (RDE_PARAM p) { 2108 /* 2109 * x 2110 * '&' 2111 * (WHITESPACE) 2112 */ 2113 2114 rde_param_i_state_push_void (p); 2115 rde_param_i_next_char (p, "&", 6); 2116 if (rde_param_i_seq_void2void(p)) return; 2117 sym_WHITESPACE (p); 2118 rde_param_i_state_merge_void (p); 2119 return; 2120 } 2121 2122 /* 2123 * void Symbol 'APOSTROPH' 2124 */ 2125 2126 static void sym_APOSTROPH (RDE_PARAM p) { 2127 /* 2128 * ''' 2129 */ 2130 2131 if (rde_param_i_symbol_void_start (p, 11)) return ; 2132 rde_param_i_next_char (p, "'", 9); 2133 rde_param_i_symbol_done_void (p, 11, 10); 2134 return; 2135 } 2136 2137 /* 2138 * leaf Symbol 'ASCII' 2139 */ 2140 2141 static void sym_ASCII (RDE_PARAM p) { 2142 /* 2143 * x 2144 * "<ascii>" 2145 * (WHITESPACE) 2146 */ 2147 2148 if (rde_param_i_symbol_start (p, 14)) return ; 2149 sequence_21 (p); 2150 rde_param_i_symbol_done_leaf (p, 14, 13); 2151 return; 2152 } 2153 2154 static void sequence_21 (RDE_PARAM p) { 2155 /* 2156 * x 2157 * "<ascii>" 2158 * (WHITESPACE) 2159 */ 2160 2161 rde_param_i_state_push_void (p); 2162 rde_param_i_next_str (p, "<ascii>", 12); 2163 if (rde_param_i_seq_void2void(p)) return; 2164 sym_WHITESPACE (p); 2165 rde_param_i_state_merge_void (p); 2166 return; 2167 } 2168 2169 /* 2170 * value Symbol 'Attribute' 2171 */ 2172 2173 static void sym_Attribute (RDE_PARAM p) { 2174 /* 2175 * x 2176 * / 2177 * (VOID) 2178 * (LEAF) 2179 * (COLON) 2180 */ 2181 2182 if (rde_param_i_symbol_start_d (p, 16)) return ; 2183 sequence_29 (p); 2184 rde_param_i_symbol_done_d_reduce (p, 16, 15); 2185 return; 2186 } 2187 2188 static void sequence_29 (RDE_PARAM p) { 2189 /* 2190 * x 2191 * / 2192 * (VOID) 2193 * (LEAF) 2194 * (COLON) 2195 */ 2196 2197 rde_param_i_state_push_value (p); 2198 choice_26 (p); 2199 if (rde_param_i_seq_value2value(p)) return; 2200 sym_COLON (p); 2201 rde_param_i_state_merge_value (p); 2202 return; 2203 } 2204 2205 static void choice_26 (RDE_PARAM p) { 2206 /* 2207 * / 2208 * (VOID) 2209 * (LEAF) 2210 */ 2211 2212 rde_param_i_state_push_value (p); 2213 sym_VOID (p); 2214 if (rde_param_i_bra_value2value(p)) return; 2215 sym_LEAF (p); 2216 rde_param_i_state_merge_value (p); 2217 return; 2218 } 2219 2220 /* 2221 * value Symbol 'Char' 2222 */ 2223 2224 static void sym_Char (RDE_PARAM p) { 2225 /* 2226 * / 2227 * (CharSpecial) 2228 * (CharOctalFull) 2229 * (CharOctalPart) 2230 * (CharUnicode) 2231 * (CharUnescaped) 2232 */ 2233 2234 if (rde_param_i_symbol_start_d (p, 18)) return ; 2235 choice_37 (p); 2236 rde_param_i_symbol_done_d_reduce (p, 18, 17); 2237 return; 2238 } 2239 2240 static void choice_37 (RDE_PARAM p) { 2241 /* 2242 * / 2243 * (CharSpecial) 2244 * (CharOctalFull) 2245 * (CharOctalPart) 2246 * (CharUnicode) 2247 * (CharUnescaped) 2248 */ 2249 2250 rde_param_i_state_push_value (p); 2251 sym_CharSpecial (p); 2252 if (rde_param_i_bra_value2value(p)) return; 2253 sym_CharOctalFull (p); 2254 if (rde_param_i_bra_value2value(p)) return; 2255 sym_CharOctalPart (p); 2256 if (rde_param_i_bra_value2value(p)) return; 2257 sym_CharUnicode (p); 2258 if (rde_param_i_bra_value2value(p)) return; 2259 sym_CharUnescaped (p); 2260 rde_param_i_state_merge_value (p); 2261 return; 2262 } 2263 2264 /* 2265 * leaf Symbol 'CharOctalFull' 2266 */ 2267 2268 static void sym_CharOctalFull (RDE_PARAM p) { 2269 /* 2270 * x 2271 * '\' 2272 * range (0 .. 2) 2273 * range (0 .. 7) 2274 * range (0 .. 7) 2275 */ 2276 2277 if (rde_param_i_symbol_start (p, 23)) return ; 2278 sequence_44 (p); 2279 rde_param_i_symbol_done_leaf (p, 23, 22); 2280 return; 2281 } 2282 2283 static void sequence_44 (RDE_PARAM p) { 2284 /* 2285 * x 2286 * '\' 2287 * range (0 .. 2) 2288 * range (0 .. 7) 2289 * range (0 .. 7) 2290 */ 2291 2292 rde_param_i_state_push_void (p); 2293 rde_param_i_next_char (p, "\134", 19); 2294 if (rde_param_i_seq_void2void(p)) return; 2295 rde_param_i_next_range (p, "0", "2", 20); 2296 if (rde_param_i_seq_void2void(p)) return; 2297 rde_param_i_next_range (p, "0", "7", 21); 2298 if (rde_param_i_seq_void2void(p)) return; 2299 rde_param_i_next_range (p, "0", "7", 21); 2300 rde_param_i_state_merge_void (p); 2301 return; 2302 } 2303 2304 /* 2305 * leaf Symbol 'CharOctalPart' 2306 */ 2307 2308 static void sym_CharOctalPart (RDE_PARAM p) { 2309 /* 2310 * x 2311 * '\' 2312 * range (0 .. 7) 2313 * ? 2314 * range (0 .. 7) 2315 */ 2316 2317 if (rde_param_i_symbol_start (p, 25)) return ; 2318 sequence_52 (p); 2319 rde_param_i_symbol_done_leaf (p, 25, 24); 2320 return; 2321 } 2322 2323 static void sequence_52 (RDE_PARAM p) { 2324 /* 2325 * x 2326 * '\' 2327 * range (0 .. 7) 2328 * ? 2329 * range (0 .. 7) 2330 */ 2331 2332 rde_param_i_state_push_void (p); 2333 rde_param_i_next_char (p, "\134", 19); 2334 if (rde_param_i_seq_void2void(p)) return; 2335 rde_param_i_next_range (p, "0", "7", 21); 2336 if (rde_param_i_seq_void2void(p)) return; 2337 optional_50 (p); 2338 rde_param_i_state_merge_void (p); 2339 return; 2340 } 2341 2342 static void optional_50 (RDE_PARAM p) { 2343 /* 2344 * ? 2345 * range (0 .. 7) 2346 */ 2347 2348 rde_param_i_state_push_2 (p); 2349 rde_param_i_next_range (p, "0", "7", 21); 2350 rde_param_i_state_merge_ok (p); 2351 return; 2352 } 2353 2354 /* 2355 * leaf Symbol 'CharSpecial' 2356 */ 2357 2358 static void sym_CharSpecial (RDE_PARAM p) { 2359 /* 2360 * x 2361 * '\' 2362 * [nrt'"[]\] 2363 */ 2364 2365 if (rde_param_i_symbol_start (p, 28)) return ; 2366 sequence_57 (p); 2367 rde_param_i_symbol_done_leaf (p, 28, 27); 2368 return; 2369 } 2370 2371 static void sequence_57 (RDE_PARAM p) { 2372 /* 2373 * x 2374 * '\' 2375 * [nrt'"[]\] 2376 */ 2377 2378 rde_param_i_state_push_void (p); 2379 rde_param_i_next_char (p, "\134", 19); 2380 if (rde_param_i_seq_void2void(p)) return; 2381 rde_param_i_next_class (p, "nrt'\42\133\135\134", 26); 2382 rde_param_i_state_merge_void (p); 2383 return; 2384 } 2385 2386 /* 2387 * leaf Symbol 'CharUnescaped' 2388 */ 2389 2390 static void sym_CharUnescaped (RDE_PARAM p) { 2391 /* 2392 * x 2393 * ! 2394 * '\' 2395 * <dot> 2396 */ 2397 2398 if (rde_param_i_symbol_start (p, 31)) return ; 2399 sequence_64 (p); 2400 rde_param_i_symbol_done_leaf (p, 31, 30); 2401 return; 2402 } 2403 2404 static void sequence_64 (RDE_PARAM p) { 2405 /* 2406 * x 2407 * ! 2408 * '\' 2409 * <dot> 2410 */ 2411 2412 rde_param_i_state_push_void (p); 2413 notahead_61 (p); 2414 if (rde_param_i_seq_void2void(p)) return; 2415 rde_param_i_input_next (p, 29); 2416 rde_param_i_state_merge_void (p); 2417 return; 2418 } 2419 2420 static void notahead_61 (RDE_PARAM p) { 2421 /* 2422 * ! 2423 * '\' 2424 */ 2425 2426 rde_param_i_loc_push (p); 2427 rde_param_i_next_char (p, "\134", 19); 2428 rde_param_i_notahead_exit (p); 2429 return; 2430 } 2431 2432 /* 2433 * leaf Symbol 'CharUnicode' 2434 */ 2435 2436 static void sym_CharUnicode (RDE_PARAM p) { 2437 /* 2438 * x 2439 * "\u" 2440 * <xdigit> 2441 * ? 2442 * x 2443 * <xdigit> 2444 * ? 2445 * x 2446 * <xdigit> 2447 * ? 2448 * <xdigit> 2449 */ 2450 2451 if (rde_param_i_symbol_start (p, 35)) return ; 2452 sequence_82 (p); 2453 rde_param_i_symbol_done_leaf (p, 35, 34); 2454 return; 2455 } 2456 2457 static void sequence_82 (RDE_PARAM p) { 2458 /* 2459 * x 2460 * "\u" 2461 * <xdigit> 2462 * ? 2463 * x 2464 * <xdigit> 2465 * ? 2466 * x 2467 * <xdigit> 2468 * ? 2469 * <xdigit> 2470 */ 2471 2472 rde_param_i_state_push_void (p); 2473 rde_param_i_next_str (p, "\134u", 32); 2474 if (rde_param_i_seq_void2void(p)) return; 2475 rde_param_i_next_xdigit (p, 33); 2476 if (rde_param_i_seq_void2void(p)) return; 2477 optional_80 (p); 2478 rde_param_i_state_merge_void (p); 2479 return; 2480 } 2481 2482 static void optional_80 (RDE_PARAM p) { 2483 /* 2484 * ? 2485 * x 2486 * <xdigit> 2487 * ? 2488 * x 2489 * <xdigit> 2490 * ? 2491 * <xdigit> 2492 */ 2493 2494 rde_param_i_state_push_2 (p); 2495 sequence_78 (p); 2496 rde_param_i_state_merge_ok (p); 2497 return; 2498 } 2499 2500 static void sequence_78 (RDE_PARAM p) { 2501 /* 2502 * x 2503 * <xdigit> 2504 * ? 2505 * x 2506 * <xdigit> 2507 * ? 2508 * <xdigit> 2509 */ 2510 2511 rde_param_i_state_push_void (p); 2512 rde_param_i_next_xdigit (p, 33); 2513 if (rde_param_i_seq_void2void(p)) return; 2514 optional_76 (p); 2515 rde_param_i_state_merge_void (p); 2516 return; 2517 } 2518 2519 static void optional_76 (RDE_PARAM p) { 2520 /* 2521 * ? 2522 * x 2523 * <xdigit> 2524 * ? 2525 * <xdigit> 2526 */ 2527 2528 rde_param_i_state_push_2 (p); 2529 sequence_74 (p); 2530 rde_param_i_state_merge_ok (p); 2531 return; 2532 } 2533 2534 static void sequence_74 (RDE_PARAM p) { 2535 /* 2536 * x 2537 * <xdigit> 2538 * ? 2539 * <xdigit> 2540 */ 2541 2542 rde_param_i_state_push_void (p); 2543 rde_param_i_next_xdigit (p, 33); 2544 if (rde_param_i_seq_void2void(p)) return; 2545 optional_72 (p); 2546 rde_param_i_state_merge_void (p); 2547 return; 2548 } 2549 2550 static void optional_72 (RDE_PARAM p) { 2551 /* 2552 * ? 2553 * <xdigit> 2554 */ 2555 2556 rde_param_i_state_push_2 (p); 2557 rde_param_i_next_xdigit (p, 33); 2558 rde_param_i_state_merge_ok (p); 2559 return; 2560 } 2561 2562 /* 2563 * value Symbol 'Class' 2564 */ 2565 2566 static void sym_Class (RDE_PARAM p) { 2567 /* 2568 * x 2569 * (OPENB) 2570 * * 2571 * x 2572 * ! 2573 * (CLOSEB) 2574 * (Range) 2575 * (CLOSEB) 2576 * (WHITESPACE) 2577 */ 2578 2579 if (rde_param_i_symbol_start_d (p, 37)) return ; 2580 sequence_96 (p); 2581 rde_param_i_symbol_done_d_reduce (p, 37, 36); 2582 return; 2583 } 2584 2585 static void sequence_96 (RDE_PARAM p) { 2586 /* 2587 * x 2588 * (OPENB) 2589 * * 2590 * x 2591 * ! 2592 * (CLOSEB) 2593 * (Range) 2594 * (CLOSEB) 2595 * (WHITESPACE) 2596 */ 2597 2598 rde_param_i_state_push_void (p); 2599 sym_OPENB (p); 2600 if (rde_param_i_seq_void2value(p)) return; 2601 kleene_92 (p); 2602 if (rde_param_i_seq_value2value(p)) return; 2603 sym_CLOSEB (p); 2604 if (rde_param_i_seq_value2value(p)) return; 2605 sym_WHITESPACE (p); 2606 rde_param_i_state_merge_value (p); 2607 return; 2608 } 2609 2610 static void kleene_92 (RDE_PARAM p) { 2611 /* 2612 * * 2613 * x 2614 * ! 2615 * (CLOSEB) 2616 * (Range) 2617 */ 2618 2619 while (1) { 2620 rde_param_i_state_push_2 (p); 2621 sequence_90 (p); 2622 if (rde_param_i_kleene_close(p)) return; 2623 } 2624 return; 2625 } 2626 2627 static void sequence_90 (RDE_PARAM p) { 2628 /* 2629 * x 2630 * ! 2631 * (CLOSEB) 2632 * (Range) 2633 */ 2634 2635 rde_param_i_state_push_void (p); 2636 notahead_87 (p); 2637 if (rde_param_i_seq_void2value(p)) return; 2638 sym_Range (p); 2639 rde_param_i_state_merge_value (p); 2640 return; 2641 } 2642 2643 static void notahead_87 (RDE_PARAM p) { 2644 /* 2645 * ! 2646 * (CLOSEB) 2647 */ 2648 2649 rde_param_i_loc_push (p); 2650 sym_CLOSEB (p); 2651 rde_param_i_notahead_exit (p); 2652 return; 2653 } 2654 2655 /* 2656 * void Symbol 'CLOSE' 2657 */ 2658 2659 static void sym_CLOSE (RDE_PARAM p) { 2660 /* 2661 * x 2662 * '\)' 2663 * (WHITESPACE) 2664 */ 2665 2666 if (rde_param_i_symbol_void_start (p, 40)) return ; 2667 sequence_101 (p); 2668 rde_param_i_symbol_done_void (p, 40, 39); 2669 return; 2670 } 2671 2672 static void sequence_101 (RDE_PARAM p) { 2673 /* 2674 * x 2675 * '\)' 2676 * (WHITESPACE) 2677 */ 2678 2679 rde_param_i_state_push_void (p); 2680 rde_param_i_next_char (p, "\51", 38); 2681 if (rde_param_i_seq_void2void(p)) return; 2682 sym_WHITESPACE (p); 2683 rde_param_i_state_merge_void (p); 2684 return; 2685 } 2686 2687 /* 2688 * void Symbol 'CLOSEB' 2689 */ 2690 2691 static void sym_CLOSEB (RDE_PARAM p) { 2692 /* 2693 * ']' 2694 */ 2695 2696 if (rde_param_i_symbol_void_start (p, 43)) return ; 2697 rde_param_i_next_char (p, "\135", 41); 2698 rde_param_i_symbol_done_void (p, 43, 42); 2699 return; 2700 } 2701 2702 /* 2703 * void Symbol 'COLON' 2704 */ 2705 2706 static void sym_COLON (RDE_PARAM p) { 2707 /* 2708 * x 2709 * ':' 2710 * (WHITESPACE) 2711 */ 2712 2713 if (rde_param_i_symbol_void_start (p, 46)) return ; 2714 sequence_108 (p); 2715 rde_param_i_symbol_done_void (p, 46, 45); 2716 return; 2717 } 2718 2719 static void sequence_108 (RDE_PARAM p) { 2720 /* 2721 * x 2722 * ':' 2723 * (WHITESPACE) 2724 */ 2725 2726 rde_param_i_state_push_void (p); 2727 rde_param_i_next_char (p, ":", 44); 2728 if (rde_param_i_seq_void2void(p)) return; 2729 sym_WHITESPACE (p); 2730 rde_param_i_state_merge_void (p); 2731 return; 2732 } 2733 2734 /* 2735 * void Symbol 'COMMENT' 2736 */ 2737 2738 static void sym_COMMENT (RDE_PARAM p) { 2739 /* 2740 * x 2741 * '#' 2742 * * 2743 * x 2744 * ! 2745 * (EOL) 2746 * <dot> 2747 * (EOL) 2748 */ 2749 2750 if (rde_param_i_symbol_void_start (p, 49)) return ; 2751 sequence_121 (p); 2752 rde_param_i_symbol_done_void (p, 49, 48); 2753 return; 2754 } 2755 2756 static void sequence_121 (RDE_PARAM p) { 2757 /* 2758 * x 2759 * '#' 2760 * * 2761 * x 2762 * ! 2763 * (EOL) 2764 * <dot> 2765 * (EOL) 2766 */ 2767 2768 rde_param_i_state_push_void (p); 2769 rde_param_i_next_char (p, "#", 47); 2770 if (rde_param_i_seq_void2void(p)) return; 2771 kleene_118 (p); 2772 if (rde_param_i_seq_void2void(p)) return; 2773 sym_EOL (p); 2774 rde_param_i_state_merge_void (p); 2775 return; 2776 } 2777 2778 static void kleene_118 (RDE_PARAM p) { 2779 /* 2780 * * 2781 * x 2782 * ! 2783 * (EOL) 2784 * <dot> 2785 */ 2786 2787 while (1) { 2788 rde_param_i_state_push_2 (p); 2789 sequence_116 (p); 2790 if (rde_param_i_kleene_close(p)) return; 2791 } 2792 return; 2793 } 2794 2795 static void sequence_116 (RDE_PARAM p) { 2796 /* 2797 * x 2798 * ! 2799 * (EOL) 2800 * <dot> 2801 */ 2802 2803 rde_param_i_state_push_void (p); 2804 notahead_113 (p); 2805 if (rde_param_i_seq_void2void(p)) return; 2806 rde_param_i_input_next (p, 29); 2807 rde_param_i_state_merge_void (p); 2808 return; 2809 } 2810 2811 static void notahead_113 (RDE_PARAM p) { 2812 /* 2813 * ! 2814 * (EOL) 2815 */ 2816 2817 rde_param_i_loc_push (p); 2818 sym_EOL (p); 2819 rde_param_i_notahead_exit (p); 2820 return; 2821 } 2822 2823 /* 2824 * leaf Symbol 'CONTROL' 2825 */ 2826 2827 static void sym_CONTROL (RDE_PARAM p) { 2828 /* 2829 * x 2830 * "<control>" 2831 * (WHITESPACE) 2832 */ 2833 2834 if (rde_param_i_symbol_start (p, 52)) return ; 2835 sequence_126 (p); 2836 rde_param_i_symbol_done_leaf (p, 52, 51); 2837 return; 2838 } 2839 2840 static void sequence_126 (RDE_PARAM p) { 2841 /* 2842 * x 2843 * "<control>" 2844 * (WHITESPACE) 2845 */ 2846 2847 rde_param_i_state_push_void (p); 2848 rde_param_i_next_str (p, "<control>", 50); 2849 if (rde_param_i_seq_void2void(p)) return; 2850 sym_WHITESPACE (p); 2851 rde_param_i_state_merge_void (p); 2852 return; 2853 } 2854 2855 /* 2856 * void Symbol 'DAPOSTROPH' 2857 */ 2858 2859 static void sym_DAPOSTROPH (RDE_PARAM p) { 2860 /* 2861 * '\"' 2862 */ 2863 2864 if (rde_param_i_symbol_void_start (p, 55)) return ; 2865 rde_param_i_next_char (p, "\42", 53); 2866 rde_param_i_symbol_done_void (p, 55, 54); 2867 return; 2868 } 2869 2870 /* 2871 * leaf Symbol 'DDIGIT' 2872 */ 2873 2874 static void sym_DDIGIT (RDE_PARAM p) { 2875 /* 2876 * x 2877 * "<ddigit>" 2878 * (WHITESPACE) 2879 */ 2880 2881 if (rde_param_i_symbol_start (p, 58)) return ; 2882 sequence_133 (p); 2883 rde_param_i_symbol_done_leaf (p, 58, 57); 2884 return; 2885 } 2886 2887 static void sequence_133 (RDE_PARAM p) { 2888 /* 2889 * x 2890 * "<ddigit>" 2891 * (WHITESPACE) 2892 */ 2893 2894 rde_param_i_state_push_void (p); 2895 rde_param_i_next_str (p, "<ddigit>", 56); 2896 if (rde_param_i_seq_void2void(p)) return; 2897 sym_WHITESPACE (p); 2898 rde_param_i_state_merge_void (p); 2899 return; 2900 } 2901 2902 /* 2903 * value Symbol 'Definition' 2904 */ 2905 2906 static void sym_Definition (RDE_PARAM p) { 2907 /* 2908 * x 2909 * ? 2910 * (Attribute) 2911 * (Identifier) 2912 * (IS) 2913 * (Expression) 2914 * (SEMICOLON) 2915 */ 2916 2917 if (rde_param_i_symbol_start_d (p, 60)) return ; 2918 sequence_143 (p); 2919 rde_param_i_symbol_done_d_reduce (p, 60, 59); 2920 return; 2921 } 2922 2923 static void sequence_143 (RDE_PARAM p) { 2924 /* 2925 * x 2926 * ? 2927 * (Attribute) 2928 * (Identifier) 2929 * (IS) 2930 * (Expression) 2931 * (SEMICOLON) 2932 */ 2933 2934 rde_param_i_state_push_value (p); 2935 optional_137 (p); 2936 if (rde_param_i_seq_value2value(p)) return; 2937 sym_Identifier (p); 2938 if (rde_param_i_seq_value2value(p)) return; 2939 sym_IS (p); 2940 if (rde_param_i_seq_value2value(p)) return; 2941 sym_Expression (p); 2942 if (rde_param_i_seq_value2value(p)) return; 2943 sym_SEMICOLON (p); 2944 rde_param_i_state_merge_value (p); 2945 return; 2946 } 2947 2948 static void optional_137 (RDE_PARAM p) { 2949 /* 2950 * ? 2951 * (Attribute) 2952 */ 2953 2954 rde_param_i_state_push_2 (p); 2955 sym_Attribute (p); 2956 rde_param_i_state_merge_ok (p); 2957 return; 2958 } 2959 2960 /* 2961 * leaf Symbol 'DIGIT' 2962 */ 2963 2964 static void sym_DIGIT (RDE_PARAM p) { 2965 /* 2966 * x 2967 * "<digit>" 2968 * (WHITESPACE) 2969 */ 2970 2971 if (rde_param_i_symbol_start (p, 63)) return ; 2972 sequence_148 (p); 2973 rde_param_i_symbol_done_leaf (p, 63, 62); 2974 return; 2975 } 2976 2977 static void sequence_148 (RDE_PARAM p) { 2978 /* 2979 * x 2980 * "<digit>" 2981 * (WHITESPACE) 2982 */ 2983 2984 rde_param_i_state_push_void (p); 2985 rde_param_i_next_str (p, "<digit>", 61); 2986 if (rde_param_i_seq_void2void(p)) return; 2987 sym_WHITESPACE (p); 2988 rde_param_i_state_merge_void (p); 2989 return; 2990 } 2991 2992 /* 2993 * leaf Symbol 'DOT' 2994 */ 2995 2996 static void sym_DOT (RDE_PARAM p) { 2997 /* 2998 * x 2999 * '.' 3000 * (WHITESPACE) 3001 */ 3002 3003 if (rde_param_i_symbol_start (p, 66)) return ; 3004 sequence_153 (p); 3005 rde_param_i_symbol_done_leaf (p, 66, 65); 3006 return; 3007 } 3008 3009 static void sequence_153 (RDE_PARAM p) { 3010 /* 3011 * x 3012 * '.' 3013 * (WHITESPACE) 3014 */ 3015 3016 rde_param_i_state_push_void (p); 3017 rde_param_i_next_char (p, ".", 64); 3018 if (rde_param_i_seq_void2void(p)) return; 3019 sym_WHITESPACE (p); 3020 rde_param_i_state_merge_void (p); 3021 return; 3022 } 3023 3024 /* 3025 * void Symbol 'END' 3026 */ 3027 3028 static void sym_END (RDE_PARAM p) { 3029 /* 3030 * x 3031 * "END" 3032 * (WHITESPACE) 3033 */ 3034 3035 if (rde_param_i_symbol_void_start (p, 69)) return ; 3036 sequence_158 (p); 3037 rde_param_i_symbol_done_void (p, 69, 68); 3038 return; 3039 } 3040 3041 static void sequence_158 (RDE_PARAM p) { 3042 /* 3043 * x 3044 * "END" 3045 * (WHITESPACE) 3046 */ 3047 3048 rde_param_i_state_push_void (p); 3049 rde_param_i_next_str (p, "END", 67); 3050 if (rde_param_i_seq_void2void(p)) return; 3051 sym_WHITESPACE (p); 3052 rde_param_i_state_merge_void (p); 3053 return; 3054 } 3055 3056 /* 3057 * void Symbol 'EOF' 3058 */ 3059 3060 static void sym_EOF (RDE_PARAM p) { 3061 /* 3062 * ! 3063 * <dot> 3064 */ 3065 3066 if (rde_param_i_symbol_void_start (p, 71)) return ; 3067 notahead_162 (p); 3068 rde_param_i_symbol_done_void (p, 71, 70); 3069 return; 3070 } 3071 3072 static void notahead_162 (RDE_PARAM p) { 3073 /* 3074 * ! 3075 * <dot> 3076 */ 3077 3078 rde_param_i_loc_push (p); 3079 rde_param_i_input_next (p, 29); 3080 rde_param_i_notahead_exit (p); 3081 return; 3082 } 3083 3084 /* 3085 * void Symbol 'EOL' 3086 */ 3087 3088 static void sym_EOL (RDE_PARAM p) { 3089 /* 3090 * [ 3091 * 3092] 3093 */ 3094 3095 if (rde_param_i_symbol_void_start (p, 74)) return ; 3096 rde_param_i_next_class (p, "\n\r", 72); 3097 rde_param_i_symbol_done_void (p, 74, 73); 3098 return; 3099 } 3100 3101 /* 3102 * value Symbol 'Expression' 3103 */ 3104 3105 static void sym_Expression (RDE_PARAM p) { 3106 /* 3107 * x 3108 * (Sequence) 3109 * * 3110 * x 3111 * (SLASH) 3112 * (Sequence) 3113 */ 3114 3115 if (rde_param_i_symbol_start_d (p, 76)) return ; 3116 sequence_174 (p); 3117 rde_param_i_symbol_done_d_reduce (p, 76, 75); 3118 return; 3119 } 3120 3121 static void sequence_174 (RDE_PARAM p) { 3122 /* 3123 * x 3124 * (Sequence) 3125 * * 3126 * x 3127 * (SLASH) 3128 * (Sequence) 3129 */ 3130 3131 rde_param_i_state_push_value (p); 3132 sym_Sequence (p); 3133 if (rde_param_i_seq_value2value(p)) return; 3134 kleene_172 (p); 3135 rde_param_i_state_merge_value (p); 3136 return; 3137 } 3138 3139 static void kleene_172 (RDE_PARAM p) { 3140 /* 3141 * * 3142 * x 3143 * (SLASH) 3144 * (Sequence) 3145 */ 3146 3147 while (1) { 3148 rde_param_i_state_push_2 (p); 3149 sequence_170 (p); 3150 if (rde_param_i_kleene_close(p)) return; 3151 } 3152 return; 3153 } 3154 3155 static void sequence_170 (RDE_PARAM p) { 3156 /* 3157 * x 3158 * (SLASH) 3159 * (Sequence) 3160 */ 3161 3162 rde_param_i_state_push_void (p); 3163 sym_SLASH (p); 3164 if (rde_param_i_seq_void2value(p)) return; 3165 sym_Sequence (p); 3166 rde_param_i_state_merge_value (p); 3167 return; 3168 } 3169 3170 /* 3171 * void Symbol 'Final' 3172 */ 3173 3174 static void sym_Final (RDE_PARAM p) { 3175 /* 3176 * x 3177 * (END) 3178 * (SEMICOLON) 3179 * (WHITESPACE) 3180 */ 3181 3182 if (rde_param_i_symbol_void_start (p, 78)) return ; 3183 sequence_180 (p); 3184 rde_param_i_symbol_done_void (p, 78, 77); 3185 return; 3186 } 3187 3188 static void sequence_180 (RDE_PARAM p) { 3189 /* 3190 * x 3191 * (END) 3192 * (SEMICOLON) 3193 * (WHITESPACE) 3194 */ 3195 3196 rde_param_i_state_push_void (p); 3197 sym_END (p); 3198 if (rde_param_i_seq_void2void(p)) return; 3199 sym_SEMICOLON (p); 3200 if (rde_param_i_seq_void2void(p)) return; 3201 sym_WHITESPACE (p); 3202 rde_param_i_state_merge_void (p); 3203 return; 3204 } 3205 3206 /* 3207 * value Symbol 'Grammar' 3208 */ 3209 3210 static void sym_Grammar (RDE_PARAM p) { 3211 /* 3212 * x 3213 * (WHITESPACE) 3214 * (Header) 3215 * * 3216 * (Definition) 3217 * (Final) 3218 * (EOF) 3219 */ 3220 3221 if (rde_param_i_symbol_start_d (p, 80)) return ; 3222 sequence_190 (p); 3223 rde_param_i_symbol_done_d_reduce (p, 80, 79); 3224 return; 3225 } 3226 3227 static void sequence_190 (RDE_PARAM p) { 3228 /* 3229 * x 3230 * (WHITESPACE) 3231 * (Header) 3232 * * 3233 * (Definition) 3234 * (Final) 3235 * (EOF) 3236 */ 3237 3238 rde_param_i_state_push_void (p); 3239 sym_WHITESPACE (p); 3240 if (rde_param_i_seq_void2value(p)) return; 3241 sym_Header (p); 3242 if (rde_param_i_seq_value2value(p)) return; 3243 kleene_186 (p); 3244 if (rde_param_i_seq_value2value(p)) return; 3245 sym_Final (p); 3246 if (rde_param_i_seq_value2value(p)) return; 3247 sym_EOF (p); 3248 rde_param_i_state_merge_value (p); 3249 return; 3250 } 3251 3252 static void kleene_186 (RDE_PARAM p) { 3253 /* 3254 * * 3255 * (Definition) 3256 */ 3257 3258 while (1) { 3259 rde_param_i_state_push_2 (p); 3260 sym_Definition (p); 3261 if (rde_param_i_kleene_close(p)) return; 3262 } 3263 return; 3264 } 3265 3266 /* 3267 * leaf Symbol 'GRAPH' 3268 */ 3269 3270 static void sym_GRAPH (RDE_PARAM p) { 3271 /* 3272 * x 3273 * "<graph>" 3274 * (WHITESPACE) 3275 */ 3276 3277 if (rde_param_i_symbol_start (p, 83)) return ; 3278 sequence_195 (p); 3279 rde_param_i_symbol_done_leaf (p, 83, 82); 3280 return; 3281 } 3282 3283 static void sequence_195 (RDE_PARAM p) { 3284 /* 3285 * x 3286 * "<graph>" 3287 * (WHITESPACE) 3288 */ 3289 3290 rde_param_i_state_push_void (p); 3291 rde_param_i_next_str (p, "<graph>", 81); 3292 if (rde_param_i_seq_void2void(p)) return; 3293 sym_WHITESPACE (p); 3294 rde_param_i_state_merge_void (p); 3295 return; 3296 } 3297 3298 /* 3299 * value Symbol 'Header' 3300 */ 3301 3302 static void sym_Header (RDE_PARAM p) { 3303 /* 3304 * x 3305 * (PEG) 3306 * (Identifier) 3307 * (StartExpr) 3308 */ 3309 3310 if (rde_param_i_symbol_start_d (p, 85)) return ; 3311 sequence_201 (p); 3312 rde_param_i_symbol_done_d_reduce (p, 85, 84); 3313 return; 3314 } 3315 3316 static void sequence_201 (RDE_PARAM p) { 3317 /* 3318 * x 3319 * (PEG) 3320 * (Identifier) 3321 * (StartExpr) 3322 */ 3323 3324 rde_param_i_state_push_void (p); 3325 sym_PEG (p); 3326 if (rde_param_i_seq_void2value(p)) return; 3327 sym_Identifier (p); 3328 if (rde_param_i_seq_value2value(p)) return; 3329 sym_StartExpr (p); 3330 rde_param_i_state_merge_value (p); 3331 return; 3332 } 3333 3334 /* 3335 * leaf Symbol 'Ident' 3336 */ 3337 3338 static void sym_Ident (RDE_PARAM p) { 3339 /* 3340 * x 3341 * / 3342 * [_:] 3343 * <alpha> 3344 * * 3345 * / 3346 * [_:] 3347 * <alnum> 3348 */ 3349 3350 if (rde_param_i_symbol_start (p, 90)) return ; 3351 sequence_214 (p); 3352 rde_param_i_symbol_done_leaf (p, 90, 89); 3353 return; 3354 } 3355 3356 static void sequence_214 (RDE_PARAM p) { 3357 /* 3358 * x 3359 * / 3360 * [_:] 3361 * <alpha> 3362 * * 3363 * / 3364 * [_:] 3365 * <alnum> 3366 */ 3367 3368 rde_param_i_state_push_void (p); 3369 choice_206 (p); 3370 if (rde_param_i_seq_void2void(p)) return; 3371 kleene_212 (p); 3372 rde_param_i_state_merge_void (p); 3373 return; 3374 } 3375 3376 static void choice_206 (RDE_PARAM p) { 3377 /* 3378 * / 3379 * [_:] 3380 * <alpha> 3381 */ 3382 3383 rde_param_i_state_push_void (p); 3384 rde_param_i_next_class (p, "_:", 86); 3385 if (rde_param_i_bra_void2void(p)) return; 3386 rde_param_i_next_alpha (p, 87); 3387 rde_param_i_state_merge_void (p); 3388 return; 3389 } 3390 3391 static void kleene_212 (RDE_PARAM p) { 3392 /* 3393 * * 3394 * / 3395 * [_:] 3396 * <alnum> 3397 */ 3398 3399 while (1) { 3400 rde_param_i_state_push_2 (p); 3401 choice_210 (p); 3402 if (rde_param_i_kleene_close(p)) return; 3403 } 3404 return; 3405 } 3406 3407 static void choice_210 (RDE_PARAM p) { 3408 /* 3409 * / 3410 * [_:] 3411 * <alnum> 3412 */ 3413 3414 rde_param_i_state_push_void (p); 3415 rde_param_i_next_class (p, "_:", 86); 3416 if (rde_param_i_bra_void2void(p)) return; 3417 rde_param_i_next_alnum (p, 88); 3418 rde_param_i_state_merge_void (p); 3419 return; 3420 } 3421 3422 /* 3423 * value Symbol 'Identifier' 3424 */ 3425 3426 static void sym_Identifier (RDE_PARAM p) { 3427 /* 3428 * x 3429 * (Ident) 3430 * (WHITESPACE) 3431 */ 3432 3433 if (rde_param_i_symbol_start_d (p, 92)) return ; 3434 sequence_219 (p); 3435 rde_param_i_symbol_done_d_reduce (p, 92, 91); 3436 return; 3437 } 3438 3439 static void sequence_219 (RDE_PARAM p) { 3440 /* 3441 * x 3442 * (Ident) 3443 * (WHITESPACE) 3444 */ 3445 3446 rde_param_i_state_push_value (p); 3447 sym_Ident (p); 3448 if (rde_param_i_seq_value2value(p)) return; 3449 sym_WHITESPACE (p); 3450 rde_param_i_state_merge_value (p); 3451 return; 3452 } 3453 3454 /* 3455 * void Symbol 'IS' 3456 */ 3457 3458 static void sym_IS (RDE_PARAM p) { 3459 /* 3460 * x 3461 * "<-" 3462 * (WHITESPACE) 3463 */ 3464 3465 if (rde_param_i_symbol_void_start (p, 95)) return ; 3466 sequence_224 (p); 3467 rde_param_i_symbol_done_void (p, 95, 94); 3468 return; 3469 } 3470 3471 static void sequence_224 (RDE_PARAM p) { 3472 /* 3473 * x 3474 * "<-" 3475 * (WHITESPACE) 3476 */ 3477 3478 rde_param_i_state_push_void (p); 3479 rde_param_i_next_str (p, "<-", 93); 3480 if (rde_param_i_seq_void2void(p)) return; 3481 sym_WHITESPACE (p); 3482 rde_param_i_state_merge_void (p); 3483 return; 3484 } 3485 3486 /* 3487 * leaf Symbol 'LEAF' 3488 */ 3489 3490 static void sym_LEAF (RDE_PARAM p) { 3491 /* 3492 * x 3493 * "leaf" 3494 * (WHITESPACE) 3495 */ 3496 3497 if (rde_param_i_symbol_start (p, 98)) return ; 3498 sequence_229 (p); 3499 rde_param_i_symbol_done_leaf (p, 98, 97); 3500 return; 3501 } 3502 3503 static void sequence_229 (RDE_PARAM p) { 3504 /* 3505 * x 3506 * "leaf" 3507 * (WHITESPACE) 3508 */ 3509 3510 rde_param_i_state_push_void (p); 3511 rde_param_i_next_str (p, "leaf", 96); 3512 if (rde_param_i_seq_void2void(p)) return; 3513 sym_WHITESPACE (p); 3514 rde_param_i_state_merge_void (p); 3515 return; 3516 } 3517 3518 /* 3519 * value Symbol 'Literal' 3520 */ 3521 3522 static void sym_Literal (RDE_PARAM p) { 3523 /* 3524 * / 3525 * x 3526 * (APOSTROPH) 3527 * * 3528 * x 3529 * ! 3530 * (APOSTROPH) 3531 * (Char) 3532 * (APOSTROPH) 3533 * (WHITESPACE) 3534 * x 3535 * (DAPOSTROPH) 3536 * * 3537 * x 3538 * ! 3539 * (DAPOSTROPH) 3540 * (Char) 3541 * (DAPOSTROPH) 3542 * (WHITESPACE) 3543 */ 3544 3545 if (rde_param_i_symbol_start_d (p, 100)) return ; 3546 choice_258 (p); 3547 rde_param_i_symbol_done_d_reduce (p, 100, 99); 3548 return; 3549 } 3550 3551 static void choice_258 (RDE_PARAM p) { 3552 /* 3553 * / 3554 * x 3555 * (APOSTROPH) 3556 * * 3557 * x 3558 * ! 3559 * (APOSTROPH) 3560 * (Char) 3561 * (APOSTROPH) 3562 * (WHITESPACE) 3563 * x 3564 * (DAPOSTROPH) 3565 * * 3566 * x 3567 * ! 3568 * (DAPOSTROPH) 3569 * (Char) 3570 * (DAPOSTROPH) 3571 * (WHITESPACE) 3572 */ 3573 3574 rde_param_i_state_push_value (p); 3575 sequence_243 (p); 3576 if (rde_param_i_bra_value2value(p)) return; 3577 sequence_256 (p); 3578 rde_param_i_state_merge_value (p); 3579 return; 3580 } 3581 3582 static void sequence_243 (RDE_PARAM p) { 3583 /* 3584 * x 3585 * (APOSTROPH) 3586 * * 3587 * x 3588 * ! 3589 * (APOSTROPH) 3590 * (Char) 3591 * (APOSTROPH) 3592 * (WHITESPACE) 3593 */ 3594 3595 rde_param_i_state_push_void (p); 3596 sym_APOSTROPH (p); 3597 if (rde_param_i_seq_void2value(p)) return; 3598 kleene_239 (p); 3599 if (rde_param_i_seq_value2value(p)) return; 3600 sym_APOSTROPH (p); 3601 if (rde_param_i_seq_value2value(p)) return; 3602 sym_WHITESPACE (p); 3603 rde_param_i_state_merge_value (p); 3604 return; 3605 } 3606 3607 static void kleene_239 (RDE_PARAM p) { 3608 /* 3609 * * 3610 * x 3611 * ! 3612 * (APOSTROPH) 3613 * (Char) 3614 */ 3615 3616 while (1) { 3617 rde_param_i_state_push_2 (p); 3618 sequence_237 (p); 3619 if (rde_param_i_kleene_close(p)) return; 3620 } 3621 return; 3622 } 3623 3624 static void sequence_237 (RDE_PARAM p) { 3625 /* 3626 * x 3627 * ! 3628 * (APOSTROPH) 3629 * (Char) 3630 */ 3631 3632 rde_param_i_state_push_void (p); 3633 notahead_234 (p); 3634 if (rde_param_i_seq_void2value(p)) return; 3635 sym_Char (p); 3636 rde_param_i_state_merge_value (p); 3637 return; 3638 } 3639 3640 static void notahead_234 (RDE_PARAM p) { 3641 /* 3642 * ! 3643 * (APOSTROPH) 3644 */ 3645 3646 rde_param_i_loc_push (p); 3647 sym_APOSTROPH (p); 3648 rde_param_i_notahead_exit (p); 3649 return; 3650 } 3651 3652 static void sequence_256 (RDE_PARAM p) { 3653 /* 3654 * x 3655 * (DAPOSTROPH) 3656 * * 3657 * x 3658 * ! 3659 * (DAPOSTROPH) 3660 * (Char) 3661 * (DAPOSTROPH) 3662 * (WHITESPACE) 3663 */ 3664 3665 rde_param_i_state_push_void (p); 3666 sym_DAPOSTROPH (p); 3667 if (rde_param_i_seq_void2value(p)) return; 3668 kleene_252 (p); 3669 if (rde_param_i_seq_value2value(p)) return; 3670 sym_DAPOSTROPH (p); 3671 if (rde_param_i_seq_value2value(p)) return; 3672 sym_WHITESPACE (p); 3673 rde_param_i_state_merge_value (p); 3674 return; 3675 } 3676 3677 static void kleene_252 (RDE_PARAM p) { 3678 /* 3679 * * 3680 * x 3681 * ! 3682 * (DAPOSTROPH) 3683 * (Char) 3684 */ 3685 3686 while (1) { 3687 rde_param_i_state_push_2 (p); 3688 sequence_250 (p); 3689 if (rde_param_i_kleene_close(p)) return; 3690 } 3691 return; 3692 } 3693 3694 static void sequence_250 (RDE_PARAM p) { 3695 /* 3696 * x 3697 * ! 3698 * (DAPOSTROPH) 3699 * (Char) 3700 */ 3701 3702 rde_param_i_state_push_void (p); 3703 notahead_247 (p); 3704 if (rde_param_i_seq_void2value(p)) return; 3705 sym_Char (p); 3706 rde_param_i_state_merge_value (p); 3707 return; 3708 } 3709 3710 static void notahead_247 (RDE_PARAM p) { 3711 /* 3712 * ! 3713 * (DAPOSTROPH) 3714 */ 3715 3716 rde_param_i_loc_push (p); 3717 sym_DAPOSTROPH (p); 3718 rde_param_i_notahead_exit (p); 3719 return; 3720 } 3721 3722 /* 3723 * leaf Symbol 'LOWER' 3724 */ 3725 3726 static void sym_LOWER (RDE_PARAM p) { 3727 /* 3728 * x 3729 * "<lower>" 3730 * (WHITESPACE) 3731 */ 3732 3733 if (rde_param_i_symbol_start (p, 103)) return ; 3734 sequence_263 (p); 3735 rde_param_i_symbol_done_leaf (p, 103, 102); 3736 return; 3737 } 3738 3739 static void sequence_263 (RDE_PARAM p) { 3740 /* 3741 * x 3742 * "<lower>" 3743 * (WHITESPACE) 3744 */ 3745 3746 rde_param_i_state_push_void (p); 3747 rde_param_i_next_str (p, "<lower>", 101); 3748 if (rde_param_i_seq_void2void(p)) return; 3749 sym_WHITESPACE (p); 3750 rde_param_i_state_merge_void (p); 3751 return; 3752 } 3753 3754 /* 3755 * leaf Symbol 'NOT' 3756 */ 3757 3758 static void sym_NOT (RDE_PARAM p) { 3759 /* 3760 * x 3761 * '!' 3762 * (WHITESPACE) 3763 */ 3764 3765 if (rde_param_i_symbol_start (p, 106)) return ; 3766 sequence_268 (p); 3767 rde_param_i_symbol_done_leaf (p, 106, 105); 3768 return; 3769 } 3770 3771 static void sequence_268 (RDE_PARAM p) { 3772 /* 3773 * x 3774 * '!' 3775 * (WHITESPACE) 3776 */ 3777 3778 rde_param_i_state_push_void (p); 3779 rde_param_i_next_char (p, "!", 104); 3780 if (rde_param_i_seq_void2void(p)) return; 3781 sym_WHITESPACE (p); 3782 rde_param_i_state_merge_void (p); 3783 return; 3784 } 3785 3786 /* 3787 * void Symbol 'OPEN' 3788 */ 3789 3790 static void sym_OPEN (RDE_PARAM p) { 3791 /* 3792 * x 3793 * '\(' 3794 * (WHITESPACE) 3795 */ 3796 3797 if (rde_param_i_symbol_void_start (p, 109)) return ; 3798 sequence_273 (p); 3799 rde_param_i_symbol_done_void (p, 109, 108); 3800 return; 3801 } 3802 3803 static void sequence_273 (RDE_PARAM p) { 3804 /* 3805 * x 3806 * '\(' 3807 * (WHITESPACE) 3808 */ 3809 3810 rde_param_i_state_push_void (p); 3811 rde_param_i_next_char (p, "\50", 107); 3812 if (rde_param_i_seq_void2void(p)) return; 3813 sym_WHITESPACE (p); 3814 rde_param_i_state_merge_void (p); 3815 return; 3816 } 3817 3818 /* 3819 * void Symbol 'OPENB' 3820 */ 3821 3822 static void sym_OPENB (RDE_PARAM p) { 3823 /* 3824 * '[' 3825 */ 3826 3827 if (rde_param_i_symbol_void_start (p, 112)) return ; 3828 rde_param_i_next_char (p, "\133", 110); 3829 rde_param_i_symbol_done_void (p, 112, 111); 3830 return; 3831 } 3832 3833 /* 3834 * void Symbol 'PEG' 3835 */ 3836 3837 static void sym_PEG (RDE_PARAM p) { 3838 /* 3839 * x 3840 * "PEG" 3841 * (WHITESPACE) 3842 */ 3843 3844 if (rde_param_i_symbol_void_start (p, 115)) return ; 3845 sequence_280 (p); 3846 rde_param_i_symbol_done_void (p, 115, 114); 3847 return; 3848 } 3849 3850 static void sequence_280 (RDE_PARAM p) { 3851 /* 3852 * x 3853 * "PEG" 3854 * (WHITESPACE) 3855 */ 3856 3857 rde_param_i_state_push_void (p); 3858 rde_param_i_next_str (p, "PEG", 113); 3859 if (rde_param_i_seq_void2void(p)) return; 3860 sym_WHITESPACE (p); 3861 rde_param_i_state_merge_void (p); 3862 return; 3863 } 3864 3865 /* 3866 * leaf Symbol 'PLUS' 3867 */ 3868 3869 static void sym_PLUS (RDE_PARAM p) { 3870 /* 3871 * x 3872 * '+' 3873 * (WHITESPACE) 3874 */ 3875 3876 if (rde_param_i_symbol_start (p, 118)) return ; 3877 sequence_285 (p); 3878 rde_param_i_symbol_done_leaf (p, 118, 117); 3879 return; 3880 } 3881 3882 static void sequence_285 (RDE_PARAM p) { 3883 /* 3884 * x 3885 * '+' 3886 * (WHITESPACE) 3887 */ 3888 3889 rde_param_i_state_push_void (p); 3890 rde_param_i_next_char (p, "+", 116); 3891 if (rde_param_i_seq_void2void(p)) return; 3892 sym_WHITESPACE (p); 3893 rde_param_i_state_merge_void (p); 3894 return; 3895 } 3896 3897 /* 3898 * value Symbol 'Prefix' 3899 */ 3900 3901 static void sym_Prefix (RDE_PARAM p) { 3902 /* 3903 * x 3904 * ? 3905 * / 3906 * (AND) 3907 * (NOT) 3908 * (Suffix) 3909 */ 3910 3911 if (rde_param_i_symbol_start_d (p, 120)) return ; 3912 sequence_295 (p); 3913 rde_param_i_symbol_done_d_reduce (p, 120, 119); 3914 return; 3915 } 3916 3917 static void sequence_295 (RDE_PARAM p) { 3918 /* 3919 * x 3920 * ? 3921 * / 3922 * (AND) 3923 * (NOT) 3924 * (Suffix) 3925 */ 3926 3927 rde_param_i_state_push_value (p); 3928 optional_292 (p); 3929 if (rde_param_i_seq_value2value(p)) return; 3930 sym_Suffix (p); 3931 rde_param_i_state_merge_value (p); 3932 return; 3933 } 3934 3935 static void optional_292 (RDE_PARAM p) { 3936 /* 3937 * ? 3938 * / 3939 * (AND) 3940 * (NOT) 3941 */ 3942 3943 rde_param_i_state_push_2 (p); 3944 choice_290 (p); 3945 rde_param_i_state_merge_ok (p); 3946 return; 3947 } 3948 3949 static void choice_290 (RDE_PARAM p) { 3950 /* 3951 * / 3952 * (AND) 3953 * (NOT) 3954 */ 3955 3956 rde_param_i_state_push_value (p); 3957 sym_AND (p); 3958 if (rde_param_i_bra_value2value(p)) return; 3959 sym_NOT (p); 3960 rde_param_i_state_merge_value (p); 3961 return; 3962 } 3963 3964 /* 3965 * value Symbol 'Primary' 3966 */ 3967 3968 static void sym_Primary (RDE_PARAM p) { 3969 /* 3970 * / 3971 * (ALNUM) 3972 * (ALPHA) 3973 * (ASCII) 3974 * (CONTROL) 3975 * (DDIGIT) 3976 * (DIGIT) 3977 * (GRAPH) 3978 * (LOWER) 3979 * (PRINTABLE) 3980 * (PUNCT) 3981 * (SPACE) 3982 * (UPPER) 3983 * (WORDCHAR) 3984 * (XDIGIT) 3985 * (Identifier) 3986 * x 3987 * (OPEN) 3988 * (Expression) 3989 * (CLOSE) 3990 * (Literal) 3991 * (Class) 3992 * (DOT) 3993 */ 3994 3995 if (rde_param_i_symbol_start_d (p, 122)) return ; 3996 choice_321 (p); 3997 rde_param_i_symbol_done_d_reduce (p, 122, 121); 3998 return; 3999 } 4000 4001 static void choice_321 (RDE_PARAM p) { 4002 /* 4003 * / 4004 * (ALNUM) 4005 * (ALPHA) 4006 * (ASCII) 4007 * (CONTROL) 4008 * (DDIGIT) 4009 * (DIGIT) 4010 * (GRAPH) 4011 * (LOWER) 4012 * (PRINTABLE) 4013 * (PUNCT) 4014 * (SPACE) 4015 * (UPPER) 4016 * (WORDCHAR) 4017 * (XDIGIT) 4018 * (Identifier) 4019 * x 4020 * (OPEN) 4021 * (Expression) 4022 * (CLOSE) 4023 * (Literal) 4024 * (Class) 4025 * (DOT) 4026 */ 4027 4028 rde_param_i_state_push_value (p); 4029 sym_ALNUM (p); 4030 if (rde_param_i_bra_value2value(p)) return; 4031 sym_ALPHA (p); 4032 if (rde_param_i_bra_value2value(p)) return; 4033 sym_ASCII (p); 4034 if (rde_param_i_bra_value2value(p)) return; 4035 sym_CONTROL (p); 4036 if (rde_param_i_bra_value2value(p)) return; 4037 sym_DDIGIT (p); 4038 if (rde_param_i_bra_value2value(p)) return; 4039 sym_DIGIT (p); 4040 if (rde_param_i_bra_value2value(p)) return; 4041 sym_GRAPH (p); 4042 if (rde_param_i_bra_value2value(p)) return; 4043 sym_LOWER (p); 4044 if (rde_param_i_bra_value2value(p)) return; 4045 sym_PRINTABLE (p); 4046 if (rde_param_i_bra_value2value(p)) return; 4047 sym_PUNCT (p); 4048 if (rde_param_i_bra_value2value(p)) return; 4049 sym_SPACE (p); 4050 if (rde_param_i_bra_value2value(p)) return; 4051 sym_UPPER (p); 4052 if (rde_param_i_bra_value2value(p)) return; 4053 sym_WORDCHAR (p); 4054 if (rde_param_i_bra_value2value(p)) return; 4055 sym_XDIGIT (p); 4056 if (rde_param_i_bra_value2value(p)) return; 4057 sym_Identifier (p); 4058 if (rde_param_i_bra_value2value(p)) return; 4059 sequence_316 (p); 4060 if (rde_param_i_bra_value2value(p)) return; 4061 sym_Literal (p); 4062 if (rde_param_i_bra_value2value(p)) return; 4063 sym_Class (p); 4064 if (rde_param_i_bra_value2value(p)) return; 4065 sym_DOT (p); 4066 rde_param_i_state_merge_value (p); 4067 return; 4068 } 4069 4070 static void sequence_316 (RDE_PARAM p) { 4071 /* 4072 * x 4073 * (OPEN) 4074 * (Expression) 4075 * (CLOSE) 4076 */ 4077 4078 rde_param_i_state_push_void (p); 4079 sym_OPEN (p); 4080 if (rde_param_i_seq_void2value(p)) return; 4081 sym_Expression (p); 4082 if (rde_param_i_seq_value2value(p)) return; 4083 sym_CLOSE (p); 4084 rde_param_i_state_merge_value (p); 4085 return; 4086 } 4087 4088 /* 4089 * leaf Symbol 'PRINTABLE' 4090 */ 4091 4092 static void sym_PRINTABLE (RDE_PARAM p) { 4093 /* 4094 * x 4095 * "<print>" 4096 * (WHITESPACE) 4097 */ 4098 4099 if (rde_param_i_symbol_start (p, 125)) return ; 4100 sequence_326 (p); 4101 rde_param_i_symbol_done_leaf (p, 125, 124); 4102 return; 4103 } 4104 4105 static void sequence_326 (RDE_PARAM p) { 4106 /* 4107 * x 4108 * "<print>" 4109 * (WHITESPACE) 4110 */ 4111 4112 rde_param_i_state_push_void (p); 4113 rde_param_i_next_str (p, "<print>", 123); 4114 if (rde_param_i_seq_void2void(p)) return; 4115 sym_WHITESPACE (p); 4116 rde_param_i_state_merge_void (p); 4117 return; 4118 } 4119 4120 /* 4121 * leaf Symbol 'PUNCT' 4122 */ 4123 4124 static void sym_PUNCT (RDE_PARAM p) { 4125 /* 4126 * x 4127 * "<punct>" 4128 * (WHITESPACE) 4129 */ 4130 4131 if (rde_param_i_symbol_start (p, 128)) return ; 4132 sequence_331 (p); 4133 rde_param_i_symbol_done_leaf (p, 128, 127); 4134 return; 4135 } 4136 4137 static void sequence_331 (RDE_PARAM p) { 4138 /* 4139 * x 4140 * "<punct>" 4141 * (WHITESPACE) 4142 */ 4143 4144 rde_param_i_state_push_void (p); 4145 rde_param_i_next_str (p, "<punct>", 126); 4146 if (rde_param_i_seq_void2void(p)) return; 4147 sym_WHITESPACE (p); 4148 rde_param_i_state_merge_void (p); 4149 return; 4150 } 4151 4152 /* 4153 * leaf Symbol 'QUESTION' 4154 */ 4155 4156 static void sym_QUESTION (RDE_PARAM p) { 4157 /* 4158 * x 4159 * '?' 4160 * (WHITESPACE) 4161 */ 4162 4163 if (rde_param_i_symbol_start (p, 131)) return ; 4164 sequence_336 (p); 4165 rde_param_i_symbol_done_leaf (p, 131, 130); 4166 return; 4167 } 4168 4169 static void sequence_336 (RDE_PARAM p) { 4170 /* 4171 * x 4172 * '?' 4173 * (WHITESPACE) 4174 */ 4175 4176 rde_param_i_state_push_void (p); 4177 rde_param_i_next_char (p, "?", 129); 4178 if (rde_param_i_seq_void2void(p)) return; 4179 sym_WHITESPACE (p); 4180 rde_param_i_state_merge_void (p); 4181 return; 4182 } 4183 4184 /* 4185 * value Symbol 'Range' 4186 */ 4187 4188 static void sym_Range (RDE_PARAM p) { 4189 /* 4190 * / 4191 * x 4192 * (Char) 4193 * (TO) 4194 * (Char) 4195 * (Char) 4196 */ 4197 4198 if (rde_param_i_symbol_start_d (p, 133)) return ; 4199 choice_345 (p); 4200 rde_param_i_symbol_done_d_reduce (p, 133, 132); 4201 return; 4202 } 4203 4204 static void choice_345 (RDE_PARAM p) { 4205 /* 4206 * / 4207 * x 4208 * (Char) 4209 * (TO) 4210 * (Char) 4211 * (Char) 4212 */ 4213 4214 rde_param_i_state_push_value (p); 4215 sequence_342 (p); 4216 if (rde_param_i_bra_value2value(p)) return; 4217 sym_Char (p); 4218 rde_param_i_state_merge_value (p); 4219 return; 4220 } 4221 4222 static void sequence_342 (RDE_PARAM p) { 4223 /* 4224 * x 4225 * (Char) 4226 * (TO) 4227 * (Char) 4228 */ 4229 4230 rde_param_i_state_push_value (p); 4231 sym_Char (p); 4232 if (rde_param_i_seq_value2value(p)) return; 4233 sym_TO (p); 4234 if (rde_param_i_seq_value2value(p)) return; 4235 sym_Char (p); 4236 rde_param_i_state_merge_value (p); 4237 return; 4238 } 4239 4240 /* 4241 * void Symbol 'SEMICOLON' 4242 */ 4243 4244 static void sym_SEMICOLON (RDE_PARAM p) { 4245 /* 4246 * x 4247 * ';' 4248 * (WHITESPACE) 4249 */ 4250 4251 if (rde_param_i_symbol_void_start (p, 136)) return ; 4252 sequence_350 (p); 4253 rde_param_i_symbol_done_void (p, 136, 135); 4254 return; 4255 } 4256 4257 static void sequence_350 (RDE_PARAM p) { 4258 /* 4259 * x 4260 * ';' 4261 * (WHITESPACE) 4262 */ 4263 4264 rde_param_i_state_push_void (p); 4265 rde_param_i_next_char (p, "\73", 134); 4266 if (rde_param_i_seq_void2void(p)) return; 4267 sym_WHITESPACE (p); 4268 rde_param_i_state_merge_void (p); 4269 return; 4270 } 4271 4272 /* 4273 * value Symbol 'Sequence' 4274 */ 4275 4276 static void sym_Sequence (RDE_PARAM p) { 4277 /* 4278 * + 4279 * (Prefix) 4280 */ 4281 4282 if (rde_param_i_symbol_start_d (p, 138)) return ; 4283 poskleene_354 (p); 4284 rde_param_i_symbol_done_d_reduce (p, 138, 137); 4285 return; 4286 } 4287 4288 static void poskleene_354 (RDE_PARAM p) { 4289 /* 4290 * + 4291 * (Prefix) 4292 */ 4293 4294 rde_param_i_loc_push (p); 4295 sym_Prefix (p); 4296 if (rde_param_i_kleene_abort(p)) return; 4297 while (1) { 4298 rde_param_i_state_push_2 (p); 4299 sym_Prefix (p); 4300 if (rde_param_i_kleene_close(p)) return; 4301 } 4302 return; 4303 } 4304 4305 /* 4306 * void Symbol 'SLASH' 4307 */ 4308 4309 static void sym_SLASH (RDE_PARAM p) { 4310 /* 4311 * x 4312 * '/' 4313 * (WHITESPACE) 4314 */ 4315 4316 if (rde_param_i_symbol_void_start (p, 141)) return ; 4317 sequence_359 (p); 4318 rde_param_i_symbol_done_void (p, 141, 140); 4319 return; 4320 } 4321 4322 static void sequence_359 (RDE_PARAM p) { 4323 /* 4324 * x 4325 * '/' 4326 * (WHITESPACE) 4327 */ 4328 4329 rde_param_i_state_push_void (p); 4330 rde_param_i_next_char (p, "/", 139); 4331 if (rde_param_i_seq_void2void(p)) return; 4332 sym_WHITESPACE (p); 4333 rde_param_i_state_merge_void (p); 4334 return; 4335 } 4336 4337 /* 4338 * leaf Symbol 'SPACE' 4339 */ 4340 4341 static void sym_SPACE (RDE_PARAM p) { 4342 /* 4343 * x 4344 * "<space>" 4345 * (WHITESPACE) 4346 */ 4347 4348 if (rde_param_i_symbol_start (p, 144)) return ; 4349 sequence_364 (p); 4350 rde_param_i_symbol_done_leaf (p, 144, 143); 4351 return; 4352 } 4353 4354 static void sequence_364 (RDE_PARAM p) { 4355 /* 4356 * x 4357 * "<space>" 4358 * (WHITESPACE) 4359 */ 4360 4361 rde_param_i_state_push_void (p); 4362 rde_param_i_next_str (p, "<space>", 142); 4363 if (rde_param_i_seq_void2void(p)) return; 4364 sym_WHITESPACE (p); 4365 rde_param_i_state_merge_void (p); 4366 return; 4367 } 4368 4369 /* 4370 * leaf Symbol 'STAR' 4371 */ 4372 4373 static void sym_STAR (RDE_PARAM p) { 4374 /* 4375 * x 4376 * '*' 4377 * (WHITESPACE) 4378 */ 4379 4380 if (rde_param_i_symbol_start (p, 147)) return ; 4381 sequence_369 (p); 4382 rde_param_i_symbol_done_leaf (p, 147, 146); 4383 return; 4384 } 4385 4386 static void sequence_369 (RDE_PARAM p) { 4387 /* 4388 * x 4389 * '*' 4390 * (WHITESPACE) 4391 */ 4392 4393 rde_param_i_state_push_void (p); 4394 rde_param_i_next_char (p, "*", 145); 4395 if (rde_param_i_seq_void2void(p)) return; 4396 sym_WHITESPACE (p); 4397 rde_param_i_state_merge_void (p); 4398 return; 4399 } 4400 4401 /* 4402 * value Symbol 'StartExpr' 4403 */ 4404 4405 static void sym_StartExpr (RDE_PARAM p) { 4406 /* 4407 * x 4408 * (OPEN) 4409 * (Expression) 4410 * (CLOSE) 4411 */ 4412 4413 if (rde_param_i_symbol_start_d (p, 149)) return ; 4414 sequence_316 (p); 4415 rde_param_i_symbol_done_d_reduce (p, 149, 148); 4416 return; 4417 } 4418 4419 /* 4420 * value Symbol 'Suffix' 4421 */ 4422 4423 static void sym_Suffix (RDE_PARAM p) { 4424 /* 4425 * x 4426 * (Primary) 4427 * ? 4428 * / 4429 * (QUESTION) 4430 * (STAR) 4431 * (PLUS) 4432 */ 4433 4434 if (rde_param_i_symbol_start_d (p, 151)) return ; 4435 sequence_385 (p); 4436 rde_param_i_symbol_done_d_reduce (p, 151, 150); 4437 return; 4438 } 4439 4440 static void sequence_385 (RDE_PARAM p) { 4441 /* 4442 * x 4443 * (Primary) 4444 * ? 4445 * / 4446 * (QUESTION) 4447 * (STAR) 4448 * (PLUS) 4449 */ 4450 4451 rde_param_i_state_push_value (p); 4452 sym_Primary (p); 4453 if (rde_param_i_seq_value2value(p)) return; 4454 optional_383 (p); 4455 rde_param_i_state_merge_value (p); 4456 return; 4457 } 4458 4459 static void optional_383 (RDE_PARAM p) { 4460 /* 4461 * ? 4462 * / 4463 * (QUESTION) 4464 * (STAR) 4465 * (PLUS) 4466 */ 4467 4468 rde_param_i_state_push_2 (p); 4469 choice_381 (p); 4470 rde_param_i_state_merge_ok (p); 4471 return; 4472 } 4473 4474 static void choice_381 (RDE_PARAM p) { 4475 /* 4476 * / 4477 * (QUESTION) 4478 * (STAR) 4479 * (PLUS) 4480 */ 4481 4482 rde_param_i_state_push_value (p); 4483 sym_QUESTION (p); 4484 if (rde_param_i_bra_value2value(p)) return; 4485 sym_STAR (p); 4486 if (rde_param_i_bra_value2value(p)) return; 4487 sym_PLUS (p); 4488 rde_param_i_state_merge_value (p); 4489 return; 4490 } 4491 4492 /* 4493 * void Symbol 'TO' 4494 */ 4495 4496 static void sym_TO (RDE_PARAM p) { 4497 /* 4498 * '-' 4499 */ 4500 4501 if (rde_param_i_symbol_void_start (p, 154)) return ; 4502 rde_param_i_next_char (p, "-", 152); 4503 rde_param_i_symbol_done_void (p, 154, 153); 4504 return; 4505 } 4506 4507 /* 4508 * leaf Symbol 'UPPER' 4509 */ 4510 4511 static void sym_UPPER (RDE_PARAM p) { 4512 /* 4513 * x 4514 * "<upper>" 4515 * (WHITESPACE) 4516 */ 4517 4518 if (rde_param_i_symbol_start (p, 157)) return ; 4519 sequence_392 (p); 4520 rde_param_i_symbol_done_leaf (p, 157, 156); 4521 return; 4522 } 4523 4524 static void sequence_392 (RDE_PARAM p) { 4525 /* 4526 * x 4527 * "<upper>" 4528 * (WHITESPACE) 4529 */ 4530 4531 rde_param_i_state_push_void (p); 4532 rde_param_i_next_str (p, "<upper>", 155); 4533 if (rde_param_i_seq_void2void(p)) return; 4534 sym_WHITESPACE (p); 4535 rde_param_i_state_merge_void (p); 4536 return; 4537 } 4538 4539 /* 4540 * leaf Symbol 'VOID' 4541 */ 4542 4543 static void sym_VOID (RDE_PARAM p) { 4544 /* 4545 * x 4546 * "void" 4547 * (WHITESPACE) 4548 */ 4549 4550 if (rde_param_i_symbol_start (p, 160)) return ; 4551 sequence_397 (p); 4552 rde_param_i_symbol_done_leaf (p, 160, 159); 4553 return; 4554 } 4555 4556 static void sequence_397 (RDE_PARAM p) { 4557 /* 4558 * x 4559 * "void" 4560 * (WHITESPACE) 4561 */ 4562 4563 rde_param_i_state_push_void (p); 4564 rde_param_i_next_str (p, "void", 158); 4565 if (rde_param_i_seq_void2void(p)) return; 4566 sym_WHITESPACE (p); 4567 rde_param_i_state_merge_void (p); 4568 return; 4569 } 4570 4571 /* 4572 * void Symbol 'WHITESPACE' 4573 */ 4574 4575 static void sym_WHITESPACE (RDE_PARAM p) { 4576 /* 4577 * * 4578 * / 4579 * <space> 4580 * (COMMENT) 4581 */ 4582 4583 if (rde_param_i_symbol_void_start (p, 163)) return ; 4584 kleene_404 (p); 4585 rde_param_i_symbol_done_void (p, 163, 162); 4586 return; 4587 } 4588 4589 static void kleene_404 (RDE_PARAM p) { 4590 /* 4591 * * 4592 * / 4593 * <space> 4594 * (COMMENT) 4595 */ 4596 4597 while (1) { 4598 rde_param_i_state_push_2 (p); 4599 choice_402 (p); 4600 if (rde_param_i_kleene_close(p)) return; 4601 } 4602 return; 4603 } 4604 4605 static void choice_402 (RDE_PARAM p) { 4606 /* 4607 * / 4608 * <space> 4609 * (COMMENT) 4610 */ 4611 4612 rde_param_i_state_push_void (p); 4613 rde_param_i_next_space (p, 161); 4614 if (rde_param_i_bra_void2void(p)) return; 4615 sym_COMMENT (p); 4616 rde_param_i_state_merge_void (p); 4617 return; 4618 } 4619 4620 /* 4621 * leaf Symbol 'WORDCHAR' 4622 */ 4623 4624 static void sym_WORDCHAR (RDE_PARAM p) { 4625 /* 4626 * x 4627 * "<wordchar>" 4628 * (WHITESPACE) 4629 */ 4630 4631 if (rde_param_i_symbol_start (p, 166)) return ; 4632 sequence_409 (p); 4633 rde_param_i_symbol_done_leaf (p, 166, 165); 4634 return; 4635 } 4636 4637 static void sequence_409 (RDE_PARAM p) { 4638 /* 4639 * x 4640 * "<wordchar>" 4641 * (WHITESPACE) 4642 */ 4643 4644 rde_param_i_state_push_void (p); 4645 rde_param_i_next_str (p, "<wordchar>", 164); 4646 if (rde_param_i_seq_void2void(p)) return; 4647 sym_WHITESPACE (p); 4648 rde_param_i_state_merge_void (p); 4649 return; 4650 } 4651 4652 /* 4653 * leaf Symbol 'XDIGIT' 4654 */ 4655 4656 static void sym_XDIGIT (RDE_PARAM p) { 4657 /* 4658 * x 4659 * "<xdigit>" 4660 * (WHITESPACE) 4661 */ 4662 4663 if (rde_param_i_symbol_start (p, 169)) return ; 4664 sequence_414 (p); 4665 rde_param_i_symbol_done_leaf (p, 169, 168); 4666 return; 4667 } 4668 4669 static void sequence_414 (RDE_PARAM p) { 4670 /* 4671 * x 4672 * "<xdigit>" 4673 * (WHITESPACE) 4674 */ 4675 4676 rde_param_i_state_push_void (p); 4677 rde_param_i_next_str (p, "<xdigit>", 167); 4678 if (rde_param_i_seq_void2void(p)) return; 4679 sym_WHITESPACE (p); 4680 rde_param_i_state_merge_void (p); 4681 return; 4682 } 4683 4684 } 4685 4686 ## END of GENERATED CODE. DO NOT EDIT. 4687 # # ## ### ###### ######## ############# 4688 4689 # # ## ### ###### ######## ############# 4690 ## Global PARSER management, per interp 4691 4692 critcl::ccode { 4693 /* -*- c -*- */ 4694 4695 typedef struct PARSERg { 4696 long int counter; 4697 char buf [50]; 4698 } PARSERg; 4699 4700 static void 4701 PARSERgRelease (ClientData cd, Tcl_Interp* interp) 4702 { 4703 ckfree((char*) cd); 4704 } 4705 4706 static const char* 4707 PARSERnewName (Tcl_Interp* interp) 4708 { 4709#define KEY "tcllib/parser/pt_parse_peg_c/critcl" 4710 4711 Tcl_InterpDeleteProc* proc = PARSERgRelease; 4712 PARSERg* parserg; 4713 4714 parserg = Tcl_GetAssocData (interp, KEY, &proc); 4715 if (parserg == NULL) { 4716 parserg = (PARSERg*) ckalloc (sizeof (PARSERg)); 4717 parserg->counter = 0; 4718 4719 Tcl_SetAssocData (interp, KEY, proc, 4720 (ClientData) parserg); 4721 } 4722 4723 parserg->counter ++; 4724 sprintf (parserg->buf, "peg%d", parserg->counter); 4725 return parserg->buf; 4726#undef KEY 4727 } 4728 4729 static void 4730 PARSERdeleteCmd (ClientData clientData) 4731 { 4732 /* 4733 * Release the whole PARSER 4734 * (Low-level engine only actually). 4735 */ 4736 rde_param_del ((RDE_PARAM) clientData); 4737 } 4738 } 4739 4740 # # ## ### ##### ######## ############# 4741 ## Functions implementing the object methods, and helper. 4742 4743 critcl::ccode { 4744 static int COMPLETE (RDE_PARAM p, Tcl_Interp* interp); 4745 4746 static int parser_PARSE (RDE_PARAM p, Tcl_Interp* interp, int objc, Tcl_Obj* CONST* objv) 4747 { 4748 int mode; 4749 Tcl_Channel chan; 4750 4751 if (objc != 3) { 4752 Tcl_WrongNumArgs (interp, 2, objv, "chan"); 4753 return TCL_ERROR; 4754 } 4755 4756 chan = Tcl_GetChannel(interp, 4757 Tcl_GetString (objv[2]), 4758 &mode); 4759 4760 if (!chan) { 4761 return TCL_ERROR; 4762 } 4763 4764 rde_param_reset (p, chan); 4765 MAIN (p) ; /* Entrypoint for the generated code. */ 4766 return COMPLETE (p, interp); 4767 } 4768 4769 static int parser_PARSET (RDE_PARAM p, Tcl_Interp* interp, int objc, Tcl_Obj* CONST* objv) 4770 { 4771 char* buf; 4772 int len; 4773 4774 if (objc != 3) { 4775 Tcl_WrongNumArgs (interp, 2, objv, "text"); 4776 return TCL_ERROR; 4777 } 4778 4779 buf = Tcl_GetStringFromObj (objv[2], &len); 4780 4781 rde_param_reset (p, NULL); 4782 rde_param_data (p, buf, len); 4783 MAIN (p) ; /* Entrypoint for the generated code. */ 4784 return COMPLETE (p, interp); 4785 } 4786 4787 static int COMPLETE (RDE_PARAM p, Tcl_Interp* interp) 4788 { 4789 if (rde_param_query_st (p)) { 4790 long int ac; 4791 Tcl_Obj** av; 4792 4793 rde_param_query_ast (p, &ac, &av); 4794 4795 if (ac > 1) { 4796 long int lsc; 4797 long int* lsv; 4798 Tcl_Obj** lv = NALLOC (3+ac, Tcl_Obj*); 4799 4800 rde_param_query_ls (p, &lsc, &lsv); 4801 4802 memcpy(lv + 3, av, ac * sizeof (Tcl_Obj*)); 4803 lv [0] = Tcl_NewObj (); 4804 lv [1] = Tcl_NewIntObj (1 + lsv [lsc-1]); 4805 lv [2] = Tcl_NewIntObj (rde_param_query_cl (p)); 4806 4807 Tcl_SetObjResult (interp, Tcl_NewListObj (3, lv)); 4808 ckfree ((char*) lv); 4809 } else { 4810 Tcl_SetObjResult (interp, av [0]); 4811 } 4812 4813 return TCL_OK; 4814 } else { 4815 Tcl_Obj* xv [1]; 4816 const ERROR_STATE* er = rde_param_query_er (p); 4817 Tcl_Obj* res = rde_param_query_er_tcl (p, er); 4818 4819 xv [0] = Tcl_NewStringObj ("pt::rde",-1); 4820 Tcl_ListObjReplace(interp, res, 0, 1, 1, xv); 4821 4822 Tcl_SetObjResult (interp, res); 4823 return TCL_ERROR; 4824 } 4825 } 4826 } 4827 4828 # # ## ### ##### ######## ############# 4829 ## Object command, method dispatch. 4830 4831 critcl::ccode { 4832 static int parser_objcmd (ClientData cd, Tcl_Interp* interp, int objc, Tcl_Obj* CONST* objv) 4833 { 4834 RDE_PARAM p = (RDE_PARAM) cd; 4835 int m, res; 4836 4837 static CONST char* methods [] = { 4838 "destroy", "parse", "parset", NULL 4839 }; 4840 enum methods { 4841 M_DESTROY, M_PARSE, M_PARSET 4842 }; 4843 4844 if (objc < 2) { 4845 Tcl_WrongNumArgs (interp, objc, objv, "option ?arg arg ...?"); 4846 return TCL_ERROR; 4847 } else if (Tcl_GetIndexFromObj (interp, objv [1], methods, "option", 4848 0, &m) != TCL_OK) { 4849 return TCL_ERROR; 4850 } 4851 4852 /* Dispatch to methods. They check the #args in 4853 * detail before performing the requested 4854 * functionality 4855 */ 4856 4857 switch (m) { 4858 case M_DESTROY: 4859 if (objc != 2) { 4860 Tcl_WrongNumArgs (interp, 2, objv, NULL); 4861 return TCL_ERROR; 4862 } 4863 4864 Tcl_DeleteCommandFromToken(interp, (Tcl_Command) rde_param_query_clientdata (p)); 4865 return TCL_OK; 4866 4867 case M_PARSE: res = parser_PARSE (p, interp, objc, objv); break; 4868 case M_PARSET: res = parser_PARSET (p, interp, objc, objv); break; 4869 default: 4870 /* Not coming to this place */ 4871 ASSERT (0,"Reached unreachable location"); 4872 } 4873 4874 return res; 4875 } 4876 } 4877 4878 # # ## ### ##### ######## ############# 4879 # Class command, i.e. object construction. 4880 4881 critcl::ccommand peg_critcl {dummy interp objc objv} { 4882 /* 4883 * Syntax: No arguments beyond the name 4884 */ 4885 4886 RDE_PARAM parser; 4887 CONST char* name; 4888 Tcl_Obj* fqn; 4889 Tcl_CmdInfo ci; 4890 Tcl_Command c; 4891 4892#define USAGE "?name?" 4893 4894 if ((objc != 2) && (objc != 1)) { 4895 Tcl_WrongNumArgs (interp, 1, objv, USAGE); 4896 return TCL_ERROR; 4897 } 4898 4899 if (objc < 2) { 4900 name = PARSERnewName (interp); 4901 } else { 4902 name = Tcl_GetString (objv [1]); 4903 } 4904 4905 if (!Tcl_StringMatch (name, "::*")) { 4906 /* Relative name. Prefix with current namespace */ 4907 4908 Tcl_Eval (interp, "namespace current"); 4909 fqn = Tcl_GetObjResult (interp); 4910 fqn = Tcl_DuplicateObj (fqn); 4911 Tcl_IncrRefCount (fqn); 4912 4913 if (!Tcl_StringMatch (Tcl_GetString (fqn), "::")) { 4914 Tcl_AppendToObj (fqn, "::", -1); 4915 } 4916 Tcl_AppendToObj (fqn, name, -1); 4917 } else { 4918 fqn = Tcl_NewStringObj (name, -1); 4919 Tcl_IncrRefCount (fqn); 4920 } 4921 Tcl_ResetResult (interp); 4922 4923 if (Tcl_GetCommandInfo (interp, 4924 Tcl_GetString (fqn), 4925 &ci)) { 4926 Tcl_Obj* err; 4927 4928 err = Tcl_NewObj (); 4929 Tcl_AppendToObj (err, "command \"", -1); 4930 Tcl_AppendObjToObj (err, fqn); 4931 Tcl_AppendToObj (err, "\" already exists", -1); 4932 4933 Tcl_DecrRefCount (fqn); 4934 Tcl_SetObjResult (interp, err); 4935 return TCL_ERROR; 4936 } 4937 4938 parser = rde_param_new (sizeof(p_string)/sizeof(char*), (char**) p_string); 4939 c = Tcl_CreateObjCommand (interp, Tcl_GetString (fqn), 4940 parser_objcmd, (ClientData) parser, 4941 PARSERdeleteCmd); 4942 rde_param_clientdata (parser, (ClientData) c); 4943 Tcl_SetObjResult (interp, fqn); 4944 Tcl_DecrRefCount (fqn); 4945 return TCL_OK; 4946 } 4947 4948 ## 4949 # # ## ### ##### ######## ############# 4950} 4951 4952# # ## ### ##### ######## ############# ##################### 4953## Ready (Note: Our package provide is at the top). 4954return 4955