parse_lemon.tcl

Go to the documentation of this file.
00001 /*  -*- tcl -*-*/
00002 /*  Parsing Expression Grammar 'page::parse::lemon'.*/
00003 /*  RD parser by the PG backend 'MEwriter'.*/
00004 
00005 /*  ### ### ### ######### ######### #########*/
00006 /*  Package description*/
00007 
00008 /*  The commands provided here match an input provided through a buffer*/
00009 /*  command to the PE grammar 'page::parse::lemon'. The parser is based on the package*/
00010 /*  'grammar::mengine' (recursive-descent, packrat, pulling chars,*/
00011 /*  pushing the generated AST).*/
00012 
00013 /*  ### ### ### ######### ######### #########*/
00014 /*  Requisites*/
00015 
00016 package require grammar::me::tcl
00017 
00018 /*  ### ### ### ######### ######### #########*/
00019 /*  Implementation*/
00020 
00021 namespace ::page::parse::lemon {
00022     /*  Import the virtual machine for matching.*/
00023 
00024     namespace import ::grammar::me::tcl::*
00025     upvar /* 0 ::grammar::me::tcl::ok ok*/
00026 }
00027 
00028 /*  ### ### ### ######### ######### #########*/
00029 /*  API Implementation.*/
00030 
00031 ret  ::page::parse::lemon::parse (type nxcmd , type emvar , type astvar) {
00032     variable ok
00033     variable se
00034 
00035     upvar 1 $emvar emsg $astvar ast
00036 
00037     init $nxcmd
00038 
00039     matchSymbol_LemonGrammar    ; # (n LemonGrammar)
00040 
00041     isv_nonterminal_reduce ALL -1
00042     set ast [sv]
00043     if {!$ok} {
00044         foreach {l m} [ier_get] break
00045         lappend l [lc $l]
00046     set mx {}
00047     foreach x $m {lappend mx "Expected $x"}
00048         set emsg [list $l $mx]
00049     }
00050 
00051     return $ok
00052 }
00053 
00054 /*  ### ### ### ######### ######### #########*/
00055 /*  Internal helper methods*/
00056 
00057 /*  Grammar 'page::parse::lemon'*/
00058 /* */
00059 /*  ASSIGN = (x (t :)*/
00060 /*              (t :)*/
00061 /*              (t =)*/
00062 /*              (n SPACE))*/
00063 /* */
00064 /*  C_COMMENT = (x (n CCOM_OPEN)*/
00065 /*                 (* (x (! (n CCOM_CLOSE))*/
00066 /*                       (dot)))*/
00067 /*                 (n CCOM_CLOSE))*/
00068 /* */
00069 /*  CCOM_CLOSE = (x (t *)*/
00070 /*                  (t /))*/
00071 /* */
00072 /*  CCOM_OPEN = (x (t /)*/
00073 /*                 (t *))*/
00074 /* */
00075 /*  Code = (x (n DCODE)*/
00076 /*            (n Codeblock))*/
00077 /* */
00078 /*  Codeblock = (x (n LBRACE)*/
00079 /*                 (* (/ (n Codeblock)*/
00080 /*                       (n C_COMMENT)*/
00081 /*                       (n Cplusplus_COMMENT)*/
00082 /*                       (x (! (n RBRACE))*/
00083 /*                          (dot))))*/
00084 /*                 (n RBRACE))*/
00085 /* */
00086 /*  Cplusplus_COMMENT = (x (t /)*/
00087 /*                         (t /)*/
00088 /*                         (* (x (! (n EOL))*/
00089 /*                               (dot)))*/
00090 /*                         (n EOL))*/
00091 /* */
00092 /*  DCODE = (x (t c)*/
00093 /*             (t o)*/
00094 /*             (t d)*/
00095 /*             (t e)*/
00096 /*             (n SPACE))*/
00097 /* */
00098 /*  DDEFDEST = (x (t d)*/
00099 /*                (t e)*/
00100 /*                (t f)*/
00101 /*                (t a)*/
00102 /*                (t u)*/
00103 /*                (t l)*/
00104 /*                (t t)*/
00105 /*                (t _)*/
00106 /*                (t d)*/
00107 /*                (t e)*/
00108 /*                (t s)*/
00109 /*                (t t)*/
00110 /*                (t r)*/
00111 /*                (t u)*/
00112 /*                (t c)*/
00113 /*                (t t)*/
00114 /*                (t o)*/
00115 /*                (t r)*/
00116 /*                (n SPACE))*/
00117 /* */
00118 /*  DDEFTYPE = (x (t d)*/
00119 /*                (t e)*/
00120 /*                (t f)*/
00121 /*                (t a)*/
00122 /*                (t u)*/
00123 /*                (t l)*/
00124 /*                (t t)*/
00125 /*                (t _)*/
00126 /*                (t t)*/
00127 /*                (t y)*/
00128 /*                (t p)*/
00129 /*                (t e)*/
00130 /*                (n SPACE))*/
00131 /* */
00132 /*  DDEST = (x (t d)*/
00133 /*             (t e)*/
00134 /*             (t s)*/
00135 /*             (t t)*/
00136 /*             (t r)*/
00137 /*             (t u)*/
00138 /*             (t c)*/
00139 /*             (t t)*/
00140 /*             (t o)*/
00141 /*             (t r)*/
00142 /*             (n SPACE))*/
00143 /* */
00144 /*  DefaultDestructor = (x (n DDEFDEST)*/
00145 /*                         (n Identifier)*/
00146 /*                         (n Codeblock))*/
00147 /* */
00148 /*  DefaultType = (x (n DDEFTYPE)*/
00149 /*                   (n Codeblock))*/
00150 /* */
00151 /*  Definition = (* (x (n Identifier)*/
00152 /*                     (? (n Label))))*/
00153 /* */
00154 /*  DENDIF = (x (t %)*/
00155 /*              (t e)*/
00156 /*              (t n)*/
00157 /*              (t d)*/
00158 /*              (t i)*/
00159 /*              (t f)*/
00160 /*              (n SPACE))*/
00161 /* */
00162 /*  Destructor = (x (n DDEST)*/
00163 /*                  (n Identifier)*/
00164 /*                  (n Codeblock))*/
00165 /* */
00166 /*  DEXTRA = (x (t e)*/
00167 /*              (t x)*/
00168 /*              (t t)*/
00169 /*              (t r)*/
00170 /*              (t a)*/
00171 /*              (t _)*/
00172 /*              (t a)*/
00173 /*              (t r)*/
00174 /*              (t g)*/
00175 /*              (t u)*/
00176 /*              (t m)*/
00177 /*              (t e)*/
00178 /*              (t n)*/
00179 /*              (t t)*/
00180 /*              (n SPACE))*/
00181 /* */
00182 /*  DFALLBK = (x (t f)*/
00183 /*               (t a)*/
00184 /*               (t l)*/
00185 /*               (t l)*/
00186 /*               (t b)*/
00187 /*               (t a)*/
00188 /*               (t c)*/
00189 /*               (t k)*/
00190 /*               (n SPACE))*/
00191 /* */
00192 /*  DIFDEF = (x (t %)*/
00193 /*              (t i)*/
00194 /*              (t f)*/
00195 /*              (t d)*/
00196 /*              (t e)*/
00197 /*              (t f)*/
00198 /*              (n SPACE))*/
00199 /* */
00200 /*  DIFNDEF = (x (t %)*/
00201 /*               (t i)*/
00202 /*               (t f)*/
00203 /*               (t n)*/
00204 /*               (t d)*/
00205 /*               (t e)*/
00206 /*               (t f)*/
00207 /*               (n SPACE))*/
00208 /* */
00209 /*  DINCL = (x (t i)*/
00210 /*             (t n)*/
00211 /*             (t c)*/
00212 /*             (t l)*/
00213 /*             (t u)*/
00214 /*             (t d)*/
00215 /*             (t e)*/
00216 /*             (n SPACE))*/
00217 /* */
00218 /*  DINTRO = (t %)*/
00219 /* */
00220 /*  Directive = (x (n DINTRO)*/
00221 /*                 (/ (n Code)*/
00222 /*                    (n DefaultDestructor)*/
00223 /*                    (n DefaultType)*/
00224 /*                    (n Destructor)*/
00225 /*                    (n ExtraArgument)*/
00226 /*                    (n Include)*/
00227 /*                    (n Left)*/
00228 /*                    (n Name)*/
00229 /*                    (n Nonassoc)*/
00230 /*                    (n ParseAccept)*/
00231 /*                    (n ParseFailure)*/
00232 /*                    (n Right)*/
00233 /*                    (n StackOverflow)*/
00234 /*                    (n Stacksize)*/
00235 /*                    (n StartSymbol)*/
00236 /*                    (n SyntaxError)*/
00237 /*                    (n TokenDestructor)*/
00238 /*                    (n TokenPrefix)*/
00239 /*                    (n TokenType)*/
00240 /*                    (n Type)*/
00241 /*                    (n Fallback)))*/
00242 /* */
00243 /*  DLEFT = (x (t l)*/
00244 /*             (t e)*/
00245 /*             (t f)*/
00246 /*             (t t)*/
00247 /*             (n SPACE))*/
00248 /* */
00249 /*  DNAME = (x (t n)*/
00250 /*             (t a)*/
00251 /*             (t m)*/
00252 /*             (t e)*/
00253 /*             (n SPACE))*/
00254 /* */
00255 /*  DNON = (x (t n)*/
00256 /*            (t o)*/
00257 /*            (t n)*/
00258 /*            (t a)*/
00259 /*            (t s)*/
00260 /*            (t s)*/
00261 /*            (t o)*/
00262 /*            (t c)*/
00263 /*            (n SPACE))*/
00264 /* */
00265 /*  DOT = (x (t .)*/
00266 /*           (n SPACE))*/
00267 /* */
00268 /*  DPACC = (x (t p)*/
00269 /*             (t a)*/
00270 /*             (t r)*/
00271 /*             (t s)*/
00272 /*             (t e)*/
00273 /*             (t _)*/
00274 /*             (t a)*/
00275 /*             (t c)*/
00276 /*             (t c)*/
00277 /*             (t e)*/
00278 /*             (t p)*/
00279 /*             (t t)*/
00280 /*             (n SPACE))*/
00281 /* */
00282 /*  DPFAIL = (x (t p)*/
00283 /*              (t a)*/
00284 /*              (t r)*/
00285 /*              (t s)*/
00286 /*              (t e)*/
00287 /*              (t _)*/
00288 /*              (t f)*/
00289 /*              (t a)*/
00290 /*              (t i)*/
00291 /*              (t l)*/
00292 /*              (t u)*/
00293 /*              (t r)*/
00294 /*              (t e)*/
00295 /*              (n SPACE))*/
00296 /* */
00297 /*  DRIGHT = (x (t r)*/
00298 /*              (t i)*/
00299 /*              (t g)*/
00300 /*              (t h)*/
00301 /*              (t t)*/
00302 /*              (n SPACE))*/
00303 /* */
00304 /*  DSTART = (x (t s)*/
00305 /*              (t t)*/
00306 /*              (t a)*/
00307 /*              (t r)*/
00308 /*              (t t)*/
00309 /*              (t _)*/
00310 /*              (t s)*/
00311 /*              (t y)*/
00312 /*              (t m)*/
00313 /*              (t b)*/
00314 /*              (t o)*/
00315 /*              (t l)*/
00316 /*              (n SPACE))*/
00317 /* */
00318 /*  DSTKOVER = (x (t s)*/
00319 /*                (t t)*/
00320 /*                (t a)*/
00321 /*                (t c)*/
00322 /*                (t k)*/
00323 /*                (t _)*/
00324 /*                (t o)*/
00325 /*                (t v)*/
00326 /*                (t e)*/
00327 /*                (t r)*/
00328 /*                (t f)*/
00329 /*                (t l)*/
00330 /*                (t o)*/
00331 /*                (t w)*/
00332 /*                (n SPACE))*/
00333 /* */
00334 /*  DSTKSZ = (x (t s)*/
00335 /*              (t t)*/
00336 /*              (t a)*/
00337 /*              (t c)*/
00338 /*              (t k)*/
00339 /*              (t _)*/
00340 /*              (t s)*/
00341 /*              (t i)*/
00342 /*              (t z)*/
00343 /*              (t e)*/
00344 /*              (n SPACE))*/
00345 /* */
00346 /*  DSYNERR = (x (t s)*/
00347 /*               (t y)*/
00348 /*               (t n)*/
00349 /*               (t t)*/
00350 /*               (t a)*/
00351 /*               (t x)*/
00352 /*               (t _)*/
00353 /*               (t e)*/
00354 /*               (t r)*/
00355 /*               (t r)*/
00356 /*               (t o)*/
00357 /*               (t r)*/
00358 /*               (n SPACE))*/
00359 /* */
00360 /*  DTOKDEST = (x (t t)*/
00361 /*                (t o)*/
00362 /*                (t k)*/
00363 /*                (t e)*/
00364 /*                (t n)*/
00365 /*                (t _)*/
00366 /*                (t d)*/
00367 /*                (t e)*/
00368 /*                (t s)*/
00369 /*                (t t)*/
00370 /*                (t r)*/
00371 /*                (t u)*/
00372 /*                (t c)*/
00373 /*                (t t)*/
00374 /*                (t o)*/
00375 /*                (t r)*/
00376 /*                (n SPACE))*/
00377 /* */
00378 /*  DTOKPFX = (x (t t)*/
00379 /*               (t o)*/
00380 /*               (t k)*/
00381 /*               (t e)*/
00382 /*               (t n)*/
00383 /*               (t _)*/
00384 /*               (t p)*/
00385 /*               (t r)*/
00386 /*               (t e)*/
00387 /*               (t f)*/
00388 /*               (t i)*/
00389 /*               (t x)*/
00390 /*               (n SPACE))*/
00391 /* */
00392 /*  DTOKTYPE = (x (t t)*/
00393 /*                (t o)*/
00394 /*                (t k)*/
00395 /*                (t e)*/
00396 /*                (t n)*/
00397 /*                (t _)*/
00398 /*                (t t)*/
00399 /*                (t y)*/
00400 /*                (t p)*/
00401 /*                (t e)*/
00402 /*                (n SPACE))*/
00403 /* */
00404 /*  DTYPE = (x (t t)*/
00405 /*             (t y)*/
00406 /*             (t p)*/
00407 /*             (t e)*/
00408 /*             (n SPACE))*/
00409 /* */
00410 /*  Endif = (n DENDIF)*/
00411 /* */
00412 /*  EOF = (! (dot))*/
00413 /* */
00414 /*  EOL = (/ (x (t \r)*/
00415 /*              (t \n))*/
00416 /*           (t \r)*/
00417 /*           (t \n))*/
00418 /* */
00419 /*  ExtraArgument = (x (n DEXTRA)*/
00420 /*                     (n Codeblock))*/
00421 /* */
00422 /*  Fallback = (x (n DFALLBK)*/
00423 /*                (+ (n Identifier))*/
00424 /*                (n DOT))*/
00425 /* */
00426 /*  Ident = (x (/ (alpha)*/
00427 /*                (t _))*/
00428 /*             (* (/ (alnum)*/
00429 /*                   (t _))))*/
00430 /* */
00431 /*  Identifier = (x (n Ident)*/
00432 /*                  (n SPACE))*/
00433 /* */
00434 /*  Ifdef = (x (n DIFDEF)*/
00435 /*             (n Identifier))*/
00436 /* */
00437 /*  Ifndef = (x (n DIFNDEF)*/
00438 /*              (n Identifier))*/
00439 /* */
00440 /*  Include = (x (n DINCL)*/
00441 /*               (n Codeblock))*/
00442 /* */
00443 /*  Label = (x (n LPAREN)*/
00444 /*             (n Identifier)*/
00445 /*             (n RPAREN))*/
00446 /* */
00447 /*  LBRACE = (t \{)*/
00448 /* */
00449 /*  LBRACKET = (x (t [)*/
00450 /*                (n SPACE))*/
00451 /* */
00452 /*  Left = (x (n DLEFT)*/
00453 /*            (+ (n Identifier))*/
00454 /*            (n DOT))*/
00455 /* */
00456 /*  LemonGrammar = (x (n SPACE)*/
00457 /*                    (+ (n Statement))*/
00458 /*                    (n EOF))*/
00459 /* */
00460 /*  LPAREN = (x (t \()*/
00461 /*              (n SPACE))*/
00462 /* */
00463 /*  Name = (x (n DNAME)*/
00464 /*            (n Identifier))*/
00465 /* */
00466 /*  NatNum = (+ (.. 0 9))*/
00467 /* */
00468 /*  NaturalNumber = (x (n NatNum)*/
00469 /*                     (n SPACE))*/
00470 /* */
00471 /*  Nonassoc = (x (n DNON)*/
00472 /*                (+ (n Identifier))*/
00473 /*                (n DOT))*/
00474 /* */
00475 /*  ParseAccept = (x (n DPACC)*/
00476 /*                   (n Codeblock))*/
00477 /* */
00478 /*  ParseFailure = (x (n DPFAIL)*/
00479 /*                    (n Codeblock))*/
00480 /* */
00481 /*  Precedence = (x (n LBRACKET)*/
00482 /*                  (n Identifier)*/
00483 /*                  (n RBRACKET))*/
00484 /* */
00485 /*  RBRACE = (t \})*/
00486 /* */
00487 /*  RBRACKET = (x (t ])*/
00488 /*                (n SPACE))*/
00489 /* */
00490 /*  Right = (x (n DRIGHT)*/
00491 /*             (+ (n Identifier))*/
00492 /*             (n DOT))*/
00493 /* */
00494 /*  RPAREN = (x (t \))*/
00495 /*              (n SPACE))*/
00496 /* */
00497 /*  Rule = (x (n Identifier)*/
00498 /*            (? (n Label))*/
00499 /*            (n ASSIGN)*/
00500 /*            (n Definition)*/
00501 /*            (n DOT)*/
00502 /*            (? (n Precedence))*/
00503 /*            (? (n Codeblock)))*/
00504 /* */
00505 /*  SPACE = (* (/ (t <blank>)*/
00506 /*                (t \t)*/
00507 /*                (t \n)*/
00508 /*                (t \r)*/
00509 /*                (n C_COMMENT)*/
00510 /*                (n Cplusplus_COMMENT)*/
00511 /*                (n Ifndef)*/
00512 /*                (n Ifdef)*/
00513 /*                (n Endif)))*/
00514 /* */
00515 /*  StackOverflow = (x (n DSTKOVER)*/
00516 /*                     (n Codeblock))*/
00517 /* */
00518 /*  Stacksize = (x (n DSTKSZ)*/
00519 /*                 (n NaturalNumber))*/
00520 /* */
00521 /*  StartSymbol = (x (n DSTART)*/
00522 /*                   (n Identifier))*/
00523 /* */
00524 /*  Statement = (x (/ (n Directive)*/
00525 /*                    (n Rule))*/
00526 /*                 (n SPACE))*/
00527 /* */
00528 /*  SyntaxError = (x (n DSYNERR)*/
00529 /*                   (n Codeblock))*/
00530 /* */
00531 /*  TokenDestructor = (x (n DTOKDEST)*/
00532 /*                       (n Identifier)*/
00533 /*                       (n Codeblock))*/
00534 /* */
00535 /*  TokenPrefix = (x (n DTOKPFX)*/
00536 /*                   (n Identifier))*/
00537 /* */
00538 /*  TokenType = (x (n DTOKTYPE)*/
00539 /*                 (n Codeblock))*/
00540 /* */
00541 /*  Type = (x (n DTYPE)*/
00542 /*            (n Identifier)*/
00543 /*            (n Codeblock))*/
00544 /* */
00545 
00546 ret  ::page::parse::lemon::matchSymbol_ASSIGN () {
00547     # ASSIGN = (x (t :)
00548     #             (t :)
00549     #             (t =)
00550     #             (n SPACE))
00551 
00552     if {[inc_restore ASSIGN]} return
00553 
00554     set pos [icl_get]
00555 
00556     eseq53                ; # (x (t :)
00557                             #    (t :)
00558                             #    (t =)
00559                             #    (n SPACE))
00560 
00561     isv_clear
00562     inc_save               ASSIGN $pos
00563     ier_nonterminal        ASSIGN $pos
00564     return
00565 }
00566 
00567 ret  ::page::parse::lemon::eseq53 () {
00568 
00569     # (x (t :)
00570     #    (t :)
00571     #    (t =)
00572     #    (n SPACE))
00573 
00574     variable ok
00575 
00576     set pos [icl_get]
00577 
00578     set old [ier_get]
00579     ict_advance :
00580     if {$ok} {ict_match_token :}
00581     ier_merge $old
00582 
00583     if {!$ok} {icl_rewind $pos ; return}
00584 
00585     set old [ier_get]
00586     ict_advance :
00587     if {$ok} {ict_match_token :}
00588     ier_merge $old
00589 
00590     if {!$ok} {icl_rewind $pos ; return}
00591 
00592     set old [ier_get]
00593     ict_advance =
00594     if {$ok} {ict_match_token =}
00595     ier_merge $old
00596 
00597     if {!$ok} {icl_rewind $pos ; return}
00598 
00599     set old [ier_get]
00600     matchSymbol_SPACE    ; # (n SPACE)
00601     ier_merge $old
00602 
00603     if {!$ok} {icl_rewind $pos ; return}
00604 
00605     return
00606 }
00607 
00608 ret  ::page::parse::lemon::matchSymbol_C_COMMENT () {
00609     # C_COMMENT = (x (n CCOM_OPEN)
00610     #                (* (x (! (n CCOM_CLOSE))
00611     #                      (dot)))
00612     #                (n CCOM_CLOSE))
00613 
00614     if {[inc_restore C_COMMENT]} return
00615 
00616     set pos [icl_get]
00617 
00618     eseq90                ; # (x (n CCOM_OPEN)
00619                             #    (* (x (! (n CCOM_CLOSE))
00620                             #          (dot)))
00621                             #    (n CCOM_CLOSE))
00622 
00623     isv_clear
00624     inc_save               C_COMMENT $pos
00625     ier_nonterminal        C_COMMENT $pos
00626     return
00627 }
00628 
00629 ret  ::page::parse::lemon::eseq90 () {
00630 
00631     # (x (n CCOM_OPEN)
00632     #    (* (x (! (n CCOM_CLOSE))
00633     #          (dot)))
00634     #    (n CCOM_CLOSE))
00635 
00636     variable ok
00637 
00638     set pos [icl_get]
00639 
00640     set old [ier_get]
00641     matchSymbol_CCOM_OPEN    ; # (n CCOM_OPEN)
00642     ier_merge $old
00643 
00644     if {!$ok} {icl_rewind $pos ; return}
00645 
00646     set old [ier_get]
00647     ekleene89                ; # (* (x (! (n CCOM_CLOSE))
00648                                #       (dot)))
00649     ier_merge $old
00650 
00651     if {!$ok} {icl_rewind $pos ; return}
00652 
00653     set old [ier_get]
00654     matchSymbol_CCOM_CLOSE    ; # (n CCOM_CLOSE)
00655     ier_merge $old
00656 
00657     if {!$ok} {icl_rewind $pos ; return}
00658 
00659     return
00660 }
00661 
00662 ret  ::page::parse::lemon::ekleene89 () {
00663 
00664     # (* (x (! (n CCOM_CLOSE))
00665     #       (dot)))
00666 
00667     variable ok
00668 
00669     while {1} {
00670         set pos [icl_get]
00671 
00672         set old [ier_get]
00673         eseq88                ; # (x (! (n CCOM_CLOSE))
00674                                 #    (dot))
00675         ier_merge $old
00676 
00677         if {$ok} continue
00678         break
00679     }
00680 
00681     icl_rewind $pos
00682     iok_ok
00683     return
00684 }
00685 
00686 ret  ::page::parse::lemon::eseq88 () {
00687 
00688     # (x (! (n CCOM_CLOSE))
00689     #    (dot))
00690 
00691     variable ok
00692 
00693     set pos [icl_get]
00694 
00695     set old [ier_get]
00696     ebang87
00697     ier_merge $old
00698 
00699     if {!$ok} {icl_rewind $pos ; return}
00700 
00701     set old [ier_get]
00702     ict_advance "any character"
00703     ier_merge $old
00704 
00705     if {!$ok} {icl_rewind $pos ; return}
00706 
00707     return
00708 }
00709 
00710 ret  ::page::parse::lemon::ebang87 () {
00711     set pos [icl_get]
00712 
00713     matchSymbol_CCOM_CLOSE    ; # (n CCOM_CLOSE)
00714 
00715     icl_rewind $pos
00716     iok_negate
00717     return
00718 }
00719 
00720 ret  ::page::parse::lemon::matchSymbol_CCOM_CLOSE () {
00721     # CCOM_CLOSE = (x (t *)
00722     #                 (t /))
00723 
00724     if {[inc_restore CCOM_CLOSE]} return
00725 
00726     set pos [icl_get]
00727 
00728     eseq92                ; # (x (t *)
00729                             #    (t /))
00730 
00731     isv_clear
00732     inc_save               CCOM_CLOSE $pos
00733     ier_nonterminal        CCOM_CLOSE $pos
00734     return
00735 }
00736 
00737 ret  ::page::parse::lemon::eseq92 () {
00738 
00739     # (x (t *)
00740     #    (t /))
00741 
00742     variable ok
00743 
00744     set pos [icl_get]
00745 
00746     set old [ier_get]
00747     ict_advance *
00748     if {$ok} {ict_match_token *}
00749     ier_merge $old
00750 
00751     if {!$ok} {icl_rewind $pos ; return}
00752 
00753     set old [ier_get]
00754     ict_advance /
00755     if {$ok} {ict_match_token /}
00756     ier_merge $old
00757 
00758     if {!$ok} {icl_rewind $pos ; return}
00759 
00760     return
00761 }
00762 
00763 ret  ::page::parse::lemon::matchSymbol_CCOM_OPEN () {
00764     # CCOM_OPEN = (x (t /)
00765     #                (t *))
00766 
00767     if {[inc_restore CCOM_OPEN]} return
00768 
00769     set pos [icl_get]
00770 
00771     eseq91                ; # (x (t /)
00772                             #    (t *))
00773 
00774     isv_clear
00775     inc_save               CCOM_OPEN $pos
00776     ier_nonterminal        CCOM_OPEN $pos
00777     return
00778 }
00779 
00780 ret  ::page::parse::lemon::eseq91 () {
00781 
00782     # (x (t /)
00783     #    (t *))
00784 
00785     variable ok
00786 
00787     set pos [icl_get]
00788 
00789     set old [ier_get]
00790     ict_advance /
00791     if {$ok} {ict_match_token /}
00792     ier_merge $old
00793 
00794     if {!$ok} {icl_rewind $pos ; return}
00795 
00796     set old [ier_get]
00797     ict_advance *
00798     if {$ok} {ict_match_token *}
00799     ier_merge $old
00800 
00801     if {!$ok} {icl_rewind $pos ; return}
00802 
00803     return
00804 }
00805 
00806 ret  ::page::parse::lemon::matchSymbol_Code () {
00807     # Code = (x (n DCODE)
00808     #           (n Codeblock))
00809 
00810     variable ok
00811     if {[inc_restore Code]} {
00812         if {$ok} ias_push
00813         return
00814     }
00815 
00816     set pos [icl_get]
00817     set mrk [ias_mark]
00818 
00819     eseq16                ; # (x (n DCODE)
00820                             #    (n Codeblock))
00821 
00822     isv_nonterminal_reduce Code $pos $mrk
00823     inc_save               Code $pos
00824     ias_pop2mark             $mrk
00825     if {$ok} ias_push
00826     ier_nonterminal        Code $pos
00827     return
00828 }
00829 
00830 ret  ::page::parse::lemon::eseq16 () {
00831 
00832     # (x (n DCODE)
00833     #    (n Codeblock))
00834 
00835     variable ok
00836 
00837     set pos [icl_get]
00838 
00839     set old [ier_get]
00840     matchSymbol_DCODE    ; # (n DCODE)
00841     ier_merge $old
00842 
00843     if {!$ok} {icl_rewind $pos ; return}
00844 
00845     set mrk [ias_mark]
00846 
00847     set old [ier_get]
00848     matchSymbol_Codeblock    ; # (n Codeblock)
00849     ier_merge $old
00850 
00851     if {!$ok} {
00852         ias_pop2mark $mrk
00853         icl_rewind   $pos
00854         return
00855     }
00856 
00857     return
00858 }
00859 
00860 ret  ::page::parse::lemon::matchSymbol_Codeblock () {
00861     # Codeblock = (x (n LBRACE)
00862     #                (* (/ (n Codeblock)
00863     #                      (n C_COMMENT)
00864     #                      (n Cplusplus_COMMENT)
00865     #                      (x (! (n RBRACE))
00866     #                         (dot))))
00867     #                (n RBRACE))
00868 
00869     variable ok
00870     if {[inc_restore Codeblock]} {
00871         if {$ok} ias_push
00872         return
00873     }
00874 
00875     set pos [icl_get]
00876 
00877     eseq45                ; # (x (n LBRACE)
00878                             #    (* (/ (n Codeblock)
00879                             #          (n C_COMMENT)
00880                             #          (n Cplusplus_COMMENT)
00881                             #          (x (! (n RBRACE))
00882                             #             (dot))))
00883                             #    (n RBRACE))
00884 
00885     isv_nonterminal_range  Codeblock $pos
00886     inc_save               Codeblock $pos
00887     if {$ok} ias_push
00888     ier_nonterminal        Codeblock $pos
00889     return
00890 }
00891 
00892 ret  ::page::parse::lemon::eseq45 () {
00893 
00894     # (x (n LBRACE)
00895     #    (* (/ (n Codeblock)
00896     #          (n C_COMMENT)
00897     #          (n Cplusplus_COMMENT)
00898     #          (x (! (n RBRACE))
00899     #             (dot))))
00900     #    (n RBRACE))
00901 
00902     variable ok
00903 
00904     set pos [icl_get]
00905 
00906     set old [ier_get]
00907     matchSymbol_LBRACE    ; # (n LBRACE)
00908     ier_merge $old
00909 
00910     if {!$ok} {icl_rewind $pos ; return}
00911 
00912     set old [ier_get]
00913     ekleene44                ; # (* (/ (n Codeblock)
00914                                #       (n C_COMMENT)
00915                                #       (n Cplusplus_COMMENT)
00916                                #       (x (! (n RBRACE))
00917                                #          (dot))))
00918     ier_merge $old
00919 
00920     if {!$ok} {icl_rewind $pos ; return}
00921 
00922     set old [ier_get]
00923     matchSymbol_RBRACE    ; # (n RBRACE)
00924     ier_merge $old
00925 
00926     if {!$ok} {icl_rewind $pos ; return}
00927 
00928     return
00929 }
00930 
00931 ret  ::page::parse::lemon::ekleene44 () {
00932 
00933     # (* (/ (n Codeblock)
00934     #       (n C_COMMENT)
00935     #       (n Cplusplus_COMMENT)
00936     #       (x (! (n RBRACE))
00937     #          (dot))))
00938 
00939     variable ok
00940 
00941     while {1} {
00942         set pos [icl_get]
00943 
00944         set old [ier_get]
00945         ebra43                ; # (/ (n Codeblock)
00946                                 #    (n C_COMMENT)
00947                                 #    (n Cplusplus_COMMENT)
00948                                 #    (x (! (n RBRACE))
00949                                 #       (dot)))
00950         ier_merge $old
00951 
00952         if {$ok} continue
00953         break
00954     }
00955 
00956     icl_rewind $pos
00957     iok_ok
00958     return
00959 }
00960 
00961 ret  ::page::parse::lemon::ebra43 () {
00962 
00963     # (/ (n Codeblock)
00964     #    (n C_COMMENT)
00965     #    (n Cplusplus_COMMENT)
00966     #    (x (! (n RBRACE))
00967     #       (dot)))
00968 
00969     variable ok
00970 
00971     set pos [icl_get]
00972 
00973     set old [ier_get]
00974     set pCodeblock [ias_mark]
00975     matchSymbol_Codeblock
00976     ias_pop2mark $pCodeblock    ; # (n Codeblock)
00977     ier_merge $old
00978 
00979     if {$ok} return
00980     icl_rewind   $pos
00981 
00982     set old [ier_get]
00983     matchSymbol_C_COMMENT    ; # (n C_COMMENT)
00984     ier_merge $old
00985 
00986     if {$ok} return
00987     icl_rewind   $pos
00988 
00989     set old [ier_get]
00990     matchSymbol_Cplusplus_COMMENT    ; # (n Cplusplus_COMMENT)
00991     ier_merge $old
00992 
00993     if {$ok} return
00994     icl_rewind   $pos
00995 
00996     set old [ier_get]
00997     eseq42                ; # (x (! (n RBRACE))
00998                             #    (dot))
00999     ier_merge $old
01000 
01001     if {$ok} return
01002     icl_rewind   $pos
01003 
01004     return
01005 }
01006 
01007 ret  ::page::parse::lemon::eseq42 () {
01008 
01009     # (x (! (n RBRACE))
01010     #    (dot))
01011 
01012     variable ok
01013 
01014     set pos [icl_get]
01015 
01016     set old [ier_get]
01017     ebang41
01018     ier_merge $old
01019 
01020     if {!$ok} {icl_rewind $pos ; return}
01021 
01022     set old [ier_get]
01023     ict_advance "any character"
01024     ier_merge $old
01025 
01026     if {!$ok} {icl_rewind $pos ; return}
01027 
01028     return
01029 }
01030 
01031 ret  ::page::parse::lemon::ebang41 () {
01032     set pos [icl_get]
01033 
01034     matchSymbol_RBRACE    ; # (n RBRACE)
01035 
01036     icl_rewind $pos
01037     iok_negate
01038     return
01039 }
01040 
01041 ret  ::page::parse::lemon::matchSymbol_Cplusplus_COMMENT () {
01042     # Cplusplus_COMMENT = (x (t /)
01043     #                        (t /)
01044     #                        (* (x (! (n EOL))
01045     #                              (dot)))
01046     #                        (n EOL))
01047 
01048     if {[inc_restore Cplusplus_COMMENT]} return
01049 
01050     set pos [icl_get]
01051 
01052     eseq96                ; # (x (t /)
01053                             #    (t /)
01054                             #    (* (x (! (n EOL))
01055                             #          (dot)))
01056                             #    (n EOL))
01057 
01058     isv_clear
01059     inc_save               Cplusplus_COMMENT $pos
01060     ier_nonterminal        Cplusplus_COMMENT $pos
01061     return
01062 }
01063 
01064 ret  ::page::parse::lemon::eseq96 () {
01065 
01066     # (x (t /)
01067     #    (t /)
01068     #    (* (x (! (n EOL))
01069     #          (dot)))
01070     #    (n EOL))
01071 
01072     variable ok
01073 
01074     set pos [icl_get]
01075 
01076     set old [ier_get]
01077     ict_advance /
01078     if {$ok} {ict_match_token /}
01079     ier_merge $old
01080 
01081     if {!$ok} {icl_rewind $pos ; return}
01082 
01083     set old [ier_get]
01084     ict_advance /
01085     if {$ok} {ict_match_token /}
01086     ier_merge $old
01087 
01088     if {!$ok} {icl_rewind $pos ; return}
01089 
01090     set old [ier_get]
01091     ekleene95                ; # (* (x (! (n EOL))
01092                                #       (dot)))
01093     ier_merge $old
01094 
01095     if {!$ok} {icl_rewind $pos ; return}
01096 
01097     set old [ier_get]
01098     matchSymbol_EOL    ; # (n EOL)
01099     ier_merge $old
01100 
01101     if {!$ok} {icl_rewind $pos ; return}
01102 
01103     return
01104 }
01105 
01106 ret  ::page::parse::lemon::ekleene95 () {
01107 
01108     # (* (x (! (n EOL))
01109     #       (dot)))
01110 
01111     variable ok
01112 
01113     while {1} {
01114         set pos [icl_get]
01115 
01116         set old [ier_get]
01117         eseq94                ; # (x (! (n EOL))
01118                                 #    (dot))
01119         ier_merge $old
01120 
01121         if {$ok} continue
01122         break
01123     }
01124 
01125     icl_rewind $pos
01126     iok_ok
01127     return
01128 }
01129 
01130 ret  ::page::parse::lemon::eseq94 () {
01131 
01132     # (x (! (n EOL))
01133     #    (dot))
01134 
01135     variable ok
01136 
01137     set pos [icl_get]
01138 
01139     set old [ier_get]
01140     ebang93
01141     ier_merge $old
01142 
01143     if {!$ok} {icl_rewind $pos ; return}
01144 
01145     set old [ier_get]
01146     ict_advance "any character"
01147     ier_merge $old
01148 
01149     if {!$ok} {icl_rewind $pos ; return}
01150 
01151     return
01152 }
01153 
01154 ret  ::page::parse::lemon::ebang93 () {
01155     set pos [icl_get]
01156 
01157     matchSymbol_EOL    ; # (n EOL)
01158 
01159     icl_rewind $pos
01160     iok_negate
01161     return
01162 }
01163 
01164 ret  ::page::parse::lemon::matchSymbol_DCODE () {
01165     # DCODE = (x (t c)
01166     #            (t o)
01167     #            (t d)
01168     #            (t e)
01169     #            (n SPACE))
01170 
01171     if {[inc_restore DCODE]} return
01172 
01173     set pos [icl_get]
01174 
01175     eseq59                ; # (x (t c)
01176                             #    (t o)
01177                             #    (t d)
01178                             #    (t e)
01179                             #    (n SPACE))
01180 
01181     isv_clear
01182     inc_save               DCODE $pos
01183     ier_nonterminal        DCODE $pos
01184     return
01185 }
01186 
01187 ret  ::page::parse::lemon::eseq59 () {
01188 
01189     # (x (t c)
01190     #    (t o)
01191     #    (t d)
01192     #    (t e)
01193     #    (n SPACE))
01194 
01195     variable ok
01196 
01197     set pos [icl_get]
01198 
01199     set old [ier_get]
01200     ict_advance c
01201     if {$ok} {ict_match_token c}
01202     ier_merge $old
01203 
01204     if {!$ok} {icl_rewind $pos ; return}
01205 
01206     set old [ier_get]
01207     ict_advance o
01208     if {$ok} {ict_match_token o}
01209     ier_merge $old
01210 
01211     if {!$ok} {icl_rewind $pos ; return}
01212 
01213     set old [ier_get]
01214     ict_advance d
01215     if {$ok} {ict_match_token d}
01216     ier_merge $old
01217 
01218     if {!$ok} {icl_rewind $pos ; return}
01219 
01220     set old [ier_get]
01221     ict_advance e
01222     if {$ok} {ict_match_token e}
01223     ier_merge $old
01224 
01225     if {!$ok} {icl_rewind $pos ; return}
01226 
01227     set old [ier_get]
01228     matchSymbol_SPACE    ; # (n SPACE)
01229     ier_merge $old
01230 
01231     if {!$ok} {icl_rewind $pos ; return}
01232 
01233     return
01234 }
01235 
01236 ret  ::page::parse::lemon::matchSymbol_DDEFDEST () {
01237     # DDEFDEST = (x (t d)
01238     #               (t e)
01239     #               (t f)
01240     #               (t a)
01241     #               (t u)
01242     #               (t l)
01243     #               (t t)
01244     #               (t _)
01245     #               (t d)
01246     #               (t e)
01247     #               (t s)
01248     #               (t t)
01249     #               (t r)
01250     #               (t u)
01251     #               (t c)
01252     #               (t t)
01253     #               (t o)
01254     #               (t r)
01255     #               (n SPACE))
01256 
01257     if {[inc_restore DDEFDEST]} return
01258 
01259     set pos [icl_get]
01260 
01261     eseq60                ; # (x (t d)
01262                             #    (t e)
01263                             #    (t f)
01264                             #    (t a)
01265                             #    (t u)
01266                             #    (t l)
01267                             #    (t t)
01268                             #    (t _)
01269                             #    (t d)
01270                             #    (t e)
01271                             #    (t s)
01272                             #    (t t)
01273                             #    (t r)
01274                             #    (t u)
01275                             #    (t c)
01276                             #    (t t)
01277                             #    (t o)
01278                             #    (t r)
01279                             #    (n SPACE))
01280 
01281     isv_clear
01282     inc_save               DDEFDEST $pos
01283     ier_nonterminal        DDEFDEST $pos
01284     return
01285 }
01286 
01287 ret  ::page::parse::lemon::eseq60 () {
01288 
01289     # (x (t d)
01290     #    (t e)
01291     #    (t f)
01292     #    (t a)
01293     #    (t u)
01294     #    (t l)
01295     #    (t t)
01296     #    (t _)
01297     #    (t d)
01298     #    (t e)
01299     #    (t s)
01300     #    (t t)
01301     #    (t r)
01302     #    (t u)
01303     #    (t c)
01304     #    (t t)
01305     #    (t o)
01306     #    (t r)
01307     #    (n SPACE))
01308 
01309     variable ok
01310 
01311     set pos [icl_get]
01312 
01313     set old [ier_get]
01314     ict_advance d
01315     if {$ok} {ict_match_token d}
01316     ier_merge $old
01317 
01318     if {!$ok} {icl_rewind $pos ; return}
01319 
01320     set old [ier_get]
01321     ict_advance e
01322     if {$ok} {ict_match_token e}
01323     ier_merge $old
01324 
01325     if {!$ok} {icl_rewind $pos ; return}
01326 
01327     set old [ier_get]
01328     ict_advance f
01329     if {$ok} {ict_match_token f}
01330     ier_merge $old
01331 
01332     if {!$ok} {icl_rewind $pos ; return}
01333 
01334     set old [ier_get]
01335     ict_advance a
01336     if {$ok} {ict_match_token a}
01337     ier_merge $old
01338 
01339     if {!$ok} {icl_rewind $pos ; return}
01340 
01341     set old [ier_get]
01342     ict_advance u
01343     if {$ok} {ict_match_token u}
01344     ier_merge $old
01345 
01346     if {!$ok} {icl_rewind $pos ; return}
01347 
01348     set old [ier_get]
01349     ict_advance l
01350     if {$ok} {ict_match_token l}
01351     ier_merge $old
01352 
01353     if {!$ok} {icl_rewind $pos ; return}
01354 
01355     set old [ier_get]
01356     ict_advance t
01357     if {$ok} {ict_match_token t}
01358     ier_merge $old
01359 
01360     if {!$ok} {icl_rewind $pos ; return}
01361 
01362     set old [ier_get]
01363     ict_advance _
01364     if {$ok} {ict_match_token _}
01365     ier_merge $old
01366 
01367     if {!$ok} {icl_rewind $pos ; return}
01368 
01369     set old [ier_get]
01370     ict_advance d
01371     if {$ok} {ict_match_token d}
01372     ier_merge $old
01373 
01374     if {!$ok} {icl_rewind $pos ; return}
01375 
01376     set old [ier_get]
01377     ict_advance e
01378     if {$ok} {ict_match_token e}
01379     ier_merge $old
01380 
01381     if {!$ok} {icl_rewind $pos ; return}
01382 
01383     set old [ier_get]
01384     ict_advance s
01385     if {$ok} {ict_match_token s}
01386     ier_merge $old
01387 
01388     if {!$ok} {icl_rewind $pos ; return}
01389 
01390     set old [ier_get]
01391     ict_advance t
01392     if {$ok} {ict_match_token t}
01393     ier_merge $old
01394 
01395     if {!$ok} {icl_rewind $pos ; return}
01396 
01397     set old [ier_get]
01398     ict_advance r
01399     if {$ok} {ict_match_token r}
01400     ier_merge $old
01401 
01402     if {!$ok} {icl_rewind $pos ; return}
01403 
01404     set old [ier_get]
01405     ict_advance u
01406     if {$ok} {ict_match_token u}
01407     ier_merge $old
01408 
01409     if {!$ok} {icl_rewind $pos ; return}
01410 
01411     set old [ier_get]
01412     ict_advance c
01413     if {$ok} {ict_match_token c}
01414     ier_merge $old
01415 
01416     if {!$ok} {icl_rewind $pos ; return}
01417 
01418     set old [ier_get]
01419     ict_advance t
01420     if {$ok} {ict_match_token t}
01421     ier_merge $old
01422 
01423     if {!$ok} {icl_rewind $pos ; return}
01424 
01425     set old [ier_get]
01426     ict_advance o
01427     if {$ok} {ict_match_token o}
01428     ier_merge $old
01429 
01430     if {!$ok} {icl_rewind $pos ; return}
01431 
01432     set old [ier_get]
01433     ict_advance r
01434     if {$ok} {ict_match_token r}
01435     ier_merge $old
01436 
01437     if {!$ok} {icl_rewind $pos ; return}
01438 
01439     set old [ier_get]
01440     matchSymbol_SPACE    ; # (n SPACE)
01441     ier_merge $old
01442 
01443     if {!$ok} {icl_rewind $pos ; return}
01444 
01445     return
01446 }
01447 
01448 ret  ::page::parse::lemon::matchSymbol_DDEFTYPE () {
01449     # DDEFTYPE = (x (t d)
01450     #               (t e)
01451     #               (t f)
01452     #               (t a)
01453     #               (t u)
01454     #               (t l)
01455     #               (t t)
01456     #               (t _)
01457     #               (t t)
01458     #               (t y)
01459     #               (t p)
01460     #               (t e)
01461     #               (n SPACE))
01462 
01463     if {[inc_restore DDEFTYPE]} return
01464 
01465     set pos [icl_get]
01466 
01467     eseq61                ; # (x (t d)
01468                             #    (t e)
01469                             #    (t f)
01470                             #    (t a)
01471                             #    (t u)
01472                             #    (t l)
01473                             #    (t t)
01474                             #    (t _)
01475                             #    (t t)
01476                             #    (t y)
01477                             #    (t p)
01478                             #    (t e)
01479                             #    (n SPACE))
01480 
01481     isv_clear
01482     inc_save               DDEFTYPE $pos
01483     ier_nonterminal        DDEFTYPE $pos
01484     return
01485 }
01486 
01487 ret  ::page::parse::lemon::eseq61 () {
01488 
01489     # (x (t d)
01490     #    (t e)
01491     #    (t f)
01492     #    (t a)
01493     #    (t u)
01494     #    (t l)
01495     #    (t t)
01496     #    (t _)
01497     #    (t t)
01498     #    (t y)
01499     #    (t p)
01500     #    (t e)
01501     #    (n SPACE))
01502 
01503     variable ok
01504 
01505     set pos [icl_get]
01506 
01507     set old [ier_get]
01508     ict_advance d
01509     if {$ok} {ict_match_token d}
01510     ier_merge $old
01511 
01512     if {!$ok} {icl_rewind $pos ; return}
01513 
01514     set old [ier_get]
01515     ict_advance e
01516     if {$ok} {ict_match_token e}
01517     ier_merge $old
01518 
01519     if {!$ok} {icl_rewind $pos ; return}
01520 
01521     set old [ier_get]
01522     ict_advance f
01523     if {$ok} {ict_match_token f}
01524     ier_merge $old
01525 
01526     if {!$ok} {icl_rewind $pos ; return}
01527 
01528     set old [ier_get]
01529     ict_advance a
01530     if {$ok} {ict_match_token a}
01531     ier_merge $old
01532 
01533     if {!$ok} {icl_rewind $pos ; return}
01534 
01535     set old [ier_get]
01536     ict_advance u
01537     if {$ok} {ict_match_token u}
01538     ier_merge $old
01539 
01540     if {!$ok} {icl_rewind $pos ; return}
01541 
01542     set old [ier_get]
01543     ict_advance l
01544     if {$ok} {ict_match_token l}
01545     ier_merge $old
01546 
01547     if {!$ok} {icl_rewind $pos ; return}
01548 
01549     set old [ier_get]
01550     ict_advance t
01551     if {$ok} {ict_match_token t}
01552     ier_merge $old
01553 
01554     if {!$ok} {icl_rewind $pos ; return}
01555 
01556     set old [ier_get]
01557     ict_advance _
01558     if {$ok} {ict_match_token _}
01559     ier_merge $old
01560 
01561     if {!$ok} {icl_rewind $pos ; return}
01562 
01563     set old [ier_get]
01564     ict_advance t
01565     if {$ok} {ict_match_token t}
01566     ier_merge $old
01567 
01568     if {!$ok} {icl_rewind $pos ; return}
01569 
01570     set old [ier_get]
01571     ict_advance y
01572     if {$ok} {ict_match_token y}
01573     ier_merge $old
01574 
01575     if {!$ok} {icl_rewind $pos ; return}
01576 
01577     set old [ier_get]
01578     ict_advance p
01579     if {$ok} {ict_match_token p}
01580     ier_merge $old
01581 
01582     if {!$ok} {icl_rewind $pos ; return}
01583 
01584     set old [ier_get]
01585     ict_advance e
01586     if {$ok} {ict_match_token e}
01587     ier_merge $old
01588 
01589     if {!$ok} {icl_rewind $pos ; return}
01590 
01591     set old [ier_get]
01592     matchSymbol_SPACE    ; # (n SPACE)
01593     ier_merge $old
01594 
01595     if {!$ok} {icl_rewind $pos ; return}
01596 
01597     return
01598 }
01599 
01600 ret  ::page::parse::lemon::matchSymbol_DDEST () {
01601     # DDEST = (x (t d)
01602     #            (t e)
01603     #            (t s)
01604     #            (t t)
01605     #            (t r)
01606     #            (t u)
01607     #            (t c)
01608     #            (t t)
01609     #            (t o)
01610     #            (t r)
01611     #            (n SPACE))
01612 
01613     if {[inc_restore DDEST]} return
01614 
01615     set pos [icl_get]
01616 
01617     eseq62                ; # (x (t d)
01618                             #    (t e)
01619                             #    (t s)
01620                             #    (t t)
01621                             #    (t r)
01622                             #    (t u)
01623                             #    (t c)
01624                             #    (t t)
01625                             #    (t o)
01626                             #    (t r)
01627                             #    (n SPACE))
01628 
01629     isv_clear
01630     inc_save               DDEST $pos
01631     ier_nonterminal        DDEST $pos
01632     return
01633 }
01634 
01635 ret  ::page::parse::lemon::eseq62 () {
01636 
01637     # (x (t d)
01638     #    (t e)
01639     #    (t s)
01640     #    (t t)
01641     #    (t r)
01642     #    (t u)
01643     #    (t c)
01644     #    (t t)
01645     #    (t o)
01646     #    (t r)
01647     #    (n SPACE))
01648 
01649     variable ok
01650 
01651     set pos [icl_get]
01652 
01653     set old [ier_get]
01654     ict_advance d
01655     if {$ok} {ict_match_token d}
01656     ier_merge $old
01657 
01658     if {!$ok} {icl_rewind $pos ; return}
01659 
01660     set old [ier_get]
01661     ict_advance e
01662     if {$ok} {ict_match_token e}
01663     ier_merge $old
01664 
01665     if {!$ok} {icl_rewind $pos ; return}
01666 
01667     set old [ier_get]
01668     ict_advance s
01669     if {$ok} {ict_match_token s}
01670     ier_merge $old
01671 
01672     if {!$ok} {icl_rewind $pos ; return}
01673 
01674     set old [ier_get]
01675     ict_advance t
01676     if {$ok} {ict_match_token t}
01677     ier_merge $old
01678 
01679     if {!$ok} {icl_rewind $pos ; return}
01680 
01681     set old [ier_get]
01682     ict_advance r
01683     if {$ok} {ict_match_token r}
01684     ier_merge $old
01685 
01686     if {!$ok} {icl_rewind $pos ; return}
01687 
01688     set old [ier_get]
01689     ict_advance u
01690     if {$ok} {ict_match_token u}
01691     ier_merge $old
01692 
01693     if {!$ok} {icl_rewind $pos ; return}
01694 
01695     set old [ier_get]
01696     ict_advance c
01697     if {$ok} {ict_match_token c}
01698     ier_merge $old
01699 
01700     if {!$ok} {icl_rewind $pos ; return}
01701 
01702     set old [ier_get]
01703     ict_advance t
01704     if {$ok} {ict_match_token t}
01705     ier_merge $old
01706 
01707     if {!$ok} {icl_rewind $pos ; return}
01708 
01709     set old [ier_get]
01710     ict_advance o
01711     if {$ok} {ict_match_token o}
01712     ier_merge $old
01713 
01714     if {!$ok} {icl_rewind $pos ; return}
01715 
01716     set old [ier_get]
01717     ict_advance r
01718     if {$ok} {ict_match_token r}
01719     ier_merge $old
01720 
01721     if {!$ok} {icl_rewind $pos ; return}
01722 
01723     set old [ier_get]
01724     matchSymbol_SPACE    ; # (n SPACE)
01725     ier_merge $old
01726 
01727     if {!$ok} {icl_rewind $pos ; return}
01728 
01729     return
01730 }
01731 
01732 ret  ::page::parse::lemon::matchSymbol_DefaultDestructor () {
01733     # DefaultDestructor = (x (n DDEFDEST)
01734     #                        (n Identifier)
01735     #                        (n Codeblock))
01736 
01737     variable ok
01738     if {[inc_restore DefaultDestructor]} {
01739         if {$ok} ias_push
01740         return
01741     }
01742 
01743     set pos [icl_get]
01744     set mrk [ias_mark]
01745 
01746     eseq17                ; # (x (n DDEFDEST)
01747                             #    (n Identifier)
01748                             #    (n Codeblock))
01749 
01750     isv_nonterminal_reduce DefaultDestructor $pos $mrk
01751     inc_save               DefaultDestructor $pos
01752     ias_pop2mark             $mrk
01753     if {$ok} ias_push
01754     ier_nonterminal        DefaultDestructor $pos
01755     return
01756 }
01757 
01758 ret  ::page::parse::lemon::eseq17 () {
01759 
01760     # (x (n DDEFDEST)
01761     #    (n Identifier)
01762     #    (n Codeblock))
01763 
01764     variable ok
01765 
01766     set pos [icl_get]
01767 
01768     set old [ier_get]
01769     matchSymbol_DDEFDEST    ; # (n DDEFDEST)
01770     ier_merge $old
01771 
01772     if {!$ok} {icl_rewind $pos ; return}
01773 
01774     set mrk [ias_mark]
01775 
01776     set old [ier_get]
01777     matchSymbol_Identifier    ; # (n Identifier)
01778     ier_merge $old
01779 
01780     if {!$ok} {
01781         ias_pop2mark $mrk
01782         icl_rewind   $pos
01783         return
01784     }
01785 
01786     set old [ier_get]
01787     matchSymbol_Codeblock    ; # (n Codeblock)
01788     ier_merge $old
01789 
01790     if {!$ok} {
01791         ias_pop2mark $mrk
01792         icl_rewind   $pos
01793         return
01794     }
01795 
01796     return
01797 }
01798 
01799 ret  ::page::parse::lemon::matchSymbol_DefaultType () {
01800     # DefaultType = (x (n DDEFTYPE)
01801     #                  (n Codeblock))
01802 
01803     variable ok
01804     if {[inc_restore DefaultType]} {
01805         if {$ok} ias_push
01806         return
01807     }
01808 
01809     set pos [icl_get]
01810     set mrk [ias_mark]
01811 
01812     eseq18                ; # (x (n DDEFTYPE)
01813                             #    (n Codeblock))
01814 
01815     isv_nonterminal_reduce DefaultType $pos $mrk
01816     inc_save               DefaultType $pos
01817     ias_pop2mark             $mrk
01818     if {$ok} ias_push
01819     ier_nonterminal        DefaultType $pos
01820     return
01821 }
01822 
01823 ret  ::page::parse::lemon::eseq18 () {
01824 
01825     # (x (n DDEFTYPE)
01826     #    (n Codeblock))
01827 
01828     variable ok
01829 
01830     set pos [icl_get]
01831 
01832     set old [ier_get]
01833     matchSymbol_DDEFTYPE    ; # (n DDEFTYPE)
01834     ier_merge $old
01835 
01836     if {!$ok} {icl_rewind $pos ; return}
01837 
01838     set mrk [ias_mark]
01839 
01840     set old [ier_get]
01841     matchSymbol_Codeblock    ; # (n Codeblock)
01842     ier_merge $old
01843 
01844     if {!$ok} {
01845         ias_pop2mark $mrk
01846         icl_rewind   $pos
01847         return
01848     }
01849 
01850     return
01851 }
01852 
01853 ret  ::page::parse::lemon::matchSymbol_Definition () {
01854     # Definition = (* (x (n Identifier)
01855     #                    (? (n Label))))
01856 
01857     variable ok
01858     if {[inc_restore Definition]} {
01859         if {$ok} ias_push
01860         return
01861     }
01862 
01863     set pos [icl_get]
01864     set mrk [ias_mark]
01865 
01866     ekleene11                ; # (* (x (n Identifier)
01867                                #       (? (n Label))))
01868 
01869     isv_nonterminal_reduce Definition $pos $mrk
01870     inc_save               Definition $pos
01871     ias_pop2mark             $mrk
01872     if {$ok} ias_push
01873     ier_nonterminal        Definition $pos
01874     return
01875 }
01876 
01877 ret  ::page::parse::lemon::ekleene11 () {
01878 
01879     # (* (x (n Identifier)
01880     #       (? (n Label))))
01881 
01882     variable ok
01883 
01884     while {1} {
01885         set pos [icl_get]
01886 
01887         set old [ier_get]
01888         eseq10                ; # (x (n Identifier)
01889                                 #    (? (n Label)))
01890         ier_merge $old
01891 
01892         if {$ok} continue
01893         break
01894     }
01895 
01896     icl_rewind $pos
01897     iok_ok
01898     return
01899 }
01900 
01901 ret  ::page::parse::lemon::eseq10 () {
01902 
01903     # (x (n Identifier)
01904     #    (? (n Label)))
01905 
01906     variable ok
01907 
01908     set pos [icl_get]
01909 
01910     set mrk [ias_mark]
01911 
01912     set old [ier_get]
01913     matchSymbol_Identifier    ; # (n Identifier)
01914     ier_merge $old
01915 
01916     if {!$ok} {
01917         ias_pop2mark $mrk
01918         icl_rewind   $pos
01919         return
01920     }
01921 
01922     set old [ier_get]
01923     eopt9                ; # (? (n Label))
01924     ier_merge $old
01925 
01926     if {!$ok} {
01927         ias_pop2mark $mrk
01928         icl_rewind   $pos
01929         return
01930     }
01931 
01932     return
01933 }
01934 
01935 ret  ::page::parse::lemon::eopt9 () {
01936 
01937     # (? (n Label))
01938 
01939     variable ok
01940 
01941     set pos [icl_get]
01942 
01943     set old [ier_get]
01944     matchSymbol_Label    ; # (n Label)
01945     ier_merge $old
01946 
01947     if {$ok} return
01948     icl_rewind $pos
01949     iok_ok
01950     return
01951 }
01952 
01953 ret  ::page::parse::lemon::matchSymbol_DENDIF () {
01954     # DENDIF = (x (t %)
01955     #             (t e)
01956     #             (t n)
01957     #             (t d)
01958     #             (t i)
01959     #             (t f)
01960     #             (n SPACE))
01961 
01962     if {[inc_restore DENDIF]} return
01963 
01964     set pos [icl_get]
01965 
01966     eseq82                ; # (x (t %)
01967                             #    (t e)
01968                             #    (t n)
01969                             #    (t d)
01970                             #    (t i)
01971                             #    (t f)
01972                             #    (n SPACE))
01973 
01974     isv_clear
01975     inc_save               DENDIF $pos
01976     ier_nonterminal        DENDIF $pos
01977     return
01978 }
01979 
01980 ret  ::page::parse::lemon::eseq82 () {
01981 
01982     # (x (t %)
01983     #    (t e)
01984     #    (t n)
01985     #    (t d)
01986     #    (t i)
01987     #    (t f)
01988     #    (n SPACE))
01989 
01990     variable ok
01991 
01992     set pos [icl_get]
01993 
01994     set old [ier_get]
01995     ict_advance %
01996     if {$ok} {ict_match_token %}
01997     ier_merge $old
01998 
01999     if {!$ok} {icl_rewind $pos ; return}
02000 
02001     set old [ier_get]
02002     ict_advance e
02003     if {$ok} {ict_match_token e}
02004     ier_merge $old
02005 
02006     if {!$ok} {icl_rewind $pos ; return}
02007 
02008     set old [ier_get]
02009     ict_advance n
02010     if {$ok} {ict_match_token n}
02011     ier_merge $old
02012 
02013     if {!$ok} {icl_rewind $pos ; return}
02014 
02015     set old [ier_get]
02016     ict_advance d
02017     if {$ok} {ict_match_token d}
02018     ier_merge $old
02019 
02020     if {!$ok} {icl_rewind $pos ; return}
02021 
02022     set old [ier_get]
02023     ict_advance i
02024     if {$ok} {ict_match_token i}
02025     ier_merge $old
02026 
02027     if {!$ok} {icl_rewind $pos ; return}
02028 
02029     set old [ier_get]
02030     ict_advance f
02031     if {$ok} {ict_match_token f}
02032     ier_merge $old
02033 
02034     if {!$ok} {icl_rewind $pos ; return}
02035 
02036     set old [ier_get]
02037     matchSymbol_SPACE    ; # (n SPACE)
02038     ier_merge $old
02039 
02040     if {!$ok} {icl_rewind $pos ; return}
02041 
02042     return
02043 }
02044 
02045 ret  ::page::parse::lemon::matchSymbol_Destructor () {
02046     # Destructor = (x (n DDEST)
02047     #                 (n Identifier)
02048     #                 (n Codeblock))
02049 
02050     variable ok
02051     if {[inc_restore Destructor]} {
02052         if {$ok} ias_push
02053         return
02054     }
02055 
02056     set pos [icl_get]
02057     set mrk [ias_mark]
02058 
02059     eseq19                ; # (x (n DDEST)
02060                             #    (n Identifier)
02061                             #    (n Codeblock))
02062 
02063     isv_nonterminal_reduce Destructor $pos $mrk
02064     inc_save               Destructor $pos
02065     ias_pop2mark             $mrk
02066     if {$ok} ias_push
02067     ier_nonterminal        Destructor $pos
02068     return
02069 }
02070 
02071 ret  ::page::parse::lemon::eseq19 () {
02072 
02073     # (x (n DDEST)
02074     #    (n Identifier)
02075     #    (n Codeblock))
02076 
02077     variable ok
02078 
02079     set pos [icl_get]
02080 
02081     set old [ier_get]
02082     matchSymbol_DDEST    ; # (n DDEST)
02083     ier_merge $old
02084 
02085     if {!$ok} {icl_rewind $pos ; return}
02086 
02087     set mrk [ias_mark]
02088 
02089     set old [ier_get]
02090     matchSymbol_Identifier    ; # (n Identifier)
02091     ier_merge $old
02092 
02093     if {!$ok} {
02094         ias_pop2mark $mrk
02095         icl_rewind   $pos
02096         return
02097     }
02098 
02099     set old [ier_get]
02100     matchSymbol_Codeblock    ; # (n Codeblock)
02101     ier_merge $old
02102 
02103     if {!$ok} {
02104         ias_pop2mark $mrk
02105         icl_rewind   $pos
02106         return
02107     }
02108 
02109     return
02110 }
02111 
02112 ret  ::page::parse::lemon::matchSymbol_DEXTRA () {
02113     # DEXTRA = (x (t e)
02114     #             (t x)
02115     #             (t t)
02116     #             (t r)
02117     #             (t a)
02118     #             (t _)
02119     #             (t a)
02120     #             (t r)
02121     #             (t g)
02122     #             (t u)
02123     #             (t m)
02124     #             (t e)
02125     #             (t n)
02126     #             (t t)
02127     #             (n SPACE))
02128 
02129     if {[inc_restore DEXTRA]} return
02130 
02131     set pos [icl_get]
02132 
02133     eseq63                ; # (x (t e)
02134                             #    (t x)
02135                             #    (t t)
02136                             #    (t r)
02137                             #    (t a)
02138                             #    (t _)
02139                             #    (t a)
02140                             #    (t r)
02141                             #    (t g)
02142                             #    (t u)
02143                             #    (t m)
02144                             #    (t e)
02145                             #    (t n)
02146                             #    (t t)
02147                             #    (n SPACE))
02148 
02149     isv_clear
02150     inc_save               DEXTRA $pos
02151     ier_nonterminal        DEXTRA $pos
02152     return
02153 }
02154 
02155 ret  ::page::parse::lemon::eseq63 () {
02156 
02157     # (x (t e)
02158     #    (t x)
02159     #    (t t)
02160     #    (t r)
02161     #    (t a)
02162     #    (t _)
02163     #    (t a)
02164     #    (t r)
02165     #    (t g)
02166     #    (t u)
02167     #    (t m)
02168     #    (t e)
02169     #    (t n)
02170     #    (t t)
02171     #    (n SPACE))
02172 
02173     variable ok
02174 
02175     set pos [icl_get]
02176 
02177     set old [ier_get]
02178     ict_advance e
02179     if {$ok} {ict_match_token e}
02180     ier_merge $old
02181 
02182     if {!$ok} {icl_rewind $pos ; return}
02183 
02184     set old [ier_get]
02185     ict_advance x
02186     if {$ok} {ict_match_token x}
02187     ier_merge $old
02188 
02189     if {!$ok} {icl_rewind $pos ; return}
02190 
02191     set old [ier_get]
02192     ict_advance t
02193     if {$ok} {ict_match_token t}
02194     ier_merge $old
02195 
02196     if {!$ok} {icl_rewind $pos ; return}
02197 
02198     set old [ier_get]
02199     ict_advance r
02200     if {$ok} {ict_match_token r}
02201     ier_merge $old
02202 
02203     if {!$ok} {icl_rewind $pos ; return}
02204 
02205     set old [ier_get]
02206     ict_advance a
02207     if {$ok} {ict_match_token a}
02208     ier_merge $old
02209 
02210     if {!$ok} {icl_rewind $pos ; return}
02211 
02212     set old [ier_get]
02213     ict_advance _
02214     if {$ok} {ict_match_token _}
02215     ier_merge $old
02216 
02217     if {!$ok} {icl_rewind $pos ; return}
02218 
02219     set old [ier_get]
02220     ict_advance a
02221     if {$ok} {ict_match_token a}
02222     ier_merge $old
02223 
02224     if {!$ok} {icl_rewind $pos ; return}
02225 
02226     set old [ier_get]
02227     ict_advance r
02228     if {$ok} {ict_match_token r}
02229     ier_merge $old
02230 
02231     if {!$ok} {icl_rewind $pos ; return}
02232 
02233     set old [ier_get]
02234     ict_advance g
02235     if {$ok} {ict_match_token g}
02236     ier_merge $old
02237 
02238     if {!$ok} {icl_rewind $pos ; return}
02239 
02240     set old [ier_get]
02241     ict_advance u
02242     if {$ok} {ict_match_token u}
02243     ier_merge $old
02244 
02245     if {!$ok} {icl_rewind $pos ; return}
02246 
02247     set old [ier_get]
02248     ict_advance m
02249     if {$ok} {ict_match_token m}
02250     ier_merge $old
02251 
02252     if {!$ok} {icl_rewind $pos ; return}
02253 
02254     set old [ier_get]
02255     ict_advance e
02256     if {$ok} {ict_match_token e}
02257     ier_merge $old
02258 
02259     if {!$ok} {icl_rewind $pos ; return}
02260 
02261     set old [ier_get]
02262     ict_advance n
02263     if {$ok} {ict_match_token n}
02264     ier_merge $old
02265 
02266     if {!$ok} {icl_rewind $pos ; return}
02267 
02268     set old [ier_get]
02269     ict_advance t
02270     if {$ok} {ict_match_token t}
02271     ier_merge $old
02272 
02273     if {!$ok} {icl_rewind $pos ; return}
02274 
02275     set old [ier_get]
02276     matchSymbol_SPACE    ; # (n SPACE)
02277     ier_merge $old
02278 
02279     if {!$ok} {icl_rewind $pos ; return}
02280 
02281     return
02282 }
02283 
02284 ret  ::page::parse::lemon::matchSymbol_DFALLBK () {
02285     # DFALLBK = (x (t f)
02286     #              (t a)
02287     #              (t l)
02288     #              (t l)
02289     #              (t b)
02290     #              (t a)
02291     #              (t c)
02292     #              (t k)
02293     #              (n SPACE))
02294 
02295     if {[inc_restore DFALLBK]} return
02296 
02297     set pos [icl_get]
02298 
02299     eseq79                ; # (x (t f)
02300                             #    (t a)
02301                             #    (t l)
02302                             #    (t l)
02303                             #    (t b)
02304                             #    (t a)
02305                             #    (t c)
02306                             #    (t k)
02307                             #    (n SPACE))
02308 
02309     isv_clear
02310     inc_save               DFALLBK $pos
02311     ier_nonterminal        DFALLBK $pos
02312     return
02313 }
02314 
02315 ret  ::page::parse::lemon::eseq79 () {
02316 
02317     # (x (t f)
02318     #    (t a)
02319     #    (t l)
02320     #    (t l)
02321     #    (t b)
02322     #    (t a)
02323     #    (t c)
02324     #    (t k)
02325     #    (n SPACE))
02326 
02327     variable ok
02328 
02329     set pos [icl_get]
02330 
02331     set old [ier_get]
02332     ict_advance f
02333     if {$ok} {ict_match_token f}
02334     ier_merge $old
02335 
02336     if {!$ok} {icl_rewind $pos ; return}
02337 
02338     set old [ier_get]
02339     ict_advance a
02340     if {$ok} {ict_match_token a}
02341     ier_merge $old
02342 
02343     if {!$ok} {icl_rewind $pos ; return}
02344 
02345     set old [ier_get]
02346     ict_advance l
02347     if {$ok} {ict_match_token l}
02348     ier_merge $old
02349 
02350     if {!$ok} {icl_rewind $pos ; return}
02351 
02352     set old [ier_get]
02353     ict_advance l
02354     if {$ok} {ict_match_token l}
02355     ier_merge $old
02356 
02357     if {!$ok} {icl_rewind $pos ; return}
02358 
02359     set old [ier_get]
02360     ict_advance b
02361     if {$ok} {ict_match_token b}
02362     ier_merge $old
02363 
02364     if {!$ok} {icl_rewind $pos ; return}
02365 
02366     set old [ier_get]
02367     ict_advance a
02368     if {$ok} {ict_match_token a}
02369     ier_merge $old
02370 
02371     if {!$ok} {icl_rewind $pos ; return}
02372 
02373     set old [ier_get]
02374     ict_advance c
02375     if {$ok} {ict_match_token c}
02376     ier_merge $old
02377 
02378     if {!$ok} {icl_rewind $pos ; return}
02379 
02380     set old [ier_get]
02381     ict_advance k
02382     if {$ok} {ict_match_token k}
02383     ier_merge $old
02384 
02385     if {!$ok} {icl_rewind $pos ; return}
02386 
02387     set old [ier_get]
02388     matchSymbol_SPACE    ; # (n SPACE)
02389     ier_merge $old
02390 
02391     if {!$ok} {icl_rewind $pos ; return}
02392 
02393     return
02394 }
02395 
02396 ret  ::page::parse::lemon::matchSymbol_DIFDEF () {
02397     # DIFDEF = (x (t %)
02398     #             (t i)
02399     #             (t f)
02400     #             (t d)
02401     #             (t e)
02402     #             (t f)
02403     #             (n SPACE))
02404 
02405     if {[inc_restore DIFDEF]} return
02406 
02407     set pos [icl_get]
02408 
02409     eseq80                ; # (x (t %)
02410                             #    (t i)
02411                             #    (t f)
02412                             #    (t d)
02413                             #    (t e)
02414                             #    (t f)
02415                             #    (n SPACE))
02416 
02417     isv_clear
02418     inc_save               DIFDEF $pos
02419     ier_nonterminal        DIFDEF $pos
02420     return
02421 }
02422 
02423 ret  ::page::parse::lemon::eseq80 () {
02424 
02425     # (x (t %)
02426     #    (t i)
02427     #    (t f)
02428     #    (t d)
02429     #    (t e)
02430     #    (t f)
02431     #    (n SPACE))
02432 
02433     variable ok
02434 
02435     set pos [icl_get]
02436 
02437     set old [ier_get]
02438     ict_advance %
02439     if {$ok} {ict_match_token %}
02440     ier_merge $old
02441 
02442     if {!$ok} {icl_rewind $pos ; return}
02443 
02444     set old [ier_get]
02445     ict_advance i
02446     if {$ok} {ict_match_token i}
02447     ier_merge $old
02448 
02449     if {!$ok} {icl_rewind $pos ; return}
02450 
02451     set old [ier_get]
02452     ict_advance f
02453     if {$ok} {ict_match_token f}
02454     ier_merge $old
02455 
02456     if {!$ok} {icl_rewind $pos ; return}
02457 
02458     set old [ier_get]
02459     ict_advance d
02460     if {$ok} {ict_match_token d}
02461     ier_merge $old
02462 
02463     if {!$ok} {icl_rewind $pos ; return}
02464 
02465     set old [ier_get]
02466     ict_advance e
02467     if {$ok} {ict_match_token e}
02468     ier_merge $old
02469 
02470     if {!$ok} {icl_rewind $pos ; return}
02471 
02472     set old [ier_get]
02473     ict_advance f
02474     if {$ok} {ict_match_token f}
02475     ier_merge $old
02476 
02477     if {!$ok} {icl_rewind $pos ; return}
02478 
02479     set old [ier_get]
02480     matchSymbol_SPACE    ; # (n SPACE)
02481     ier_merge $old
02482 
02483     if {!$ok} {icl_rewind $pos ; return}
02484 
02485     return
02486 }
02487 
02488 ret  ::page::parse::lemon::matchSymbol_DIFNDEF () {
02489     # DIFNDEF = (x (t %)
02490     #              (t i)
02491     #              (t f)
02492     #              (t n)
02493     #              (t d)
02494     #              (t e)
02495     #              (t f)
02496     #              (n SPACE))
02497 
02498     if {[inc_restore DIFNDEF]} return
02499 
02500     set pos [icl_get]
02501 
02502     eseq81                ; # (x (t %)
02503                             #    (t i)
02504                             #    (t f)
02505                             #    (t n)
02506                             #    (t d)
02507                             #    (t e)
02508                             #    (t f)
02509                             #    (n SPACE))
02510 
02511     isv_clear
02512     inc_save               DIFNDEF $pos
02513     ier_nonterminal        DIFNDEF $pos
02514     return
02515 }
02516 
02517 ret  ::page::parse::lemon::eseq81 () {
02518 
02519     # (x (t %)
02520     #    (t i)
02521     #    (t f)
02522     #    (t n)
02523     #    (t d)
02524     #    (t e)
02525     #    (t f)
02526     #    (n SPACE))
02527 
02528     variable ok
02529 
02530     set pos [icl_get]
02531 
02532     set old [ier_get]
02533     ict_advance %
02534     if {$ok} {ict_match_token %}
02535     ier_merge $old
02536 
02537     if {!$ok} {icl_rewind $pos ; return}
02538 
02539     set old [ier_get]
02540     ict_advance i
02541     if {$ok} {ict_match_token i}
02542     ier_merge $old
02543 
02544     if {!$ok} {icl_rewind $pos ; return}
02545 
02546     set old [ier_get]
02547     ict_advance f
02548     if {$ok} {ict_match_token f}
02549     ier_merge $old
02550 
02551     if {!$ok} {icl_rewind $pos ; return}
02552 
02553     set old [ier_get]
02554     ict_advance n
02555     if {$ok} {ict_match_token n}
02556     ier_merge $old
02557 
02558     if {!$ok} {icl_rewind $pos ; return}
02559 
02560     set old [ier_get]
02561     ict_advance d
02562     if {$ok} {ict_match_token d}
02563     ier_merge $old
02564 
02565     if {!$ok} {icl_rewind $pos ; return}
02566 
02567     set old [ier_get]
02568     ict_advance e
02569     if {$ok} {ict_match_token e}
02570     ier_merge $old
02571 
02572     if {!$ok} {icl_rewind $pos ; return}
02573 
02574     set old [ier_get]
02575     ict_advance f
02576     if {$ok} {ict_match_token f}
02577     ier_merge $old
02578 
02579     if {!$ok} {icl_rewind $pos ; return}
02580 
02581     set old [ier_get]
02582     matchSymbol_SPACE    ; # (n SPACE)
02583     ier_merge $old
02584 
02585     if {!$ok} {icl_rewind $pos ; return}
02586 
02587     return
02588 }
02589 
02590 ret  ::page::parse::lemon::matchSymbol_DINCL () {
02591     # DINCL = (x (t i)
02592     #            (t n)
02593     #            (t c)
02594     #            (t l)
02595     #            (t u)
02596     #            (t d)
02597     #            (t e)
02598     #            (n SPACE))
02599 
02600     if {[inc_restore DINCL]} return
02601 
02602     set pos [icl_get]
02603 
02604     eseq64                ; # (x (t i)
02605                             #    (t n)
02606                             #    (t c)
02607                             #    (t l)
02608                             #    (t u)
02609                             #    (t d)
02610                             #    (t e)
02611                             #    (n SPACE))
02612 
02613     isv_clear
02614     inc_save               DINCL $pos
02615     ier_nonterminal        DINCL $pos
02616     return
02617 }
02618 
02619 ret  ::page::parse::lemon::eseq64 () {
02620 
02621     # (x (t i)
02622     #    (t n)
02623     #    (t c)
02624     #    (t l)
02625     #    (t u)
02626     #    (t d)
02627     #    (t e)
02628     #    (n SPACE))
02629 
02630     variable ok
02631 
02632     set pos [icl_get]
02633 
02634     set old [ier_get]
02635     ict_advance i
02636     if {$ok} {ict_match_token i}
02637     ier_merge $old
02638 
02639     if {!$ok} {icl_rewind $pos ; return}
02640 
02641     set old [ier_get]
02642     ict_advance n
02643     if {$ok} {ict_match_token n}
02644     ier_merge $old
02645 
02646     if {!$ok} {icl_rewind $pos ; return}
02647 
02648     set old [ier_get]
02649     ict_advance c
02650     if {$ok} {ict_match_token c}
02651     ier_merge $old
02652 
02653     if {!$ok} {icl_rewind $pos ; return}
02654 
02655     set old [ier_get]
02656     ict_advance l
02657     if {$ok} {ict_match_token l}
02658     ier_merge $old
02659 
02660     if {!$ok} {icl_rewind $pos ; return}
02661 
02662     set old [ier_get]
02663     ict_advance u
02664     if {$ok} {ict_match_token u}
02665     ier_merge $old
02666 
02667     if {!$ok} {icl_rewind $pos ; return}
02668 
02669     set old [ier_get]
02670     ict_advance d
02671     if {$ok} {ict_match_token d}
02672     ier_merge $old
02673 
02674     if {!$ok} {icl_rewind $pos ; return}
02675 
02676     set old [ier_get]
02677     ict_advance e
02678     if {$ok} {ict_match_token e}
02679     ier_merge $old
02680 
02681     if {!$ok} {icl_rewind $pos ; return}
02682 
02683     set old [ier_get]
02684     matchSymbol_SPACE    ; # (n SPACE)
02685     ier_merge $old
02686 
02687     if {!$ok} {icl_rewind $pos ; return}
02688 
02689     return
02690 }
02691 
02692 ret  ::page::parse::lemon::matchSymbol_DINTRO () {
02693     # DINTRO = (t %)
02694 
02695     variable ok
02696     if {[inc_restore DINTRO]} return
02697 
02698     set pos [icl_get]
02699 
02700     ict_advance %
02701     if {$ok} {ict_match_token %}
02702 
02703     isv_clear
02704     inc_save               DINTRO $pos
02705     ier_nonterminal        DINTRO $pos
02706     return
02707 }
02708 
02709 ret  ::page::parse::lemon::matchSymbol_Directive () {
02710     # Directive = (x (n DINTRO)
02711     #                (/ (n Code)
02712     #                   (n DefaultDestructor)
02713     #                   (n DefaultType)
02714     #                   (n Destructor)
02715     #                   (n ExtraArgument)
02716     #                   (n Include)
02717     #                   (n Left)
02718     #                   (n Name)
02719     #                   (n Nonassoc)
02720     #                   (n ParseAccept)
02721     #                   (n ParseFailure)
02722     #                   (n Right)
02723     #                   (n StackOverflow)
02724     #                   (n Stacksize)
02725     #                   (n StartSymbol)
02726     #                   (n SyntaxError)
02727     #                   (n TokenDestructor)
02728     #                   (n TokenPrefix)
02729     #                   (n TokenType)
02730     #                   (n Type)
02731     #                   (n Fallback)))
02732 
02733     variable ok
02734     if {[inc_restore Directive]} {
02735         if {$ok} ias_push
02736         return
02737     }
02738 
02739     set pos [icl_get]
02740     set mrk [ias_mark]
02741 
02742     eseq15                ; # (x (n DINTRO)
02743                             #    (/ (n Code)
02744                             #       (n DefaultDestructor)
02745                             #       (n DefaultType)
02746                             #       (n Destructor)
02747                             #       (n ExtraArgument)
02748                             #       (n Include)
02749                             #       (n Left)
02750                             #       (n Name)
02751                             #       (n Nonassoc)
02752                             #       (n ParseAccept)
02753                             #       (n ParseFailure)
02754                             #       (n Right)
02755                             #       (n StackOverflow)
02756                             #       (n Stacksize)
02757                             #       (n StartSymbol)
02758                             #       (n SyntaxError)
02759                             #       (n TokenDestructor)
02760                             #       (n TokenPrefix)
02761                             #       (n TokenType)
02762                             #       (n Type)
02763                             #       (n Fallback)))
02764 
02765     isv_nonterminal_reduce Directive $pos $mrk
02766     inc_save               Directive $pos
02767     ias_pop2mark             $mrk
02768     if {$ok} ias_push
02769     ier_nonterminal        Directive $pos
02770     return
02771 }
02772 
02773 ret  ::page::parse::lemon::eseq15 () {
02774 
02775     # (x (n DINTRO)
02776     #    (/ (n Code)
02777     #       (n DefaultDestructor)
02778     #       (n DefaultType)
02779     #       (n Destructor)
02780     #       (n ExtraArgument)
02781     #       (n Include)
02782     #       (n Left)
02783     #       (n Name)
02784     #       (n Nonassoc)
02785     #       (n ParseAccept)
02786     #       (n ParseFailure)
02787     #       (n Right)
02788     #       (n StackOverflow)
02789     #       (n Stacksize)
02790     #       (n StartSymbol)
02791     #       (n SyntaxError)
02792     #       (n TokenDestructor)
02793     #       (n TokenPrefix)
02794     #       (n TokenType)
02795     #       (n Type)
02796     #       (n Fallback)))
02797 
02798     variable ok
02799 
02800     set pos [icl_get]
02801 
02802     set old [ier_get]
02803     matchSymbol_DINTRO    ; # (n DINTRO)
02804     ier_merge $old
02805 
02806     if {!$ok} {icl_rewind $pos ; return}
02807 
02808     set mrk [ias_mark]
02809 
02810     set old [ier_get]
02811     ebra14                ; # (/ (n Code)
02812                             #    (n DefaultDestructor)
02813                             #    (n DefaultType)
02814                             #    (n Destructor)
02815                             #    (n ExtraArgument)
02816                             #    (n Include)
02817                             #    (n Left)
02818                             #    (n Name)
02819                             #    (n Nonassoc)
02820                             #    (n ParseAccept)
02821                             #    (n ParseFailure)
02822                             #    (n Right)
02823                             #    (n StackOverflow)
02824                             #    (n Stacksize)
02825                             #    (n StartSymbol)
02826                             #    (n SyntaxError)
02827                             #    (n TokenDestructor)
02828                             #    (n TokenPrefix)
02829                             #    (n TokenType)
02830                             #    (n Type)
02831                             #    (n Fallback))
02832     ier_merge $old
02833 
02834     if {!$ok} {
02835         ias_pop2mark $mrk
02836         icl_rewind   $pos
02837         return
02838     }
02839 
02840     return
02841 }
02842 
02843 ret  ::page::parse::lemon::ebra14 () {
02844 
02845     # (/ (n Code)
02846     #    (n DefaultDestructor)
02847     #    (n DefaultType)
02848     #    (n Destructor)
02849     #    (n ExtraArgument)
02850     #    (n Include)
02851     #    (n Left)
02852     #    (n Name)
02853     #    (n Nonassoc)
02854     #    (n ParseAccept)
02855     #    (n ParseFailure)
02856     #    (n Right)
02857     #    (n StackOverflow)
02858     #    (n Stacksize)
02859     #    (n StartSymbol)
02860     #    (n SyntaxError)
02861     #    (n TokenDestructor)
02862     #    (n TokenPrefix)
02863     #    (n TokenType)
02864     #    (n Type)
02865     #    (n Fallback))
02866 
02867     variable ok
02868 
02869     set pos [icl_get]
02870 
02871     set mrk [ias_mark]
02872     set old [ier_get]
02873     matchSymbol_Code    ; # (n Code)
02874     ier_merge $old
02875 
02876     if {$ok} return
02877     ias_pop2mark $mrk
02878     icl_rewind   $pos
02879 
02880     set mrk [ias_mark]
02881     set old [ier_get]
02882     matchSymbol_DefaultDestructor    ; # (n DefaultDestructor)
02883     ier_merge $old
02884 
02885     if {$ok} return
02886     ias_pop2mark $mrk
02887     icl_rewind   $pos
02888 
02889     set mrk [ias_mark]
02890     set old [ier_get]
02891     matchSymbol_DefaultType    ; # (n DefaultType)
02892     ier_merge $old
02893 
02894     if {$ok} return
02895     ias_pop2mark $mrk
02896     icl_rewind   $pos
02897 
02898     set mrk [ias_mark]
02899     set old [ier_get]
02900     matchSymbol_Destructor    ; # (n Destructor)
02901     ier_merge $old
02902 
02903     if {$ok} return
02904     ias_pop2mark $mrk
02905     icl_rewind   $pos
02906 
02907     set mrk [ias_mark]
02908     set old [ier_get]
02909     matchSymbol_ExtraArgument    ; # (n ExtraArgument)
02910     ier_merge $old
02911 
02912     if {$ok} return
02913     ias_pop2mark $mrk
02914     icl_rewind   $pos
02915 
02916     set mrk [ias_mark]
02917     set old [ier_get]
02918     matchSymbol_Include    ; # (n Include)
02919     ier_merge $old
02920 
02921     if {$ok} return
02922     ias_pop2mark $mrk
02923     icl_rewind   $pos
02924 
02925     set mrk [ias_mark]
02926     set old [ier_get]
02927     matchSymbol_Left    ; # (n Left)
02928     ier_merge $old
02929 
02930     if {$ok} return
02931     ias_pop2mark $mrk
02932     icl_rewind   $pos
02933 
02934     set mrk [ias_mark]
02935     set old [ier_get]
02936     matchSymbol_Name    ; # (n Name)
02937     ier_merge $old
02938 
02939     if {$ok} return
02940     ias_pop2mark $mrk
02941     icl_rewind   $pos
02942 
02943     set mrk [ias_mark]
02944     set old [ier_get]
02945     matchSymbol_Nonassoc    ; # (n Nonassoc)
02946     ier_merge $old
02947 
02948     if {$ok} return
02949     ias_pop2mark $mrk
02950     icl_rewind   $pos
02951 
02952     set mrk [ias_mark]
02953     set old [ier_get]
02954     matchSymbol_ParseAccept    ; # (n ParseAccept)
02955     ier_merge $old
02956 
02957     if {$ok} return
02958     ias_pop2mark $mrk
02959     icl_rewind   $pos
02960 
02961     set mrk [ias_mark]
02962     set old [ier_get]
02963     matchSymbol_ParseFailure    ; # (n ParseFailure)
02964     ier_merge $old
02965 
02966     if {$ok} return
02967     ias_pop2mark $mrk
02968     icl_rewind   $pos
02969 
02970     set mrk [ias_mark]
02971     set old [ier_get]
02972     matchSymbol_Right    ; # (n Right)
02973     ier_merge $old
02974 
02975     if {$ok} return
02976     ias_pop2mark $mrk
02977     icl_rewind   $pos
02978 
02979     set mrk [ias_mark]
02980     set old [ier_get]
02981     matchSymbol_StackOverflow    ; # (n StackOverflow)
02982     ier_merge $old
02983 
02984     if {$ok} return
02985     ias_pop2mark $mrk
02986     icl_rewind   $pos
02987 
02988     set mrk [ias_mark]
02989     set old [ier_get]
02990     matchSymbol_Stacksize    ; # (n Stacksize)
02991     ier_merge $old
02992 
02993     if {$ok} return
02994     ias_pop2mark $mrk
02995     icl_rewind   $pos
02996 
02997     set mrk [ias_mark]
02998     set old [ier_get]
02999     matchSymbol_StartSymbol    ; # (n StartSymbol)
03000     ier_merge $old
03001 
03002     if {$ok} return
03003     ias_pop2mark $mrk
03004     icl_rewind   $pos
03005 
03006     set mrk [ias_mark]
03007     set old [ier_get]
03008     matchSymbol_SyntaxError    ; # (n SyntaxError)
03009     ier_merge $old
03010 
03011     if {$ok} return
03012     ias_pop2mark $mrk
03013     icl_rewind   $pos
03014 
03015     set mrk [ias_mark]
03016     set old [ier_get]
03017     matchSymbol_TokenDestructor    ; # (n TokenDestructor)
03018     ier_merge $old
03019 
03020     if {$ok} return
03021     ias_pop2mark $mrk
03022     icl_rewind   $pos
03023 
03024     set mrk [ias_mark]
03025     set old [ier_get]
03026     matchSymbol_TokenPrefix    ; # (n TokenPrefix)
03027     ier_merge $old
03028 
03029     if {$ok} return
03030     ias_pop2mark $mrk
03031     icl_rewind   $pos
03032 
03033     set mrk [ias_mark]
03034     set old [ier_get]
03035     matchSymbol_TokenType    ; # (n TokenType)
03036     ier_merge $old
03037 
03038     if {$ok} return
03039     ias_pop2mark $mrk
03040     icl_rewind   $pos
03041 
03042     set mrk [ias_mark]
03043     set old [ier_get]
03044     matchSymbol_Type    ; # (n Type)
03045     ier_merge $old
03046 
03047     if {$ok} return
03048     ias_pop2mark $mrk
03049     icl_rewind   $pos
03050 
03051     set mrk [ias_mark]
03052     set old [ier_get]
03053     matchSymbol_Fallback    ; # (n Fallback)
03054     ier_merge $old
03055 
03056     if {$ok} return
03057     ias_pop2mark $mrk
03058     icl_rewind   $pos
03059 
03060     return
03061 }
03062 
03063 ret  ::page::parse::lemon::matchSymbol_DLEFT () {
03064     # DLEFT = (x (t l)
03065     #            (t e)
03066     #            (t f)
03067     #            (t t)
03068     #            (n SPACE))
03069 
03070     if {[inc_restore DLEFT]} return
03071 
03072     set pos [icl_get]
03073 
03074     eseq65                ; # (x (t l)
03075                             #    (t e)
03076                             #    (t f)
03077                             #    (t t)
03078                             #    (n SPACE))
03079 
03080     isv_clear
03081     inc_save               DLEFT $pos
03082     ier_nonterminal        DLEFT $pos
03083     return
03084 }
03085 
03086 ret  ::page::parse::lemon::eseq65 () {
03087 
03088     # (x (t l)
03089     #    (t e)
03090     #    (t f)
03091     #    (t t)
03092     #    (n SPACE))
03093 
03094     variable ok
03095 
03096     set pos [icl_get]
03097 
03098     set old [ier_get]
03099     ict_advance l
03100     if {$ok} {ict_match_token l}
03101     ier_merge $old
03102 
03103     if {!$ok} {icl_rewind $pos ; return}
03104 
03105     set old [ier_get]
03106     ict_advance e
03107     if {$ok} {ict_match_token e}
03108     ier_merge $old
03109 
03110     if {!$ok} {icl_rewind $pos ; return}
03111 
03112     set old [ier_get]
03113     ict_advance f
03114     if {$ok} {ict_match_token f}
03115     ier_merge $old
03116 
03117     if {!$ok} {icl_rewind $pos ; return}
03118 
03119     set old [ier_get]
03120     ict_advance t
03121     if {$ok} {ict_match_token t}
03122     ier_merge $old
03123 
03124     if {!$ok} {icl_rewind $pos ; return}
03125 
03126     set old [ier_get]
03127     matchSymbol_SPACE    ; # (n SPACE)
03128     ier_merge $old
03129 
03130     if {!$ok} {icl_rewind $pos ; return}
03131 
03132     return
03133 }
03134 
03135 ret  ::page::parse::lemon::matchSymbol_DNAME () {
03136     # DNAME = (x (t n)
03137     #            (t a)
03138     #            (t m)
03139     #            (t e)
03140     #            (n SPACE))
03141 
03142     if {[inc_restore DNAME]} return
03143 
03144     set pos [icl_get]
03145 
03146     eseq66                ; # (x (t n)
03147                             #    (t a)
03148                             #    (t m)
03149                             #    (t e)
03150                             #    (n SPACE))
03151 
03152     isv_clear
03153     inc_save               DNAME $pos
03154     ier_nonterminal        DNAME $pos
03155     return
03156 }
03157 
03158 ret  ::page::parse::lemon::eseq66 () {
03159 
03160     # (x (t n)
03161     #    (t a)
03162     #    (t m)
03163     #    (t e)
03164     #    (n SPACE))
03165 
03166     variable ok
03167 
03168     set pos [icl_get]
03169 
03170     set old [ier_get]
03171     ict_advance n
03172     if {$ok} {ict_match_token n}
03173     ier_merge $old
03174 
03175     if {!$ok} {icl_rewind $pos ; return}
03176 
03177     set old [ier_get]
03178     ict_advance a
03179     if {$ok} {ict_match_token a}
03180     ier_merge $old
03181 
03182     if {!$ok} {icl_rewind $pos ; return}
03183 
03184     set old [ier_get]
03185     ict_advance m
03186     if {$ok} {ict_match_token m}
03187     ier_merge $old
03188 
03189     if {!$ok} {icl_rewind $pos ; return}
03190 
03191     set old [ier_get]
03192     ict_advance e
03193     if {$ok} {ict_match_token e}
03194     ier_merge $old
03195 
03196     if {!$ok} {icl_rewind $pos ; return}
03197 
03198     set old [ier_get]
03199     matchSymbol_SPACE    ; # (n SPACE)
03200     ier_merge $old
03201 
03202     if {!$ok} {icl_rewind $pos ; return}
03203 
03204     return
03205 }
03206 
03207 ret  ::page::parse::lemon::matchSymbol_DNON () {
03208     # DNON = (x (t n)
03209     #           (t o)
03210     #           (t n)
03211     #           (t a)
03212     #           (t s)
03213     #           (t s)
03214     #           (t o)
03215     #           (t c)
03216     #           (n SPACE))
03217 
03218     if {[inc_restore DNON]} return
03219 
03220     set pos [icl_get]
03221 
03222     eseq67                ; # (x (t n)
03223                             #    (t o)
03224                             #    (t n)
03225                             #    (t a)
03226                             #    (t s)
03227                             #    (t s)
03228                             #    (t o)
03229                             #    (t c)
03230                             #    (n SPACE))
03231 
03232     isv_clear
03233     inc_save               DNON $pos
03234     ier_nonterminal        DNON $pos
03235     return
03236 }
03237 
03238 ret  ::page::parse::lemon::eseq67 () {
03239 
03240     # (x (t n)
03241     #    (t o)
03242     #    (t n)
03243     #    (t a)
03244     #    (t s)
03245     #    (t s)
03246     #    (t o)
03247     #    (t c)
03248     #    (n SPACE))
03249 
03250     variable ok
03251 
03252     set pos [icl_get]
03253 
03254     set old [ier_get]
03255     ict_advance n
03256     if {$ok} {ict_match_token n}
03257     ier_merge $old
03258 
03259     if {!$ok} {icl_rewind $pos ; return}
03260 
03261     set old [ier_get]
03262     ict_advance o
03263     if {$ok} {ict_match_token o}
03264     ier_merge $old
03265 
03266     if {!$ok} {icl_rewind $pos ; return}
03267 
03268     set old [ier_get]
03269     ict_advance n
03270     if {$ok} {ict_match_token n}
03271     ier_merge $old
03272 
03273     if {!$ok} {icl_rewind $pos ; return}
03274 
03275     set old [ier_get]
03276     ict_advance a
03277     if {$ok} {ict_match_token a}
03278     ier_merge $old
03279 
03280     if {!$ok} {icl_rewind $pos ; return}
03281 
03282     set old [ier_get]
03283     ict_advance s
03284     if {$ok} {ict_match_token s}
03285     ier_merge $old
03286 
03287     if {!$ok} {icl_rewind $pos ; return}
03288 
03289     set old [ier_get]
03290     ict_advance s
03291     if {$ok} {ict_match_token s}
03292     ier_merge $old
03293 
03294     if {!$ok} {icl_rewind $pos ; return}
03295 
03296     set old [ier_get]
03297     ict_advance o
03298     if {$ok} {ict_match_token o}
03299     ier_merge $old
03300 
03301     if {!$ok} {icl_rewind $pos ; return}
03302 
03303     set old [ier_get]
03304     ict_advance c
03305     if {$ok} {ict_match_token c}
03306     ier_merge $old
03307 
03308     if {!$ok} {icl_rewind $pos ; return}
03309 
03310     set old [ier_get]
03311     matchSymbol_SPACE    ; # (n SPACE)
03312     ier_merge $old
03313 
03314     if {!$ok} {icl_rewind $pos ; return}
03315 
03316     return
03317 }
03318 
03319 ret  ::page::parse::lemon::matchSymbol_DOT () {
03320     # DOT = (x (t .)
03321     #          (n SPACE))
03322 
03323     if {[inc_restore DOT]} return
03324 
03325     set pos [icl_get]
03326 
03327     eseq54                ; # (x (t .)
03328                             #    (n SPACE))
03329 
03330     isv_clear
03331     inc_save               DOT $pos
03332     ier_nonterminal        DOT $pos
03333     return
03334 }
03335 
03336 ret  ::page::parse::lemon::eseq54 () {
03337 
03338     # (x (t .)
03339     #    (n SPACE))
03340 
03341     variable ok
03342 
03343     set pos [icl_get]
03344 
03345     set old [ier_get]
03346     ict_advance .
03347     if {$ok} {ict_match_token .}
03348     ier_merge $old
03349 
03350     if {!$ok} {icl_rewind $pos ; return}
03351 
03352     set old [ier_get]
03353     matchSymbol_SPACE    ; # (n SPACE)
03354     ier_merge $old
03355 
03356     if {!$ok} {icl_rewind $pos ; return}
03357 
03358     return
03359 }
03360 
03361 ret  ::page::parse::lemon::matchSymbol_DPACC () {
03362     # DPACC = (x (t p)
03363     #            (t a)
03364     #            (t r)
03365     #            (t s)
03366     #            (t e)
03367     #            (t _)
03368     #            (t a)
03369     #            (t c)
03370     #            (t c)
03371     #            (t e)
03372     #            (t p)
03373     #            (t t)
03374     #            (n SPACE))
03375 
03376     if {[inc_restore DPACC]} return
03377 
03378     set pos [icl_get]
03379 
03380     eseq68                ; # (x (t p)
03381                             #    (t a)
03382                             #    (t r)
03383                             #    (t s)
03384                             #    (t e)
03385                             #    (t _)
03386                             #    (t a)
03387                             #    (t c)
03388                             #    (t c)
03389                             #    (t e)
03390                             #    (t p)
03391                             #    (t t)
03392                             #    (n SPACE))
03393 
03394     isv_clear
03395     inc_save               DPACC $pos
03396     ier_nonterminal        DPACC $pos
03397     return
03398 }
03399 
03400 ret  ::page::parse::lemon::eseq68 () {
03401 
03402     # (x (t p)
03403     #    (t a)
03404     #    (t r)
03405     #    (t s)
03406     #    (t e)
03407     #    (t _)
03408     #    (t a)
03409     #    (t c)
03410     #    (t c)
03411     #    (t e)
03412     #    (t p)
03413     #    (t t)
03414     #    (n SPACE))
03415 
03416     variable ok
03417 
03418     set pos [icl_get]
03419 
03420     set old [ier_get]
03421     ict_advance p
03422     if {$ok} {ict_match_token p}
03423     ier_merge $old
03424 
03425     if {!$ok} {icl_rewind $pos ; return}
03426 
03427     set old [ier_get]
03428     ict_advance a
03429     if {$ok} {ict_match_token a}
03430     ier_merge $old
03431 
03432     if {!$ok} {icl_rewind $pos ; return}
03433 
03434     set old [ier_get]
03435     ict_advance r
03436     if {$ok} {ict_match_token r}
03437     ier_merge $old
03438 
03439     if {!$ok} {icl_rewind $pos ; return}
03440 
03441     set old [ier_get]
03442     ict_advance s
03443     if {$ok} {ict_match_token s}
03444     ier_merge $old
03445 
03446     if {!$ok} {icl_rewind $pos ; return}
03447 
03448     set old [ier_get]
03449     ict_advance e
03450     if {$ok} {ict_match_token e}
03451     ier_merge $old
03452 
03453     if {!$ok} {icl_rewind $pos ; return}
03454 
03455     set old [ier_get]
03456     ict_advance _
03457     if {$ok} {ict_match_token _}
03458     ier_merge $old
03459 
03460     if {!$ok} {icl_rewind $pos ; return}
03461 
03462     set old [ier_get]
03463     ict_advance a
03464     if {$ok} {ict_match_token a}
03465     ier_merge $old
03466 
03467     if {!$ok} {icl_rewind $pos ; return}
03468 
03469     set old [ier_get]
03470     ict_advance c
03471     if {$ok} {ict_match_token c}
03472     ier_merge $old
03473 
03474     if {!$ok} {icl_rewind $pos ; return}
03475 
03476     set old [ier_get]
03477     ict_advance c
03478     if {$ok} {ict_match_token c}
03479     ier_merge $old
03480 
03481     if {!$ok} {icl_rewind $pos ; return}
03482 
03483     set old [ier_get]
03484     ict_advance e
03485     if {$ok} {ict_match_token e}
03486     ier_merge $old
03487 
03488     if {!$ok} {icl_rewind $pos ; return}
03489 
03490     set old [ier_get]
03491     ict_advance p
03492     if {$ok} {ict_match_token p}
03493     ier_merge $old
03494 
03495     if {!$ok} {icl_rewind $pos ; return}
03496 
03497     set old [ier_get]
03498     ict_advance t
03499     if {$ok} {ict_match_token t}
03500     ier_merge $old
03501 
03502     if {!$ok} {icl_rewind $pos ; return}
03503 
03504     set old [ier_get]
03505     matchSymbol_SPACE    ; # (n SPACE)
03506     ier_merge $old
03507 
03508     if {!$ok} {icl_rewind $pos ; return}
03509 
03510     return
03511 }
03512 
03513 ret  ::page::parse::lemon::matchSymbol_DPFAIL () {
03514     # DPFAIL = (x (t p)
03515     #             (t a)
03516     #             (t r)
03517     #             (t s)
03518     #             (t e)
03519     #             (t _)
03520     #             (t f)
03521     #             (t a)
03522     #             (t i)
03523     #             (t l)
03524     #             (t u)
03525     #             (t r)
03526     #             (t e)
03527     #             (n SPACE))
03528 
03529     if {[inc_restore DPFAIL]} return
03530 
03531     set pos [icl_get]
03532 
03533     eseq69                ; # (x (t p)
03534                             #    (t a)
03535                             #    (t r)
03536                             #    (t s)
03537                             #    (t e)
03538                             #    (t _)
03539                             #    (t f)
03540                             #    (t a)
03541                             #    (t i)
03542                             #    (t l)
03543                             #    (t u)
03544                             #    (t r)
03545                             #    (t e)
03546                             #    (n SPACE))
03547 
03548     isv_clear
03549     inc_save               DPFAIL $pos
03550     ier_nonterminal        DPFAIL $pos
03551     return
03552 }
03553 
03554 ret  ::page::parse::lemon::eseq69 () {
03555 
03556     # (x (t p)
03557     #    (t a)
03558     #    (t r)
03559     #    (t s)
03560     #    (t e)
03561     #    (t _)
03562     #    (t f)
03563     #    (t a)
03564     #    (t i)
03565     #    (t l)
03566     #    (t u)
03567     #    (t r)
03568     #    (t e)
03569     #    (n SPACE))
03570 
03571     variable ok
03572 
03573     set pos [icl_get]
03574 
03575     set old [ier_get]
03576     ict_advance p
03577     if {$ok} {ict_match_token p}
03578     ier_merge $old
03579 
03580     if {!$ok} {icl_rewind $pos ; return}
03581 
03582     set old [ier_get]
03583     ict_advance a
03584     if {$ok} {ict_match_token a}
03585     ier_merge $old
03586 
03587     if {!$ok} {icl_rewind $pos ; return}
03588 
03589     set old [ier_get]
03590     ict_advance r
03591     if {$ok} {ict_match_token r}
03592     ier_merge $old
03593 
03594     if {!$ok} {icl_rewind $pos ; return}
03595 
03596     set old [ier_get]
03597     ict_advance s
03598     if {$ok} {ict_match_token s}
03599     ier_merge $old
03600 
03601     if {!$ok} {icl_rewind $pos ; return}
03602 
03603     set old [ier_get]
03604     ict_advance e
03605     if {$ok} {ict_match_token e}
03606     ier_merge $old
03607 
03608     if {!$ok} {icl_rewind $pos ; return}
03609 
03610     set old [ier_get]
03611     ict_advance _
03612     if {$ok} {ict_match_token _}
03613     ier_merge $old
03614 
03615     if {!$ok} {icl_rewind $pos ; return}
03616 
03617     set old [ier_get]
03618     ict_advance f
03619     if {$ok} {ict_match_token f}
03620     ier_merge $old
03621 
03622     if {!$ok} {icl_rewind $pos ; return}
03623 
03624     set old [ier_get]
03625     ict_advance a
03626     if {$ok} {ict_match_token a}
03627     ier_merge $old
03628 
03629     if {!$ok} {icl_rewind $pos ; return}
03630 
03631     set old [ier_get]
03632     ict_advance i
03633     if {$ok} {ict_match_token i}
03634     ier_merge $old
03635 
03636     if {!$ok} {icl_rewind $pos ; return}
03637 
03638     set old [ier_get]
03639     ict_advance l
03640     if {$ok} {ict_match_token l}
03641     ier_merge $old
03642 
03643     if {!$ok} {icl_rewind $pos ; return}
03644 
03645     set old [ier_get]
03646     ict_advance u
03647     if {$ok} {ict_match_token u}
03648     ier_merge $old
03649 
03650     if {!$ok} {icl_rewind $pos ; return}
03651 
03652     set old [ier_get]
03653     ict_advance r
03654     if {$ok} {ict_match_token r}
03655     ier_merge $old
03656 
03657     if {!$ok} {icl_rewind $pos ; return}
03658 
03659     set old [ier_get]
03660     ict_advance e
03661     if {$ok} {ict_match_token e}
03662     ier_merge $old
03663 
03664     if {!$ok} {icl_rewind $pos ; return}
03665 
03666     set old [ier_get]
03667     matchSymbol_SPACE    ; # (n SPACE)
03668     ier_merge $old
03669 
03670     if {!$ok} {icl_rewind $pos ; return}
03671 
03672     return
03673 }
03674 
03675 ret  ::page::parse::lemon::matchSymbol_DRIGHT () {
03676     # DRIGHT = (x (t r)
03677     #             (t i)
03678     #             (t g)
03679     #             (t h)
03680     #             (t t)
03681     #             (n SPACE))
03682 
03683     if {[inc_restore DRIGHT]} return
03684 
03685     set pos [icl_get]
03686 
03687     eseq70                ; # (x (t r)
03688                             #    (t i)
03689                             #    (t g)
03690                             #    (t h)
03691                             #    (t t)
03692                             #    (n SPACE))
03693 
03694     isv_clear
03695     inc_save               DRIGHT $pos
03696     ier_nonterminal        DRIGHT $pos
03697     return
03698 }
03699 
03700 ret  ::page::parse::lemon::eseq70 () {
03701 
03702     # (x (t r)
03703     #    (t i)
03704     #    (t g)
03705     #    (t h)
03706     #    (t t)
03707     #    (n SPACE))
03708 
03709     variable ok
03710 
03711     set pos [icl_get]
03712 
03713     set old [ier_get]
03714     ict_advance r
03715     if {$ok} {ict_match_token r}
03716     ier_merge $old
03717 
03718     if {!$ok} {icl_rewind $pos ; return}
03719 
03720     set old [ier_get]
03721     ict_advance i
03722     if {$ok} {ict_match_token i}
03723     ier_merge $old
03724 
03725     if {!$ok} {icl_rewind $pos ; return}
03726 
03727     set old [ier_get]
03728     ict_advance g
03729     if {$ok} {ict_match_token g}
03730     ier_merge $old
03731 
03732     if {!$ok} {icl_rewind $pos ; return}
03733 
03734     set old [ier_get]
03735     ict_advance h
03736     if {$ok} {ict_match_token h}
03737     ier_merge $old
03738 
03739     if {!$ok} {icl_rewind $pos ; return}
03740 
03741     set old [ier_get]
03742     ict_advance t
03743     if {$ok} {ict_match_token t}
03744     ier_merge $old
03745 
03746     if {!$ok} {icl_rewind $pos ; return}
03747 
03748     set old [ier_get]
03749     matchSymbol_SPACE    ; # (n SPACE)
03750     ier_merge $old
03751 
03752     if {!$ok} {icl_rewind $pos ; return}
03753 
03754     return
03755 }
03756 
03757 ret  ::page::parse::lemon::matchSymbol_DSTART () {
03758     # DSTART = (x (t s)
03759     #             (t t)
03760     #             (t a)
03761     #             (t r)
03762     #             (t t)
03763     #             (t _)
03764     #             (t s)
03765     #             (t y)
03766     #             (t m)
03767     #             (t b)
03768     #             (t o)
03769     #             (t l)
03770     #             (n SPACE))
03771 
03772     if {[inc_restore DSTART]} return
03773 
03774     set pos [icl_get]
03775 
03776     eseq73                ; # (x (t s)
03777                             #    (t t)
03778                             #    (t a)
03779                             #    (t r)
03780                             #    (t t)
03781                             #    (t _)
03782                             #    (t s)
03783                             #    (t y)
03784                             #    (t m)
03785                             #    (t b)
03786                             #    (t o)
03787                             #    (t l)
03788                             #    (n SPACE))
03789 
03790     isv_clear
03791     inc_save               DSTART $pos
03792     ier_nonterminal        DSTART $pos
03793     return
03794 }
03795 
03796 ret  ::page::parse::lemon::eseq73 () {
03797 
03798     # (x (t s)
03799     #    (t t)
03800     #    (t a)
03801     #    (t r)
03802     #    (t t)
03803     #    (t _)
03804     #    (t s)
03805     #    (t y)
03806     #    (t m)
03807     #    (t b)
03808     #    (t o)
03809     #    (t l)
03810     #    (n SPACE))
03811 
03812     variable ok
03813 
03814     set pos [icl_get]
03815 
03816     set old [ier_get]
03817     ict_advance s
03818     if {$ok} {ict_match_token s}
03819     ier_merge $old
03820 
03821     if {!$ok} {icl_rewind $pos ; return}
03822 
03823     set old [ier_get]
03824     ict_advance t
03825     if {$ok} {ict_match_token t}
03826     ier_merge $old
03827 
03828     if {!$ok} {icl_rewind $pos ; return}
03829 
03830     set old [ier_get]
03831     ict_advance a
03832     if {$ok} {ict_match_token a}
03833     ier_merge $old
03834 
03835     if {!$ok} {icl_rewind $pos ; return}
03836 
03837     set old [ier_get]
03838     ict_advance r
03839     if {$ok} {ict_match_token r}
03840     ier_merge $old
03841 
03842     if {!$ok} {icl_rewind $pos ; return}
03843 
03844     set old [ier_get]
03845     ict_advance t
03846     if {$ok} {ict_match_token t}
03847     ier_merge $old
03848 
03849     if {!$ok} {icl_rewind $pos ; return}
03850 
03851     set old [ier_get]
03852     ict_advance _
03853     if {$ok} {ict_match_token _}
03854     ier_merge $old
03855 
03856     if {!$ok} {icl_rewind $pos ; return}
03857 
03858     set old [ier_get]
03859     ict_advance s
03860     if {$ok} {ict_match_token s}
03861     ier_merge $old
03862 
03863     if {!$ok} {icl_rewind $pos ; return}
03864 
03865     set old [ier_get]
03866     ict_advance y
03867     if {$ok} {ict_match_token y}
03868     ier_merge $old
03869 
03870     if {!$ok} {icl_rewind $pos ; return}
03871 
03872     set old [ier_get]
03873     ict_advance m
03874     if {$ok} {ict_match_token m}
03875     ier_merge $old
03876 
03877     if {!$ok} {icl_rewind $pos ; return}
03878 
03879     set old [ier_get]
03880     ict_advance b
03881     if {$ok} {ict_match_token b}
03882     ier_merge $old
03883 
03884     if {!$ok} {icl_rewind $pos ; return}
03885 
03886     set old [ier_get]
03887     ict_advance o
03888     if {$ok} {ict_match_token o}
03889     ier_merge $old
03890 
03891     if {!$ok} {icl_rewind $pos ; return}
03892 
03893     set old [ier_get]
03894     ict_advance l
03895     if {$ok} {ict_match_token l}
03896     ier_merge $old
03897 
03898     if {!$ok} {icl_rewind $pos ; return}
03899 
03900     set old [ier_get]
03901     matchSymbol_SPACE    ; # (n SPACE)
03902     ier_merge $old
03903 
03904     if {!$ok} {icl_rewind $pos ; return}
03905 
03906     return
03907 }
03908 
03909 ret  ::page::parse::lemon::matchSymbol_DSTKOVER () {
03910     # DSTKOVER = (x (t s)
03911     #               (t t)
03912     #               (t a)
03913     #               (t c)
03914     #               (t k)
03915     #               (t _)
03916     #               (t o)
03917     #               (t v)
03918     #               (t e)
03919     #               (t r)
03920     #               (t f)
03921     #               (t l)
03922     #               (t o)
03923     #               (t w)
03924     #               (n SPACE))
03925 
03926     if {[inc_restore DSTKOVER]} return
03927 
03928     set pos [icl_get]
03929 
03930     eseq71                ; # (x (t s)
03931                             #    (t t)
03932                             #    (t a)
03933                             #    (t c)
03934                             #    (t k)
03935                             #    (t _)
03936                             #    (t o)
03937                             #    (t v)
03938                             #    (t e)
03939                             #    (t r)
03940                             #    (t f)
03941                             #    (t l)
03942                             #    (t o)
03943                             #    (t w)
03944                             #    (n SPACE))
03945 
03946     isv_clear
03947     inc_save               DSTKOVER $pos
03948     ier_nonterminal        DSTKOVER $pos
03949     return
03950 }
03951 
03952 ret  ::page::parse::lemon::eseq71 () {
03953 
03954     # (x (t s)
03955     #    (t t)
03956     #    (t a)
03957     #    (t c)
03958     #    (t k)
03959     #    (t _)
03960     #    (t o)
03961     #    (t v)
03962     #    (t e)
03963     #    (t r)
03964     #    (t f)
03965     #    (t l)
03966     #    (t o)
03967     #    (t w)
03968     #    (n SPACE))
03969 
03970     variable ok
03971 
03972     set pos [icl_get]
03973 
03974     set old [ier_get]
03975     ict_advance s
03976     if {$ok} {ict_match_token s}
03977     ier_merge $old
03978 
03979     if {!$ok} {icl_rewind $pos ; return}
03980 
03981     set old [ier_get]
03982     ict_advance t
03983     if {$ok} {ict_match_token t}
03984     ier_merge $old
03985 
03986     if {!$ok} {icl_rewind $pos ; return}
03987 
03988     set old [ier_get]
03989     ict_advance a
03990     if {$ok} {ict_match_token a}
03991     ier_merge $old
03992 
03993     if {!$ok} {icl_rewind $pos ; return}
03994 
03995     set old [ier_get]
03996     ict_advance c
03997     if {$ok} {ict_match_token c}
03998     ier_merge $old
03999 
04000     if {!$ok} {icl_rewind $pos ; return}
04001 
04002     set old [ier_get]
04003     ict_advance k
04004     if {$ok} {ict_match_token k}
04005     ier_merge $old
04006 
04007     if {!$ok} {icl_rewind $pos ; return}
04008 
04009     set old [ier_get]
04010     ict_advance _
04011     if {$ok} {ict_match_token _}
04012     ier_merge $old
04013 
04014     if {!$ok} {icl_rewind $pos ; return}
04015 
04016     set old [ier_get]
04017     ict_advance o
04018     if {$ok} {ict_match_token o}
04019     ier_merge $old
04020 
04021     if {!$ok} {icl_rewind $pos ; return}
04022 
04023     set old [ier_get]
04024     ict_advance v
04025     if {$ok} {ict_match_token v}
04026     ier_merge $old
04027 
04028     if {!$ok} {icl_rewind $pos ; return}
04029 
04030     set old [ier_get]
04031     ict_advance e
04032     if {$ok} {ict_match_token e}
04033     ier_merge $old
04034 
04035     if {!$ok} {icl_rewind $pos ; return}
04036 
04037     set old [ier_get]
04038     ict_advance r
04039     if {$ok} {ict_match_token r}
04040     ier_merge $old
04041 
04042     if {!$ok} {icl_rewind $pos ; return}
04043 
04044     set old [ier_get]
04045     ict_advance f
04046     if {$ok} {ict_match_token f}
04047     ier_merge $old
04048 
04049     if {!$ok} {icl_rewind $pos ; return}
04050 
04051     set old [ier_get]
04052     ict_advance l
04053     if {$ok} {ict_match_token l}
04054     ier_merge $old
04055 
04056     if {!$ok} {icl_rewind $pos ; return}
04057 
04058     set old [ier_get]
04059     ict_advance o
04060     if {$ok} {ict_match_token o}
04061     ier_merge $old
04062 
04063     if {!$ok} {icl_rewind $pos ; return}
04064 
04065     set old [ier_get]
04066     ict_advance w
04067     if {$ok} {ict_match_token w}
04068     ier_merge $old
04069 
04070     if {!$ok} {icl_rewind $pos ; return}
04071 
04072     set old [ier_get]
04073     matchSymbol_SPACE    ; # (n SPACE)
04074     ier_merge $old
04075 
04076     if {!$ok} {icl_rewind $pos ; return}
04077 
04078     return
04079 }
04080 
04081 ret  ::page::parse::lemon::matchSymbol_DSTKSZ () {
04082     # DSTKSZ = (x (t s)
04083     #             (t t)
04084     #             (t a)
04085     #             (t c)
04086     #             (t k)
04087     #             (t _)
04088     #             (t s)
04089     #             (t i)
04090     #             (t z)
04091     #             (t e)
04092     #             (n SPACE))
04093 
04094     if {[inc_restore DSTKSZ]} return
04095 
04096     set pos [icl_get]
04097 
04098     eseq72                ; # (x (t s)
04099                             #    (t t)
04100                             #    (t a)
04101                             #    (t c)
04102                             #    (t k)
04103                             #    (t _)
04104                             #    (t s)
04105                             #    (t i)
04106                             #    (t z)
04107                             #    (t e)
04108                             #    (n SPACE))
04109 
04110     isv_clear
04111     inc_save               DSTKSZ $pos
04112     ier_nonterminal        DSTKSZ $pos
04113     return
04114 }
04115 
04116 ret  ::page::parse::lemon::eseq72 () {
04117 
04118     # (x (t s)
04119     #    (t t)
04120     #    (t a)
04121     #    (t c)
04122     #    (t k)
04123     #    (t _)
04124     #    (t s)
04125     #    (t i)
04126     #    (t z)
04127     #    (t e)
04128     #    (n SPACE))
04129 
04130     variable ok
04131 
04132     set pos [icl_get]
04133 
04134     set old [ier_get]
04135     ict_advance s
04136     if {$ok} {ict_match_token s}
04137     ier_merge $old
04138 
04139     if {!$ok} {icl_rewind $pos ; return}
04140 
04141     set old [ier_get]
04142     ict_advance t
04143     if {$ok} {ict_match_token t}
04144     ier_merge $old
04145 
04146     if {!$ok} {icl_rewind $pos ; return}
04147 
04148     set old [ier_get]
04149     ict_advance a
04150     if {$ok} {ict_match_token a}
04151     ier_merge $old
04152 
04153     if {!$ok} {icl_rewind $pos ; return}
04154 
04155     set old [ier_get]
04156     ict_advance c
04157     if {$ok} {ict_match_token c}
04158     ier_merge $old
04159 
04160     if {!$ok} {icl_rewind $pos ; return}
04161 
04162     set old [ier_get]
04163     ict_advance k
04164     if {$ok} {ict_match_token k}
04165     ier_merge $old
04166 
04167     if {!$ok} {icl_rewind $pos ; return}
04168 
04169     set old [ier_get]
04170     ict_advance _
04171     if {$ok} {ict_match_token _}
04172     ier_merge $old
04173 
04174     if {!$ok} {icl_rewind $pos ; return}
04175 
04176     set old [ier_get]
04177     ict_advance s
04178     if {$ok} {ict_match_token s}
04179     ier_merge $old
04180 
04181     if {!$ok} {icl_rewind $pos ; return}
04182 
04183     set old [ier_get]
04184     ict_advance i
04185     if {$ok} {ict_match_token i}
04186     ier_merge $old
04187 
04188     if {!$ok} {icl_rewind $pos ; return}
04189 
04190     set old [ier_get]
04191     ict_advance z
04192     if {$ok} {ict_match_token z}
04193     ier_merge $old
04194 
04195     if {!$ok} {icl_rewind $pos ; return}
04196 
04197     set old [ier_get]
04198     ict_advance e
04199     if {$ok} {ict_match_token e}
04200     ier_merge $old
04201 
04202     if {!$ok} {icl_rewind $pos ; return}
04203 
04204     set old [ier_get]
04205     matchSymbol_SPACE    ; # (n SPACE)
04206     ier_merge $old
04207 
04208     if {!$ok} {icl_rewind $pos ; return}
04209 
04210     return
04211 }
04212 
04213 ret  ::page::parse::lemon::matchSymbol_DSYNERR () {
04214     # DSYNERR = (x (t s)
04215     #              (t y)
04216     #              (t n)
04217     #              (t t)
04218     #              (t a)
04219     #              (t x)
04220     #              (t _)
04221     #              (t e)
04222     #              (t r)
04223     #              (t r)
04224     #              (t o)
04225     #              (t r)
04226     #              (n SPACE))
04227 
04228     if {[inc_restore DSYNERR]} return
04229 
04230     set pos [icl_get]
04231 
04232     eseq74                ; # (x (t s)
04233                             #    (t y)
04234                             #    (t n)
04235                             #    (t t)
04236                             #    (t a)
04237                             #    (t x)
04238                             #    (t _)
04239                             #    (t e)
04240                             #    (t r)
04241                             #    (t r)
04242                             #    (t o)
04243                             #    (t r)
04244                             #    (n SPACE))
04245 
04246     isv_clear
04247     inc_save               DSYNERR $pos
04248     ier_nonterminal        DSYNERR $pos
04249     return
04250 }
04251 
04252 ret  ::page::parse::lemon::eseq74 () {
04253 
04254     # (x (t s)
04255     #    (t y)
04256     #    (t n)
04257     #    (t t)
04258     #    (t a)
04259     #    (t x)
04260     #    (t _)
04261     #    (t e)
04262     #    (t r)
04263     #    (t r)
04264     #    (t o)
04265     #    (t r)
04266     #    (n SPACE))
04267 
04268     variable ok
04269 
04270     set pos [icl_get]
04271 
04272     set old [ier_get]
04273     ict_advance s
04274     if {$ok} {ict_match_token s}
04275     ier_merge $old
04276 
04277     if {!$ok} {icl_rewind $pos ; return}
04278 
04279     set old [ier_get]
04280     ict_advance y
04281     if {$ok} {ict_match_token y}
04282     ier_merge $old
04283 
04284     if {!$ok} {icl_rewind $pos ; return}
04285 
04286     set old [ier_get]
04287     ict_advance n
04288     if {$ok} {ict_match_token n}
04289     ier_merge $old
04290 
04291     if {!$ok} {icl_rewind $pos ; return}
04292 
04293     set old [ier_get]
04294     ict_advance t
04295     if {$ok} {ict_match_token t}
04296     ier_merge $old
04297 
04298     if {!$ok} {icl_rewind $pos ; return}
04299 
04300     set old [ier_get]
04301     ict_advance a
04302     if {$ok} {ict_match_token a}
04303     ier_merge $old
04304 
04305     if {!$ok} {icl_rewind $pos ; return}
04306 
04307     set old [ier_get]
04308     ict_advance x
04309     if {$ok} {ict_match_token x}
04310     ier_merge $old
04311 
04312     if {!$ok} {icl_rewind $pos ; return}
04313 
04314     set old [ier_get]
04315     ict_advance _
04316     if {$ok} {ict_match_token _}
04317     ier_merge $old
04318 
04319     if {!$ok} {icl_rewind $pos ; return}
04320 
04321     set old [ier_get]
04322     ict_advance e
04323     if {$ok} {ict_match_token e}
04324     ier_merge $old
04325 
04326     if {!$ok} {icl_rewind $pos ; return}
04327 
04328     set old [ier_get]
04329     ict_advance r
04330     if {$ok} {ict_match_token r}
04331     ier_merge $old
04332 
04333     if {!$ok} {icl_rewind $pos ; return}
04334 
04335     set old [ier_get]
04336     ict_advance r
04337     if {$ok} {ict_match_token r}
04338     ier_merge $old
04339 
04340     if {!$ok} {icl_rewind $pos ; return}
04341 
04342     set old [ier_get]
04343     ict_advance o
04344     if {$ok} {ict_match_token o}
04345     ier_merge $old
04346 
04347     if {!$ok} {icl_rewind $pos ; return}
04348 
04349     set old [ier_get]
04350     ict_advance r
04351     if {$ok} {ict_match_token r}
04352     ier_merge $old
04353 
04354     if {!$ok} {icl_rewind $pos ; return}
04355 
04356     set old [ier_get]
04357     matchSymbol_SPACE    ; # (n SPACE)
04358     ier_merge $old
04359 
04360     if {!$ok} {icl_rewind $pos ; return}
04361 
04362     return
04363 }
04364 
04365 ret  ::page::parse::lemon::matchSymbol_DTOKDEST () {
04366     # DTOKDEST = (x (t t)
04367     #               (t o)
04368     #               (t k)
04369     #               (t e)
04370     #               (t n)
04371     #               (t _)
04372     #               (t d)
04373     #               (t e)
04374     #               (t s)
04375     #               (t t)
04376     #               (t r)
04377     #               (t u)
04378     #               (t c)
04379     #               (t t)
04380     #               (t o)
04381     #               (t r)
04382     #               (n SPACE))
04383 
04384     if {[inc_restore DTOKDEST]} return
04385 
04386     set pos [icl_get]
04387 
04388     eseq75                ; # (x (t t)
04389                             #    (t o)
04390                             #    (t k)
04391                             #    (t e)
04392                             #    (t n)
04393                             #    (t _)
04394                             #    (t d)
04395                             #    (t e)
04396                             #    (t s)
04397                             #    (t t)
04398                             #    (t r)
04399                             #    (t u)
04400                             #    (t c)
04401                             #    (t t)
04402                             #    (t o)
04403                             #    (t r)
04404                             #    (n SPACE))
04405 
04406     isv_clear
04407     inc_save               DTOKDEST $pos
04408     ier_nonterminal        DTOKDEST $pos
04409     return
04410 }
04411 
04412 ret  ::page::parse::lemon::eseq75 () {
04413 
04414     # (x (t t)
04415     #    (t o)
04416     #    (t k)
04417     #    (t e)
04418     #    (t n)
04419     #    (t _)
04420     #    (t d)
04421     #    (t e)
04422     #    (t s)
04423     #    (t t)
04424     #    (t r)
04425     #    (t u)
04426     #    (t c)
04427     #    (t t)
04428     #    (t o)
04429     #    (t r)
04430     #    (n SPACE))
04431 
04432     variable ok
04433 
04434     set pos [icl_get]
04435 
04436     set old [ier_get]
04437     ict_advance t
04438     if {$ok} {ict_match_token t}
04439     ier_merge $old
04440 
04441     if {!$ok} {icl_rewind $pos ; return}
04442 
04443     set old [ier_get]
04444     ict_advance o
04445     if {$ok} {ict_match_token o}
04446     ier_merge $old
04447 
04448     if {!$ok} {icl_rewind $pos ; return}
04449 
04450     set old [ier_get]
04451     ict_advance k
04452     if {$ok} {ict_match_token k}
04453     ier_merge $old
04454 
04455     if {!$ok} {icl_rewind $pos ; return}
04456 
04457     set old [ier_get]
04458     ict_advance e
04459     if {$ok} {ict_match_token e}
04460     ier_merge $old
04461 
04462     if {!$ok} {icl_rewind $pos ; return}
04463 
04464     set old [ier_get]
04465     ict_advance n
04466     if {$ok} {ict_match_token n}
04467     ier_merge $old
04468 
04469     if {!$ok} {icl_rewind $pos ; return}
04470 
04471     set old [ier_get]
04472     ict_advance _
04473     if {$ok} {ict_match_token _}
04474     ier_merge $old
04475 
04476     if {!$ok} {icl_rewind $pos ; return}
04477 
04478     set old [ier_get]
04479     ict_advance d
04480     if {$ok} {ict_match_token d}
04481     ier_merge $old
04482 
04483     if {!$ok} {icl_rewind $pos ; return}
04484 
04485     set old [ier_get]
04486     ict_advance e
04487     if {$ok} {ict_match_token e}
04488     ier_merge $old
04489 
04490     if {!$ok} {icl_rewind $pos ; return}
04491 
04492     set old [ier_get]
04493     ict_advance s
04494     if {$ok} {ict_match_token s}
04495     ier_merge $old
04496 
04497     if {!$ok} {icl_rewind $pos ; return}
04498 
04499     set old [ier_get]
04500     ict_advance t
04501     if {$ok} {ict_match_token t}
04502     ier_merge $old
04503 
04504     if {!$ok} {icl_rewind $pos ; return}
04505 
04506     set old [ier_get]
04507     ict_advance r
04508     if {$ok} {ict_match_token r}
04509     ier_merge $old
04510 
04511     if {!$ok} {icl_rewind $pos ; return}
04512 
04513     set old [ier_get]
04514     ict_advance u
04515     if {$ok} {ict_match_token u}
04516     ier_merge $old
04517 
04518     if {!$ok} {icl_rewind $pos ; return}
04519 
04520     set old [ier_get]
04521     ict_advance c
04522     if {$ok} {ict_match_token c}
04523     ier_merge $old
04524 
04525     if {!$ok} {icl_rewind $pos ; return}
04526 
04527     set old [ier_get]
04528     ict_advance t
04529     if {$ok} {ict_match_token t}
04530     ier_merge $old
04531 
04532     if {!$ok} {icl_rewind $pos ; return}
04533 
04534     set old [ier_get]
04535     ict_advance o
04536     if {$ok} {ict_match_token o}
04537     ier_merge $old
04538 
04539     if {!$ok} {icl_rewind $pos ; return}
04540 
04541     set old [ier_get]
04542     ict_advance r
04543     if {$ok} {ict_match_token r}
04544     ier_merge $old
04545 
04546     if {!$ok} {icl_rewind $pos ; return}
04547 
04548     set old [ier_get]
04549     matchSymbol_SPACE    ; # (n SPACE)
04550     ier_merge $old
04551 
04552     if {!$ok} {icl_rewind $pos ; return}
04553 
04554     return
04555 }
04556 
04557 ret  ::page::parse::lemon::matchSymbol_DTOKPFX () {
04558     # DTOKPFX = (x (t t)
04559     #              (t o)
04560     #              (t k)
04561     #              (t e)
04562     #              (t n)
04563     #              (t _)
04564     #              (t p)
04565     #              (t r)
04566     #              (t e)
04567     #              (t f)
04568     #              (t i)
04569     #              (t x)
04570     #              (n SPACE))
04571 
04572     if {[inc_restore DTOKPFX]} return
04573 
04574     set pos [icl_get]
04575 
04576     eseq76                ; # (x (t t)
04577                             #    (t o)
04578                             #    (t k)
04579                             #    (t e)
04580                             #    (t n)
04581                             #    (t _)
04582                             #    (t p)
04583                             #    (t r)
04584                             #    (t e)
04585                             #    (t f)
04586                             #    (t i)
04587                             #    (t x)
04588                             #    (n SPACE))
04589 
04590     isv_clear
04591     inc_save               DTOKPFX $pos
04592     ier_nonterminal        DTOKPFX $pos
04593     return
04594 }
04595 
04596 ret  ::page::parse::lemon::eseq76 () {
04597 
04598     # (x (t t)
04599     #    (t o)
04600     #    (t k)
04601     #    (t e)
04602     #    (t n)
04603     #    (t _)
04604     #    (t p)
04605     #    (t r)
04606     #    (t e)
04607     #    (t f)
04608     #    (t i)
04609     #    (t x)
04610     #    (n SPACE))
04611 
04612     variable ok
04613 
04614     set pos [icl_get]
04615 
04616     set old [ier_get]
04617     ict_advance t
04618     if {$ok} {ict_match_token t}
04619     ier_merge $old
04620 
04621     if {!$ok} {icl_rewind $pos ; return}
04622 
04623     set old [ier_get]
04624     ict_advance o
04625     if {$ok} {ict_match_token o}
04626     ier_merge $old
04627 
04628     if {!$ok} {icl_rewind $pos ; return}
04629 
04630     set old [ier_get]
04631     ict_advance k
04632     if {$ok} {ict_match_token k}
04633     ier_merge $old
04634 
04635     if {!$ok} {icl_rewind $pos ; return}
04636 
04637     set old [ier_get]
04638     ict_advance e
04639     if {$ok} {ict_match_token e}
04640     ier_merge $old
04641 
04642     if {!$ok} {icl_rewind $pos ; return}
04643 
04644     set old [ier_get]
04645     ict_advance n
04646     if {$ok} {ict_match_token n}
04647     ier_merge $old
04648 
04649     if {!$ok} {icl_rewind $pos ; return}
04650 
04651     set old [ier_get]
04652     ict_advance _
04653     if {$ok} {ict_match_token _}
04654     ier_merge $old
04655 
04656     if {!$ok} {icl_rewind $pos ; return}
04657 
04658     set old [ier_get]
04659     ict_advance p
04660     if {$ok} {ict_match_token p}
04661     ier_merge $old
04662 
04663     if {!$ok} {icl_rewind $pos ; return}
04664 
04665     set old [ier_get]
04666     ict_advance r
04667     if {$ok} {ict_match_token r}
04668     ier_merge $old
04669 
04670     if {!$ok} {icl_rewind $pos ; return}
04671 
04672     set old [ier_get]
04673     ict_advance e
04674     if {$ok} {ict_match_token e}
04675     ier_merge $old
04676 
04677     if {!$ok} {icl_rewind $pos ; return}
04678 
04679     set old [ier_get]
04680     ict_advance f
04681     if {$ok} {ict_match_token f}
04682     ier_merge $old
04683 
04684     if {!$ok} {icl_rewind $pos ; return}
04685 
04686     set old [ier_get]
04687     ict_advance i
04688     if {$ok} {ict_match_token i}
04689     ier_merge $old
04690 
04691     if {!$ok} {icl_rewind $pos ; return}
04692 
04693     set old [ier_get]
04694     ict_advance x
04695     if {$ok} {ict_match_token x}
04696     ier_merge $old
04697 
04698     if {!$ok} {icl_rewind $pos ; return}
04699 
04700     set old [ier_get]
04701     matchSymbol_SPACE    ; # (n SPACE)
04702     ier_merge $old
04703 
04704     if {!$ok} {icl_rewind $pos ; return}
04705 
04706     return
04707 }
04708 
04709 ret  ::page::parse::lemon::matchSymbol_DTOKTYPE () {
04710     # DTOKTYPE = (x (t t)
04711     #               (t o)
04712     #               (t k)
04713     #               (t e)
04714     #               (t n)
04715     #               (t _)
04716     #               (t t)
04717     #               (t y)
04718     #               (t p)
04719     #               (t e)
04720     #               (n SPACE))
04721 
04722     if {[inc_restore DTOKTYPE]} return
04723 
04724     set pos [icl_get]
04725 
04726     eseq77                ; # (x (t t)
04727                             #    (t o)
04728                             #    (t k)
04729                             #    (t e)
04730                             #    (t n)
04731                             #    (t _)
04732                             #    (t t)
04733                             #    (t y)
04734                             #    (t p)
04735                             #    (t e)
04736                             #    (n SPACE))
04737 
04738     isv_clear
04739     inc_save               DTOKTYPE $pos
04740     ier_nonterminal        DTOKTYPE $pos
04741     return
04742 }
04743 
04744 ret  ::page::parse::lemon::eseq77 () {
04745 
04746     # (x (t t)
04747     #    (t o)
04748     #    (t k)
04749     #    (t e)
04750     #    (t n)
04751     #    (t _)
04752     #    (t t)
04753     #    (t y)
04754     #    (t p)
04755     #    (t e)
04756     #    (n SPACE))
04757 
04758     variable ok
04759 
04760     set pos [icl_get]
04761 
04762     set old [ier_get]
04763     ict_advance t
04764     if {$ok} {ict_match_token t}
04765     ier_merge $old
04766 
04767     if {!$ok} {icl_rewind $pos ; return}
04768 
04769     set old [ier_get]
04770     ict_advance o
04771     if {$ok} {ict_match_token o}
04772     ier_merge $old
04773 
04774     if {!$ok} {icl_rewind $pos ; return}
04775 
04776     set old [ier_get]
04777     ict_advance k
04778     if {$ok} {ict_match_token k}
04779     ier_merge $old
04780 
04781     if {!$ok} {icl_rewind $pos ; return}
04782 
04783     set old [ier_get]
04784     ict_advance e
04785     if {$ok} {ict_match_token e}
04786     ier_merge $old
04787 
04788     if {!$ok} {icl_rewind $pos ; return}
04789 
04790     set old [ier_get]
04791     ict_advance n
04792     if {$ok} {ict_match_token n}
04793     ier_merge $old
04794 
04795     if {!$ok} {icl_rewind $pos ; return}
04796 
04797     set old [ier_get]
04798     ict_advance _
04799     if {$ok} {ict_match_token _}
04800     ier_merge $old
04801 
04802     if {!$ok} {icl_rewind $pos ; return}
04803 
04804     set old [ier_get]
04805     ict_advance t
04806     if {$ok} {ict_match_token t}
04807     ier_merge $old
04808 
04809     if {!$ok} {icl_rewind $pos ; return}
04810 
04811     set old [ier_get]
04812     ict_advance y
04813     if {$ok} {ict_match_token y}
04814     ier_merge $old
04815 
04816     if {!$ok} {icl_rewind $pos ; return}
04817 
04818     set old [ier_get]
04819     ict_advance p
04820     if {$ok} {ict_match_token p}
04821     ier_merge $old
04822 
04823     if {!$ok} {icl_rewind $pos ; return}
04824 
04825     set old [ier_get]
04826     ict_advance e
04827     if {$ok} {ict_match_token e}
04828     ier_merge $old
04829 
04830     if {!$ok} {icl_rewind $pos ; return}
04831 
04832     set old [ier_get]
04833     matchSymbol_SPACE    ; # (n SPACE)
04834     ier_merge $old
04835 
04836     if {!$ok} {icl_rewind $pos ; return}
04837 
04838     return
04839 }
04840 
04841 ret  ::page::parse::lemon::matchSymbol_DTYPE () {
04842     # DTYPE = (x (t t)
04843     #            (t y)
04844     #            (t p)
04845     #            (t e)
04846     #            (n SPACE))
04847 
04848     if {[inc_restore DTYPE]} return
04849 
04850     set pos [icl_get]
04851 
04852     eseq78                ; # (x (t t)
04853                             #    (t y)
04854                             #    (t p)
04855                             #    (t e)
04856                             #    (n SPACE))
04857 
04858     isv_clear
04859     inc_save               DTYPE $pos
04860     ier_nonterminal        DTYPE $pos
04861     return
04862 }
04863 
04864 ret  ::page::parse::lemon::eseq78 () {
04865 
04866     # (x (t t)
04867     #    (t y)
04868     #    (t p)
04869     #    (t e)
04870     #    (n SPACE))
04871 
04872     variable ok
04873 
04874     set pos [icl_get]
04875 
04876     set old [ier_get]
04877     ict_advance t
04878     if {$ok} {ict_match_token t}
04879     ier_merge $old
04880 
04881     if {!$ok} {icl_rewind $pos ; return}
04882 
04883     set old [ier_get]
04884     ict_advance y
04885     if {$ok} {ict_match_token y}
04886     ier_merge $old
04887 
04888     if {!$ok} {icl_rewind $pos ; return}
04889 
04890     set old [ier_get]
04891     ict_advance p
04892     if {$ok} {ict_match_token p}
04893     ier_merge $old
04894 
04895     if {!$ok} {icl_rewind $pos ; return}
04896 
04897     set old [ier_get]
04898     ict_advance e
04899     if {$ok} {ict_match_token e}
04900     ier_merge $old
04901 
04902     if {!$ok} {icl_rewind $pos ; return}
04903 
04904     set old [ier_get]
04905     matchSymbol_SPACE    ; # (n SPACE)
04906     ier_merge $old
04907 
04908     if {!$ok} {icl_rewind $pos ; return}
04909 
04910     return
04911 }
04912 
04913 ret  ::page::parse::lemon::matchSymbol_Endif () {
04914     # Endif = (n DENDIF)
04915 
04916     if {[inc_restore Endif]} return
04917 
04918     set pos [icl_get]
04919 
04920     matchSymbol_DENDIF    ; # (n DENDIF)
04921 
04922     isv_clear
04923     inc_save               Endif $pos
04924     ier_nonterminal        Endif $pos
04925     return
04926 }
04927 
04928 ret  ::page::parse::lemon::matchSymbol_EOF () {
04929     # EOF = (! (dot))
04930 
04931     if {[inc_restore EOF]} return
04932 
04933     set pos [icl_get]
04934 
04935     ebang99
04936 
04937     isv_clear
04938     inc_save               EOF $pos
04939     ier_nonterminal        EOF $pos
04940     return
04941 }
04942 
04943 ret  ::page::parse::lemon::ebang99 () {
04944     set pos [icl_get]
04945 
04946     ict_advance "any character"
04947 
04948     icl_rewind $pos
04949     iok_negate
04950     return
04951 }
04952 
04953 ret  ::page::parse::lemon::matchSymbol_EOL () {
04954     # EOL = (/ (x (t \r)
04955     #             (t \n))
04956     #          (t \r)
04957     #          (t \n))
04958 
04959     if {[inc_restore EOL]} return
04960 
04961     set pos [icl_get]
04962 
04963     ebra98                ; # (/ (x (t \r)
04964                             #       (t \n))
04965                             #    (t \r)
04966                             #    (t \n))
04967 
04968     isv_clear
04969     inc_save               EOL $pos
04970     ier_nonterminal        EOL $pos
04971     return
04972 }
04973 
04974 ret  ::page::parse::lemon::ebra98 () {
04975 
04976     # (/ (x (t \r)
04977     #       (t \n))
04978     #    (t \r)
04979     #    (t \n))
04980 
04981     variable ok
04982 
04983     set pos [icl_get]
04984 
04985     set old [ier_get]
04986     eseq97                ; # (x (t \r)
04987                             #    (t \n))
04988     ier_merge $old
04989 
04990     if {$ok} return
04991     icl_rewind   $pos
04992 
04993     set old [ier_get]
04994     ict_advance \\r
04995     if {$ok} {ict_match_token \r}
04996     ier_merge $old
04997 
04998     if {$ok} return
04999     icl_rewind   $pos
05000 
05001     set old [ier_get]
05002     ict_advance \\n
05003     if {$ok} {ict_match_token \n}
05004     ier_merge $old
05005 
05006     if {$ok} return
05007     icl_rewind   $pos
05008 
05009     return
05010 }
05011 
05012 ret  ::page::parse::lemon::eseq97 () {
05013 
05014     # (x (t \r)
05015     #    (t \n))
05016 
05017     variable ok
05018 
05019     set pos [icl_get]
05020 
05021     set old [ier_get]
05022     ict_advance \\r
05023     if {$ok} {ict_match_token \r}
05024     ier_merge $old
05025 
05026     if {!$ok} {icl_rewind $pos ; return}
05027 
05028     set old [ier_get]
05029     ict_advance \\n
05030     if {$ok} {ict_match_token \n}
05031     ier_merge $old
05032 
05033     if {!$ok} {icl_rewind $pos ; return}
05034 
05035     return
05036 }
05037 
05038 ret  ::page::parse::lemon::matchSymbol_ExtraArgument () {
05039     # ExtraArgument = (x (n DEXTRA)
05040     #                    (n Codeblock))
05041 
05042     variable ok
05043     if {[inc_restore ExtraArgument]} {
05044         if {$ok} ias_push
05045         return
05046     }
05047 
05048     set pos [icl_get]
05049     set mrk [ias_mark]
05050 
05051     eseq20                ; # (x (n DEXTRA)
05052                             #    (n Codeblock))
05053 
05054     isv_nonterminal_reduce ExtraArgument $pos $mrk
05055     inc_save               ExtraArgument $pos
05056     ias_pop2mark             $mrk
05057     if {$ok} ias_push
05058     ier_nonterminal        ExtraArgument $pos
05059     return
05060 }
05061 
05062 ret  ::page::parse::lemon::eseq20 () {
05063 
05064     # (x (n DEXTRA)
05065     #    (n Codeblock))
05066 
05067     variable ok
05068 
05069     set pos [icl_get]
05070 
05071     set old [ier_get]
05072     matchSymbol_DEXTRA    ; # (n DEXTRA)
05073     ier_merge $old
05074 
05075     if {!$ok} {icl_rewind $pos ; return}
05076 
05077     set mrk [ias_mark]
05078 
05079     set old [ier_get]
05080     matchSymbol_Codeblock    ; # (n Codeblock)
05081     ier_merge $old
05082 
05083     if {!$ok} {
05084         ias_pop2mark $mrk
05085         icl_rewind   $pos
05086         return
05087     }
05088 
05089     return
05090 }
05091 
05092 ret  ::page::parse::lemon::matchSymbol_Fallback () {
05093     # Fallback = (x (n DFALLBK)
05094     #               (+ (n Identifier))
05095     #               (n DOT))
05096 
05097     variable ok
05098     if {[inc_restore Fallback]} {
05099         if {$ok} ias_push
05100         return
05101     }
05102 
05103     set pos [icl_get]
05104     set mrk [ias_mark]
05105 
05106     eseq40                ; # (x (n DFALLBK)
05107                             #    (+ (n Identifier))
05108                             #    (n DOT))
05109 
05110     isv_nonterminal_reduce Fallback $pos $mrk
05111     inc_save               Fallback $pos
05112     ias_pop2mark             $mrk
05113     if {$ok} ias_push
05114     ier_nonterminal        Fallback $pos
05115     return
05116 }
05117 
05118 ret  ::page::parse::lemon::eseq40 () {
05119 
05120     # (x (n DFALLBK)
05121     #    (+ (n Identifier))
05122     #    (n DOT))
05123 
05124     variable ok
05125 
05126     set pos [icl_get]
05127 
05128     set old [ier_get]
05129     matchSymbol_DFALLBK    ; # (n DFALLBK)
05130     ier_merge $old
05131 
05132     if {!$ok} {icl_rewind $pos ; return}
05133 
05134     set mrk [ias_mark]
05135 
05136     set old [ier_get]
05137     epkleene39                ; # (+ (n Identifier))
05138     ier_merge $old
05139 
05140     if {!$ok} {
05141         ias_pop2mark $mrk
05142         icl_rewind   $pos
05143         return
05144     }
05145 
05146     set old [ier_get]
05147     matchSymbol_DOT    ; # (n DOT)
05148     ier_merge $old
05149 
05150     if {!$ok} {
05151         ias_pop2mark $mrk
05152         icl_rewind   $pos
05153         return
05154     }
05155 
05156     return
05157 }
05158 
05159 ret  ::page::parse::lemon::epkleene39 () {
05160 
05161     # (+ (n Identifier))
05162 
05163     variable ok
05164 
05165     set pos [icl_get]
05166 
05167     set old [ier_get]
05168     matchSymbol_Identifier    ; # (n Identifier)
05169     ier_merge $old
05170 
05171     if {!$ok} {
05172         icl_rewind $pos
05173         return
05174     }
05175 
05176     while {1} {
05177         set pos [icl_get]
05178 
05179         set old [ier_get]
05180         matchSymbol_Identifier    ; # (n Identifier)
05181         ier_merge $old
05182 
05183         if {$ok} continue
05184         break
05185     }
05186 
05187     icl_rewind $pos
05188     iok_ok
05189     return
05190 }
05191 
05192 ret  ::page::parse::lemon::matchSymbol_Ident () {
05193     # Ident = (x (/ (alpha)
05194     #               (t _))
05195     #            (* (/ (alnum)
05196     #                  (t _))))
05197 
05198     variable ok
05199     if {[inc_restore Ident]} {
05200         if {$ok} ias_push
05201         return
05202     }
05203 
05204     set pos [icl_get]
05205 
05206     eseq50                ; # (x (/ (alpha)
05207                             #       (t _))
05208                             #    (* (/ (alnum)
05209                             #          (t _))))
05210 
05211     isv_nonterminal_range  Ident $pos
05212     inc_save               Ident $pos
05213     if {$ok} ias_push
05214     ier_nonterminal        Ident $pos
05215     return
05216 }
05217 
05218 ret  ::page::parse::lemon::eseq50 () {
05219 
05220     # (x (/ (alpha)
05221     #       (t _))
05222     #    (* (/ (alnum)
05223     #          (t _))))
05224 
05225     variable ok
05226 
05227     set pos [icl_get]
05228 
05229     set old [ier_get]
05230     ebra47                ; # (/ (alpha)
05231                             #    (t _))
05232     ier_merge $old
05233 
05234     if {!$ok} {icl_rewind $pos ; return}
05235 
05236     set old [ier_get]
05237     ekleene49                ; # (* (/ (alnum)
05238                                #       (t _)))
05239     ier_merge $old
05240 
05241     if {!$ok} {icl_rewind $pos ; return}
05242 
05243     return
05244 }
05245 
05246 ret  ::page::parse::lemon::ebra47 () {
05247 
05248     # (/ (alpha)
05249     #    (t _))
05250 
05251     variable ok
05252 
05253     set pos [icl_get]
05254 
05255     set old [ier_get]
05256     ict_advance alpha
05257     if {$ok} {ict_match_tokclass alpha}
05258     ier_merge $old
05259 
05260     if {$ok} return
05261     icl_rewind   $pos
05262 
05263     set old [ier_get]
05264     ict_advance _
05265     if {$ok} {ict_match_token _}
05266     ier_merge $old
05267 
05268     if {$ok} return
05269     icl_rewind   $pos
05270 
05271     return
05272 }
05273 
05274 ret  ::page::parse::lemon::ekleene49 () {
05275 
05276     # (* (/ (alnum)
05277     #       (t _)))
05278 
05279     variable ok
05280 
05281     while {1} {
05282         set pos [icl_get]
05283 
05284         set old [ier_get]
05285         ebra48                ; # (/ (alnum)
05286                                 #    (t _))
05287         ier_merge $old
05288 
05289         if {$ok} continue
05290         break
05291     }
05292 
05293     icl_rewind $pos
05294     iok_ok
05295     return
05296 }
05297 
05298 ret  ::page::parse::lemon::ebra48 () {
05299 
05300     # (/ (alnum)
05301     #    (t _))
05302 
05303     variable ok
05304 
05305     set pos [icl_get]
05306 
05307     set old [ier_get]
05308     ict_advance alnum
05309     if {$ok} {ict_match_tokclass alnum}
05310     ier_merge $old
05311 
05312     if {$ok} return
05313     icl_rewind   $pos
05314 
05315     set old [ier_get]
05316     ict_advance _
05317     if {$ok} {ict_match_token _}
05318     ier_merge $old
05319 
05320     if {$ok} return
05321     icl_rewind   $pos
05322 
05323     return
05324 }
05325 
05326 ret  ::page::parse::lemon::matchSymbol_Identifier () {
05327     # Identifier = (x (n Ident)
05328     #                 (n SPACE))
05329 
05330     variable ok
05331     if {[inc_restore Identifier]} {
05332         if {$ok} ias_push
05333         return
05334     }
05335 
05336     set pos [icl_get]
05337     set mrk [ias_mark]
05338 
05339     eseq46                ; # (x (n Ident)
05340                             #    (n SPACE))
05341 
05342     isv_nonterminal_reduce Identifier $pos $mrk
05343     inc_save               Identifier $pos
05344     ias_pop2mark             $mrk
05345     if {$ok} ias_push
05346     ier_nonterminal        Identifier $pos
05347     return
05348 }
05349 
05350 ret  ::page::parse::lemon::eseq46 () {
05351 
05352     # (x (n Ident)
05353     #    (n SPACE))
05354 
05355     variable ok
05356 
05357     set pos [icl_get]
05358 
05359     set mrk [ias_mark]
05360 
05361     set old [ier_get]
05362     matchSymbol_Ident    ; # (n Ident)
05363     ier_merge $old
05364 
05365     if {!$ok} {
05366         ias_pop2mark $mrk
05367         icl_rewind   $pos
05368         return
05369     }
05370 
05371     set old [ier_get]
05372     matchSymbol_SPACE    ; # (n SPACE)
05373     ier_merge $old
05374 
05375     if {!$ok} {
05376         ias_pop2mark $mrk
05377         icl_rewind   $pos
05378         return
05379     }
05380 
05381     return
05382 }
05383 
05384 ret  ::page::parse::lemon::matchSymbol_Ifdef () {
05385     # Ifdef = (x (n DIFDEF)
05386     #            (n Identifier))
05387 
05388     if {[inc_restore Ifdef]} return
05389 
05390     set pos [icl_get]
05391 
05392     eseq83                ; # (x (n DIFDEF)
05393                             #    (n Identifier))
05394 
05395     isv_clear
05396     inc_save               Ifdef $pos
05397     ier_nonterminal        Ifdef $pos
05398     return
05399 }
05400 
05401 ret  ::page::parse::lemon::eseq83 () {
05402 
05403     # (x (n DIFDEF)
05404     #    (n Identifier))
05405 
05406     variable ok
05407 
05408     set pos [icl_get]
05409 
05410     set old [ier_get]
05411     matchSymbol_DIFDEF    ; # (n DIFDEF)
05412     ier_merge $old
05413 
05414     if {!$ok} {icl_rewind $pos ; return}
05415 
05416     set old [ier_get]
05417     set pIdentifier [ias_mark]
05418     matchSymbol_Identifier
05419     ias_pop2mark $pIdentifier    ; # (n Identifier)
05420     ier_merge $old
05421 
05422     if {!$ok} {icl_rewind $pos ; return}
05423 
05424     return
05425 }
05426 
05427 ret  ::page::parse::lemon::matchSymbol_Ifndef () {
05428     # Ifndef = (x (n DIFNDEF)
05429     #             (n Identifier))
05430 
05431     if {[inc_restore Ifndef]} return
05432 
05433     set pos [icl_get]
05434 
05435     eseq84                ; # (x (n DIFNDEF)
05436                             #    (n Identifier))
05437 
05438     isv_clear
05439     inc_save               Ifndef $pos
05440     ier_nonterminal        Ifndef $pos
05441     return
05442 }
05443 
05444 ret  ::page::parse::lemon::eseq84 () {
05445 
05446     # (x (n DIFNDEF)
05447     #    (n Identifier))
05448 
05449     variable ok
05450 
05451     set pos [icl_get]
05452 
05453     set old [ier_get]
05454     matchSymbol_DIFNDEF    ; # (n DIFNDEF)
05455     ier_merge $old
05456 
05457     if {!$ok} {icl_rewind $pos ; return}
05458 
05459     set old [ier_get]
05460     set pIdentifier [ias_mark]
05461     matchSymbol_Identifier
05462     ias_pop2mark $pIdentifier    ; # (n Identifier)
05463     ier_merge $old
05464 
05465     if {!$ok} {icl_rewind $pos ; return}
05466 
05467     return
05468 }
05469 
05470 ret  ::page::parse::lemon::matchSymbol_Include () {
05471     # Include = (x (n DINCL)
05472     #              (n Codeblock))
05473 
05474     variable ok
05475     if {[inc_restore Include]} {
05476         if {$ok} ias_push
05477         return
05478     }
05479 
05480     set pos [icl_get]
05481     set mrk [ias_mark]
05482 
05483     eseq21                ; # (x (n DINCL)
05484                             #    (n Codeblock))
05485 
05486     isv_nonterminal_reduce Include $pos $mrk
05487     inc_save               Include $pos
05488     ias_pop2mark             $mrk
05489     if {$ok} ias_push
05490     ier_nonterminal        Include $pos
05491     return
05492 }
05493 
05494 ret  ::page::parse::lemon::eseq21 () {
05495 
05496     # (x (n DINCL)
05497     #    (n Codeblock))
05498 
05499     variable ok
05500 
05501     set pos [icl_get]
05502 
05503     set old [ier_get]
05504     matchSymbol_DINCL    ; # (n DINCL)
05505     ier_merge $old
05506 
05507     if {!$ok} {icl_rewind $pos ; return}
05508 
05509     set mrk [ias_mark]
05510 
05511     set old [ier_get]
05512     matchSymbol_Codeblock    ; # (n Codeblock)
05513     ier_merge $old
05514 
05515     if {!$ok} {
05516         ias_pop2mark $mrk
05517         icl_rewind   $pos
05518         return
05519     }
05520 
05521     return
05522 }
05523 
05524 ret  ::page::parse::lemon::matchSymbol_Label () {
05525     # Label = (x (n LPAREN)
05526     #            (n Identifier)
05527     #            (n RPAREN))
05528 
05529     variable ok
05530     if {[inc_restore Label]} {
05531         if {$ok} ias_push
05532         return
05533     }
05534 
05535     set pos [icl_get]
05536     set mrk [ias_mark]
05537 
05538     eseq12                ; # (x (n LPAREN)
05539                             #    (n Identifier)
05540                             #    (n RPAREN))
05541 
05542     isv_nonterminal_reduce Label $pos $mrk
05543     inc_save               Label $pos
05544     ias_pop2mark             $mrk
05545     if {$ok} ias_push
05546     ier_nonterminal        Label $pos
05547     return
05548 }
05549 
05550 ret  ::page::parse::lemon::eseq12 () {
05551 
05552     # (x (n LPAREN)
05553     #    (n Identifier)
05554     #    (n RPAREN))
05555 
05556     variable ok
05557 
05558     set pos [icl_get]
05559 
05560     set old [ier_get]
05561     matchSymbol_LPAREN    ; # (n LPAREN)
05562     ier_merge $old
05563 
05564     if {!$ok} {icl_rewind $pos ; return}
05565 
05566     set mrk [ias_mark]
05567 
05568     set old [ier_get]
05569     matchSymbol_Identifier    ; # (n Identifier)
05570     ier_merge $old
05571 
05572     if {!$ok} {
05573         ias_pop2mark $mrk
05574         icl_rewind   $pos
05575         return
05576     }
05577 
05578     set old [ier_get]
05579     matchSymbol_RPAREN    ; # (n RPAREN)
05580     ier_merge $old
05581 
05582     if {!$ok} {
05583         ias_pop2mark $mrk
05584         icl_rewind   $pos
05585         return
05586     }
05587 
05588     return
05589 }
05590 
05591 ret  ::page::parse::lemon::matchSymbol_LBRACE () {
05592     # LBRACE = (t \{)
05593 
05594     variable ok
05595     if {[inc_restore LBRACE]} return
05596 
05597     set pos [icl_get]
05598 
05599     ict_advance \{
05600     if {$ok} {ict_match_token \173}
05601 
05602     isv_clear
05603     inc_save               LBRACE $pos
05604     ier_nonterminal        LBRACE $pos
05605     return
05606 }
05607 
05608 proc ::page::parse::lemon::matchSymbol_LBRACKET {} {
05609     # LBRACKET = (x (t [)
05610     #               (n SPACE))
05611 
05612     if {[inc_restore LBRACKET]} return
05613 
05614     set pos [icl_get]
05615 
05616     eseq57                ; # (x (t [)
05617                             #    (n SPACE))
05618 
05619     isv_clear
05620     inc_save               LBRACKET $pos
05621     ier_nonterminal        LBRACKET $pos
05622     return
05623 }
05624 
05625 proc ::page::parse::lemon::eseq57 {} {
05626 
05627     # (x (t [)
05628     #    (n SPACE))
05629 
05630     variable ok
05631 
05632     set pos [icl_get]
05633 
05634     set old [ier_get]
05635     ict_advance \[
05636     if {$ok} {ict_match_token \133}
05637     ier_merge $old
05638 
05639     if {!$ok} {icl_rewind $pos ; return}
05640 
05641     set old [ier_get]
05642     matchSymbol_SPACE    ; # (n SPACE)
05643     ier_merge $old
05644 
05645     if {!$ok} {icl_rewind $pos ; return}
05646 
05647     return
05648 }
05649 
05650 proc ::page::parse::lemon::matchSymbol_Left {} {
05651     # Left = (x (n DLEFT)
05652     #           (+ (n Identifier))
05653     #           (n DOT))
05654 
05655     variable ok
05656     if {[inc_restore Left]} {
05657         if {$ok} ias_push
05658         return
05659     }
05660 
05661     set pos [icl_get]
05662     set mrk [ias_mark]
05663 
05664     eseq23                ; # (x (n DLEFT)
05665                             #    (+ (n Identifier))
05666                             #    (n DOT))
05667 
05668     isv_nonterminal_reduce Left $pos $mrk
05669     inc_save               Left $pos
05670     ias_pop2mark             $mrk
05671     if {$ok} ias_push
05672     ier_nonterminal        Left $pos
05673     return
05674 }
05675 
05676 proc ::page::parse::lemon::eseq23 {} {
05677 
05678     # (x (n DLEFT)
05679     #    (+ (n Identifier))
05680     #    (n DOT))
05681 
05682     variable ok
05683 
05684     set pos [icl_get]
05685 
05686     set old [ier_get]
05687     matchSymbol_DLEFT    ; # (n DLEFT)
05688     ier_merge $old
05689 
05690     if {!$ok} {icl_rewind $pos ; return}
05691 
05692     set mrk [ias_mark]
05693 
05694     set old [ier_get]
05695     epkleene22                ; # (+ (n Identifier))
05696     ier_merge $old
05697 
05698     if {!$ok} {
05699         ias_pop2mark $mrk
05700         icl_rewind   $pos
05701         return
05702     }
05703 
05704     set old [ier_get]
05705     matchSymbol_DOT    ; # (n DOT)
05706     ier_merge $old
05707 
05708     if {!$ok} {
05709         ias_pop2mark $mrk
05710         icl_rewind   $pos
05711         return
05712     }
05713 
05714     return
05715 }
05716 
05717 proc ::page::parse::lemon::epkleene22 {} {
05718 
05719     # (+ (n Identifier))
05720 
05721     variable ok
05722 
05723     set pos [icl_get]
05724 
05725     set old [ier_get]
05726     matchSymbol_Identifier    ; # (n Identifier)
05727     ier_merge $old
05728 
05729     if {!$ok} {
05730         icl_rewind $pos
05731         return
05732     }
05733 
05734     while {1} {
05735         set pos [icl_get]
05736 
05737         set old [ier_get]
05738         matchSymbol_Identifier    ; # (n Identifier)
05739         ier_merge $old
05740 
05741         if {$ok} continue
05742         break
05743     }
05744 
05745     icl_rewind $pos
05746     iok_ok
05747     return
05748 }
05749 
05750 proc ::page::parse::lemon::matchSymbol_LemonGrammar {} {
05751     # LemonGrammar = (x (n SPACE)
05752     #                   (+ (n Statement))
05753     #                   (n EOF))
05754 
05755     variable ok
05756     if {[inc_restore LemonGrammar]} {
05757         if {$ok} ias_push
05758         return
05759     }
05760 
05761     set pos [icl_get]
05762     set mrk [ias_mark]
05763 
05764     eseq2                ; # (x (n SPACE)
05765                            #    (+ (n Statement))
05766                            #    (n EOF))
05767 
05768     isv_nonterminal_reduce LemonGrammar $pos $mrk
05769     inc_save               LemonGrammar $pos
05770     ias_pop2mark             $mrk
05771     if {$ok} ias_push
05772     ier_nonterminal        LemonGrammar $pos
05773     return
05774 }
05775 
05776 proc ::page::parse::lemon::eseq2 {} {
05777 
05778     # (x (n SPACE)
05779     #    (+ (n Statement))
05780     #    (n EOF))
05781 
05782     variable ok
05783 
05784     set pos [icl_get]
05785 
05786     set old [ier_get]
05787     matchSymbol_SPACE    ; # (n SPACE)
05788     ier_merge $old
05789 
05790     if {!$ok} {icl_rewind $pos ; return}
05791 
05792     set mrk [ias_mark]
05793 
05794     set old [ier_get]
05795     epkleene1                ; # (+ (n Statement))
05796     ier_merge $old
05797 
05798     if {!$ok} {
05799         ias_pop2mark $mrk
05800         icl_rewind   $pos
05801         return
05802     }
05803 
05804     set old [ier_get]
05805     matchSymbol_EOF    ; # (n EOF)
05806     ier_merge $old
05807 
05808     if {!$ok} {
05809         ias_pop2mark $mrk
05810         icl_rewind   $pos
05811         return
05812     }
05813 
05814     return
05815 }
05816 
05817 proc ::page::parse::lemon::epkleene1 {} {
05818 
05819     # (+ (n Statement))
05820 
05821     variable ok
05822 
05823     set pos [icl_get]
05824 
05825     set old [ier_get]
05826     matchSymbol_Statement    ; # (n Statement)
05827     ier_merge $old
05828 
05829     if {!$ok} {
05830         icl_rewind $pos
05831         return
05832     }
05833 
05834     while {1} {
05835         set pos [icl_get]
05836 
05837         set old [ier_get]
05838         matchSymbol_Statement    ; # (n Statement)
05839         ier_merge $old
05840 
05841         if {$ok} continue
05842         break
05843     }
05844 
05845     icl_rewind $pos
05846     iok_ok
05847     return
05848 }
05849 
05850 proc ::page::parse::lemon::matchSymbol_LPAREN {} {
05851     # LPAREN = (x (t \()
05852     #             (n SPACE))
05853 
05854     if {[inc_restore LPAREN]} return
05855 
05856     set pos [icl_get]
05857 
05858     eseq55                ; # (x (t \()
05859                             #    (n SPACE))
05860 
05861     isv_clear
05862     inc_save               LPAREN $pos
05863     ier_nonterminal        LPAREN $pos
05864     return
05865 }
05866 
05867 proc ::page::parse::lemon::eseq55 {} {
05868 
05869     # (x (t \()
05870     #    (n SPACE))
05871 
05872     variable ok
05873 
05874     set pos [icl_get]
05875 
05876     set old [ier_get]
05877     ict_advance \(
05878     if {$ok} {ict_match_token \50}
05879     ier_merge $old
05880 
05881     if {!$ok} {icl_rewind $pos ; return}
05882 
05883     set old [ier_get]
05884     matchSymbol_SPACE    ; # (n SPACE)
05885     ier_merge $old
05886 
05887     if {!$ok} {icl_rewind $pos ; return}
05888 
05889     return
05890 }
05891 
05892 proc ::page::parse::lemon::matchSymbol_Name {} {
05893     # Name = (x (n DNAME)
05894     #           (n Identifier))
05895 
05896     variable ok
05897     if {[inc_restore Name]} {
05898         if {$ok} ias_push
05899         return
05900     }
05901 
05902     set pos [icl_get]
05903     set mrk [ias_mark]
05904 
05905     eseq24                ; # (x (n DNAME)
05906                             #    (n Identifier))
05907 
05908     isv_nonterminal_reduce Name $pos $mrk
05909     inc_save               Name $pos
05910     ias_pop2mark             $mrk
05911     if {$ok} ias_push
05912     ier_nonterminal        Name $pos
05913     return
05914 }
05915 
05916 proc ::page::parse::lemon::eseq24 {} {
05917 
05918     # (x (n DNAME)
05919     #    (n Identifier))
05920 
05921     variable ok
05922 
05923     set pos [icl_get]
05924 
05925     set old [ier_get]
05926     matchSymbol_DNAME    ; # (n DNAME)
05927     ier_merge $old
05928 
05929     if {!$ok} {icl_rewind $pos ; return}
05930 
05931     set mrk [ias_mark]
05932 
05933     set old [ier_get]
05934     matchSymbol_Identifier    ; # (n Identifier)
05935     ier_merge $old
05936 
05937     if {!$ok} {
05938         ias_pop2mark $mrk
05939         icl_rewind   $pos
05940         return
05941     }
05942 
05943     return
05944 }
05945 
05946 proc ::page::parse::lemon::matchSymbol_NatNum {} {
05947     # NatNum = (+ (.. 0 9))
05948 
05949     variable ok
05950     if {[inc_restore NatNum]} {
05951         if {$ok} ias_push
05952         return
05953     }
05954 
05955     set pos [icl_get]
05956 
05957     epkleene52                ; # (+ (.. 0 9))
05958 
05959     isv_nonterminal_range  NatNum $pos
05960     inc_save               NatNum $pos
05961     if {$ok} ias_push
05962     ier_nonterminal        NatNum $pos
05963     return
05964 }
05965 
05966 proc ::page::parse::lemon::epkleene52 {} {
05967 
05968     # (+ (.. 0 9))
05969 
05970     variable ok
05971 
05972     set pos [icl_get]
05973 
05974     set old [ier_get]
05975     ict_advance "any in 0..9"
05976     if {$ok} {ict_match_tokrange 0 9}
05977     ier_merge $old
05978 
05979     if {!$ok} {
05980         icl_rewind $pos
05981         return
05982     }
05983 
05984     while {1} {
05985         set pos [icl_get]
05986 
05987         set old [ier_get]
05988         ict_advance "any in 0..9"
05989         if {$ok} {ict_match_tokrange 0 9}
05990         ier_merge $old
05991 
05992         if {$ok} continue
05993         break
05994     }
05995 
05996     icl_rewind $pos
05997     iok_ok
05998     return
05999 }
06000 
06001 proc ::page::parse::lemon::matchSymbol_NaturalNumber {} {
06002     # NaturalNumber = (x (n NatNum)
06003     #                    (n SPACE))
06004 
06005     variable ok
06006     if {[inc_restore NaturalNumber]} {
06007         if {$ok} ias_push
06008         return
06009     }
06010 
06011     set pos [icl_get]
06012     set mrk [ias_mark]
06013 
06014     eseq51                ; # (x (n NatNum)
06015                             #    (n SPACE))
06016 
06017     isv_nonterminal_reduce NaturalNumber $pos $mrk
06018     inc_save               NaturalNumber $pos
06019     ias_pop2mark             $mrk
06020     if {$ok} ias_push
06021     ier_nonterminal        NaturalNumber $pos
06022     return
06023 }
06024 
06025 proc ::page::parse::lemon::eseq51 {} {
06026 
06027     # (x (n NatNum)
06028     #    (n SPACE))
06029 
06030     variable ok
06031 
06032     set pos [icl_get]
06033 
06034     set mrk [ias_mark]
06035 
06036     set old [ier_get]
06037     matchSymbol_NatNum    ; # (n NatNum)
06038     ier_merge $old
06039 
06040     if {!$ok} {
06041         ias_pop2mark $mrk
06042         icl_rewind   $pos
06043         return
06044     }
06045 
06046     set old [ier_get]
06047     matchSymbol_SPACE    ; # (n SPACE)
06048     ier_merge $old
06049 
06050     if {!$ok} {
06051         ias_pop2mark $mrk
06052         icl_rewind   $pos
06053         return
06054     }
06055 
06056     return
06057 }
06058 
06059 proc ::page::parse::lemon::matchSymbol_Nonassoc {} {
06060     # Nonassoc = (x (n DNON)
06061     #               (+ (n Identifier))
06062     #               (n DOT))
06063 
06064     variable ok
06065     if {[inc_restore Nonassoc]} {
06066         if {$ok} ias_push
06067         return
06068     }
06069 
06070     set pos [icl_get]
06071     set mrk [ias_mark]
06072 
06073     eseq26                ; # (x (n DNON)
06074                             #    (+ (n Identifier))
06075                             #    (n DOT))
06076 
06077     isv_nonterminal_reduce Nonassoc $pos $mrk
06078     inc_save               Nonassoc $pos
06079     ias_pop2mark             $mrk
06080     if {$ok} ias_push
06081     ier_nonterminal        Nonassoc $pos
06082     return
06083 }
06084 
06085 proc ::page::parse::lemon::eseq26 {} {
06086 
06087     # (x (n DNON)
06088     #    (+ (n Identifier))
06089     #    (n DOT))
06090 
06091     variable ok
06092 
06093     set pos [icl_get]
06094 
06095     set old [ier_get]
06096     matchSymbol_DNON    ; # (n DNON)
06097     ier_merge $old
06098 
06099     if {!$ok} {icl_rewind $pos ; return}
06100 
06101     set mrk [ias_mark]
06102 
06103     set old [ier_get]
06104     epkleene25                ; # (+ (n Identifier))
06105     ier_merge $old
06106 
06107     if {!$ok} {
06108         ias_pop2mark $mrk
06109         icl_rewind   $pos
06110         return
06111     }
06112 
06113     set old [ier_get]
06114     matchSymbol_DOT    ; # (n DOT)
06115     ier_merge $old
06116 
06117     if {!$ok} {
06118         ias_pop2mark $mrk
06119         icl_rewind   $pos
06120         return
06121     }
06122 
06123     return
06124 }
06125 
06126 proc ::page::parse::lemon::epkleene25 {} {
06127 
06128     # (+ (n Identifier))
06129 
06130     variable ok
06131 
06132     set pos [icl_get]
06133 
06134     set old [ier_get]
06135     matchSymbol_Identifier    ; # (n Identifier)
06136     ier_merge $old
06137 
06138     if {!$ok} {
06139         icl_rewind $pos
06140         return
06141     }
06142 
06143     while {1} {
06144         set pos [icl_get]
06145 
06146         set old [ier_get]
06147         matchSymbol_Identifier    ; # (n Identifier)
06148         ier_merge $old
06149 
06150         if {$ok} continue
06151         break
06152     }
06153 
06154     icl_rewind $pos
06155     iok_ok
06156     return
06157 }
06158 
06159 proc ::page::parse::lemon::matchSymbol_ParseAccept {} {
06160     # ParseAccept = (x (n DPACC)
06161     #                  (n Codeblock))
06162 
06163     variable ok
06164     if {[inc_restore ParseAccept]} {
06165         if {$ok} ias_push
06166         return
06167     }
06168 
06169     set pos [icl_get]
06170     set mrk [ias_mark]
06171 
06172     eseq27                ; # (x (n DPACC)
06173                             #    (n Codeblock))
06174 
06175     isv_nonterminal_reduce ParseAccept $pos $mrk
06176     inc_save               ParseAccept $pos
06177     ias_pop2mark             $mrk
06178     if {$ok} ias_push
06179     ier_nonterminal        ParseAccept $pos
06180     return
06181 }
06182 
06183 proc ::page::parse::lemon::eseq27 {} {
06184 
06185     # (x (n DPACC)
06186     #    (n Codeblock))
06187 
06188     variable ok
06189 
06190     set pos [icl_get]
06191 
06192     set old [ier_get]
06193     matchSymbol_DPACC    ; # (n DPACC)
06194     ier_merge $old
06195 
06196     if {!$ok} {icl_rewind $pos ; return}
06197 
06198     set mrk [ias_mark]
06199 
06200     set old [ier_get]
06201     matchSymbol_Codeblock    ; # (n Codeblock)
06202     ier_merge $old
06203 
06204     if {!$ok} {
06205         ias_pop2mark $mrk
06206         icl_rewind   $pos
06207         return
06208     }
06209 
06210     return
06211 }
06212 
06213 proc ::page::parse::lemon::matchSymbol_ParseFailure {} {
06214     # ParseFailure = (x (n DPFAIL)
06215     #                   (n Codeblock))
06216 
06217     variable ok
06218     if {[inc_restore ParseFailure]} {
06219         if {$ok} ias_push
06220         return
06221     }
06222 
06223     set pos [icl_get]
06224     set mrk [ias_mark]
06225 
06226     eseq28                ; # (x (n DPFAIL)
06227                             #    (n Codeblock))
06228 
06229     isv_nonterminal_reduce ParseFailure $pos $mrk
06230     inc_save               ParseFailure $pos
06231     ias_pop2mark             $mrk
06232     if {$ok} ias_push
06233     ier_nonterminal        ParseFailure $pos
06234     return
06235 }
06236 
06237 proc ::page::parse::lemon::eseq28 {} {
06238 
06239     # (x (n DPFAIL)
06240     #    (n Codeblock))
06241 
06242     variable ok
06243 
06244     set pos [icl_get]
06245 
06246     set old [ier_get]
06247     matchSymbol_DPFAIL    ; # (n DPFAIL)
06248     ier_merge $old
06249 
06250     if {!$ok} {icl_rewind $pos ; return}
06251 
06252     set mrk [ias_mark]
06253 
06254     set old [ier_get]
06255     matchSymbol_Codeblock    ; # (n Codeblock)
06256     ier_merge $old
06257 
06258     if {!$ok} {
06259         ias_pop2mark $mrk
06260         icl_rewind   $pos
06261         return
06262     }
06263 
06264     return
06265 }
06266 
06267 proc ::page::parse::lemon::matchSymbol_Precedence {} {
06268     # Precedence = (x (n LBRACKET)
06269     #                 (n Identifier)
06270     #                 (n RBRACKET))
06271 
06272     variable ok
06273     if {[inc_restore Precedence]} {
06274         if {$ok} ias_push
06275         return
06276     }
06277 
06278     set pos [icl_get]
06279     set mrk [ias_mark]
06280 
06281     eseq13                ; # (x (n LBRACKET)
06282                             #    (n Identifier)
06283                             #    (n RBRACKET))
06284 
06285     isv_nonterminal_reduce Precedence $pos $mrk
06286     inc_save               Precedence $pos
06287     ias_pop2mark             $mrk
06288     if {$ok} ias_push
06289     ier_nonterminal        Precedence $pos
06290     return
06291 }
06292 
06293 proc ::page::parse::lemon::eseq13 {} {
06294 
06295     # (x (n LBRACKET)
06296     #    (n Identifier)
06297     #    (n RBRACKET))
06298 
06299     variable ok
06300 
06301     set pos [icl_get]
06302 
06303     set old [ier_get]
06304     matchSymbol_LBRACKET    ; # (n LBRACKET)
06305     ier_merge $old
06306 
06307     if {!$ok} {icl_rewind $pos ; return}
06308 
06309     set mrk [ias_mark]
06310 
06311     set old [ier_get]
06312     matchSymbol_Identifier    ; # (n Identifier)
06313     ier_merge $old
06314 
06315     if {!$ok} {
06316         ias_pop2mark $mrk
06317         icl_rewind   $pos
06318         return
06319     }
06320 
06321     set old [ier_get]
06322     matchSymbol_RBRACKET    ; # (n RBRACKET)
06323     ier_merge $old
06324 
06325     if {!$ok} {
06326         ias_pop2mark $mrk
06327         icl_rewind   $pos
06328         return
06329     }
06330 
06331     return
06332 }
06333 
06334 proc ::page::parse::lemon::matchSymbol_RBRACE {} {
06335     # RBRACE = (t \})
06336 
06337     variable ok
06338     if {[inc_restore RBRACE]} return
06339 
06340     set pos [icl_get]
06341 
06342     ict_advance \}
06343     if {$ok} {ict_match_token \175}
06344 
06345     isv_clear
06346     inc_save               RBRACE $pos
06347     ier_nonterminal        RBRACE $pos
06348     return
06349 }
06350 
06351 ret  ::page::parse::lemon::matchSymbol_RBRACKET () {
06352     # RBRACKET = (x (t ])
06353     #               (n SPACE))
06354 
06355     if {[inc_restore RBRACKET]} return
06356 
06357     set pos [icl_get]
06358 
06359     eseq58                ; # (x (t ])
06360                             #    (n SPACE))
06361 
06362     isv_clear
06363     inc_save               RBRACKET $pos
06364     ier_nonterminal        RBRACKET $pos
06365     return
06366 }
06367 
06368 ret  ::page::parse::lemon::eseq58 () {
06369 
06370     # (x (t ])
06371     #    (n SPACE))
06372 
06373     variable ok
06374 
06375     set pos [icl_get]
06376 
06377     set old [ier_get]
06378     ict_advance \]
06379     if {$ok} {ict_match_token \135}
06380     ier_merge $old
06381 
06382     if {!$ok} {icl_rewind $pos ; return}
06383 
06384     set old [ier_get]
06385     matchSymbol_SPACE    ; # (n SPACE)
06386     ier_merge $old
06387 
06388     if {!$ok} {icl_rewind $pos ; return}
06389 
06390     return
06391 }
06392 
06393 ret  ::page::parse::lemon::matchSymbol_Right () {
06394     # Right = (x (n DRIGHT)
06395     #            (+ (n Identifier))
06396     #            (n DOT))
06397 
06398     variable ok
06399     if {[inc_restore Right]} {
06400         if {$ok} ias_push
06401         return
06402     }
06403 
06404     set pos [icl_get]
06405     set mrk [ias_mark]
06406 
06407     eseq30                ; # (x (n DRIGHT)
06408                             #    (+ (n Identifier))
06409                             #    (n DOT))
06410 
06411     isv_nonterminal_reduce Right $pos $mrk
06412     inc_save               Right $pos
06413     ias_pop2mark             $mrk
06414     if {$ok} ias_push
06415     ier_nonterminal        Right $pos
06416     return
06417 }
06418 
06419 ret  ::page::parse::lemon::eseq30 () {
06420 
06421     # (x (n DRIGHT)
06422     #    (+ (n Identifier))
06423     #    (n DOT))
06424 
06425     variable ok
06426 
06427     set pos [icl_get]
06428 
06429     set old [ier_get]
06430     matchSymbol_DRIGHT    ; # (n DRIGHT)
06431     ier_merge $old
06432 
06433     if {!$ok} {icl_rewind $pos ; return}
06434 
06435     set mrk [ias_mark]
06436 
06437     set old [ier_get]
06438     epkleene29                ; # (+ (n Identifier))
06439     ier_merge $old
06440 
06441     if {!$ok} {
06442         ias_pop2mark $mrk
06443         icl_rewind   $pos
06444         return
06445     }
06446 
06447     set old [ier_get]
06448     matchSymbol_DOT    ; # (n DOT)
06449     ier_merge $old
06450 
06451     if {!$ok} {
06452         ias_pop2mark $mrk
06453         icl_rewind   $pos
06454         return
06455     }
06456 
06457     return
06458 }
06459 
06460 ret  ::page::parse::lemon::epkleene29 () {
06461 
06462     # (+ (n Identifier))
06463 
06464     variable ok
06465 
06466     set pos [icl_get]
06467 
06468     set old [ier_get]
06469     matchSymbol_Identifier    ; # (n Identifier)
06470     ier_merge $old
06471 
06472     if {!$ok} {
06473         icl_rewind $pos
06474         return
06475     }
06476 
06477     while {1} {
06478         set pos [icl_get]
06479 
06480         set old [ier_get]
06481         matchSymbol_Identifier    ; # (n Identifier)
06482         ier_merge $old
06483 
06484         if {$ok} continue
06485         break
06486     }
06487 
06488     icl_rewind $pos
06489     iok_ok
06490     return
06491 }
06492 
06493 ret  ::page::parse::lemon::matchSymbol_RPAREN () {
06494     # RPAREN = (x (t \))
06495     #             (n SPACE))
06496 
06497     if {[inc_restore RPAREN]} return
06498 
06499     set pos [icl_get]
06500 
06501     eseq56                ; # (x (t \))
06502                             #    (n SPACE))
06503 
06504     isv_clear
06505     inc_save               RPAREN $pos
06506     ier_nonterminal        RPAREN $pos
06507     return
06508 }
06509 
06510 ret  ::page::parse::lemon::eseq56 () {
06511 
06512     # (x (t \))
06513     #    (n SPACE))
06514 
06515     variable ok
06516 
06517     set pos [icl_get]
06518 
06519     set old [ier_get]
06520     ict_advance \)
06521     if {$ok} {ict_match_token \51}
06522     ier_merge $old
06523 
06524     if {!$ok} {icl_rewind $pos ; return}
06525 
06526     set old [ier_get]
06527     matchSymbol_SPACE    ; # (n SPACE)
06528     ier_merge $old
06529 
06530     if {!$ok} {icl_rewind $pos ; return}
06531 
06532     return
06533 }
06534 
06535 ret  ::page::parse::lemon::matchSymbol_Rule () {
06536     # Rule = (x (n Identifier)
06537     #           (? (n Label))
06538     #           (n ASSIGN)
06539     #           (n Definition)
06540     #           (n DOT)
06541     #           (? (n Precedence))
06542     #           (? (n Codeblock)))
06543 
06544     variable ok
06545     if {[inc_restore Rule]} {
06546         if {$ok} ias_push
06547         return
06548     }
06549 
06550     set pos [icl_get]
06551     set mrk [ias_mark]
06552 
06553     eseq8                ; # (x (n Identifier)
06554                            #    (? (n Label))
06555                            #    (n ASSIGN)
06556                            #    (n Definition)
06557                            #    (n DOT)
06558                            #    (? (n Precedence))
06559                            #    (? (n Codeblock)))
06560 
06561     isv_nonterminal_reduce Rule $pos $mrk
06562     inc_save               Rule $pos
06563     ias_pop2mark             $mrk
06564     if {$ok} ias_push
06565     ier_nonterminal        Rule $pos
06566     return
06567 }
06568 
06569 ret  ::page::parse::lemon::eseq8 () {
06570 
06571     # (x (n Identifier)
06572     #    (? (n Label))
06573     #    (n ASSIGN)
06574     #    (n Definition)
06575     #    (n DOT)
06576     #    (? (n Precedence))
06577     #    (? (n Codeblock)))
06578 
06579     variable ok
06580 
06581     set pos [icl_get]
06582 
06583     set mrk [ias_mark]
06584 
06585     set old [ier_get]
06586     matchSymbol_Identifier    ; # (n Identifier)
06587     ier_merge $old
06588 
06589     if {!$ok} {
06590         ias_pop2mark $mrk
06591         icl_rewind   $pos
06592         return
06593     }
06594 
06595     set old [ier_get]
06596     eopt5                ; # (? (n Label))
06597     ier_merge $old
06598 
06599     if {!$ok} {
06600         ias_pop2mark $mrk
06601         icl_rewind   $pos
06602         return
06603     }
06604 
06605     set old [ier_get]
06606     matchSymbol_ASSIGN    ; # (n ASSIGN)
06607     ier_merge $old
06608 
06609     if {!$ok} {
06610         ias_pop2mark $mrk
06611         icl_rewind   $pos
06612         return
06613     }
06614 
06615     set old [ier_get]
06616     matchSymbol_Definition    ; # (n Definition)
06617     ier_merge $old
06618 
06619     if {!$ok} {
06620         ias_pop2mark $mrk
06621         icl_rewind   $pos
06622         return
06623     }
06624 
06625     set old [ier_get]
06626     matchSymbol_DOT    ; # (n DOT)
06627     ier_merge $old
06628 
06629     if {!$ok} {
06630         ias_pop2mark $mrk
06631         icl_rewind   $pos
06632         return
06633     }
06634 
06635     set old [ier_get]
06636     eopt6                ; # (? (n Precedence))
06637     ier_merge $old
06638 
06639     if {!$ok} {
06640         ias_pop2mark $mrk
06641         icl_rewind   $pos
06642         return
06643     }
06644 
06645     set old [ier_get]
06646     eopt7                ; # (? (n Codeblock))
06647     ier_merge $old
06648 
06649     if {!$ok} {
06650         ias_pop2mark $mrk
06651         icl_rewind   $pos
06652         return
06653     }
06654 
06655     return
06656 }
06657 
06658 ret  ::page::parse::lemon::eopt5 () {
06659 
06660     # (? (n Label))
06661 
06662     variable ok
06663 
06664     set pos [icl_get]
06665 
06666     set old [ier_get]
06667     matchSymbol_Label    ; # (n Label)
06668     ier_merge $old
06669 
06670     if {$ok} return
06671     icl_rewind $pos
06672     iok_ok
06673     return
06674 }
06675 
06676 ret  ::page::parse::lemon::eopt6 () {
06677 
06678     # (? (n Precedence))
06679 
06680     variable ok
06681 
06682     set pos [icl_get]
06683 
06684     set old [ier_get]
06685     matchSymbol_Precedence    ; # (n Precedence)
06686     ier_merge $old
06687 
06688     if {$ok} return
06689     icl_rewind $pos
06690     iok_ok
06691     return
06692 }
06693 
06694 ret  ::page::parse::lemon::eopt7 () {
06695 
06696     # (? (n Codeblock))
06697 
06698     variable ok
06699 
06700     set pos [icl_get]
06701 
06702     set old [ier_get]
06703     matchSymbol_Codeblock    ; # (n Codeblock)
06704     ier_merge $old
06705 
06706     if {$ok} return
06707     icl_rewind $pos
06708     iok_ok
06709     return
06710 }
06711 
06712 ret  ::page::parse::lemon::matchSymbol_SPACE () {
06713     # SPACE = (* (/ (t <blank>)
06714     #               (t \t)
06715     #               (t \n)
06716     #               (t \r)
06717     #               (n C_COMMENT)
06718     #               (n Cplusplus_COMMENT)
06719     #               (n Ifndef)
06720     #               (n Ifdef)
06721     #               (n Endif)))
06722 
06723     if {[inc_restore SPACE]} return
06724 
06725     set pos [icl_get]
06726 
06727     ekleene86                ; # (* (/ (t <blank>)
06728                                #       (t \t)
06729                                #       (t \n)
06730                                #       (t \r)
06731                                #       (n C_COMMENT)
06732                                #       (n Cplusplus_COMMENT)
06733                                #       (n Ifndef)
06734                                #       (n Ifdef)
06735                                #       (n Endif)))
06736 
06737     isv_clear
06738     inc_save               SPACE $pos
06739     ier_nonterminal        SPACE $pos
06740     return
06741 }
06742 
06743 ret  ::page::parse::lemon::ekleene86 () {
06744 
06745     # (* (/ (t <blank>)
06746     #       (t \t)
06747     #       (t \n)
06748     #       (t \r)
06749     #       (n C_COMMENT)
06750     #       (n Cplusplus_COMMENT)
06751     #       (n Ifndef)
06752     #       (n Ifdef)
06753     #       (n Endif)))
06754 
06755     variable ok
06756 
06757     while {1} {
06758         set pos [icl_get]
06759 
06760         set old [ier_get]
06761         ebra85                ; # (/ (t <blank>)
06762                                 #    (t \t)
06763                                 #    (t \n)
06764                                 #    (t \r)
06765                                 #    (n C_COMMENT)
06766                                 #    (n Cplusplus_COMMENT)
06767                                 #    (n Ifndef)
06768                                 #    (n Ifdef)
06769                                 #    (n Endif))
06770         ier_merge $old
06771 
06772         if {$ok} continue
06773         break
06774     }
06775 
06776     icl_rewind $pos
06777     iok_ok
06778     return
06779 }
06780 
06781 ret  ::page::parse::lemon::ebra85 () {
06782 
06783     # (/ (t <blank>)
06784     #    (t \t)
06785     #    (t \n)
06786     #    (t \r)
06787     #    (n C_COMMENT)
06788     #    (n Cplusplus_COMMENT)
06789     #    (n Ifndef)
06790     #    (n Ifdef)
06791     #    (n Endif))
06792 
06793     variable ok
06794 
06795     set pos [icl_get]
06796 
06797     set old [ier_get]
06798     ict_advance <blank>
06799     if {$ok} {ict_match_token \40}
06800     ier_merge $old
06801 
06802     if {$ok} return
06803     icl_rewind   $pos
06804 
06805     set old [ier_get]
06806     ict_advance \\t
06807     if {$ok} {ict_match_token \t}
06808     ier_merge $old
06809 
06810     if {$ok} return
06811     icl_rewind   $pos
06812 
06813     set old [ier_get]
06814     ict_advance \\n
06815     if {$ok} {ict_match_token \n}
06816     ier_merge $old
06817 
06818     if {$ok} return
06819     icl_rewind   $pos
06820 
06821     set old [ier_get]
06822     ict_advance \\r
06823     if {$ok} {ict_match_token \r}
06824     ier_merge $old
06825 
06826     if {$ok} return
06827     icl_rewind   $pos
06828 
06829     set old [ier_get]
06830     matchSymbol_C_COMMENT    ; # (n C_COMMENT)
06831     ier_merge $old
06832 
06833     if {$ok} return
06834     icl_rewind   $pos
06835 
06836     set old [ier_get]
06837     matchSymbol_Cplusplus_COMMENT    ; # (n Cplusplus_COMMENT)
06838     ier_merge $old
06839 
06840     if {$ok} return
06841     icl_rewind   $pos
06842 
06843     set old [ier_get]
06844     matchSymbol_Ifndef    ; # (n Ifndef)
06845     ier_merge $old
06846 
06847     if {$ok} return
06848     icl_rewind   $pos
06849 
06850     set old [ier_get]
06851     matchSymbol_Ifdef    ; # (n Ifdef)
06852     ier_merge $old
06853 
06854     if {$ok} return
06855     icl_rewind   $pos
06856 
06857     set old [ier_get]
06858     matchSymbol_Endif    ; # (n Endif)
06859     ier_merge $old
06860 
06861     if {$ok} return
06862     icl_rewind   $pos
06863 
06864     return
06865 }
06866 
06867 ret  ::page::parse::lemon::matchSymbol_StackOverflow () {
06868     # StackOverflow = (x (n DSTKOVER)
06869     #                    (n Codeblock))
06870 
06871     variable ok
06872     if {[inc_restore StackOverflow]} {
06873         if {$ok} ias_push
06874         return
06875     }
06876 
06877     set pos [icl_get]
06878     set mrk [ias_mark]
06879 
06880     eseq31                ; # (x (n DSTKOVER)
06881                             #    (n Codeblock))
06882 
06883     isv_nonterminal_reduce StackOverflow $pos $mrk
06884     inc_save               StackOverflow $pos
06885     ias_pop2mark             $mrk
06886     if {$ok} ias_push
06887     ier_nonterminal        StackOverflow $pos
06888     return
06889 }
06890 
06891 ret  ::page::parse::lemon::eseq31 () {
06892 
06893     # (x (n DSTKOVER)
06894     #    (n Codeblock))
06895 
06896     variable ok
06897 
06898     set pos [icl_get]
06899 
06900     set old [ier_get]
06901     matchSymbol_DSTKOVER    ; # (n DSTKOVER)
06902     ier_merge $old
06903 
06904     if {!$ok} {icl_rewind $pos ; return}
06905 
06906     set mrk [ias_mark]
06907 
06908     set old [ier_get]
06909     matchSymbol_Codeblock    ; # (n Codeblock)
06910     ier_merge $old
06911 
06912     if {!$ok} {
06913         ias_pop2mark $mrk
06914         icl_rewind   $pos
06915         return
06916     }
06917 
06918     return
06919 }
06920 
06921 ret  ::page::parse::lemon::matchSymbol_Stacksize () {
06922     # Stacksize = (x (n DSTKSZ)
06923     #                (n NaturalNumber))
06924 
06925     variable ok
06926     if {[inc_restore Stacksize]} {
06927         if {$ok} ias_push
06928         return
06929     }
06930 
06931     set pos [icl_get]
06932     set mrk [ias_mark]
06933 
06934     eseq32                ; # (x (n DSTKSZ)
06935                             #    (n NaturalNumber))
06936 
06937     isv_nonterminal_reduce Stacksize $pos $mrk
06938     inc_save               Stacksize $pos
06939     ias_pop2mark             $mrk
06940     if {$ok} ias_push
06941     ier_nonterminal        Stacksize $pos
06942     return
06943 }
06944 
06945 ret  ::page::parse::lemon::eseq32 () {
06946 
06947     # (x (n DSTKSZ)
06948     #    (n NaturalNumber))
06949 
06950     variable ok
06951 
06952     set pos [icl_get]
06953 
06954     set old [ier_get]
06955     matchSymbol_DSTKSZ    ; # (n DSTKSZ)
06956     ier_merge $old
06957 
06958     if {!$ok} {icl_rewind $pos ; return}
06959 
06960     set mrk [ias_mark]
06961 
06962     set old [ier_get]
06963     matchSymbol_NaturalNumber    ; # (n NaturalNumber)
06964     ier_merge $old
06965 
06966     if {!$ok} {
06967         ias_pop2mark $mrk
06968         icl_rewind   $pos
06969         return
06970     }
06971 
06972     return
06973 }
06974 
06975 ret  ::page::parse::lemon::matchSymbol_StartSymbol () {
06976     # StartSymbol = (x (n DSTART)
06977     #                  (n Identifier))
06978 
06979     variable ok
06980     if {[inc_restore StartSymbol]} {
06981         if {$ok} ias_push
06982         return
06983     }
06984 
06985     set pos [icl_get]
06986     set mrk [ias_mark]
06987 
06988     eseq33                ; # (x (n DSTART)
06989                             #    (n Identifier))
06990 
06991     isv_nonterminal_reduce StartSymbol $pos $mrk
06992     inc_save               StartSymbol $pos
06993     ias_pop2mark             $mrk
06994     if {$ok} ias_push
06995     ier_nonterminal        StartSymbol $pos
06996     return
06997 }
06998 
06999 ret  ::page::parse::lemon::eseq33 () {
07000 
07001     # (x (n DSTART)
07002     #    (n Identifier))
07003 
07004     variable ok
07005 
07006     set pos [icl_get]
07007 
07008     set old [ier_get]
07009     matchSymbol_DSTART    ; # (n DSTART)
07010     ier_merge $old
07011 
07012     if {!$ok} {icl_rewind $pos ; return}
07013 
07014     set mrk [ias_mark]
07015 
07016     set old [ier_get]
07017     matchSymbol_Identifier    ; # (n Identifier)
07018     ier_merge $old
07019 
07020     if {!$ok} {
07021         ias_pop2mark $mrk
07022         icl_rewind   $pos
07023         return
07024     }
07025 
07026     return
07027 }
07028 
07029 ret  ::page::parse::lemon::matchSymbol_Statement () {
07030     # Statement = (x (/ (n Directive)
07031     #                   (n Rule))
07032     #                (n SPACE))
07033 
07034     variable ok
07035     if {[inc_restore Statement]} {
07036         if {$ok} ias_push
07037         return
07038     }
07039 
07040     set pos [icl_get]
07041     set mrk [ias_mark]
07042 
07043     eseq4                ; # (x (/ (n Directive)
07044                            #       (n Rule))
07045                            #    (n SPACE))
07046 
07047     isv_nonterminal_reduce Statement $pos $mrk
07048     inc_save               Statement $pos
07049     ias_pop2mark             $mrk
07050     if {$ok} ias_push
07051     ier_nonterminal        Statement $pos
07052     return
07053 }
07054 
07055 ret  ::page::parse::lemon::eseq4 () {
07056 
07057     # (x (/ (n Directive)
07058     #       (n Rule))
07059     #    (n SPACE))
07060 
07061     variable ok
07062 
07063     set pos [icl_get]
07064 
07065     set mrk [ias_mark]
07066 
07067     set old [ier_get]
07068     ebra3                ; # (/ (n Directive)
07069                            #    (n Rule))
07070     ier_merge $old
07071 
07072     if {!$ok} {
07073         ias_pop2mark $mrk
07074         icl_rewind   $pos
07075         return
07076     }
07077 
07078     set old [ier_get]
07079     matchSymbol_SPACE    ; # (n SPACE)
07080     ier_merge $old
07081 
07082     if {!$ok} {
07083         ias_pop2mark $mrk
07084         icl_rewind   $pos
07085         return
07086     }
07087 
07088     return
07089 }
07090 
07091 ret  ::page::parse::lemon::ebra3 () {
07092 
07093     # (/ (n Directive)
07094     #    (n Rule))
07095 
07096     variable ok
07097 
07098     set pos [icl_get]
07099 
07100     set mrk [ias_mark]
07101     set old [ier_get]
07102     matchSymbol_Directive    ; # (n Directive)
07103     ier_merge $old
07104 
07105     if {$ok} return
07106     ias_pop2mark $mrk
07107     icl_rewind   $pos
07108 
07109     set mrk [ias_mark]
07110     set old [ier_get]
07111     matchSymbol_Rule    ; # (n Rule)
07112     ier_merge $old
07113 
07114     if {$ok} return
07115     ias_pop2mark $mrk
07116     icl_rewind   $pos
07117 
07118     return
07119 }
07120 
07121 ret  ::page::parse::lemon::matchSymbol_SyntaxError () {
07122     # SyntaxError = (x (n DSYNERR)
07123     #                  (n Codeblock))
07124 
07125     variable ok
07126     if {[inc_restore SyntaxError]} {
07127         if {$ok} ias_push
07128         return
07129     }
07130 
07131     set pos [icl_get]
07132     set mrk [ias_mark]
07133 
07134     eseq34                ; # (x (n DSYNERR)
07135                             #    (n Codeblock))
07136 
07137     isv_nonterminal_reduce SyntaxError $pos $mrk
07138     inc_save               SyntaxError $pos
07139     ias_pop2mark             $mrk
07140     if {$ok} ias_push
07141     ier_nonterminal        SyntaxError $pos
07142     return
07143 }
07144 
07145 ret  ::page::parse::lemon::eseq34 () {
07146 
07147     # (x (n DSYNERR)
07148     #    (n Codeblock))
07149 
07150     variable ok
07151 
07152     set pos [icl_get]
07153 
07154     set old [ier_get]
07155     matchSymbol_DSYNERR    ; # (n DSYNERR)
07156     ier_merge $old
07157 
07158     if {!$ok} {icl_rewind $pos ; return}
07159 
07160     set mrk [ias_mark]
07161 
07162     set old [ier_get]
07163     matchSymbol_Codeblock    ; # (n Codeblock)
07164     ier_merge $old
07165 
07166     if {!$ok} {
07167         ias_pop2mark $mrk
07168         icl_rewind   $pos
07169         return
07170     }
07171 
07172     return
07173 }
07174 
07175 ret  ::page::parse::lemon::matchSymbol_TokenDestructor () {
07176     # TokenDestructor = (x (n DTOKDEST)
07177     #                      (n Identifier)
07178     #                      (n Codeblock))
07179 
07180     variable ok
07181     if {[inc_restore TokenDestructor]} {
07182         if {$ok} ias_push
07183         return
07184     }
07185 
07186     set pos [icl_get]
07187     set mrk [ias_mark]
07188 
07189     eseq35                ; # (x (n DTOKDEST)
07190                             #    (n Identifier)
07191                             #    (n Codeblock))
07192 
07193     isv_nonterminal_reduce TokenDestructor $pos $mrk
07194     inc_save               TokenDestructor $pos
07195     ias_pop2mark             $mrk
07196     if {$ok} ias_push
07197     ier_nonterminal        TokenDestructor $pos
07198     return
07199 }
07200 
07201 ret  ::page::parse::lemon::eseq35 () {
07202 
07203     # (x (n DTOKDEST)
07204     #    (n Identifier)
07205     #    (n Codeblock))
07206 
07207     variable ok
07208 
07209     set pos [icl_get]
07210 
07211     set old [ier_get]
07212     matchSymbol_DTOKDEST    ; # (n DTOKDEST)
07213     ier_merge $old
07214 
07215     if {!$ok} {icl_rewind $pos ; return}
07216 
07217     set mrk [ias_mark]
07218 
07219     set old [ier_get]
07220     matchSymbol_Identifier    ; # (n Identifier)
07221     ier_merge $old
07222 
07223     if {!$ok} {
07224         ias_pop2mark $mrk
07225         icl_rewind   $pos
07226         return
07227     }
07228 
07229     set old [ier_get]
07230     matchSymbol_Codeblock    ; # (n Codeblock)
07231     ier_merge $old
07232 
07233     if {!$ok} {
07234         ias_pop2mark $mrk
07235         icl_rewind   $pos
07236         return
07237     }
07238 
07239     return
07240 }
07241 
07242 ret  ::page::parse::lemon::matchSymbol_TokenPrefix () {
07243     # TokenPrefix = (x (n DTOKPFX)
07244     #                  (n Identifier))
07245 
07246     variable ok
07247     if {[inc_restore TokenPrefix]} {
07248         if {$ok} ias_push
07249         return
07250     }
07251 
07252     set pos [icl_get]
07253     set mrk [ias_mark]
07254 
07255     eseq36                ; # (x (n DTOKPFX)
07256                             #    (n Identifier))
07257 
07258     isv_nonterminal_reduce TokenPrefix $pos $mrk
07259     inc_save               TokenPrefix $pos
07260     ias_pop2mark             $mrk
07261     if {$ok} ias_push
07262     ier_nonterminal        TokenPrefix $pos
07263     return
07264 }
07265 
07266 ret  ::page::parse::lemon::eseq36 () {
07267 
07268     # (x (n DTOKPFX)
07269     #    (n Identifier))
07270 
07271     variable ok
07272 
07273     set pos [icl_get]
07274 
07275     set old [ier_get]
07276     matchSymbol_DTOKPFX    ; # (n DTOKPFX)
07277     ier_merge $old
07278 
07279     if {!$ok} {icl_rewind $pos ; return}
07280 
07281     set mrk [ias_mark]
07282 
07283     set old [ier_get]
07284     matchSymbol_Identifier    ; # (n Identifier)
07285     ier_merge $old
07286 
07287     if {!$ok} {
07288         ias_pop2mark $mrk
07289         icl_rewind   $pos
07290         return
07291     }
07292 
07293     return
07294 }
07295 
07296 ret  ::page::parse::lemon::matchSymbol_TokenType () {
07297     # TokenType = (x (n DTOKTYPE)
07298     #                (n Codeblock))
07299 
07300     variable ok
07301     if {[inc_restore TokenType]} {
07302         if {$ok} ias_push
07303         return
07304     }
07305 
07306     set pos [icl_get]
07307     set mrk [ias_mark]
07308 
07309     eseq37                ; # (x (n DTOKTYPE)
07310                             #    (n Codeblock))
07311 
07312     isv_nonterminal_reduce TokenType $pos $mrk
07313     inc_save               TokenType $pos
07314     ias_pop2mark             $mrk
07315     if {$ok} ias_push
07316     ier_nonterminal        TokenType $pos
07317     return
07318 }
07319 
07320 ret  ::page::parse::lemon::eseq37 () {
07321 
07322     # (x (n DTOKTYPE)
07323     #    (n Codeblock))
07324 
07325     variable ok
07326 
07327     set pos [icl_get]
07328 
07329     set old [ier_get]
07330     matchSymbol_DTOKTYPE    ; # (n DTOKTYPE)
07331     ier_merge $old
07332 
07333     if {!$ok} {icl_rewind $pos ; return}
07334 
07335     set mrk [ias_mark]
07336 
07337     set old [ier_get]
07338     matchSymbol_Codeblock    ; # (n Codeblock)
07339     ier_merge $old
07340 
07341     if {!$ok} {
07342         ias_pop2mark $mrk
07343         icl_rewind   $pos
07344         return
07345     }
07346 
07347     return
07348 }
07349 
07350 ret  ::page::parse::lemon::matchSymbol_Type () {
07351     # Type = (x (n DTYPE)
07352     #           (n Identifier)
07353     #           (n Codeblock))
07354 
07355     variable ok
07356     if {[inc_restore Type]} {
07357         if {$ok} ias_push
07358         return
07359     }
07360 
07361     set pos [icl_get]
07362     set mrk [ias_mark]
07363 
07364     eseq38                ; # (x (n DTYPE)
07365                             #    (n Identifier)
07366                             #    (n Codeblock))
07367 
07368     isv_nonterminal_reduce Type $pos $mrk
07369     inc_save               Type $pos
07370     ias_pop2mark             $mrk
07371     if {$ok} ias_push
07372     ier_nonterminal        Type $pos
07373     return
07374 }
07375 
07376 ret  ::page::parse::lemon::eseq38 () {
07377 
07378     # (x (n DTYPE)
07379     #    (n Identifier)
07380     #    (n Codeblock))
07381 
07382     variable ok
07383 
07384     set pos [icl_get]
07385 
07386     set old [ier_get]
07387     matchSymbol_DTYPE    ; # (n DTYPE)
07388     ier_merge $old
07389 
07390     if {!$ok} {icl_rewind $pos ; return}
07391 
07392     set mrk [ias_mark]
07393 
07394     set old [ier_get]
07395     matchSymbol_Identifier    ; # (n Identifier)
07396     ier_merge $old
07397 
07398     if {!$ok} {
07399         ias_pop2mark $mrk
07400         icl_rewind   $pos
07401         return
07402     }
07403 
07404     set old [ier_get]
07405     matchSymbol_Codeblock    ; # (n Codeblock)
07406     ier_merge $old
07407 
07408     if {!$ok} {
07409         ias_pop2mark $mrk
07410         icl_rewind   $pos
07411         return
07412     }
07413 
07414     return
07415 }
07416 
07417 /*  ### ### ### ######### ######### #########*/
07418 /*  Package Management*/
07419 
07420 package provide page::parse::lemon 0.1
07421