phpDocumentor PHP_ParserGenerator
[ class tree: PHP_ParserGenerator ] [ index: PHP_ParserGenerator ] [ all elements ]

Sample parser file format PHP code (PHP_LexerGenerator's parser)

  1. <?php
  2. /* Driver template for the PHP_PHP_LexerGenerator_ParserrGenerator parser generator. (PHP port of LEMON)
  3. */
  4.  
  5. /**
  6.  * This can be used to store both the string representation of
  7.  * a token, and any useful meta-data associated with the token.
  8.  *
  9.  * meta-data should be stored as an array
  10.  */
  11. class PHP_LexerGenerator_ParseryyToken implements ArrayAccess
  12. {
  13.     public $string '';
  14.     public $metadata array();
  15.  
  16.     function __construct($s$m array())
  17.     {
  18.         if ($s instanceof PHP_LexerGenerator_ParseryyToken{
  19.             $this->string $s->string;
  20.             $this->metadata $s->metadata;
  21.         else {
  22.             $this->string = (string) $s;
  23.             if ($m instanceof PHP_LexerGenerator_ParseryyToken{
  24.                 $this->metadata $m->metadata;
  25.             elseif (is_array($m)) {
  26.                 $this->metadata $m;
  27.             }
  28.         }
  29.     }
  30.  
  31.     function __toString()
  32.     {
  33.         return $this->_string;
  34.     }
  35.  
  36.     function offsetExists($offset)
  37.     {
  38.         return isset($this->metadata[$offset]);
  39.     }
  40.  
  41.     function offsetGet($offset)
  42.     {
  43.         return $this->metadata[$offset];
  44.     }
  45.  
  46.     function offsetSet($offset$value)
  47.     {
  48.         if ($offset === null{
  49.             if (isset($value[0])) {
  50.                 $x ($value instanceof PHP_LexerGenerator_ParseryyToken?
  51.                     $value->metadata $value;
  52.                 $this->metadata array_merge($this->metadata$x);
  53.                 return;
  54.             }
  55.             $offset count($this->metadata);
  56.         }
  57.         if ($value === null{
  58.             return;
  59.         }
  60.         if ($value instanceof PHP_LexerGenerator_ParseryyToken{
  61.             if ($value->metadata{
  62.                 $this->metadata[$offset$value->metadata;
  63.             }
  64.         elseif ($value{
  65.             $this->metadata[$offset$value;
  66.         }
  67.     }
  68.  
  69.     function offsetUnset($offset)
  70.     {
  71.         unset($this->metadata[$offset]);
  72.     }
  73. }
  74.  
  75. // code external to the class is included here
  76. #line 3 "LexerGenerator\Parser.y"
  77.  
  78. /* ?><?php {//*/
  79. /**
  80.  * PHP_LexerGenerator, a php 5 lexer generator.
  81.  * 
  82.  * This lexer generator translates a file in a format similar to
  83.  * re2c ({@link http://re2c.org}) and translates it into a PHP 5-based lexer
  84.  *
  85.  * PHP version 5
  86.  *
  87.  * LICENSE: This source file is subject to version 3.01 of the PHP license
  88.  * that is available through the world-wide-web at the following URI:
  89.  * http://www.php.net/license/3_01.txt.  If you did not receive a copy of
  90.  * the PHP License and are unable to obtain it through the web, please
  91.  * send a note to license@php.net so we can mail you a copy immediately.
  92.  *
  93.  * @category   php
  94.  * @package    PHP_LexerGenerator
  95.  * @author     Gregory Beaver <cellog@php.net>
  96.  * @copyright  2006 Gregory Beaver
  97.  * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
  98.  * @version    CVS: $Id$
  99.  * @since      File available since Release 0.1.0
  100.  */
  101. /**
  102.  * Token parser for plex files.
  103.  * 
  104.  * This parser converts tokens pulled from {@link PHP_LexerGenerator_Lexer}
  105.  * into abstract patterns and rules, then creates the output file
  106.  * @package    PHP_LexerGenerator
  107.  * @author     Gregory Beaver <cellog@php.net>
  108.  * @copyright  2006 Gregory Beaver
  109.  * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
  110.  * @version    @package_version@
  111.  * @since      Class available since Release 0.1.0
  112.  */
  113. #line 115 "LexerGenerator\Parser.php"
  114.  
  115. /** The following structure represents a single element of the
  116.  * parser's stack.  Information stored includes:
  117.  *
  118.  *   +  The state number for the parser at this level of the stack.
  119.  *
  120.  *   +  The value of the token stored at this level of the stack.
  121.  *      (In other words, the "major" token.)
  122.  *
  123.  *   +  The semantic value stored at this level of the stack.  This is
  124.  *      the information used by the action routines in the grammar.
  125.  *      It is sometimes called the "minor" token.
  126.  */
  127. class PHP_LexerGenerator_ParseryyStackEntry
  128. {
  129.     public $stateno;       /* The state-number */
  130.     public $major;         /* The major token value.  This is the code
  131.                      ** number for the token at this stack level */
  132.     public $minor/* The user-supplied minor token value.  This
  133.                      ** is the value of the token  */
  134. };
  135.  
  136. // any extra class_declaration (extends/implements) are defined here
  137. /**
  138.  * The state of the parser is completely contained in an instance of
  139.  * the following structure
  140.  */
  141. #line 2 "LexerGenerator\Parser.y"
  142. class PHP_LexerGenerator_Parser#line 145 "LexerGenerator\Parser.php"
  143. {
  144. /* First off, code is included which follows the "include_class" declaration
  145. ** in the input file. */
  146. #line 52 "LexerGenerator\Parser.y"
  147.  
  148.     
  149.     private $patterns;
  150.     private $out;
  151.     private $lex;
  152.     private $input;
  153.     private $counter;
  154.     private $token;
  155.     private $value;
  156.     private $line;
  157.  
  158.     public $transTable array(
  159.         => self::PHPCODE,
  160.         => self::COMMENTSTART,
  161.         => self::COMMENTEND,
  162.         => self::QUOTE,
  163.         => self::PATTERN,
  164.         => self::CODE,
  165.         => self::SUBPATTERN,
  166.         => self::PI,
  167.     );
  168.  
  169.     function __construct($outfile$lex)
  170.     {
  171.         $this->out fopen($outfile'wb');
  172.         if (!$this->out{
  173.             throw new Exception('unable to open lexer output file "' $outfile '"');
  174.         }
  175.         $this->lex $lex;
  176.     }
  177.  
  178.     function outputRules($rules$statename)
  179.     {
  180.         static $ruleindex 1;
  181.         $patterns array();
  182.         $pattern '/';
  183.         foreach ($rules as $rule{
  184.             $patterns['^(' $rule['pattern'')';
  185.         }
  186.         $pattern .= implode('|'$patterns);
  187.         $pattern .= '/';
  188.         if ($statename{
  189.             fwrite($this->out'
  190.     const ' $statename ' = ' $ruleindex ';
  191. ');
  192.         }
  193.         fwrite($this->out'
  194.     function yylex' $ruleindex '()
  195.     {
  196.         if (' $this->counter ' >= strlen(' $this->input ')) {
  197.             return false; // end of input
  198.         }
  199.         ');
  200.         fwrite($this->out'    $yy_global_pattern = "' .
  201.             $pattern '";' "\n");
  202.         fwrite($this->out'
  203.         do {
  204.             if (preg_match($yy_global_pattern, substr(' $this->input ', ' .
  205.              $this->counter .
  206.                     '), $yymatches)) {
  207.                 $yymatches = array_filter($yymatches, \'strlen\'); // remove empty sub-patterns
  208.                 if (!count($yymatches)) {
  209.                     throw new Exception(\'Error: lexing failed because a rule matched\' .
  210.                         \'an empty string\');
  211.                 }
  212.                 next($yymatches); // skip global match
  213.                 ' $this->token ' = key($yymatches); // token number
  214.                 ' $this->value ' = current($yymatches); // token value
  215.                 $r = $this->{\'yy_r' $ruleindex '_\' . ' $this->token '}();
  216.                 if ($r === null) {
  217.                     ' $this->counter ' += strlen($this->value);
  218.                     ' $this->line ' += substr_count("\n", ' $this->value ');
  219.                     // accept this token
  220.                     return true;
  221.                 } elseif ($r === true) {
  222.                     // we have changed state
  223.                     // process this token in the new state
  224.                     return $this->yylex();
  225.                 } elseif ($r === false) {
  226.                     ' $this->counter ' += strlen($this->value);
  227.                     ' $this->line ' += substr_count("\n", ' $this->value ');
  228.                     if (' $this->counter ' >= strlen(' $this->input ')) {
  229.                         return false; // end of input
  230.                     }
  231.                     // skip this token
  232.                     continue;
  233.                 } else {');
  234.         fwrite($this->out'                    $yy_yymore_patterns = array(' "\n");
  235.         for($i 0count($patterns)$i++{
  236.             unset($patterns[$i]);
  237.             fwrite($this->out'        ' ($i 1' => "' .
  238.                 implode('|'$patterns"\",\n");
  239.         }
  240.         fwrite($this->out'    );' "\n");
  241.         fwrite($this->out'
  242.                     // yymore is needed
  243.                     do {
  244.                         if (!strlen($yy_yymore_patterns[' $this->token '])) {
  245.                             throw new Exception(\'cannot do yymore for the last token\');
  246.                         }
  247.                         if (preg_match($yy_yymore_patterns[' $this->token '],
  248.                               substr(' $this->input ', ' $this->counter '), $yymatches)) {
  249.                             $yymatches = array_filter($yymatches, \'strlen\'); // remove empty sub-patterns
  250.                             next($yymatches); // skip global match
  251.                             ' $this->token ' = key($yymatches); // token number
  252.                             ' $this->value ' = current($yymatches); // token value
  253.                             ' $this->line ' = substr_count("\n", ' $this->value ');
  254.                         }
  255.                     } while ($this->{\'yy_r' $ruleindex '_\' . ' $this->token '}() !== null);
  256.                     // accept
  257.                     ' $this->counter ' += strlen($this->value);
  258.                     ' $this->line ' += substr_count("\n", ' $this->value ');
  259.                     return true;
  260.                 }
  261.             } else {
  262.                 throw new Exception(\'Unexpected input at line\' . ' $this->line ' .
  263.                     \': \' . ' $this->input '[' $this->counter ']);
  264.             }
  265.             break;
  266.         } while (true);
  267.     } // end function
  268.  
  269. ');
  270.         foreach ($rules as $i => $rule{
  271.             fwrite($this->out'    function yy_r' $ruleindex '_' ($i 1'()
  272.     {
  273. $rule['code'.
  274. '    }
  275. ');
  276.         }
  277.         $ruleindex++// for next set of rules
  278.     }
  279.  
  280.     function error($msg)
  281.     {
  282.         echo 'Error on line ' $this->lex->line ': ' $msg;
  283.     }
  284.  
  285.     function _validatePattern($pattern)
  286.     {
  287.         if ($pattern[0== '^'{
  288.             $this->error('Pattern "' $pattern .
  289.                 '" should not begin with ^, lexer may fail');
  290.         }
  291.         if ($pattern[strlen($pattern1== '$'{
  292.             $this->error('Pattern "' $pattern .
  293.                 '" should not end with $, lexer may fail');
  294.         }
  295.         // match ( but not \( or (?:
  296.         $savepattern $pattern;
  297.         $pattern str_replace('\\\\'''$pattern);
  298.         $pattern str_replace('\\('''$pattern);
  299.         if (preg_match('/\([^?][^:]|\(\?[^:]|\(\?$|\($/'$pattern)) {
  300.             $this->error('Pattern "' $savepattern .
  301.                 '" must not contain sub-patterns (like this), generated lexer will fail');
  302.         }
  303.     }
  304. #line 307 "LexerGenerator\Parser.php"
  305.  
  306. /* Next is all token values, in a form suitable for use by makeheaders.
  307. ** This section will be null unless lemon is run with the -m switch.
  308. */
  309. /* 
  310. ** These constants (all generated automatically by the parser generator)
  311. ** specify the various kinds of tokens (terminals) that the parser
  312. ** understands. 
  313. **
  314. ** Each symbol here is a terminal symbol in the grammar.
  315. */
  316.     const PHPCODE                        =  1;
  317.     const COMMENTSTART                   =  2;
  318.     const COMMENTEND                     =  3;
  319.     const PI                             =  4;
  320.     const SUBPATTERN                     =  5;
  321.     const CODE                           =  6;
  322.     const PATTERN                        =  7;
  323.     const QUOTE                          =  8;
  324.     const YY_NO_ACTION 94;
  325.     const YY_ACCEPT_ACTION 93;
  326.     const YY_ERROR_ACTION 92;
  327.  
  328. /* Next are that tables used to determine what action to take based on the
  329. ** current state and lookahead token.  These tables are used to implement
  330. ** functions that take a state number and lookahead value and return an
  331. ** action integer.  
  332. **
  333. ** Suppose the action integer is N.  Then the action is determined as
  334. ** follows
  335. **
  336. **   0 <= N < YYNSTATE                  Shift N.  That is, push the lookahead
  337. **                                      token onto the stack and goto state N.
  338. **
  339. **   YYNSTATE <= N < YYNSTATE+YYNRULE   Reduce by rule N-YYNSTATE.
  340. **
  341. **   N == YYNSTATE+YYNRULE              A syntax error has occurred.
  342. **
  343. **   N == YYNSTATE+YYNRULE+1            The parser accepts its input.
  344. **
  345. **   N == YYNSTATE+YYNRULE+2            No such action.  Denotes unused
  346. **                                      slots in the yy_action[] table.
  347. **
  348. ** The action table is constructed as a single large table named yy_action[].
  349. ** Given state S and lookahead X, the action is computed as
  350. **
  351. **      yy_action[ yy_shift_ofst[S] + X ]
  352. **
  353. ** If the index value yy_shift_ofst[S]+X is out of range or if the value
  354. ** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
  355. ** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
  356. ** and that yy_default[S] should be used instead.  
  357. **
  358. ** The formula above is for computing the action when the lookahead is
  359. ** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
  360. ** a reduce action) then the yy_reduce_ofst[] array is used in place of
  361. ** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
  362. ** YY_SHIFT_USE_DFLT.
  363. **
  364. ** The following are the tables generated in this section:
  365. **
  366. **  yy_action[]        A single table containing all actions.
  367. **  yy_lookahead[]     A table containing the lookahead for each entry in
  368. **                     yy_action.  Used to detect hash collisions.
  369. **  yy_shift_ofst[]    For each state, the offset into yy_action for
  370. **                     shifting terminals.
  371. **  yy_reduce_ofst[]   For each state, the offset into yy_action for
  372. **                     shifting non-terminals after a reduce.
  373. **  yy_default[]       Default action for each state.
  374. */
  375.     const YY_SZ_ACTTAB 87;
  376. static public $yy_action array(
  377.  /*     0 */        33,   31,   58,   58,    3,   50,   50,   57,   44,   39,
  378.  /*    10 */        42,   58,   57,   55,   50,   42,   51,   36,   58,   58,
  379.  /*    20 */        59,   50,   50,   38,   58,   46,   45,   50,   35,   58,
  380.  /*    30 */        17,    2,   50,   93,   52,   16,   18,    6,   24,   19,
  381.  /*    40 */          2,   12,   41,   53,   48,   40,   30,   60,    1,    4,
  382.  /*    50 */        34,   10,   20,   43,   49,   32,   14,   58,    7,   20,
  383.  /*    60 */        50,    8,   20,    9,   20,   37,   47,   11,   20,   56,
  384.  /*    70 */        15,    5,   22,   54,   28,   23,   53,   21,   29,   25,
  385.  /*    80 */          2,   27,    6,   13,   53,   53,   26,
  386.     );
  387.     static public $yy_lookahead array(
  388.  /*     0 */          3,    3,    5,    5,    5,    8,    8,    5,    6,    3,
  389.  /*    10 */          8,    5,    5,    6,    8,    8,    3,    3,    5,    5,
  390.  /*    20 */          3,    8,    8,    4,    5,    5,    6,    8,    4,    5,
  391.  /*    30 */          1,    2,    8,   10,   11,   12,    1,    2,    4,    1,
  392.  /*    40 */          2,    7,    5,    1,    5,    8,   16,    8,    2,    5,
  393.  /*    50 */          4,   18,   19,    5,    6,   14,   15,    5,   18,   19,
  394.  /*    60 */          8,   18,   19,   18,   19,    5,    1,   18,   19,    1,
  395.  /*    70 */          7,    2,   13,    1,   17,   13,   20,   19,    4,   13,
  396.  /*    80 */          2,   17,    2,   12,   20,   20,   13,
  397. );
  398.     const YY_SHIFT_USE_DFLT = -4;
  399.     const YY_SHIFT_MAX 39;
  400.     static public $yy_shift_ofst array(
  401.  /*     0 */        35,   24,   19,   52,   52,   52,   74,   13,   -2,   -3,
  402.  /*    10 */        14,    6,   37,   38,   34,   37,   29,   78,   80,   78,
  403.  /*    20 */          7,    2,   46,   46,   48,   46,   46,   39,   39,   20,
  404.  /*    30 */        63,   42,   17,   72,   60,   -1,   68,   69,   44,   65,
  405. );
  406.     const YY_REDUCE_USE_DFLT = -1;
  407.     const YY_REDUCE_MAX 19;
  408.     static public $yy_reduce_ofst array(
  409.  /*     0 */        23,   49,   45,   33,   43,   40,   41,   58,   58,   58,
  410.  /*    10 */        58,   58,   64,   59,   30,   57,   62,   73,   71,   66,
  411. );
  412.     static public $yyExpectedTokens array(
  413.         /* 0 */  array(12),
  414.         /* 1 */  array(458),
  415.         /* 2 */  array(458),
  416.         /* 3 */  array(58),
  417.         /* 4 */  array(58),
  418.         /* 5 */  array(58),
  419.         /* 6 */  array(4),
  420.         /* 7 */  array(358),
  421.         /* 8 */  array(358),
  422.         /* 9 */  array(358),
  423.         /* 10 */  array(358),
  424.         /* 11 */  array(358),
  425.         /* 12 */  array(58),
  426.         /* 13 */  array(12),
  427.         /* 14 */  array(47),
  428.         /* 15 */  array(58),
  429.         /* 16 */  array(12),
  430.         /* 17 */  array(2),
  431.         /* 18 */  array(2),
  432.         /* 19 */  array(2),
  433.         /* 20 */  array(568),
  434.         /* 21 */  array(568),
  435.         /* 22 */  array(24),
  436.         /* 23 */  array(24),
  437.         /* 24 */  array(56),
  438.         /* 25 */  array(24),
  439.         /* 26 */  array(24),
  440.         /* 27 */  array(58),
  441.         /* 28 */  array(58),
  442.         /* 29 */  array(56),
  443.         /* 30 */  array(7),
  444.         /* 31 */  array(1),
  445.         /* 32 */  array(3),
  446.         /* 33 */  array(1),
  447.         /* 34 */  array(5),
  448.         /* 35 */  array(5),
  449.         /* 36 */  array(1),
  450.         /* 37 */  array(2),
  451.         /* 38 */  array(5),
  452.         /* 39 */  array(1),
  453.         /* 40 */  array(),
  454.         /* 41 */  array(),
  455.         /* 42 */  array(),
  456.         /* 43 */  array(),
  457.         /* 44 */  array(),
  458.         /* 45 */  array(),
  459.         /* 46 */  array(),
  460.         /* 47 */  array(),
  461.         /* 48 */  array(),
  462.         /* 49 */  array(),
  463.         /* 50 */  array(),
  464.         /* 51 */  array(),
  465.         /* 52 */  array(),
  466.         /* 53 */  array(),
  467.         /* 54 */  array(),
  468.         /* 55 */  array(),
  469.         /* 56 */  array(),
  470.         /* 57 */  array(),
  471.         /* 58 */  array(),
  472.         /* 59 */  array(),
  473.         /* 60 */  array(),
  474. );
  475.     static public $yy_default array(
  476.  /*     0 */        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
  477.  /*    10 */        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
  478.  /*    20 */        92,   92,   64,   62,   92,   65,   63,   72,   73,   92,
  479.  /*    30 */        67,   75,   92,   74,   92,   92,   92,   92,   92,   78,
  480.  /*    40 */        88,   89,   86,   70,   83,   69,   68,   80,   91,   71,
  481.  /*    50 */        84,   79,   61,   77,   76,   82,   81,   87,   85,   66,
  482.  /*    60 */        90,
  483. );
  484. /* The next thing included is series of defines which control
  485. ** various aspects of the generated parser.
  486. **    YYCODETYPE         is the data type used for storing terminal
  487. **                       and nonterminal numbers.  "unsigned char" is
  488. **                       used if there are fewer than 250 terminals
  489. **                       and nonterminals.  "int" is used otherwise.
  490. **    YYNOCODE           is a number of type YYCODETYPE which corresponds
  491. **                       to no legal terminal or nonterminal number.  This
  492. **                       number is used to fill in empty slots of the hash 
  493. **                       table.
  494. **    YYFALLBACK         If defined, this indicates that one or more tokens
  495. **                       have fall-back values which should be used if the
  496. **                       original value of the token will not parse.
  497. **    YYACTIONTYPE       is the data type used for storing terminal
  498. **                       and nonterminal numbers.  "unsigned char" is
  499. **                       used if there are fewer than 250 rules and
  500. **                       states combined.  "int" is used otherwise.
  501. **    PHP_LexerGenerator_ParserTOKENTYPE     is the data type used for minor tokens given 
  502. **                       directly to the parser from the tokenizer.
  503. **    YYMINORTYPE        is the data type used for all minor tokens.
  504. **                       This is typically a union of many types, one of
  505. **                       which is PHP_LexerGenerator_ParserTOKENTYPE.  The entry in the union
  506. **                       for base tokens is called "yy0".
  507. **    YYSTACKDEPTH       is the maximum depth of the parser's stack.
  508. **    PHP_LexerGenerator_ParserARG_DECL      A global declaration for the %extra_argument
  509. **    YYNSTATE           the combined number of states.
  510. **    YYNRULE            the number of rules in the grammar
  511. **    YYERRORSYMBOL      is the code number of the error symbol.  If not
  512. **                       defined, then do no error processing.
  513. */
  514.     const YYNOCODE 21;
  515.     const YYSTACKDEPTH 100;
  516.     const PHP_LexerGenerator_ParserARG_DECL '0';
  517.     const YYNSTATE 61;
  518.     const YYNRULE 31;
  519.     const YYERRORSYMBOL 9;
  520.     const YYERRSYMDT 'yy0';
  521.     const YYFALLBACK 0;
  522.     /** The next table maps tokens into fallback tokens.  If a construct
  523.      * like the following:
  524.      * 
  525.      *      %fallback ID X Y Z.
  526.      *
  527.      * appears in the grammer, then ID becomes a fallback token for X, Y,
  528.      * and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
  529.      * but it does not parse, the type of the token is changed to ID and
  530.      * the parse is retried before an error is thrown.
  531.      */
  532.     static public $yyFallback array(
  533.     );
  534.     /**
  535.      * Turn parser tracing on by giving a stream to which to write the trace
  536.      * and a prompt to preface each trace message.  Tracing is turned off
  537.      * by making either argument NULL
  538.      *
  539.      * Inputs:
  540.      * 
  541.      * - A stream resource to which trace output should be written.
  542.      *   If NULL, then tracing is turned off.
  543.      * - A prefix string written at the beginning of every
  544.      *   line of trace output.  If NULL, then tracing is
  545.      *   turned off.
  546.      *
  547.      * Outputs:
  548.      * 
  549.      * - None.
  550.      * @param resource 
  551.      * @param string 
  552.      */
  553.     static function Trace($TraceFILE$zTracePrompt)
  554.     {
  555.         if (!$TraceFILE{
  556.             $zTracePrompt 0;
  557.         elseif (!$zTracePrompt{
  558.             $TraceFILE 0;
  559.         }
  560.         self::$yyTraceFILE $TraceFILE;
  561.         self::$yyTracePrompt $zTracePrompt;
  562.     }
  563.  
  564.     static function PrintTrace()
  565.     {
  566.         self::$yyTraceFILE fopen('php://output''w');
  567.         self::$yyTracePrompt '';
  568.     }
  569.  
  570.     static public $yyTraceFILE;
  571.     static public $yyTracePrompt;
  572.     /**
  573.      * @var int 
  574.      */
  575.     public $yyidx;                    /* Index of top element in stack */
  576.     /**
  577.      * @var int 
  578.      */
  579.     public $yyerrcnt;                 /* Shifts left before out of the error */
  580.     //public $???????;      /* A place to hold %extra_argument - dynamically added */
  581.     /**
  582.      * @var array 
  583.      */
  584.     public $yystack array();  /* The parser's stack */
  585.  
  586.     /**
  587.      * For tracing shifts, the names of all terminals and nonterminals
  588.      * are required.  The following table supplies these names
  589.      * @var array 
  590.      */
  591.     static public $yyTokenName array
  592.   '$',             'PHPCODE',       'COMMENTSTART',  'COMMENTEND',  
  593.   'PI',            'SUBPATTERN',    'CODE',          'PATTERN',     
  594.   'QUOTE',         'error',         'start',         'lexfile',     
  595.   'declare',       'rules',         'declarations',  'processing_instructions',
  596.   'pattern_declarations',  'subpattern',    'rule',          'rule_subpattern',
  597.     );
  598.  
  599.     /**
  600.      * For tracing reduce actions, the names of all rules are required.
  601.      * @var array 
  602.      */
  603.     static public $yyRuleName array(
  604.  /*   0 */  "start ::= lexfile",
  605.  /*   1 */  "lexfile ::= declare rules",
  606.  /*   2 */  "lexfile ::= declare PHPCODE rules",
  607.  /*   3 */  "lexfile ::= PHPCODE declare rules",
  608.  /*   4 */  "lexfile ::= PHPCODE declare PHPCODE rules",
  609.  /*   5 */  "declare ::= COMMENTSTART declarations COMMENTEND",
  610.  /*   6 */  "declarations ::= processing_instructions pattern_declarations",
  611.  /*   7 */  "processing_instructions ::= PI SUBPATTERN",
  612.  /*   8 */  "processing_instructions ::= PI CODE",
  613.  /*   9 */  "processing_instructions ::= processing_instructions PI SUBPATTERN",
  614.  /*  10 */  "processing_instructions ::= processing_instructions PI CODE",
  615.  /*  11 */  "pattern_declarations ::= PATTERN subpattern",
  616.  /*  12 */  "pattern_declarations ::= pattern_declarations PATTERN subpattern",
  617.  /*  13 */  "rules ::= COMMENTSTART rule COMMENTEND",
  618.  /*  14 */  "rules ::= COMMENTSTART PI SUBPATTERN rule COMMENTEND",
  619.  /*  15 */  "rules ::= COMMENTSTART rule COMMENTEND PHPCODE",
  620.  /*  16 */  "rules ::= COMMENTSTART PI SUBPATTERN rule COMMENTEND PHPCODE",
  621.  /*  17 */  "rules ::= rules COMMENTSTART rule COMMENTEND",
  622.  /*  18 */  "rules ::= rules PI SUBPATTERN COMMENTSTART rule COMMENTEND",
  623.  /*  19 */  "rules ::= rules COMMENTSTART rule COMMENTEND PHPCODE",
  624.  /*  20 */  "rules ::= rules COMMENTSTART PI SUBPATTERN rule COMMENTEND PHPCODE",
  625.  /*  21 */  "rule ::= rule_subpattern CODE",
  626.  /*  22 */  "rule ::= rule rule_subpattern CODE",
  627.  /*  23 */  "rule_subpattern ::= QUOTE",
  628.  /*  24 */  "rule_subpattern ::= SUBPATTERN",
  629.  /*  25 */  "rule_subpattern ::= rule_subpattern QUOTE",
  630.  /*  26 */  "rule_subpattern ::= rule_subpattern SUBPATTERN",
  631.  /*  27 */  "subpattern ::= QUOTE",
  632.  /*  28 */  "subpattern ::= SUBPATTERN",
  633.  /*  29 */  "subpattern ::= subpattern QUOTE",
  634.  /*  30 */  "subpattern ::= subpattern SUBPATTERN",
  635.     );
  636.  
  637.     /**
  638.      * This function returns the symbolic name associated with a token
  639.      * value.
  640.      * @param int 
  641.      * @return string 
  642.      */
  643.     function tokenName($tokenType)
  644.     {
  645.         if ($tokenType && $tokenType count(self::$yyTokenName)) {
  646.             return self::$yyTokenName[$tokenType];
  647.         else {
  648.             return "Unknown";
  649.         }
  650.     }
  651.  
  652.     /* The following function deletes the value associated with a
  653.     ** symbol.  The symbol can be either a terminal or nonterminal.
  654.     ** "yymajor" is the symbol code, and "yypminor" is a pointer to
  655.     ** the value.
  656.     */
  657.     static function yy_destructor($yymajor$yypminor)
  658.     {
  659.         switch ($yymajor{
  660.         /* Here is inserted the actions which take place when a
  661.         ** terminal or non-terminal is destroyed.  This can happen
  662.         ** when the symbol is popped from the stack during a
  663.         ** reduce or during error processing or when a parser is 
  664.         ** being destroyed before it is finished parsing.
  665.         **
  666.         ** Note: during a reduce, the only symbols destroyed are those
  667.         ** which appear on the RHS of the rule, but which are not used
  668.         ** inside the C code.
  669.         */
  670.             default:  break;   /* If no destructor action specified: do nothing */
  671.         }
  672.     }
  673.  
  674.     /**
  675.      * Pop the parser's stack once.
  676.      *
  677.      * If there is a destructor routine associated with the token which
  678.      * is popped from the stack, then call it.
  679.      *
  680.      * Return the major token number for the symbol popped.
  681.      * @param PHP_LexerGenerator_ParseryyParser 
  682.      * @return int 
  683.      */
  684.     function yy_pop_parser_stack()
  685.     {
  686.         if (!count($this->yystack)) {
  687.             return;
  688.         }
  689.         $yytos array_pop($this->yystack);
  690.         if (self::$yyTraceFILE && $this->yyidx >= 0{
  691.             fwrite(self::$yyTraceFILE,
  692.                 self::$yyTracePrompt 'Popping ' self::$yyTokenName[$yytos->major.
  693.                     "\n");
  694.         }
  695.         $yymajor $yytos->major;
  696.         self::yy_destructor($yymajor$yytos->minor);
  697.         $this->yyidx--;
  698.         return $yymajor;
  699.     }
  700.  
  701.     /**
  702.      * Deallocate and destroy a parser.  Destructors are all called for
  703.      * all stack elements before shutting the parser down.
  704.      */
  705.     function __destruct()
  706.     {
  707.         while ($this->yyidx >= 0{
  708.             $this->yy_pop_parser_stack();
  709.         }
  710.         if (is_resource(self::$yyTraceFILE)) {
  711.             fclose(self::$yyTraceFILE);
  712.         }
  713.     }
  714.  
  715.     function yy_get_expected_tokens($token)
  716.     {
  717.         $state $this->yystack[$this->yyidx]->stateno;
  718.         $expected self::$yyExpectedTokens[$state];
  719.         if (in_array($tokenself::$yyExpectedTokens[$state]true)) {
  720.             return $expected;
  721.         }
  722.         $stack $this->yystack;
  723.         $yyidx $this->yyidx;
  724.         do {
  725.             $yyact $this->yy_find_shift_action($token);
  726.             if ($yyact >= self::YYNSTATE && $yyact self::YYNSTATE self::YYNRULE{
  727.                 // reduce action
  728.                 $done 0;
  729.                 do {
  730.                     if ($done++ == 100{
  731.                         $this->yyidx $yyidx;
  732.                         $this->yystack $stack;
  733.                         // too much recursion prevents proper detection
  734.                         // so give up
  735.                         return array_unique($expected);
  736.                     }
  737.                     $yyruleno $yyact self::YYNSTATE;
  738.                     $this->yyidx -= self::$yyRuleInfo[$yyruleno]['rhs'];
  739.                     $nextstate $this->yy_find_reduce_action(
  740.                         $this->yystack[$this->yyidx]->stateno,
  741.                         self::$yyRuleInfo[$yyruleno]['lhs']);
  742.                     if (isset(self::$yyExpectedTokens[$nextstate])) {
  743.                         $expected += self::$yyExpectedTokens[$nextstate];
  744.                             if (in_array($token,
  745.                                   self::$yyExpectedTokens[$nextstate]true)) {
  746.                             $this->yyidx $yyidx;
  747.                             $this->yystack $stack;
  748.                             return array_unique($expected);
  749.                         }
  750.                     }
  751.                     if ($nextstate self::YYNSTATE{
  752.                         // we need to shift a non-terminal
  753.                         $this->yyidx++;
  754.                         $x new PHP_LexerGenerator_ParseryyStackEntry;
  755.                         $x->stateno $nextstate;
  756.                         $x->major self::$yyRuleInfo[$yyruleno]['lhs'];
  757.                         $this->yystack[$this->yyidx$x;
  758.                         continue 2;
  759.                     elseif ($nextstate == self::YYNSTATE self::YYNRULE 1{
  760.                         $this->yyidx $yyidx;
  761.                         $this->yystack $stack;
  762.                         // the last token was just ignored, we can't accept
  763.                         // by ignoring input, this is in essence ignoring a
  764.                         // syntax error!
  765.                         return array_unique($expected);
  766.                     elseif ($nextstate === self::YY_NO_ACTION{
  767.                         $this->yyidx $yyidx;
  768.                         $this->yystack $stack;
  769.                         // input accepted, but not shifted (I guess)
  770.                         return $expected;
  771.                     else {
  772.                         $yyact $nextstate;
  773.                     }
  774.                 while (true);
  775.             }
  776.             break;
  777.         while (true);
  778.         return array_unique($expected);
  779.     }
  780.  
  781.     function yy_is_expected_token($token)
  782.     {
  783.         $state $this->yystack[$this->yyidx]->stateno;
  784.         if (in_array($tokenself::$yyExpectedTokens[$state]true)) {
  785.             return true;
  786.         }
  787.         $stack $this->yystack;
  788.         $yyidx $this->yyidx;
  789.         do {
  790.             $yyact $this->yy_find_shift_action($token);
  791.             if ($yyact >= self::YYNSTATE && $yyact self::YYNSTATE self::YYNRULE{
  792.                 // reduce action
  793.                 $done 0;
  794.                 do {
  795.                     if ($done++ == 100{
  796.                         $this->yyidx $yyidx;
  797.                         $this->yystack $stack;
  798.                         // too much recursion prevents proper detection
  799.                         // so give up
  800.                         return true;
  801.                     }
  802.                     $yyruleno $yyact self::YYNSTATE;
  803.                     $this->yyidx -= self::$yyRuleInfo[$yyruleno]['rhs'];
  804.                     $nextstate $this->yy_find_reduce_action(
  805.                         $this->yystack[$this->yyidx]->stateno,
  806.                         self::$yyRuleInfo[$yyruleno]['lhs']);
  807.                     if (isset(self::$yyExpectedTokens[$nextstate]&&
  808.                           in_array($tokenself::$yyExpectedTokens[$nextstate]true)) {
  809.                         $this->yyidx $yyidx;
  810.                         $this->yystack $stack;
  811.                         return true;
  812.                     }
  813.                     if ($nextstate self::YYNSTATE{
  814.                         // we need to shift a non-terminal
  815.                         $this->yyidx++;
  816.                         $x new PHP_LexerGenerator_ParseryyStackEntry;
  817.                         $x->stateno $nextstate;
  818.                         $x->major self::$yyRuleInfo[$yyruleno]['lhs'];
  819.                         $this->yystack[$this->yyidx$x;
  820.                         continue 2;
  821.                     elseif ($nextstate == self::YYNSTATE self::YYNRULE 1{
  822.                         $this->yyidx $yyidx;
  823.                         $this->yystack $stack;
  824.                         if (!$token{
  825.                             // end of input: this is valid
  826.                             return true;
  827.                         }
  828.                         // the last token was just ignored, we can't accept
  829.                         // by ignoring input, this is in essence ignoring a
  830.                         // syntax error!
  831.                         return false;
  832.                     elseif ($nextstate === self::YY_NO_ACTION{
  833.                         $this->yyidx $yyidx;
  834.                         $this->yystack $stack;
  835.                         // input accepted, but not shifted (I guess)
  836.                         return true;
  837.                     else {
  838.                         $yyact $nextstate;
  839.                     }
  840.                 while (true);
  841.             }
  842.             break;
  843.         while (true);
  844.         return true;
  845.     }
  846.  
  847.     /**
  848.      * Find the appropriate action for a parser given the terminal
  849.      * look-ahead token iLookAhead.
  850.      *
  851.      * If the look-ahead token is YYNOCODE, then check to see if the action is
  852.      * independent of the look-ahead.  If it is, return the action, otherwise
  853.      * return YY_NO_ACTION.
  854.      * @param int The look-ahead token
  855.      */
  856.     function yy_find_shift_action($iLookAhead)
  857.     {
  858.         $stateno $this->yystack[$this->yyidx]->stateno;
  859.      
  860.         /* if ($this->yyidx < 0) return self::YY_NO_ACTION;  */
  861.         if (!isset(self::$yy_shift_ofst[$stateno])) {
  862.             // no shift actions
  863.             return self::$yy_default[$stateno];
  864.         }
  865.         $i self::$yy_shift_ofst[$stateno];
  866.         if ($i === self::YY_SHIFT_USE_DFLT{
  867.             return self::$yy_default[$stateno];
  868.         }
  869.         if ($iLookAhead == self::YYNOCODE{
  870.             return self::YY_NO_ACTION;
  871.         }
  872.         $i += $iLookAhead;
  873.         if ($i || $i >= self::YY_SZ_ACTTAB ||
  874.               self::$yy_lookahead[$i!= $iLookAhead{
  875.             if (count(self::$yyFallback&& $iLookAhead count(self::$yyFallback)
  876.                    && ($iFallback self::$yyFallback[$iLookAhead]!= 0{
  877.                 if (self::$yyTraceFILE{
  878.                     fwrite(self::$yyTraceFILEself::$yyTracePrompt "FALLBACK " .
  879.                         self::$yyTokenName[$iLookAhead" => " .
  880.                         self::$yyTokenName[$iFallback"\n");
  881.                 }
  882.                 return $this->yy_find_shift_action($iFallback);
  883.             }
  884.             return self::$yy_default[$stateno];
  885.         else {
  886.             return self::$yy_action[$i];
  887.         }
  888.     }
  889.  
  890.     /**
  891.      * Find the appropriate action for a parser given the non-terminal
  892.      * look-ahead token iLookAhead.
  893.      *
  894.      * If the look-ahead token is YYNOCODE, then check to see if the action is
  895.      * independent of the look-ahead.  If it is, return the action, otherwise
  896.      * return YY_NO_ACTION.
  897.      * @param int Current state number
  898.      * @param int The look-ahead token
  899.      */
  900.     function yy_find_reduce_action($stateno$iLookAhead)
  901.     {
  902.         /* $stateno = $this->yystack[$this->yyidx]->stateno; */
  903.  
  904.         if (!isset(self::$yy_reduce_ofst[$stateno])) {
  905.             return self::$yy_default[$stateno];
  906.         }
  907.         $i self::$yy_reduce_ofst[$stateno];
  908.         if ($i == self::YY_REDUCE_USE_DFLT{
  909.             return self::$yy_default[$stateno];
  910.         }
  911.         if ($iLookAhead == self::YYNOCODE{
  912.             return self::YY_NO_ACTION;
  913.         }
  914.         $i += $iLookAhead;
  915.         if ($i || $i >= self::YY_SZ_ACTTAB ||
  916.               self::$yy_lookahead[$i!= $iLookAhead{
  917.             return self::$yy_default[$stateno];
  918.         else {
  919.             return self::$yy_action[$i];
  920.         }
  921.     }
  922.  
  923.     /**
  924.      * Perform a shift action.
  925.      * @param int The new state to shift in
  926.      * @param int The major token to shift in
  927.      * @param mixed the minor token to shift in
  928.      */
  929.     function yy_shift($yyNewState$yyMajor$yypMinor)
  930.     {
  931.         $this->yyidx++;
  932.         if ($this->yyidx >= self::YYSTACKDEPTH{
  933.             $this->yyidx--;
  934.             if (self::$yyTraceFILE{
  935.                 fprintf(self::$yyTraceFILE"%sStack Overflow!\n"self::$yyTracePrompt);
  936.             }
  937.             while ($this->yyidx >= 0{
  938.                 $this->yy_pop_parser_stack();
  939.             }
  940.             /* Here code is inserted which will execute if the parser
  941.             ** stack ever overflows */
  942.             return;
  943.         }
  944.         $yytos new PHP_LexerGenerator_ParseryyStackEntry;
  945.         $yytos->stateno $yyNewState;
  946.         $yytos->major $yyMajor;
  947.         $yytos->minor $yypMinor;
  948.         array_push($this->yystack$yytos);
  949.         if (self::$yyTraceFILE && $this->yyidx 0{
  950.             fprintf(self::$yyTraceFILE"%sShift %d\n"self::$yyTracePrompt,
  951.                 $yyNewState);
  952.             fprintf(self::$yyTraceFILE"%sStack:"self::$yyTracePrompt);
  953.             for($i 1$i <= $this->yyidx$i++{
  954.                 fprintf(self::$yyTraceFILE" %s",
  955.                     self::$yyTokenName[$this->yystack[$i]->major]);
  956.             }
  957.             fwrite(self::$yyTraceFILE,"\n");
  958.         }
  959.     }
  960.  
  961.     /**
  962.      * The following table contains information about every rule that
  963.      * is used during the reduce.
  964.      *
  965.      * static const struct {
  966.      *  YYCODETYPE lhs;         Symbol on the left-hand side of the rule
  967.      *  unsigned char nrhs;     Number of right-hand side symbols in the rule
  968.      * }
  969.      */
  970.     static public $yyRuleInfo array(
  971.   array'lhs' => 10'rhs' => ),
  972.   array'lhs' => 11'rhs' => ),
  973.   array'lhs' => 11'rhs' => ),
  974.   array'lhs' => 11'rhs' => ),
  975.   array'lhs' => 11'rhs' => ),
  976.   array'lhs' => 12'rhs' => ),
  977.   array'lhs' => 14'rhs' => ),
  978.   array'lhs' => 15'rhs' => ),
  979.   array'lhs' => 15'rhs' => ),
  980.   array'lhs' => 15'rhs' => ),
  981.   array'lhs' => 15'rhs' => ),
  982.   array'lhs' => 16'rhs' => ),
  983.   array'lhs' => 16'rhs' => ),
  984.   array'lhs' => 13'rhs' => ),
  985.   array'lhs' => 13'rhs' => ),
  986.   array'lhs' => 13'rhs' => ),
  987.   array'lhs' => 13'rhs' => ),
  988.   array'lhs' => 13'rhs' => ),
  989.   array'lhs' => 13'rhs' => ),
  990.   array'lhs' => 13'rhs' => ),
  991.   array'lhs' => 13'rhs' => ),
  992.   array'lhs' => 18'rhs' => ),
  993.   array'lhs' => 18'rhs' => ),
  994.   array'lhs' => 19'rhs' => ),
  995.   array'lhs' => 19'rhs' => ),
  996.   array'lhs' => 19'rhs' => ),
  997.   array'lhs' => 19'rhs' => ),
  998.   array'lhs' => 17'rhs' => ),
  999.   array'lhs' => 17'rhs' => ),
  1000.   array'lhs' => 17'rhs' => ),
  1001.   array'lhs' => 17'rhs' => ),
  1002.     );
  1003.  
  1004.     /**
  1005.      * The following table contains a mapping of reduce action to method name
  1006.      * that handles the reduction.
  1007.      * 
  1008.      * If a rule is not set, it has no handler.
  1009.      */
  1010.     static public $yyReduceMap array(
  1011.         => 1,
  1012.         => 2,
  1013.         => 3,
  1014.         => 4,
  1015.         => 5,
  1016.         => 6,
  1017.         => 7,
  1018.         => 7,
  1019.         => 9,
  1020.         10 => 9,
  1021.         11 => 11,
  1022.         12 => 12,
  1023.         13 => 13,
  1024.         14 => 14,
  1025.         15 => 15,
  1026.         16 => 16,
  1027.         17 => 17,
  1028.         18 => 18,
  1029.         19 => 19,
  1030.         20 => 20,
  1031.         21 => 21,
  1032.         22 => 22,
  1033.         23 => 23,
  1034.         27 => 23,
  1035.         24 => 24,
  1036.         25 => 25,
  1037.         29 => 25,
  1038.         26 => 26,
  1039.         28 => 28,
  1040.         30 => 30,
  1041.     );
  1042.     /* Beginning here are the reduction cases.  A typical example
  1043.     ** follows:
  1044.     **  #line <lineno> <grammarfile>
  1045.     **   function yy_r0($yymsp){ ... }           // User supplied code
  1046.     **  #line <lineno> <thisfile>
  1047.     */
  1048. #line 212 "LexerGenerator\Parser.y"
  1049.         function yy_r1(){
  1050.     fwrite($this->out'
  1051.     private $_yy_state = 1;
  1052.     private $_yy_stack = array();
  1053.  
  1054.     function yylex()
  1055.     {
  1056.         return $this->{\'yylex\' . $this->_yy_state}();
  1057.     }
  1058.  
  1059.     function yypushstate($state)
  1060.     {
  1061.         array_push($this->_yy_stack, $this->_yy_state);
  1062.         $this->_yy_state = $state;
  1063.     }
  1064.  
  1065.     function yypopstate()
  1066.     {
  1067.         $this->_yy_state = array_pop($this->_yy_stack);
  1068.     }
  1069.  
  1070.     function yybegin($state)
  1071.     {
  1072.         $this->_yy_state = $state;
  1073.     }
  1074.  
  1075. ');
  1076.     foreach ($this->yystack[$this->yyidx 0]->minor as $rule{
  1077.         $this->outputRules($rule['rules']$rule['statename']);
  1078.         if ($rule['code']{
  1079.             fwrite($this->out$rule['code']);
  1080.         }
  1081.     }
  1082.     }
  1083. #line 1088 "LexerGenerator\Parser.php"
  1084. #line 246 "LexerGenerator\Parser.y"
  1085.         function yy_r2(){
  1086.     fwrite($this->out'
  1087.     private $_yy_state = 1;
  1088.     private $_yy_stack = array();
  1089.  
  1090.     function yylex()
  1091.     {
  1092.         return $this->{\'yylex\' . $this->_yy_state}();
  1093.     }
  1094.  
  1095.     function yypushstate($state)
  1096.     {
  1097.         array_push($this->_yy_stack, $this->_yy_state);
  1098.         $this->_yy_state = $state;
  1099.     }
  1100.  
  1101.     function yypopstate()
  1102.     {
  1103.         $this->_yy_state = array_pop($this->_yy_stack);
  1104.     }
  1105.  
  1106.     function yybegin($state)
  1107.     {
  1108.         $this->_yy_state = $state;
  1109.     }
  1110.  
  1111. ');
  1112.     if (strlen($this->yystack[$this->yyidx + -1]->minor)) {
  1113.         fwrite($this->out$this->yystack[$this->yyidx + -1]->minor);
  1114.     }
  1115.     foreach ($this->yystack[$this->yyidx 0]->minor as $rule{
  1116.         $this->outputRules($rule['rules']$rule['statename']);
  1117.         if ($rule['code']{
  1118.             fwrite($this->out$rule['code']);
  1119.         }
  1120.     }
  1121.     }
  1122. #line 1127 "LexerGenerator\Parser.php"
  1123. #line 283 "LexerGenerator\Parser.y"
  1124.         function yy_r3(){
  1125.     if (strlen($this->yystack[$this->yyidx + -2]->minor)) {
  1126.         fwrite($this->out$this->yystack[$this->yyidx + -2]->minor);
  1127.     }
  1128.     fwrite($this->out'
  1129.     private $_yy_state = 1;
  1130.     private $_yy_stack = array();
  1131.  
  1132.     function yylex()
  1133.     {
  1134.         return $this->{\'yylex\' . $this->_yy_state}();
  1135.     }
  1136.  
  1137.     function yypushstate($state)
  1138.     {
  1139.         array_push($this->_yy_stack, $this->_yy_state);
  1140.         $this->_yy_state = $state;
  1141.     }
  1142.  
  1143.     function yypopstate()
  1144.     {
  1145.         $this->_yy_state = array_pop($this->_yy_stack);
  1146.     }
  1147.  
  1148.     function yybegin($state)
  1149.     {
  1150.         $this->_yy_state = $state;
  1151.     }
  1152.  
  1153. ');
  1154.     foreach ($this->yystack[$this->yyidx 0]->minor as $rule{
  1155.         $this->outputRules($rule['rules']$rule['statename']);
  1156.         if ($rule['code']{
  1157.             fwrite($this->out$rule['code']);
  1158.         }
  1159.     }
  1160.     }
  1161. #line 1166 "LexerGenerator\Parser.php"
  1162. #line 320 "LexerGenerator\Parser.y"
  1163.         function yy_r4(){
  1164.     if (strlen($this->yystack[$this->yyidx + -3]->minor)) {
  1165.         fwrite($this->out$this->yystack[$this->yyidx + -3]->minor);
  1166.     }
  1167.     fwrite($this->out'
  1168.     private $_yy_state = 1;
  1169.     private $_yy_stack = array();
  1170.  
  1171.     function yylex()
  1172.     {
  1173.         return $this->{\'yylex\' . $this->_yy_state}();
  1174.     }
  1175.  
  1176.     function yypushstate($state)
  1177.     {
  1178.         array_push($this->_yy_stack, $this->_yy_state);
  1179.         $this->_yy_state = $state;
  1180.     }
  1181.  
  1182.     function yypopstate()
  1183.     {
  1184.         $this->_yy_state = array_pop($this->_yy_stack);
  1185.     }
  1186.  
  1187.     function yybegin($state)
  1188.     {
  1189.         $this->_yy_state = $state;
  1190.     }
  1191.  
  1192. ');
  1193.     if (strlen($this->yystack[$this->yyidx + -1]->minor)) {
  1194.         fwrite($this->out$this->yystack[$this->yyidx + -1]->minor);
  1195.     }
  1196.     foreach ($this->yystack[$this->yyidx 0]->minor as $rule{
  1197.         $this->outputRules($rule['rules']$rule['statename']);
  1198.         if ($rule['code']{
  1199.             fwrite($this->out$rule['code']);
  1200.         }
  1201.     }
  1202.     }
  1203. #line 1208 "LexerGenerator\Parser.php"
  1204. #line 361 "LexerGenerator\Parser.y"
  1205.         function yy_r5(){
  1206.     $this->_retvalue $this->yystack[$this->yyidx + -1]->minor;
  1207.     $this->patterns $this->yystack[$this->yyidx + -1]->minor['patterns'];
  1208.     }
  1209. #line 1214 "LexerGenerator\Parser.php"
  1210. #line 366 "LexerGenerator\Parser.y"
  1211.         function yy_r6(){
  1212.     $expected array(
  1213.         'counter' => true,
  1214.         'input' => true,
  1215.         'token' => true,
  1216.         'value' => true,
  1217.         'line' => true,
  1218.     );
  1219.     foreach ($this->yystack[$this->yyidx + -1]->minor as $pi{
  1220.         if (isset($expected[$pi['pi']])) {
  1221.             unset($expected[$pi['pi']]);
  1222.             continue;
  1223.         }
  1224.         if (count($expected)) {
  1225.             throw new Exception('Processing Instructions "' .
  1226.                 implode(', 'array_keys($expected)) '" must be defined');
  1227.         }
  1228.     }
  1229.     $expected array(
  1230.         'counter' => true,
  1231.         'input' => true,
  1232.         'token' => true,
  1233.         'value' => true,
  1234.         'line' => true,
  1235.     );
  1236.     foreach ($this->yystack[$this->yyidx + -1]->minor as $pi{
  1237.         if (isset($expected[$pi['pi']])) {
  1238.             $this->{$pi['pi']$pi['definition'];
  1239.             continue;
  1240.         }
  1241.         $this->error('Unknown processing instruction %' $pi['pi'.
  1242.             ', should be one of "' implode(', 'array_keys($expected)) '"');
  1243.     }
  1244.     $this->_retvalue array('patterns' => $this->yystack[$this->yyidx 0]->minor'pis' => $this->yystack[$this->yyidx + -1]->minor);
  1245.     }
  1246. #line 1251 "LexerGenerator\Parser.php"
  1247. #line 402 "LexerGenerator\Parser.y"
  1248.         function yy_r7(){
  1249.     $this->_retvalue array(array('pi' => $this->yystack[$this->yyidx + -1]->minor'definition' => $this->yystack[$this->yyidx 0]->minor));
  1250.     }
  1251. #line 1256 "LexerGenerator\Parser.php"
  1252. #line 408 "LexerGenerator\Parser.y"
  1253.         function yy_r9(){
  1254.     $this->_retvalue $this->yystack[$this->yyidx + -2]->minor;
  1255.     $this->_retvalue[array('pi' => $this->yystack[$this->yyidx + -1]->minor'definition' => $this->yystack[$this->yyidx 0]->minor);
  1256.     }
  1257. #line 1262 "LexerGenerator\Parser.php"
  1258. #line 417 "LexerGenerator\Parser.y"
  1259.         function yy_r11(){
  1260.     $this->_retvalue array($this->yystack[$this->yyidx + -1]->minor => $this->yystack[$this->yyidx 0]->minor);
  1261.     }
  1262. #line 1267 "LexerGenerator\Parser.php"
  1263. #line 420 "LexerGenerator\Parser.y"
  1264.         function yy_r12(){
  1265.     $this->_retvalue $this->yystack[$this->yyidx + -2]->minor;
  1266.     if (isset($this->_retvalue[$this->yystack[$this->yyidx + -1]->minor])) {
  1267.         throw new Exception('Pattern "' $this->yystack[$this->yyidx + -1]->minor '" is already defined as "' .
  1268.             $this->_retvalue[$this->yystack[$this->yyidx + -1]->minor'", cannot redefine as "' $this->yystack[$this->yyidx 0]->minor '"');
  1269.     }
  1270.     $this->_retvalue[$this->yystack[$this->yyidx + -1]->minor$this->yystack[$this->yyidx 0]->minor;
  1271.     }
  1272. #line 1277 "LexerGenerator\Parser.php"
  1273. #line 429 "LexerGenerator\Parser.y"
  1274.         function yy_r13(){
  1275.     $this->_retvalue array(array('rules' => $this->yystack[$this->yyidx + -1]->minor'code' => '''statename' => ''));
  1276.     }
  1277. #line 1282 "LexerGenerator\Parser.php"
  1278. #line 432 "LexerGenerator\Parser.y"
  1279.         function yy_r14(){
  1280.     if ($this->yystack[$this->yyidx + -3]->minor != 'statename'{
  1281.         throw new Exception('Error: only %statename processing instruction ' .
  1282.             'is allowed in rule sections');
  1283.     }
  1284.     $this->_retvalue array(array('rules' => $this->yystack[$this->yyidx + -1]->minor'code' => '''statename' => $this->yystack[$this->yyidx + -2]->minor));
  1285.     }
  1286. #line 1291 "LexerGenerator\Parser.php"
  1287. #line 439 "LexerGenerator\Parser.y"
  1288.         function yy_r15(){
  1289.     $this->_retvalue array(array('rules' => $this->yystack[$this->yyidx + -2]->minor'code' => $this->yystack[$this->yyidx 0]->minor'statename' => ''));
  1290.     }
  1291. #line 1296 "LexerGenerator\Parser.php"
  1292. #line 442 "LexerGenerator\Parser.y"
  1293.         function yy_r16(){
  1294.     if ($this->yystack[$this->yyidx + -4]->minor != 'statename'{
  1295.         throw new Exception('Error: only %statename processing instruction ' .
  1296.             'is allowed in rule sections');
  1297.     }
  1298.     $this->_retvalue array(array('rules' => $this->yystack[$this->yyidx + -2]->minor'code' => $this->yystack[$this->yyidx 0]->minor'statename' => $this->yystack[$this->yyidx + -3]->minor));
  1299.     }
  1300. #line 1305 "LexerGenerator\Parser.php"
  1301. #line 449 "LexerGenerator\Parser.y"
  1302.         function yy_r17(){
  1303.     $this->_retvalue $this->yystack[$this->yyidx + -3]->minor;
  1304.     $this->_retvalue[array('rules' => $this->yystack[$this->yyidx + -1]->minor'code' => '''statename' => '');
  1305.     }
  1306. #line 1311 "LexerGenerator\Parser.php"
  1307. #line 453 "LexerGenerator\Parser.y"
  1308.         function yy_r18(){
  1309.     if ($this->yystack[$this->yyidx + -4]->minor != 'statename'{
  1310.         throw new Exception('Error: only %statename processing instruction ' .
  1311.             'is allowed in rule sections');
  1312.     }
  1313.     $this->_retvalue $this->yystack[$this->yyidx + -5]->minor;
  1314.     $this->_retvalue[array('rules' => $this->yystack[$this->yyidx + -1]->minor'code' => '''statename' => $this->yystack[$this->yyidx + -3]->minor);
  1315.     }
  1316. #line 1321 "LexerGenerator\Parser.php"
  1317. #line 461 "LexerGenerator\Parser.y"
  1318.         function yy_r19(){
  1319.     $this->_retvalue $this->yystack[$this->yyidx + -4]->minor;
  1320.     $this->_retvalue[array('rules' => $this->yystack[$this->yyidx + -2]->minor'code' => $this->yystack[$this->yyidx 0]->minor'statename' => '');
  1321.     }
  1322. #line 1327 "LexerGenerator\Parser.php"
  1323. #line 465 "LexerGenerator\Parser.y"
  1324.         function yy_r20(){
  1325.     if ($this->yystack[$this->yyidx + -4]->minor != 'statename'{
  1326.         throw new Exception('Error: only %statename processing instruction ' .
  1327.             'is allowed in rule sections');
  1328.     }
  1329.     $this->_retvalue $this->yystack[$this->yyidx + -6]->minor;
  1330.     $this->_retvalue[array('rules' => $this->yystack[$this->yyidx + -2]->minor'code' => $this->yystack[$this->yyidx 0]->minor'statename' => $this->yystack[$this->yyidx + -3]->minor);
  1331.     }
  1332. #line 1337 "LexerGenerator\Parser.php"
  1333. #line 474 "LexerGenerator\Parser.y"
  1334.         function yy_r21(){
  1335.     $this->_retvalue array(array('pattern' => $this->yystack[$this->yyidx + -1]->minor'code' => $this->yystack[$this->yyidx 0]->minor));
  1336.     }
  1337. #line 1342 "LexerGenerator\Parser.php"
  1338. #line 477 "LexerGenerator\Parser.y"
  1339.         function yy_r22(){
  1340.     $this->_retvalue $this->yystack[$this->yyidx + -2]->minor;
  1341.     $this->_retvalue[array('pattern' => $this->yystack[$this->yyidx + -1]->minor'code' => $this->yystack[$this->yyidx 0]->minor);
  1342.     }
  1343. #line 1348 "LexerGenerator\Parser.php"
  1344. #line 482 "LexerGenerator\Parser.y"
  1345.         function yy_r23(){
  1346.     $this->_retvalue str_replace(array('\\''"')array('\\\\''\\"')preg_quote($this->yystack[$this->yyidx 0]->minor'/'));
  1347.     }
  1348. #line 1353 "LexerGenerator\Parser.php"
  1349. #line 485 "LexerGenerator\Parser.y"
  1350.         function yy_r24(){
  1351.     if (!isset($this->patterns[$this->yystack[$this->yyidx 0]->minor])) {
  1352.         $this->error('Undefined pattern "' $this->yystack[$this->yyidx 0]->minor '" used in rules');
  1353.         throw new Exception('Undefined pattern "' $this->yystack[$this->yyidx 0]->minor '" used in rules');
  1354.     }
  1355.     $this->_retvalue $this->patterns[$this->yystack[$this->yyidx 0]->minor];
  1356.     }
  1357. #line 1362 "LexerGenerator\Parser.php"
  1358. #line 492 "LexerGenerator\Parser.y"
  1359.         function yy_r25(){
  1360.     $this->_retvalue $this->yystack[$this->yyidx + -1]->minor str_replace(array('\\''"')array('\\\\''\\"')preg_quote($this->yystack[$this->yyidx 0]->minor'/'));
  1361.     }
  1362. #line 1367 "LexerGenerator\Parser.php"
  1363. #line 495 "LexerGenerator\Parser.y"
  1364.         function yy_r26(){
  1365.     if (!isset($this->patterns[$this->yystack[$this->yyidx 0]->minor])) {
  1366.         $this->error('Undefined pattern "' $this->yystack[$this->yyidx 0]->minor '" used in rules');
  1367.         throw new Exception('Undefined pattern "' $this->yystack[$this->yyidx 0]->minor '" used in rules');
  1368.     }
  1369.     $this->_retvalue $this->yystack[$this->yyidx + -1]->minor $this->patterns[$this->yystack[$this->yyidx 0]->minor];
  1370.     }
  1371. #line 1376 "LexerGenerator\Parser.php"
  1372. #line 506 "LexerGenerator\Parser.y"
  1373.         function yy_r28(){
  1374.     $this->_retvalue str_replace(array('/''\\''"')array('\\/''\\\\''\"')$this->yystack[$this->yyidx 0]->minor);
  1375.     $this->_retvalue preg_replace('/\\\\([0-7]{1,3})/''\\\1'$this->_retvalue);
  1376.     $this->_retvalue preg_replace('/\\\\(x[0-9A-Fa-f]{1,2})/''\\x\1'$this->_retvalue);
  1377.     $this->_retvalue str_replace(array('\\\\t''\\\\n''\\\\r')array('\\t''\\n''\\r')$this->_retvalue);
  1378.     $this->_validatePattern($this->_retvalue);
  1379.     }
  1380. #line 1385 "LexerGenerator\Parser.php"
  1381. #line 516 "LexerGenerator\Parser.y"
  1382.         function yy_r30(){
  1383.     $this->_retvalue str_replace(array('/''\\''"')array('\\/''\\\\''\\"')$this->yystack[$this->yyidx 0]->minor);
  1384.     $this->_retvalue preg_replace('/\\\\([0-7]{1,3})/''\\\1'$this->_retvalue);
  1385.     $this->_retvalue preg_replace('/\\\\(x[0-9A-Fa-f]{1,2})/''\\x\1'$this->_retvalue);
  1386.     $this->_retvalue str_replace(array('\\\\t''\\\\n''\\\\r')array('\\t''\\n''\\r')$this->_retvalue);
  1387.     $this->_retvalue $this->yystack[$this->yyidx + -1]->minor $this->_retvalue;
  1388.     $this->_validatePattern($this->_retvalue);
  1389.     }
  1390. #line 1395 "LexerGenerator\Parser.php"
  1391.  
  1392.     
  1393.     /**
  1394.      * placeholder for the left hand side in a reduce operation.
  1395.      * 
  1396.      * For a parser with a rule like this:
  1397.      * <pre>
  1398.      * rule(A) ::= B. { A = 1; }
  1399.      * </pre>
  1400.      * 
  1401.      * The parser will translate to something like:
  1402.      * 
  1403.      * <code>
  1404.      * function yy_r0(){$this->_retvalue = 1;}
  1405.      * </code>
  1406.      */
  1407.     private $_retvalue;
  1408.  
  1409.     /**
  1410.      * Perform a reduce action and the shift that must immediately
  1411.      * follow the reduce.
  1412.      * 
  1413.      * For a rule such as:
  1414.      * 
  1415.      * <pre>
  1416.      * A ::= B blah C. { dosomething(); }
  1417.      * </pre>
  1418.      * 
  1419.      * This function will first call the action, if any, ("dosomething();" in our
  1420.      * example), and then it will pop three states from the stack,
  1421.      * one for each entry on the right-hand side of the expression
  1422.      * (B, blah, and C in our example rule), and then push the result of the action
  1423.      * back on to the stack with the resulting state reduced to (as described in the .out
  1424.      * file)
  1425.      * @param int Number of the rule by which to reduce
  1426.      */
  1427.     function yy_reduce($yyruleno)
  1428.     {
  1429.         //int $yygoto;                     /* The next state */
  1430.         //int $yyact;                      /* The next action */
  1431.         //mixed $yygotominor;        /* The LHS of the rule reduced */
  1432.         //PHP_LexerGenerator_ParseryyStackEntry $yymsp;            /* The top of the parser's stack */
  1433.         //int $yysize;                     /* Amount to pop the stack */
  1434.         $yymsp $this->yystack[$this->yyidx];
  1435.         if (self::$yyTraceFILE && $yyruleno >= 
  1436.               && $yyruleno count(self::$yyRuleName)) {
  1437.             fprintf(self::$yyTraceFILE"%sReduce (%d) [%s].\n",
  1438.                 self::$yyTracePrompt$yyruleno,
  1439.                 self::$yyRuleName[$yyruleno]);
  1440.         }
  1441.  
  1442.         $this->_retvalue $yy_lefthand_side null;
  1443.         if (array_key_exists($yyrulenoself::$yyReduceMap)) {
  1444.             // call the action
  1445.             $this->_retvalue null;
  1446.             $this->{'yy_r' self::$yyReduceMap[$yyruleno]}();
  1447.             $yy_lefthand_side $this->_retvalue;
  1448.         }
  1449.         $yygoto self::$yyRuleInfo[$yyruleno]['lhs'];
  1450.         $yysize self::$yyRuleInfo[$yyruleno]['rhs'];
  1451.         $this->yyidx -= $yysize;
  1452.         for($i $yysize$i$i--{
  1453.             // pop all of the right-hand side parameters
  1454.             array_pop($this->yystack);
  1455.         }
  1456.         $yyact $this->yy_find_reduce_action($this->yystack[$this->yyidx]->stateno$yygoto);
  1457.         if ($yyact self::YYNSTATE{
  1458.             /* If we are not debugging and the reduce action popped at least
  1459.             ** one element off the stack, then we can push the new element back
  1460.             ** onto the stack here, and skip the stack overflow test in yy_shift().
  1461.             ** That gives a significant speed improvement. */
  1462.             if (!self::$yyTraceFILE && $yysize{
  1463.                 $this->yyidx++;
  1464.                 $x new PHP_LexerGenerator_ParseryyStackEntry;
  1465.                 $x->stateno $yyact;
  1466.                 $x->major $yygoto;
  1467.                 $x->minor $yy_lefthand_side;
  1468.                 $this->yystack[$this->yyidx$x;
  1469.             else {
  1470.                 $this->yy_shift($yyact$yygoto$yy_lefthand_side);
  1471.             }
  1472.         elseif ($yyact == self::YYNSTATE self::YYNRULE 1{
  1473.             $this->yy_accept();
  1474.         }
  1475.     }
  1476.  
  1477.     /**
  1478.      * The following code executes when the parse fails
  1479.      */
  1480.     function yy_parse_failed()
  1481.     {
  1482.         if (self::$yyTraceFILE{
  1483.             fprintf(self::$yyTraceFILE"%sFail!\n"self::$yyTracePrompt);
  1484.         }
  1485.         while ($this->yyidx >= 0{
  1486.             $this->yy_pop_parser_stack();
  1487.         }
  1488.         /* Here code is inserted which will be executed whenever the
  1489.         ** parser fails */
  1490.     }
  1491.  
  1492.     /**
  1493.      * The following code executes when a syntax error first occurs.
  1494.      * @param int The major type of the error token
  1495.      * @param mixed The minor type of the error token
  1496.      */
  1497.     function yy_syntax_error($yymajor$TOKEN)
  1498.     {
  1499. #line 40 "LexerGenerator\Parser.y"
  1500.  
  1501.     echo "Syntax Error on line " $this->lex->line ": token '" 
  1502.         $this->lex->value "' while parsing rule:";
  1503.     foreach ($this->yystack as $entry{
  1504.         echo $this->tokenName($entry->major' ';
  1505.     }
  1506.     foreach ($this->yy_get_expected_tokens($yymajoras $token{
  1507.         $expect[self::$yyTokenName[$token];
  1508.     }
  1509.     throw new Exception('Unexpected ' $this->tokenName($yymajor'(' $TOKEN
  1510.         . '), expected one of: ' implode(','$expect));
  1511. #line 1516 "LexerGenerator\Parser.php"
  1512.     }
  1513.  
  1514.     /*
  1515.     ** The following is executed when the parser accepts
  1516.     */
  1517.     function yy_accept()
  1518.     {
  1519.         if (self::$yyTraceFILE{
  1520.             fprintf(self::$yyTraceFILE"%sAccept!\n"self::$yyTracePrompt);
  1521.         }
  1522.         while ($this->yyidx >= 0{
  1523.             $stack $this->yy_pop_parser_stack();
  1524.         }
  1525.         /* Here code is inserted which will be executed whenever the
  1526.         ** parser accepts */
  1527.     }
  1528.  
  1529.     /**
  1530.      *  The main parser program.
  1531.      * The first argument is a pointer to a structure obtained from
  1532.      * "PHP_LexerGenerator_ParserAlloc" which describes the current state of the parser.
  1533.      * The second argument is the major token number.  The third is
  1534.      * the minor token.  The fourth optional argument is whatever the
  1535.      * user wants (and specified in the grammar) and is available for
  1536.      * use by the action routines.
  1537.      *
  1538.      * Inputs:
  1539.      * 
  1540.      * - A pointer to the parser (an opaque structure.)
  1541.      * - The major token number.
  1542.      * - The minor token number (token value).
  1543.      * - An option argument of a grammar-specified type.
  1544.      *
  1545.      * Outputs:
  1546.      * None.
  1547.      * @param int the token number
  1548.      * @param mixed the token value
  1549.      * @param mixed any extra arguments that should be passed to handlers
  1550.      */
  1551.     function doParse($yymajor$yytokenvalue$extraargument null)
  1552.     {
  1553.         if (self::PHP_LexerGenerator_ParserARG_DECL && $extraargument !== null{
  1554.             $this->{self::PHP_LexerGenerator_ParserARG_DECL$extraargument;
  1555.         }
  1556. //        YYMINORTYPE yyminorunion;
  1557. //        int yyact;            /* The parser action. */
  1558. //        int yyendofinput;     /* True if we are at the end of input */
  1559.         $yyerrorhit 0;   /* True if yymajor has invoked an error */
  1560.         
  1561.         /* (re)initialize the parser, if necessary */
  1562.         if ($this->yyidx === null || $this->yyidx 0{
  1563.             /* if ($yymajor == 0) return; // not sure why this was here... */
  1564.             $this->yyidx 0;
  1565.             $this->yyerrcnt = -1;
  1566.             $x new PHP_LexerGenerator_ParseryyStackEntry;
  1567.             $x->stateno 0;
  1568.             $x->major 0;
  1569.             $this->yystack array();
  1570.             array_push($this->yystack$x);
  1571.         }
  1572.         $yyendofinput ($yymajor==0);
  1573.         
  1574.         if (self::$yyTraceFILE{
  1575.             fprintf(self::$yyTraceFILE"%sInput %s\n",
  1576.                 self::$yyTracePromptself::$yyTokenName[$yymajor]);
  1577.         }
  1578.         
  1579.         do {
  1580.             $yyact $this->yy_find_shift_action($yymajor);
  1581.             if ($yymajor self::YYERRORSYMBOL &&
  1582.                   !$this->yy_is_expected_token($yymajor)) {
  1583.                 // force a syntax error
  1584.                 $yyact self::YY_ERROR_ACTION;
  1585.             }
  1586.             if ($yyact self::YYNSTATE{
  1587.                 $this->yy_shift($yyact$yymajor$yytokenvalue);
  1588.                 $this->yyerrcnt--;
  1589.                 if ($yyendofinput && $this->yyidx >= 0{
  1590.                     $yymajor 0;
  1591.                 else {
  1592.                     $yymajor self::YYNOCODE;
  1593.                 }
  1594.             elseif ($yyact self::YYNSTATE self::YYNRULE{
  1595.                 $this->yy_reduce($yyact self::YYNSTATE);
  1596.             elseif ($yyact == self::YY_ERROR_ACTION{
  1597.                 if (self::$yyTraceFILE{
  1598.                     fprintf(self::$yyTraceFILE"%sSyntax Error!\n",
  1599.                         self::$yyTracePrompt);
  1600.                 }
  1601.                 if (self::YYERRORSYMBOL{
  1602.                     /* A syntax error has occurred.
  1603.                     ** The response to an error depends upon whether or not the
  1604.                     ** grammar defines an error token "ERROR".  
  1605.                     **
  1606.                     ** This is what we do if the grammar does define ERROR:
  1607.                     **
  1608.                     **  * Call the %syntax_error function.
  1609.                     **
  1610.                     **  * Begin popping the stack until we enter a state where
  1611.                     **    it is legal to shift the error symbol, then shift
  1612.                     **    the error symbol.
  1613.                     **
  1614.                     **  * Set the error count to three.
  1615.                     **
  1616.                     **  * Begin accepting and shifting new tokens.  No new error
  1617.                     **    processing will occur until three tokens have been
  1618.                     **    shifted successfully.
  1619.                     **
  1620.                     */
  1621.                     if ($this->yyerrcnt 0{
  1622.                         $this->yy_syntax_error($yymajor$yytokenvalue);
  1623.                     }
  1624.                     $yymx $this->yystack[$this->yyidx]->major;
  1625.                     if ($yymx == self::YYERRORSYMBOL || $yyerrorhit ){
  1626.                         if (self::$yyTraceFILE{
  1627.                             fprintf(self::$yyTraceFILE"%sDiscard input token %s\n",
  1628.                                 self::$yyTracePromptself::$yyTokenName[$yymajor]);
  1629.                         }
  1630.                         $this->yy_destructor($yymajor$yytokenvalue);
  1631.                         $yymajor self::YYNOCODE;
  1632.                     else {
  1633.                         while ($this->yyidx >= &&
  1634.                                  $yymx != self::YYERRORSYMBOL &&
  1635.         ($yyact $this->yy_find_shift_action(self::YYERRORSYMBOL)) >= self::YYNSTATE
  1636.                               ){
  1637.                             $this->yy_pop_parser_stack();
  1638.                         }
  1639.                         if ($this->yyidx || $yymajor==0{
  1640.                             $this->yy_destructor($yymajor$yytokenvalue);
  1641.                             $this->yy_parse_failed();
  1642.                             $yymajor self::YYNOCODE;
  1643.                         elseif ($yymx != self::YYERRORSYMBOL{
  1644.                             $u2 0;
  1645.                             $this->yy_shift($yyactself::YYERRORSYMBOL$u2);
  1646.                         }
  1647.                     }
  1648.                     $this->yyerrcnt 3;
  1649.                     $yyerrorhit 1;
  1650.                 else {
  1651.                     /* YYERRORSYMBOL is not defined */
  1652.                     /* This is what we do if the grammar does not define ERROR:
  1653.                     **
  1654.                     **  * Report an error message, and throw away the input token.
  1655.                     **
  1656.                     **  * If the input token is $, then fail the parse.
  1657.                     **
  1658.                     ** As before, subsequent error messages are suppressed until
  1659.                     ** three input tokens have been successfully shifted.
  1660.                     */
  1661.                     if ($this->yyerrcnt <= 0{
  1662.                         $this->yy_syntax_error($yymajor$yytokenvalue);
  1663.                     }
  1664.                     $this->yyerrcnt 3;
  1665.                     $this->yy_destructor($yymajor$yytokenvalue);
  1666.                     if ($yyendofinput{
  1667.                         $this->yy_parse_failed();
  1668.                     }
  1669.                     $yymajor self::YYNOCODE;
  1670.                 }
  1671.             else {
  1672.                 $this->yy_accept();
  1673.                 $yymajor self::YYNOCODE;
  1674.             }            
  1675.         while ($yymajor != self::YYNOCODE && $this->yyidx >= 0);
  1676.     }
  1677. }

Documentation generated on Sun, 02 Jul 2006 09:11:10 -0400 by phpDocumentor 1.3.0