phpDocumentor PHP_LexerGenerator
[ class tree: PHP_LexerGenerator ] [ index: PHP_LexerGenerator ] [ all elements ]
PHP_LexerGenerator
Packages:
PHP_LexerGenerator

Source for file Parser.php

Documentation is available at Parser.php

  1. <?php
  2. /* Driver template for the PHP_PHP_LexerGenerator_Regex_rGenerator 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_Regex_yyToken implements ArrayAccess
  12. {
  13.     public $string = '';
  14.     public $metadata = array();
  15.  
  16.     function __construct($s, $m = array())
  17.     {
  18.         if ($s instanceof PHP_LexerGenerator_Regex_yyToken) {
  19.             $this->string = $s->string;
  20.             $this->metadata = $s->metadata;
  21.         } else {
  22.             $this->string = (string) $s;
  23.             if ($m instanceof PHP_LexerGenerator_Regex_yyToken) {
  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_Regex_yyToken) ?
  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_Regex_yyToken) {
  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. /** The following structure represents a single element of the
  76.  * parser's stack.  Information stored includes:
  77.  *
  78.  *   +  The state number for the parser at this level of the stack.
  79.  *
  80.  *   +  The value of the token stored at this level of the stack.
  81.  *      (In other words, the "major" token.)
  82.  *
  83.  *   +  The semantic value stored at this level of the stack.  This is
  84.  *      the information used by the action routines in the grammar.
  85.  *      It is sometimes called the "minor" token.
  86.  */
  87. class PHP_LexerGenerator_Regex_yyStackEntry
  88. {
  89.     public $stateno;       /* The state-number */
  90.     public $major;         /* The major token value.  This is the code
  91.                      ** number for the token at this stack level */
  92.     public $minor; /* The user-supplied minor token value.  This
  93.                      ** is the value of the token  */
  94. };
  95.  
  96. // code external to the class is included here
  97. #line 2 "Parser.y"
  98.  
  99. require_once 'PHP/LexerGenerator/Exception.php';
  100. #line 102 "Parser.php"
  101.  
  102. // declare_class is output here
  103. #line 5 "Parser.y"
  104. class PHP_LexerGenerator_Regex_Parser#line 107 "Parser.php"
  105. {
  106. /* First off, code is included which follows the "include_class" declaration
  107. ** in the input file. */
  108. #line 21 "Parser.y"
  109.  
  110.     
  111.     private $_lex;
  112.     private $_subpatterns;
  113.     private $_updatePattern;
  114.     private $_patternIndex;
  115.     public $result;
  116.     function __construct($lex)
  117.     {
  118.         $this->result = new PHP_LexerGenerator_ParseryyToken('');
  119.         $this->_lex = $lex;
  120.         $this->_subpatterns = 0;
  121.         $this->_patternIndex = 1;
  122.     }
  123.  
  124.     function reset($patternIndex, $updatePattern = false)
  125.     {
  126.         $this->_updatePattern = $updatePattern;
  127.         $this->_patternIndex = $patternIndex;
  128.         $this->_subpatterns = 0;
  129.         $this->result = new PHP_LexerGenerator_ParseryyToken('');
  130.     }
  131. #line 134 "Parser.php"
  132.  
  133. /* Next is all token values, as class constants
  134. */
  135. /* 
  136. ** These constants (all generated automatically by the parser generator)
  137. ** specify the various kinds of tokens (terminals) that the parser
  138. ** understands. 
  139. **
  140. ** Each symbol here is a terminal symbol in the grammar.
  141. */
  142.     const OPENPAREN                      =  1;
  143.     const OPENASSERTION                  =  2;
  144.     const BAR                            =  3;
  145.     const MULTIPLIER                     =  4;
  146.     const MATCHSTART                     =  5;
  147.     const MATCHEND                       =  6;
  148.     const OPENCHARCLASS                  =  7;
  149.     const CLOSECHARCLASS                 =  8;
  150.     const NEGATE                         =  9;
  151.     const TEXT                           = 10;
  152.     const CONTROLCHAR                    = 11;
  153.     const ESCAPEDBACKSLASH               = 12;
  154.     const HYPHEN                         = 13;
  155.     const BACKREFERENCE                  = 14;
  156.     const COULDBEBACKREF                 = 15;
  157.     const FULLSTOP                       = 16;
  158.     const INTERNALOPTIONS                = 17;
  159.     const CLOSEPAREN                     = 18;
  160.     const COLON                          = 19;
  161.     const POSITIVELOOKAHEAD              = 20;
  162.     const NEGATIVELOOKAHEAD              = 21;
  163.     const POSITIVELOOKBEHIND             = 22;
  164.     const NEGATIVELOOKBEHIND             = 23;
  165.     const PATTERNNAME                    = 24;
  166.     const ONCEONLY                       = 25;
  167.     const COMMENT                        = 26;
  168.     const RECUR                          = 27;
  169.     const YY_NO_ACTION = 252;
  170.     const YY_ACCEPT_ACTION = 251;
  171.     const YY_ERROR_ACTION = 250;
  172.  
  173. /* Next are that tables used to determine what action to take based on the
  174. ** current state and lookahead token.  These tables are used to implement
  175. ** functions that take a state number and lookahead value and return an
  176. ** action integer.  
  177. **
  178. ** Suppose the action integer is N.  Then the action is determined as
  179. ** follows
  180. **
  181. **   0 <= N < self::YYNSTATE                              Shift N.  That is,
  182. **                                                        push the lookahead
  183. **                                                        token onto the stack
  184. **                                                        and goto state N.
  185. **
  186. **   self::YYNSTATE <= N < self::YYNSTATE+self::YYNRULE   Reduce by rule N-YYNSTATE.
  187. **
  188. **   N == self::YYNSTATE+self::YYNRULE                    A syntax error has occurred.
  189. **
  190. **   N == self::YYNSTATE+self::YYNRULE+1                  The parser accepts its
  191. **                                                        input. (and concludes parsing)
  192. **
  193. **   N == self::YYNSTATE+self::YYNRULE+2                  No such action.  Denotes unused
  194. **                                                        slots in the yy_action[] table.
  195. **
  196. ** The action table is constructed as a single large static array $yy_action.
  197. ** Given state S and lookahead X, the action is computed as
  198. **
  199. **      self::$yy_action[self::$yy_shift_ofst[S] + X ]
  200. **
  201. ** If the index value self::$yy_shift_ofst[S]+X is out of range or if the value
  202. ** self::$yy_lookahead[self::$yy_shift_ofst[S]+X] is not equal to X or if
  203. ** self::$yy_shift_ofst[S] is equal to self::YY_SHIFT_USE_DFLT, it means that
  204. ** the action is not in the table and that self::$yy_default[S] should be used instead.  
  205. **
  206. ** The formula above is for computing the action when the lookahead is
  207. ** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
  208. ** a reduce action) then the static $yy_reduce_ofst array is used in place of
  209. ** the static $yy_shift_ofst array and self::YY_REDUCE_USE_DFLT is used in place of
  210. ** self::YY_SHIFT_USE_DFLT.
  211. **
  212. ** The following are the tables generated in this section:
  213. **
  214. **  self::$yy_action        A single table containing all actions.
  215. **  self::$yy_lookahead     A table containing the lookahead for each entry in
  216. **                          yy_action.  Used to detect hash collisions.
  217. **  self::$yy_shift_ofst    For each state, the offset into self::$yy_action for
  218. **                          shifting terminals.
  219. **  self::$yy_reduce_ofst   For each state, the offset into self::$yy_action for
  220. **                          shifting non-terminals after a reduce.
  221. **  self::$yy_default       Default action for each state.
  222. */
  223.     const YY_SZ_ACTTAB = 367;
  224. static public $yy_action = array(
  225.  /*     0 */      251,   50,   16,   21,  128,  129,  141,  140,  139,  142,
  226.  /*    10 */      143,  145,  144,  138,   41,   16,   21,  128,  129,  141,
  227.  /*    20 */      140,  139,  142,  143,  145,  144,  138,   43,   16,   21,
  228.  /*    30 */      128,  129,  141,  140,  139,  142,  143,  145,  144,  138,
  229.  /*    40 */        98,   16,   21,  128,  129,  141,  140,  139,  142,  143,
  230.  /*    50 */      145,  144,  138,   32,   16,   21,  128,  129,  141,  140,
  231.  /*    60 */      139,  142,  143,  145,  144,  138,   39,   16,   21,  128,
  232.  /*    70 */      129,  141,  140,  139,  142,  143,  145,  144,  138,   31,
  233.  /*    80 */        16,   21,  128,  129,  141,  140,  139,  142,  143,  145,
  234.  /*    90 */      144,  138,   42,   16,   21,  128,  129,  141,  140,  139,
  235.  /*   100 */      142,  143,  145,  144,  138,   29,   16,   21,  128,  129,
  236.  /*   110 */      141,  140,  139,  142,  143,  145,  144,  138,   35,   16,
  237.  /*   120 */        21,  128,  129,  141,  140,  139,  142,  143,  145,  144,
  238.  /*   130 */      138,   40,   16,   21,  128,  129,  141,  140,  139,  142,
  239.  /*   140 */      143,  145,  144,  138,   37,   16,   21,  128,  129,  141,
  240.  /*   150 */      140,  139,  142,  143,  145,  144,  138,   38,   16,   21,
  241.  /*   160 */      128,  129,  141,  140,  139,  142,  143,  145,  144,  138,
  242.  /*   170 */        36,   16,   21,  128,  129,  141,  140,  139,  142,  143,
  243.  /*   180 */      145,  144,  138,   15,   21,  128,  129,  141,  140,  139,
  244.  /*   190 */      142,  143,  145,  144,  138,   54,   24,   23,   78,   75,
  245.  /*   200 */        76,   82,   83,   89,   88,   87,   84,   86,  112,  115,
  246.  /*   210 */      114,   34,   11,    1,    7,    8,    4,    2,    3,   13,
  247.  /*   220 */        52,   60,   10,   17,  102,  108,   14,   55,   18,   96,
  248.  /*   230 */        11,   47,   61,   48,  124,   46,   49,   51,   10,   17,
  249.  /*   240 */      106,   11,   11,   97,   18,   44,  103,   47,   61,   48,
  250.  /*   250 */        56,   46,   49,   51,   10,   17,   58,  132,  117,  111,
  251.  /*   260 */        18,  119,   12,   47,   61,   48,  122,   46,   49,   51,
  252.  /*   270 */        10,   17,    7,    8,    4,    2,   18,   28,   11,   47,
  253.  /*   280 */        61,   48,  135,   46,   49,   51,  116,  137,   65,  127,
  254.  /*   290 */        64,   63,   73,   79,  113,  120,   68,   70,   71,   11,
  255.  /*   300 */        67,   66,   69,   62,   26,   64,   63,   73,   99,  113,
  256.  /*   310 */      120,   19,   72,   74,   59,  126,   92,   80,   72,   74,
  257.  /*   320 */        59,   11,   92,   80,  123,  121,  118,  131,   93,  100,
  258.  /*   330 */      130,  136,  133,   11,   11,   11,   53,   11,   11,   11,
  259.  /*   340 */          6,    9,  107,  125,  110,  146,   33,   81,   57,   91,
  260.  /*   350 */      104,   85,  105,   94,   45,   27,   95,  101,   25,  109,
  261.  /*   360 */      134,   30,    5,   77,   20,   22,   90,
  262.     );
  263.     static public $yy_lookahead = array(
  264.  /*     0 */        29,   30,   31,   32,   33,   34,   35,   36,   37,   38,
  265.  /*    10 */        39,   40,   41,   42,   30,   31,   32,   33,   34,   35,
  266.  /*    20 */        36,   37,   38,   39,   40,   41,   42,   30,   31,   32,
  267.  /*    30 */        33,   34,   35,   36,   37,   38,   39,   40,   41,   42,
  268.  /*    40 */        30,   31,   32,   33,   34,   35,   36,   37,   38,   39,
  269.  /*    50 */        40,   41,   42,   30,   31,   32,   33,   34,   35,   36,
  270.  /*    60 */        37,   38,   39,   40,   41,   42,   30,   31,   32,   33,
  271.  /*    70 */        34,   35,   36,   37,   38,   39,   40,   41,   42,   30,
  272.  /*    80 */        31,   32,   33,   34,   35,   36,   37,   38,   39,   40,
  273.  /*    90 */        41,   42,   30,   31,   32,   33,   34,   35,   36,   37,
  274.  /*   100 */        38,   39,   40,   41,   42,   30,   31,   32,   33,   34,
  275.  /*   110 */        35,   36,   37,   38,   39,   40,   41,   42,   30,   31,
  276.  /*   120 */        32,   33,   34,   35,   36,   37,   38,   39,   40,   41,
  277.  /*   130 */        42,   30,   31,   32,   33,   34,   35,   36,   37,   38,
  278.  /*   140 */        39,   40,   41,   42,   30,   31,   32,   33,   34,   35,
  279.  /*   150 */        36,   37,   38,   39,   40,   41,   42,   30,   31,   32,
  280.  /*   160 */        33,   34,   35,   36,   37,   38,   39,   40,   41,   42,
  281.  /*   170 */        30,   31,   32,   33,   34,   35,   36,   37,   38,   39,
  282.  /*   180 */        40,   41,   42,   31,   32,   33,   34,   35,   36,   37,
  283.  /*   190 */        38,   39,   40,   41,   42,    1,    2,   32,   33,   34,
  284.  /*   200 */        35,   36,   37,   38,   39,   40,   41,   42,   10,   11,
  285.  /*   210 */        12,   17,    3,   19,   20,   21,   22,   23,   24,   25,
  286.  /*   220 */        26,   27,    1,    2,   10,   11,    5,   18,    7,   18,
  287.  /*   230 */          3,   10,   11,   12,    4,   14,   15,   16,    1,    2,
  288.  /*   240 */          4,    3,    3,    6,    7,   18,    4,   10,   11,   12,
  289.  /*   250 */        10,   14,   15,   16,    1,    2,   18,   18,    4,    6,
  290.  /*   260 */          7,   18,   19,   10,   11,   12,    4,   14,   15,   16,
  291.  /*   270 */          1,    2,   20,   21,   22,   23,    7,   13,    3,   10,
  292.  /*   280 */        11,   12,    4,   14,   15,   16,   10,   11,    8,    4,
  293.  /*   290 */        10,   11,   12,   18,   14,   15,   10,   11,   12,    3,
  294.  /*   300 */        14,   15,   16,    8,   13,   10,   11,   12,   18,   14,
  295.  /*   310 */        15,    9,   10,   11,   12,    4,   14,   15,   10,   11,
  296.  /*   320 */        12,    3,   14,   15,   10,   11,   12,   10,   11,   12,
  297.  /*   330 */        10,   11,   12,    3,    3,    3,   18,    3,    3,    3,
  298.  /*   340 */        36,   37,    4,    4,    4,    4,   13,    4,   18,   18,
  299.  /*   350 */        18,    4,   18,   18,   18,   13,    4,    4,   13,    4,
  300.  /*   360 */          4,   13,   18,    4,   43,   43,    4,
  301. );
  302.     const YY_SHIFT_USE_DFLT = -1;
  303.     const YY_SHIFT_MAX = 74;
  304.     static public $yy_shift_ofst = array(
  305.  /*     0 */      221,  221,  221,  221,  221,  221,  221,  221,  221,  221,
  306.  /*    10 */      221,  221,  221,  221,  269,  237,  253,  194,  302,  308,
  307.  /*    20 */      280,  286,  295,  286,  252,  320,  317,  198,  314,  336,
  308.  /*    30 */      276,  239,  335,  214,  243,  332,  330,  318,  334,  275,
  309.  /*    40 */      209,  227,  331,  238,  362,  359,  230,  278,  262,  285,
  310.  /*    50 */      296,  311,  211,  254,  240,  356,  344,  353,  347,  333,
  311.  /*    60 */      290,  341,  340,  345,  342,  339,  343,  355,  352,  338,
  312.  /*    70 */      236,  242,  264,  348,  291,
  313. );
  314.     const YY_REDUCE_USE_DFLT = -30;
  315.     const YY_REDUCE_MAX = 19;
  316.     static public $yy_reduce_ofst = array(
  317.  /*     0 */      -29,  101,  127,  140,   88,   -3,  -16,   36,   62,   75,
  318.  /*    10 */      114,   10,   49,   23,  152,  165,  165,  304,  322,  321,
  319. );
  320.     static public $yyExpectedTokens = array(
  321.         /* 0 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  322.         /* 1 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  323.         /* 2 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  324.         /* 3 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  325.         /* 4 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  326.         /* 5 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  327.         /* 6 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  328.         /* 7 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  329.         /* 8 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  330.         /* 9 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  331.         /* 10 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  332.         /* 11 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  333.         /* 12 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  334.         /* 13 */  array(1, 2, 5, 7, 10, 11, 12, 14, 15, 16, ),
  335.         /* 14 */  array(1, 2, 7, 10, 11, 12, 14, 15, 16, ),
  336.         /* 15 */  array(1, 2, 6, 7, 10, 11, 12, 14, 15, 16, ),
  337.         /* 16 */  array(1, 2, 6, 7, 10, 11, 12, 14, 15, 16, ),
  338.         /* 17 */  array(1, 2, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, ),
  339.         /* 18 */  array(9, 10, 11, 12, 14, 15, ),
  340.         /* 19 */  array(10, 11, 12, 14, 15, ),
  341.         /* 20 */  array(8, 10, 11, 12, 14, 15, ),
  342.         /* 21 */  array(10, 11, 12, 14, 15, 16, ),
  343.         /* 22 */  array(8, 10, 11, 12, 14, 15, ),
  344.         /* 23 */  array(10, 11, 12, 14, 15, 16, ),
  345.         /* 24 */  array(20, 21, 22, 23, ),
  346.         /* 25 */  array(10, 11, 12, ),
  347.         /* 26 */  array(10, 11, 12, ),
  348.         /* 27 */  array(10, 11, 12, ),
  349.         /* 28 */  array(10, 11, 12, ),
  350.         /* 29 */  array(3, 18, ),
  351.         /* 30 */  array(10, 11, ),
  352.         /* 31 */  array(3, 18, ),
  353.         /* 32 */  array(3, 18, ),
  354.         /* 33 */  array(10, 11, ),
  355.         /* 34 */  array(18, 19, ),
  356.         /* 35 */  array(3, 18, ),
  357.         /* 36 */  array(3, 18, ),
  358.         /* 37 */  array(3, 18, ),
  359.         /* 38 */  array(3, 18, ),
  360.         /* 39 */  array(3, 18, ),
  361.         /* 40 */  array(3, 18, ),
  362.         /* 41 */  array(3, 18, ),
  363.         /* 42 */  array(3, 18, ),
  364.         /* 43 */  array(3, 18, ),
  365.         /* 44 */  array(4, ),
  366.         /* 45 */  array(4, ),
  367.         /* 46 */  array(4, ),
  368.         /* 47 */  array(4, ),
  369.         /* 48 */  array(4, ),
  370.         /* 49 */  array(4, ),
  371.         /* 50 */  array(3, ),
  372.         /* 51 */  array(4, ),
  373.         /* 52 */  array(18, ),
  374.         /* 53 */  array(4, ),
  375.         /* 54 */  array(10, ),
  376.         /* 55 */  array(4, ),
  377.         /* 56 */  array(18, ),
  378.         /* 57 */  array(4, ),
  379.         /* 58 */  array(4, ),
  380.         /* 59 */  array(13, ),
  381.         /* 60 */  array(18, ),
  382.         /* 61 */  array(4, ),
  383.         /* 62 */  array(4, ),
  384.         /* 63 */  array(13, ),
  385.         /* 64 */  array(13, ),
  386.         /* 65 */  array(4, ),
  387.         /* 66 */  array(4, ),
  388.         /* 67 */  array(4, ),
  389.         /* 68 */  array(4, ),
  390.         /* 69 */  array(4, ),
  391.         /* 70 */  array(4, ),
  392.         /* 71 */  array(4, ),
  393.         /* 72 */  array(13, ),
  394.         /* 73 */  array(13, ),
  395.         /* 74 */  array(13, ),
  396.         /* 75 */  array(),
  397.         /* 76 */  array(),
  398.         /* 77 */  array(),
  399.         /* 78 */  array(),
  400.         /* 79 */  array(),
  401.         /* 80 */  array(),
  402.         /* 81 */  array(),
  403.         /* 82 */  array(),
  404.         /* 83 */  array(),
  405.         /* 84 */  array(),
  406.         /* 85 */  array(),
  407.         /* 86 */  array(),
  408.         /* 87 */  array(),
  409.         /* 88 */  array(),
  410.         /* 89 */  array(),
  411.         /* 90 */  array(),
  412.         /* 91 */  array(),
  413.         /* 92 */  array(),
  414.         /* 93 */  array(),
  415.         /* 94 */  array(),
  416.         /* 95 */  array(),
  417.         /* 96 */  array(),
  418.         /* 97 */  array(),
  419.         /* 98 */  array(),
  420.         /* 99 */  array(),
  421.         /* 100 */  array(),
  422.         /* 101 */  array(),
  423.         /* 102 */  array(),
  424.         /* 103 */  array(),
  425.         /* 104 */  array(),
  426.         /* 105 */  array(),
  427.         /* 106 */  array(),
  428.         /* 107 */  array(),
  429.         /* 108 */  array(),
  430.         /* 109 */  array(),
  431.         /* 110 */  array(),
  432.         /* 111 */  array(),
  433.         /* 112 */  array(),
  434.         /* 113 */  array(),
  435.         /* 114 */  array(),
  436.         /* 115 */  array(),
  437.         /* 116 */  array(),
  438.         /* 117 */  array(),
  439.         /* 118 */  array(),
  440.         /* 119 */  array(),
  441.         /* 120 */  array(),
  442.         /* 121 */  array(),
  443.         /* 122 */  array(),
  444.         /* 123 */  array(),
  445.         /* 124 */  array(),
  446.         /* 125 */  array(),
  447.         /* 126 */  array(),
  448.         /* 127 */  array(),
  449.         /* 128 */  array(),
  450.         /* 129 */  array(),
  451.         /* 130 */  array(),
  452.         /* 131 */  array(),
  453.         /* 132 */  array(),
  454.         /* 133 */  array(),
  455.         /* 134 */  array(),
  456.         /* 135 */  array(),
  457.         /* 136 */  array(),
  458.         /* 137 */  array(),
  459.         /* 138 */  array(),
  460.         /* 139 */  array(),
  461.         /* 140 */  array(),
  462.         /* 141 */  array(),
  463.         /* 142 */  array(),
  464.         /* 143 */  array(),
  465.         /* 144 */  array(),
  466.         /* 145 */  array(),
  467.         /* 146 */  array(),
  468. );
  469.     static public $yy_default = array(
  470.  /*     0 */      250,  250,  250,  250,  250,  250,  250,  250,  250,  250,
  471.  /*    10 */      250,  250,  250,  250,  250,  149,  151,  250,  250,  250,
  472.  /*    20 */      250,  153,  250,  164,  250,  250,  250,  250,  250,  250,
  473.  /*    30 */      250,  250,  250,  250,  250,  250,  250,  250,  250,  250,
  474.  /*    40 */      250,  250,  250,  250,  235,  237,  213,  205,  211,  215,
  475.  /*    50 */      147,  207,  250,  245,  250,  231,  250,  243,  234,  181,
  476.  /*    60 */      250,  209,  175,  192,  194,  176,  227,  225,  217,  219,
  477.  /*    70 */      221,  223,  179,  193,  180,  166,  167,  238,  165,  239,
  478.  /*    80 */      191,  228,  168,  169,  173,  233,  174,  172,  171,  170,
  479.  /*    90 */      236,  240,  190,  184,  247,  218,  248,  148,  152,  249,
  480.  /*   100 */      183,  244,  185,  224,  241,  242,  222,  220,  182,  226,
  481.  /*   110 */      177,  150,  202,  203,  201,  200,  199,  246,  189,  229,
  482.  /*   120 */      204,  188,  212,  187,  214,  178,  208,  216,  154,  155,
  483.  /*   130 */      198,  186,  230,  197,  232,  206,  195,  196,  163,  158,
  484.  /*   140 */      157,  156,  159,  160,  162,  161,  210,
  485. );
  486. /* The next thing included is series of defines which control
  487. ** various aspects of the generated parser.
  488. **    self::YYNOCODE      is a number which corresponds
  489. **                        to no legal terminal or nonterminal number.  This
  490. **                        number is used to fill in empty slots of the hash 
  491. **                        table.
  492. **    self::YYFALLBACK    If defined, this indicates that one or more tokens
  493. **                        have fall-back values which should be used if the
  494. **                        original value of the token will not parse.
  495. **    self::YYSTACKDEPTH  is the maximum depth of the parser's stack.
  496. **    self::YYNSTATE      the combined number of states.
  497. **    self::YYNRULE       the number of rules in the grammar
  498. **    self::YYERRORSYMBOL is the code number of the error symbol.  If not
  499. **                        defined, then do no error processing.
  500. */
  501.     const YYNOCODE = 45;
  502.     const YYSTACKDEPTH = 100;
  503.     const YYNSTATE = 147;
  504.     const YYNRULE = 103;
  505.     const YYERRORSYMBOL = 28;
  506.     const YYERRSYMDT = 'yy0';
  507.     const YYFALLBACK = 0;
  508.     /** The next table maps tokens into fallback tokens.  If a construct
  509.      * like the following:
  510.      * 
  511.      *      %fallback ID X Y Z.
  512.      *
  513.      * appears in the grammer, then ID becomes a fallback token for X, Y,
  514.      * and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
  515.      * but it does not parse, the type of the token is changed to ID and
  516.      * the parse is retried before an error is thrown.
  517.      */
  518.     static public $yyFallback = array(
  519.     );
  520.     /**
  521.      * Turn parser tracing on by giving a stream to which to write the trace
  522.      * and a prompt to preface each trace message.  Tracing is turned off
  523.      * by making either argument NULL
  524.      *
  525.      * Inputs:
  526.      * 
  527.      * - A stream resource to which trace output should be written.
  528.      *   If NULL, then tracing is turned off.
  529.      * - A prefix string written at the beginning of every
  530.      *   line of trace output.  If NULL, then tracing is
  531.      *   turned off.
  532.      *
  533.      * Outputs:
  534.      * 
  535.      * - None.
  536.      * @param resource 
  537.      * @param string 
  538.      */
  539.     static function Trace($TraceFILE, $zTracePrompt)
  540.     {
  541.         if (!$TraceFILE) {
  542.             $zTracePrompt = 0;
  543.         } elseif (!$zTracePrompt) {
  544.             $TraceFILE = 0;
  545.         }
  546.         self::$yyTraceFILE = $TraceFILE;
  547.         self::$yyTracePrompt = $zTracePrompt;
  548.     }
  549.  
  550.     /**
  551.      * Output debug information to output (php://output stream)
  552.      */
  553.     static function PrintTrace()
  554.     {
  555.         self::$yyTraceFILE = fopen('php://output', 'w');
  556.         self::$yyTracePrompt = '';
  557.     }
  558.  
  559.     /**
  560.      * @var resource|0
  561.      */
  562.     static public $yyTraceFILE;
  563.     /**
  564.      * String to prepend to debug output
  565.      * @var string|0
  566.      */
  567.     static public $yyTracePrompt;
  568.     /**
  569.      * @var int 
  570.      */
  571.     public $yyidx;                    /* Index of top element in stack */
  572.     /**
  573.      * @var int 
  574.      */
  575.     public $yyerrcnt;                 /* Shifts left before out of the error */
  576.     /**
  577.      * @var array 
  578.      */
  579.     public $yystack = array();  /* The parser's stack */
  580.  
  581.     /**
  582.      * For tracing shifts, the names of all terminals and nonterminals
  583.      * are required.  The following table supplies these names
  584.      * @var array 
  585.      */
  586.     static public $yyTokenName = array( 
  587.   '$',             'OPENPAREN',     'OPENASSERTION',  'BAR',         
  588.   'MULTIPLIER',    'MATCHSTART',    'MATCHEND',      'OPENCHARCLASS',
  589.   'CLOSECHARCLASS',  'NEGATE',        'TEXT',          'CONTROLCHAR', 
  590.   'ESCAPEDBACKSLASH',  'HYPHEN',        'BACKREFERENCE',  'COULDBEBACKREF',
  591.   'FULLSTOP',      'INTERNALOPTIONS',  'CLOSEPAREN',    'COLON',       
  592.   'POSITIVELOOKAHEAD',  'NEGATIVELOOKAHEAD',  'POSITIVELOOKBEHIND',  'NEGATIVELOOKBEHIND',
  593.   'PATTERNNAME',   'ONCEONLY',      'COMMENT',       'RECUR',       
  594.   'error',         'start',         'pattern',       'basic_pattern',
  595.   'basic_text',    'character_class',  'assertion',     'grouping',    
  596.   'lookahead',     'lookbehind',    'subpattern',    'onceonly',    
  597.   'comment',       'recur',         'conditional',   'character_class_contents',
  598.     );
  599.  
  600.     /**
  601.      * For tracing reduce actions, the names of all rules are required.
  602.      * @var array 
  603.      */
  604.     static public $yyRuleName = array(
  605.  /*   0 */  "start ::= pattern",
  606.  /*   1 */  "pattern ::= MATCHSTART basic_pattern MATCHEND",
  607.  /*   2 */  "pattern ::= MATCHSTART basic_pattern",
  608.  /*   3 */  "pattern ::= basic_pattern MATCHEND",
  609.  /*   4 */  "pattern ::= basic_pattern",
  610.  /*   5 */  "pattern ::= pattern BAR pattern",
  611.  /*   6 */  "basic_pattern ::= basic_text",
  612.  /*   7 */  "basic_pattern ::= character_class",
  613.  /*   8 */  "basic_pattern ::= assertion",
  614.  /*   9 */  "basic_pattern ::= grouping",
  615.  /*  10 */  "basic_pattern ::= lookahead",
  616.  /*  11 */  "basic_pattern ::= lookbehind",
  617.  /*  12 */  "basic_pattern ::= subpattern",
  618.  /*  13 */  "basic_pattern ::= onceonly",
  619.  /*  14 */  "basic_pattern ::= comment",
  620.  /*  15 */  "basic_pattern ::= recur",
  621.  /*  16 */  "basic_pattern ::= conditional",
  622.  /*  17 */  "basic_pattern ::= basic_pattern basic_text",
  623.  /*  18 */  "basic_pattern ::= basic_pattern character_class",
  624.  /*  19 */  "basic_pattern ::= basic_pattern assertion",
  625.  /*  20 */  "basic_pattern ::= basic_pattern grouping",
  626.  /*  21 */  "basic_pattern ::= basic_pattern lookahead",
  627.  /*  22 */  "basic_pattern ::= basic_pattern lookbehind",
  628.  /*  23 */  "basic_pattern ::= basic_pattern subpattern",
  629.  /*  24 */  "basic_pattern ::= basic_pattern onceonly",
  630.  /*  25 */  "basic_pattern ::= basic_pattern comment",
  631.  /*  26 */  "basic_pattern ::= basic_pattern recur",
  632.  /*  27 */  "basic_pattern ::= basic_pattern conditional",
  633.  /*  28 */  "character_class ::= OPENCHARCLASS character_class_contents CLOSECHARCLASS",
  634.  /*  29 */  "character_class ::= OPENCHARCLASS NEGATE character_class_contents CLOSECHARCLASS",
  635.  /*  30 */  "character_class ::= OPENCHARCLASS character_class_contents CLOSECHARCLASS MULTIPLIER",
  636.  /*  31 */  "character_class ::= OPENCHARCLASS NEGATE character_class_contents CLOSECHARCLASS MULTIPLIER",
  637.  /*  32 */  "character_class_contents ::= TEXT",
  638.  /*  33 */  "character_class_contents ::= CONTROLCHAR",
  639.  /*  34 */  "character_class_contents ::= ESCAPEDBACKSLASH",
  640.  /*  35 */  "character_class_contents ::= ESCAPEDBACKSLASH HYPHEN CONTROLCHAR",
  641.  /*  36 */  "character_class_contents ::= CONTROLCHAR HYPHEN ESCAPEDBACKSLASH",
  642.  /*  37 */  "character_class_contents ::= CONTROLCHAR HYPHEN CONTROLCHAR",
  643.  /*  38 */  "character_class_contents ::= ESCAPEDBACKSLASH HYPHEN TEXT",
  644.  /*  39 */  "character_class_contents ::= CONTROLCHAR HYPHEN TEXT",
  645.  /*  40 */  "character_class_contents ::= TEXT HYPHEN TEXT",
  646.  /*  41 */  "character_class_contents ::= TEXT HYPHEN CONTROLCHAR",
  647.  /*  42 */  "character_class_contents ::= TEXT HYPHEN ESCAPEDBACKSLASH",
  648.  /*  43 */  "character_class_contents ::= BACKREFERENCE",
  649.  /*  44 */  "character_class_contents ::= COULDBEBACKREF",
  650.  /*  45 */  "character_class_contents ::= character_class_contents CONTROLCHAR",
  651.  /*  46 */  "character_class_contents ::= character_class_contents ESCAPEDBACKSLASH",
  652.  /*  47 */  "character_class_contents ::= character_class_contents TEXT",
  653.  /*  48 */  "character_class_contents ::= character_class_contents CONTROLCHAR HYPHEN CONTROLCHAR",
  654.  /*  49 */  "character_class_contents ::= character_class_contents ESCAPEDBACKSLASH HYPHEN CONTROLCHAR",
  655.  /*  50 */  "character_class_contents ::= character_class_contents CONTROLCHAR HYPHEN ESCAPEDBACKSLASH",
  656.  /*  51 */  "character_class_contents ::= character_class_contents CONTROLCHAR HYPHEN TEXT",
  657.  /*  52 */  "character_class_contents ::= character_class_contents ESCAPEDBACKSLASH HYPHEN TEXT",
  658.  /*  53 */  "character_class_contents ::= character_class_contents TEXT HYPHEN CONTROLCHAR",
  659.  /*  54 */  "character_class_contents ::= character_class_contents TEXT HYPHEN ESCAPEDBACKSLASH",
  660.  /*  55 */  "character_class_contents ::= character_class_contents TEXT HYPHEN TEXT",
  661.  /*  56 */  "character_class_contents ::= character_class_contents BACKREFERENCE",
  662.  /*  57 */  "character_class_contents ::= character_class_contents COULDBEBACKREF",
  663.  /*  58 */  "basic_text ::= TEXT",
  664.  /*  59 */  "basic_text ::= TEXT MULTIPLIER",
  665.  /*  60 */  "basic_text ::= FULLSTOP",
  666.  /*  61 */  "basic_text ::= FULLSTOP MULTIPLIER",
  667.  /*  62 */  "basic_text ::= CONTROLCHAR",
  668.  /*  63 */  "basic_text ::= CONTROLCHAR MULTIPLIER",
  669.  /*  64 */  "basic_text ::= ESCAPEDBACKSLASH",
  670.  /*  65 */  "basic_text ::= ESCAPEDBACKSLASH MULTIPLIER",
  671.  /*  66 */  "basic_text ::= BACKREFERENCE",
  672.  /*  67 */  "basic_text ::= BACKREFERENCE MULTIPLIER",
  673.  /*  68 */  "basic_text ::= COULDBEBACKREF",
  674.  /*  69 */  "basic_text ::= COULDBEBACKREF MULTIPLIER",
  675.  /*  70 */  "basic_text ::= basic_text TEXT",
  676.  /*  71 */  "basic_text ::= basic_text TEXT MULTIPLIER",
  677.  /*  72 */  "basic_text ::= basic_text FULLSTOP",
  678.  /*  73 */  "basic_text ::= basic_text FULLSTOP MULTIPLIER",
  679.  /*  74 */  "basic_text ::= basic_text CONTROLCHAR",
  680.  /*  75 */  "basic_text ::= basic_text CONTROLCHAR MULTIPLIER",
  681.  /*  76 */  "basic_text ::= basic_text ESCAPEDBACKSLASH",
  682.  /*  77 */  "basic_text ::= basic_text ESCAPEDBACKSLASH MULTIPLIER",
  683.  /*  78 */  "basic_text ::= basic_text BACKREFERENCE",
  684.  /*  79 */  "basic_text ::= basic_text BACKREFERENCE MULTIPLIER",
  685.  /*  80 */  "basic_text ::= basic_text COULDBEBACKREF",
  686.  /*  81 */  "basic_text ::= basic_text COULDBEBACKREF MULTIPLIER",
  687.  /*  82 */  "assertion ::= OPENASSERTION INTERNALOPTIONS CLOSEPAREN",
  688.  /*  83 */  "assertion ::= OPENASSERTION INTERNALOPTIONS COLON pattern CLOSEPAREN",
  689.  /*  84 */  "grouping ::= OPENASSERTION COLON pattern CLOSEPAREN",
  690.  /*  85 */  "grouping ::= OPENASSERTION COLON pattern CLOSEPAREN MULTIPLIER",
  691.  /*  86 */  "conditional ::= OPENASSERTION OPENPAREN TEXT CLOSEPAREN pattern CLOSEPAREN MULTIPLIER",
  692.  /*  87 */  "conditional ::= OPENASSERTION OPENPAREN TEXT CLOSEPAREN pattern CLOSEPAREN",
  693.  /*  88 */  "conditional ::= OPENASSERTION lookahead pattern CLOSEPAREN",
  694.  /*  89 */  "conditional ::= OPENASSERTION lookahead pattern CLOSEPAREN MULTIPLIER",
  695.  /*  90 */  "conditional ::= OPENASSERTION lookbehind pattern CLOSEPAREN",
  696.  /*  91 */  "conditional ::= OPENASSERTION lookbehind pattern CLOSEPAREN MULTIPLIER",
  697.  /*  92 */  "lookahead ::= OPENASSERTION POSITIVELOOKAHEAD pattern CLOSEPAREN",
  698.  /*  93 */  "lookahead ::= OPENASSERTION NEGATIVELOOKAHEAD pattern CLOSEPAREN",
  699.  /*  94 */  "lookbehind ::= OPENASSERTION POSITIVELOOKBEHIND pattern CLOSEPAREN",
  700.  /*  95 */  "lookbehind ::= OPENASSERTION NEGATIVELOOKBEHIND pattern CLOSEPAREN",
  701.  /*  96 */  "subpattern ::= OPENASSERTION PATTERNNAME pattern CLOSEPAREN",
  702.  /*  97 */  "subpattern ::= OPENASSERTION PATTERNNAME pattern CLOSEPAREN MULTIPLIER",
  703.  /*  98 */  "subpattern ::= OPENPAREN pattern CLOSEPAREN",
  704.  /*  99 */  "subpattern ::= OPENPAREN pattern CLOSEPAREN MULTIPLIER",
  705.  /* 100 */  "onceonly ::= OPENASSERTION ONCEONLY pattern CLOSEPAREN",
  706.  /* 101 */  "comment ::= OPENASSERTION COMMENT CLOSEPAREN",
  707.  /* 102 */  "recur ::= OPENASSERTION RECUR CLOSEPAREN",
  708.     );
  709.  
  710.     /**
  711.      * This function returns the symbolic name associated with a token
  712.      * value.
  713.      * @param int 
  714.      * @return string 
  715.      */
  716.     function tokenName($tokenType)
  717.     {
  718.         if ($tokenType === 0) {
  719.             return 'End of Input';
  720.         }
  721.         if ($tokenType > 0 && $tokenType < count(self::$yyTokenName)) {
  722.             return self::$yyTokenName[$tokenType];
  723.         } else {
  724.             return "Unknown";
  725.         }
  726.     }
  727.  
  728.     /**
  729.      * The following function deletes the value associated with a
  730.      * symbol.  The symbol can be either a terminal or nonterminal.
  731.      * @param int the symbol code
  732.      * @param mixed the symbol's value
  733.      */
  734.     static function yy_destructor($yymajor, $yypminor)
  735.     {
  736.         switch ($yymajor) {
  737.         /* Here is inserted the actions which take place when a
  738.         ** terminal or non-terminal is destroyed.  This can happen
  739.         ** when the symbol is popped from the stack during a
  740.         ** reduce or during error processing or when a parser is 
  741.         ** being destroyed before it is finished parsing.
  742.         **
  743.         ** Note: during a reduce, the only symbols destroyed are those
  744.         ** which appear on the RHS of the rule, but which are not used
  745.         ** inside the C code.
  746.         */
  747.             default:  break;   /* If no destructor action specified: do nothing */
  748.         }
  749.     }
  750.  
  751.     /**
  752.      * Pop the parser's stack once.
  753.      *
  754.      * If there is a destructor routine associated with the token which
  755.      * is popped from the stack, then call it.
  756.      *
  757.      * Return the major token number for the symbol popped.
  758.      * @param PHP_LexerGenerator_Regex_yyParser 
  759.      * @return int 
  760.      */
  761.     function yy_pop_parser_stack()
  762.     {
  763.         if (!count($this->yystack)) {
  764.             return;
  765.         }
  766.         $yytos = array_pop($this->yystack);
  767.         if (self::$yyTraceFILE && $this->yyidx >= 0) {
  768.             fwrite(self::$yyTraceFILE,
  769.                 self::$yyTracePrompt . 'Popping ' . self::$yyTokenName[$yytos->major] .
  770.                     "\n");
  771.         }
  772.         $yymajor = $yytos->major;
  773.         self::yy_destructor($yymajor, $yytos->minor);
  774.         $this->yyidx--;
  775.         return $yymajor;
  776.     }
  777.  
  778.     /**
  779.      * Deallocate and destroy a parser.  Destructors are all called for
  780.      * all stack elements before shutting the parser down.
  781.      */
  782.     function __destruct()
  783.     {
  784.         while ($this->yyidx >= 0) {
  785.             $this->yy_pop_parser_stack();
  786.         }
  787.         if (is_resource(self::$yyTraceFILE)) {
  788.             fclose(self::$yyTraceFILE);
  789.         }
  790.     }
  791.  
  792.     /**
  793.      * Based on the current state and parser stack, get a list of all
  794.      * possible lookahead tokens
  795.      * @param int 
  796.      * @return array 
  797.      */
  798.     function yy_get_expected_tokens($token)
  799.     {
  800.         $state = $this->yystack[$this->yyidx]->stateno;
  801.         $expected = self::$yyExpectedTokens[$state];
  802.         if (in_array($token, self::$yyExpectedTokens[$state], true)) {
  803.             return $expected;
  804.         }
  805.         $stack = $this->yystack;
  806.         $yyidx = $this->yyidx;
  807.         do {
  808.             $yyact = $this->yy_find_shift_action($token);
  809.             if ($yyact >= self::YYNSTATE && $yyact < self::YYNSTATE + self::YYNRULE) {
  810.                 // reduce action
  811.                 $done = 0;
  812.                 do {
  813.                     if ($done++ == 100) {
  814.                         $this->yyidx = $yyidx;
  815.                         $this->yystack = $stack;
  816.                         // too much recursion prevents proper detection
  817.                         // so give up
  818.                         return array_unique($expected);
  819.                     }
  820.                     $yyruleno = $yyact - self::YYNSTATE;
  821.                     $this->yyidx -= self::$yyRuleInfo[$yyruleno]['rhs'];
  822.                     $nextstate = $this->yy_find_reduce_action(
  823.                         $this->yystack[$this->yyidx]->stateno,
  824.                         self::$yyRuleInfo[$yyruleno]['lhs']);
  825.                     if (isset(self::$yyExpectedTokens[$nextstate])) {
  826.                         $expected += self::$yyExpectedTokens[$nextstate];
  827.                             if (in_array($token,
  828.                                   self::$yyExpectedTokens[$nextstate], true)) {
  829.                             $this->yyidx = $yyidx;
  830.                             $this->yystack = $stack;
  831.                             return array_unique($expected);
  832.                         }
  833.                     }
  834.                     if ($nextstate < self::YYNSTATE) {
  835.                         // we need to shift a non-terminal
  836.                         $this->yyidx++;
  837.                         $x = new PHP_LexerGenerator_Regex_yyStackEntry;
  838.                         $x->stateno = $nextstate;
  839.                         $x->major = self::$yyRuleInfo[$yyruleno]['lhs'];
  840.                         $this->yystack[$this->yyidx] = $x;
  841.                         continue 2;
  842.                     } elseif ($nextstate == self::YYNSTATE + self::YYNRULE + 1) {
  843.                         $this->yyidx = $yyidx;
  844.                         $this->yystack = $stack;
  845.                         // the last token was just ignored, we can't accept
  846.                         // by ignoring input, this is in essence ignoring a
  847.                         // syntax error!
  848.                         return array_unique($expected);
  849.                     } elseif ($nextstate === self::YY_NO_ACTION) {
  850.                         $this->yyidx = $yyidx;
  851.                         $this->yystack = $stack;
  852.                         // input accepted, but not shifted (I guess)
  853.                         return $expected;
  854.                     } else {
  855.                         $yyact = $nextstate;
  856.                     }
  857.                 } while (true);
  858.             }
  859.             break;
  860.         } while (true);
  861.         return array_unique($expected);
  862.     }
  863.  
  864.     /**
  865.      * Based on the parser state and current parser stack, determine whether
  866.      * the lookahead token is possible.
  867.      * 
  868.      * The parser will convert the token value to an error token if not.  This
  869.      * catches some unusual edge cases where the parser would fail.
  870.      * @param int 
  871.      * @return bool 
  872.      */
  873.     function yy_is_expected_token($token)
  874.     {
  875.         if ($token === 0) {
  876.             return true; // 0 is not part of this
  877.         }
  878.         $state = $this->yystack[$this->yyidx]->stateno;
  879.         if (in_array($token, self::$yyExpectedTokens[$state], true)) {
  880.             return true;
  881.         }
  882.         $stack = $this->yystack;
  883.         $yyidx = $this->yyidx;
  884.         do {
  885.             $yyact = $this->yy_find_shift_action($token);
  886.             if ($yyact >= self::YYNSTATE && $yyact < self::YYNSTATE + self::YYNRULE) {
  887.                 // reduce action
  888.                 $done = 0;
  889.                 do {
  890.                     if ($done++ == 100) {
  891.                         $this->yyidx = $yyidx;
  892.                         $this->yystack = $stack;
  893.                         // too much recursion prevents proper detection
  894.                         // so give up
  895.                         return true;
  896.                     }
  897.                     $yyruleno = $yyact - self::YYNSTATE;
  898.                     $this->yyidx -= self::$yyRuleInfo[$yyruleno]['rhs'];
  899.                     $nextstate = $this->yy_find_reduce_action(
  900.                         $this->yystack[$this->yyidx]->stateno,
  901.                         self::$yyRuleInfo[$yyruleno]['lhs']);
  902.                     if (isset(self::$yyExpectedTokens[$nextstate]) &&
  903.                           in_array($token, self::$yyExpectedTokens[$nextstate], true)) {
  904.                         $this->yyidx = $yyidx;
  905.                         $this->yystack = $stack;
  906.                         return true;
  907.                     }
  908.                     if ($nextstate < self::YYNSTATE) {
  909.                         // we need to shift a non-terminal
  910.                         $this->yyidx++;
  911.                         $x = new PHP_LexerGenerator_Regex_yyStackEntry;
  912.                         $x->stateno = $nextstate;
  913.                         $x->major = self::$yyRuleInfo[$yyruleno]['lhs'];
  914.                         $this->yystack[$this->yyidx] = $x;
  915.                         continue 2;
  916.                     } elseif ($nextstate == self::YYNSTATE + self::YYNRULE + 1) {
  917.                         $this->yyidx = $yyidx;
  918.                         $this->yystack = $stack;
  919.                         if (!$token) {
  920.                             // end of input: this is valid
  921.                             return true;
  922.                         }
  923.                         // the last token was just ignored, we can't accept
  924.                         // by ignoring input, this is in essence ignoring a
  925.                         // syntax error!
  926.                         return false;
  927.                     } elseif ($nextstate === self::YY_NO_ACTION) {
  928.                         $this->yyidx = $yyidx;
  929.                         $this->yystack = $stack;
  930.                         // input accepted, but not shifted (I guess)
  931.                         return true;
  932.                     } else {
  933.                         $yyact = $nextstate;
  934.                     }
  935.                 } while (true);
  936.             }
  937.             break;
  938.         } while (true);
  939.         return true;
  940.     }
  941.  
  942.     /**
  943.      * Find the appropriate action for a parser given the terminal
  944.      * look-ahead token iLookAhead.
  945.      *
  946.      * If the look-ahead token is YYNOCODE, then check to see if the action is
  947.      * independent of the look-ahead.  If it is, return the action, otherwise
  948.      * return YY_NO_ACTION.
  949.      * @param int The look-ahead token
  950.      */
  951.     function yy_find_shift_action($iLookAhead)
  952.     {
  953.         $stateno = $this->yystack[$this->yyidx]->stateno;
  954.      
  955.         /* if ($this->yyidx < 0) return self::YY_NO_ACTION;  */
  956.         if (!isset(self::$yy_shift_ofst[$stateno])) {
  957.             // no shift actions
  958.             return self::$yy_default[$stateno];
  959.         }
  960.         $i = self::$yy_shift_ofst[$stateno];
  961.         if ($i === self::YY_SHIFT_USE_DFLT) {
  962.             return self::$yy_default[$stateno];
  963.         }
  964.         if ($iLookAhead == self::YYNOCODE) {
  965.             return self::YY_NO_ACTION;
  966.         }
  967.         $i += $iLookAhead;
  968.         if ($i < 0 || $i >= self::YY_SZ_ACTTAB ||
  969.               self::$yy_lookahead[$i] != $iLookAhead) {
  970.             if (count(self::$yyFallback) && $iLookAhead < count(self::$yyFallback)
  971.                    && ($iFallback = self::$yyFallback[$iLookAhead]) != 0) {
  972.                 if (self::$yyTraceFILE) {
  973.                     fwrite(self::$yyTraceFILE, self::$yyTracePrompt . "FALLBACK " .
  974.                         self::$yyTokenName[$iLookAhead] . " => " .
  975.                         self::$yyTokenName[$iFallback] . "\n");
  976.                 }
  977.                 return $this->yy_find_shift_action($iFallback);
  978.             }
  979.             return self::$yy_default[$stateno];
  980.         } else {
  981.             return self::$yy_action[$i];
  982.         }
  983.     }
  984.  
  985.     /**
  986.      * Find the appropriate action for a parser given the non-terminal
  987.      * look-ahead token $iLookAhead.
  988.      *
  989.      * If the look-ahead token is self::YYNOCODE, then check to see if the action is
  990.      * independent of the look-ahead.  If it is, return the action, otherwise
  991.      * return self::YY_NO_ACTION.
  992.      * @param int Current state number
  993.      * @param int The look-ahead token
  994.      */
  995.     function yy_find_reduce_action($stateno, $iLookAhead)
  996.     {
  997.         /* $stateno = $this->yystack[$this->yyidx]->stateno; */
  998.  
  999.         if (!isset(self::$yy_reduce_ofst[$stateno])) {
  1000.             return self::$yy_default[$stateno];
  1001.         }
  1002.         $i = self::$yy_reduce_ofst[$stateno];
  1003.         if ($i == self::YY_REDUCE_USE_DFLT) {
  1004.             return self::$yy_default[$stateno];
  1005.         }
  1006.         if ($iLookAhead == self::YYNOCODE) {
  1007.             return self::YY_NO_ACTION;
  1008.         }
  1009.         $i += $iLookAhead;
  1010.         if ($i < 0 || $i >= self::YY_SZ_ACTTAB ||
  1011.               self::$yy_lookahead[$i] != $iLookAhead) {
  1012.             return self::$yy_default[$stateno];
  1013.         } else {
  1014.             return self::$yy_action[$i];
  1015.         }
  1016.     }
  1017.  
  1018.     /**
  1019.      * Perform a shift action.
  1020.      * @param int The new state to shift in
  1021.      * @param int The major token to shift in
  1022.      * @param mixed the minor token to shift in
  1023.      */
  1024.     function yy_shift($yyNewState, $yyMajor, $yypMinor)
  1025.     {
  1026.         $this->yyidx++;
  1027.         if ($this->yyidx >= self::YYSTACKDEPTH) {
  1028.             $this->yyidx--;
  1029.             if (self::$yyTraceFILE) {
  1030.                 fprintf(self::$yyTraceFILE, "%sStack Overflow!\n", self::$yyTracePrompt);
  1031.             }
  1032.             while ($this->yyidx >= 0) {
  1033.                 $this->yy_pop_parser_stack();
  1034.             }
  1035.             /* Here code is inserted which will execute if the parser
  1036.             ** stack ever overflows */
  1037.             return;
  1038.         }
  1039.         $yytos = new PHP_LexerGenerator_Regex_yyStackEntry;
  1040.         $yytos->stateno = $yyNewState;
  1041.         $yytos->major = $yyMajor;
  1042.         $yytos->minor = $yypMinor;
  1043.         array_push($this->yystack, $yytos);
  1044.         if (self::$yyTraceFILE && $this->yyidx > 0) {
  1045.             fprintf(self::$yyTraceFILE, "%sShift %d\n", self::$yyTracePrompt,
  1046.                 $yyNewState);
  1047.             fprintf(self::$yyTraceFILE, "%sStack:", self::$yyTracePrompt);
  1048.             for($i = 1; $i <= $this->yyidx; $i++) {
  1049.                 fprintf(self::$yyTraceFILE, " %s",
  1050.                     self::$yyTokenName[$this->yystack[$i]->major]);
  1051.             }
  1052.             fwrite(self::$yyTraceFILE,"\n");
  1053.         }
  1054.     }
  1055.  
  1056.     /**
  1057.      * The following table contains information about every rule that
  1058.      * is used during the reduce.
  1059.      *
  1060.      * <pre>
  1061.      * array(
  1062.      *  array(
  1063.      *   int $lhs;         Symbol on the left-hand side of the rule
  1064.      *   int $nrhs;     Number of right-hand side symbols in the rule
  1065.      *  ),...
  1066.      * );
  1067.      * </pre>
  1068.      */
  1069.     static public $yyRuleInfo = array(
  1070.   array( 'lhs' => 29, 'rhs' => 1 ),
  1071.   array( 'lhs' => 30, 'rhs' => 3 ),
  1072.   array( 'lhs' => 30, 'rhs' => 2 ),
  1073.   array( 'lhs' => 30, 'rhs' => 2 ),
  1074.   array( 'lhs' => 30, 'rhs' => 1 ),
  1075.   array( 'lhs' => 30, 'rhs' => 3 ),
  1076.   array( 'lhs' => 31, 'rhs' => 1 ),
  1077.   array( 'lhs' => 31, 'rhs' => 1 ),
  1078.   array( 'lhs' => 31, 'rhs' => 1 ),
  1079.   array( 'lhs' => 31, 'rhs' => 1 ),
  1080.   array( 'lhs' => 31, 'rhs' => 1 ),
  1081.   array( 'lhs' => 31, 'rhs' => 1 ),
  1082.   array( 'lhs' => 31, 'rhs' => 1 ),
  1083.   array( 'lhs' => 31, 'rhs' => 1 ),
  1084.   array( 'lhs' => 31, 'rhs' => 1 ),
  1085.   array( 'lhs' => 31, 'rhs' => 1 ),
  1086.   array( 'lhs' => 31, 'rhs' => 1 ),
  1087.   array( 'lhs' => 31, 'rhs' => 2 ),
  1088.   array( 'lhs' => 31, 'rhs' => 2 ),
  1089.   array( 'lhs' => 31, 'rhs' => 2 ),
  1090.   array( 'lhs' => 31, 'rhs' => 2 ),
  1091.   array( 'lhs' => 31, 'rhs' => 2 ),
  1092.   array( 'lhs' => 31, 'rhs' => 2 ),
  1093.   array( 'lhs' => 31, 'rhs' => 2 ),
  1094.   array( 'lhs' => 31, 'rhs' => 2 ),
  1095.   array( 'lhs' => 31, 'rhs' => 2 ),
  1096.   array( 'lhs' => 31, 'rhs' => 2 ),
  1097.   array( 'lhs' => 31, 'rhs' => 2 ),
  1098.   array( 'lhs' => 33, 'rhs' => 3 ),
  1099.   array( 'lhs' => 33, 'rhs' => 4 ),
  1100.   array( 'lhs' => 33, 'rhs' => 4 ),
  1101.   array( 'lhs' => 33, 'rhs' => 5 ),
  1102.   array( 'lhs' => 43, 'rhs' => 1 ),
  1103.   array( 'lhs' => 43, 'rhs' => 1 ),
  1104.   array( 'lhs' => 43, 'rhs' => 1 ),
  1105.   array( 'lhs' => 43, 'rhs' => 3 ),
  1106.   array( 'lhs' => 43, 'rhs' => 3 ),
  1107.   array( 'lhs' => 43, 'rhs' => 3 ),
  1108.   array( 'lhs' => 43, 'rhs' => 3 ),
  1109.   array( 'lhs' => 43, 'rhs' => 3 ),
  1110.   array( 'lhs' => 43, 'rhs' => 3 ),
  1111.   array( 'lhs' => 43, 'rhs' => 3 ),
  1112.   array( 'lhs' => 43, 'rhs' => 3 ),
  1113.   array( 'lhs' => 43, 'rhs' => 1 ),
  1114.   array( 'lhs' => 43, 'rhs' => 1 ),
  1115.   array( 'lhs' => 43, 'rhs' => 2 ),
  1116.   array( 'lhs' => 43, 'rhs' => 2 ),
  1117.   array( 'lhs' => 43, 'rhs' => 2 ),
  1118.   array( 'lhs' => 43, 'rhs' => 4 ),
  1119.   array( 'lhs' => 43, 'rhs' => 4 ),
  1120.   array( 'lhs' => 43, 'rhs' => 4 ),
  1121.   array( 'lhs' => 43, 'rhs' => 4 ),
  1122.   array( 'lhs' => 43, 'rhs' => 4 ),
  1123.   array( 'lhs' => 43, 'rhs' => 4 ),
  1124.   array( 'lhs' => 43, 'rhs' => 4 ),
  1125.   array( 'lhs' => 43, 'rhs' => 4 ),
  1126.   array( 'lhs' => 43, 'rhs' => 2 ),
  1127.   array( 'lhs' => 43, 'rhs' => 2 ),
  1128.   array( 'lhs' => 32, 'rhs' => 1 ),
  1129.   array( 'lhs' => 32, 'rhs' => 2 ),
  1130.   array( 'lhs' => 32, 'rhs' => 1 ),
  1131.   array( 'lhs' => 32, 'rhs' => 2 ),
  1132.   array( 'lhs' => 32, 'rhs' => 1 ),
  1133.   array( 'lhs' => 32, 'rhs' => 2 ),
  1134.   array( 'lhs' => 32, 'rhs' => 1 ),
  1135.   array( 'lhs' => 32, 'rhs' => 2 ),
  1136.   array( 'lhs' => 32, 'rhs' => 1 ),
  1137.   array( 'lhs' => 32, 'rhs' => 2 ),
  1138.   array( 'lhs' => 32, 'rhs' => 1 ),
  1139.   array( 'lhs' => 32, 'rhs' => 2 ),
  1140.   array( 'lhs' => 32, 'rhs' => 2 ),
  1141.   array( 'lhs' => 32, 'rhs' => 3 ),
  1142.   array( 'lhs' => 32, 'rhs' => 2 ),
  1143.   array( 'lhs' => 32, 'rhs' => 3 ),
  1144.   array( 'lhs' => 32, 'rhs' => 2 ),
  1145.   array( 'lhs' => 32, 'rhs' => 3 ),
  1146.   array( 'lhs' => 32, 'rhs' => 2 ),
  1147.   array( 'lhs' => 32, 'rhs' => 3 ),
  1148.   array( 'lhs' => 32, 'rhs' => 2 ),
  1149.   array( 'lhs' => 32, 'rhs' => 3 ),
  1150.   array( 'lhs' => 32, 'rhs' => 2 ),
  1151.   array( 'lhs' => 32, 'rhs' => 3 ),
  1152.   array( 'lhs' => 34, 'rhs' => 3 ),
  1153.   array( 'lhs' => 34, 'rhs' => 5 ),
  1154.   array( 'lhs' => 35, 'rhs' => 4 ),
  1155.   array( 'lhs' => 35, 'rhs' => 5 ),
  1156.   array( 'lhs' => 42, 'rhs' => 7 ),
  1157.   array( 'lhs' => 42, 'rhs' => 6 ),
  1158.   array( 'lhs' => 42, 'rhs' => 4 ),
  1159.   array( 'lhs' => 42, 'rhs' => 5 ),
  1160.   array( 'lhs' => 42, 'rhs' => 4 ),
  1161.   array( 'lhs' => 42, 'rhs' => 5 ),
  1162.   array( 'lhs' => 36, 'rhs' => 4 ),
  1163.   array( 'lhs' => 36, 'rhs' => 4 ),
  1164.   array( 'lhs' => 37, 'rhs' => 4 ),
  1165.   array( 'lhs' => 37, 'rhs' => 4 ),
  1166.   array( 'lhs' => 38, 'rhs' => 4 ),
  1167.   array( 'lhs' => 38, 'rhs' => 5 ),
  1168.   array( 'lhs' => 38, 'rhs' => 3 ),
  1169.   array( 'lhs' => 38, 'rhs' => 4 ),
  1170.   array( 'lhs' => 39, 'rhs' => 4 ),
  1171.   array( 'lhs' => 40, 'rhs' => 3 ),
  1172.   array( 'lhs' => 41, 'rhs' => 3 ),
  1173.     );
  1174.  
  1175.     /**
  1176.      * The following table contains a mapping of reduce action to method name
  1177.      * that handles the reduction.
  1178.      * 
  1179.      * If a rule is not set, it has no handler.
  1180.      */
  1181.     static public $yyReduceMap = array(
  1182.         0 => 0,
  1183.         1 => 1,
  1184.         2 => 2,
  1185.         3 => 3,
  1186.         4 => 4,
  1187.         6 => 4,
  1188.         7 => 4,
  1189.         9 => 4,
  1190.         10 => 4,
  1191.         12 => 4,
  1192.         13 => 4,
  1193.         14 => 4,
  1194.         15 => 4,
  1195.         16 => 4,
  1196.         5 => 5,
  1197.         17 => 17,
  1198.         18 => 17,
  1199.         20 => 17,
  1200.         21 => 17,
  1201.         23 => 17,
  1202.         24 => 17,
  1203.         25 => 17,
  1204.         26 => 17,
  1205.         27 => 17,
  1206.         28 => 28,
  1207.         29 => 29,
  1208.         30 => 30,
  1209.         31 => 31,
  1210.         32 => 32,
  1211.         58 => 32,
  1212.         60 => 32,
  1213.         33 => 33,
  1214.         62 => 33,
  1215.         34 => 34,
  1216.         64 => 34,
  1217.         35 => 35,
  1218.         36 => 36,
  1219.         37 => 37,
  1220.         38 => 38,
  1221.         39 => 39,
  1222.         40 => 40,
  1223.         41 => 41,
  1224.         42 => 42,
  1225.         43 => 43,
  1226.         66 => 43,
  1227.         44 => 44,
  1228.         68 => 44,
  1229.         45 => 45,
  1230.         74 => 45,
  1231.         46 => 46,
  1232.         76 => 46,
  1233.         47 => 47,
  1234.         70 => 47,
  1235.         72 => 47,
  1236.         48 => 48,
  1237.         49 => 49,
  1238.         50 => 50,
  1239.         51 => 51,
  1240.         52 => 52,
  1241.         53 => 53,
  1242.         54 => 54,
  1243.         55 => 55,
  1244.         56 => 56,
  1245.         78 => 56,
  1246.         57 => 57,
  1247.         80 => 57,
  1248.         59 => 59,
  1249.         61 => 59,
  1250.         63 => 63,
  1251.         65 => 65,
  1252.         67 => 67,
  1253.         69 => 69,
  1254.         71 => 71,
  1255.         73 => 71,
  1256.         75 => 75,
  1257.         77 => 77,
  1258.         79 => 79,
  1259.         81 => 81,
  1260.         82 => 82,
  1261.         83 => 83,
  1262.         84 => 84,
  1263.         85 => 85,
  1264.         86 => 86,
  1265.         87 => 87,
  1266.         88 => 88,
  1267.         89 => 89,
  1268.         90 => 90,
  1269.         94 => 90,
  1270.         91 => 91,
  1271.         92 => 92,
  1272.         93 => 93,
  1273.         95 => 95,
  1274.         96 => 96,
  1275.         97 => 97,
  1276.         98 => 98,
  1277.         99 => 99,
  1278.         100 => 100,
  1279.         101 => 101,
  1280.         102 => 102,
  1281.     );
  1282.     /* Beginning here are the reduction cases.  A typical example
  1283.     ** follows:
  1284.     **  #line <lineno> <grammarfile>
  1285.     **   function yy_r0($yymsp){ ... }           // User supplied code
  1286.     **  #line <lineno> <thisfile>
  1287.     */
  1288. #line 47 "Parser.y"
  1289.         function yy_r0(){
  1290.     $this->yystack[$this->yyidx + 0]->minor->string = str_replace('"', '\\"', $this->yystack[$this->yyidx + 0]->minor->string);
  1291.     $x = $this->yystack[$this->yyidx + 0]->minor->metadata;
  1292.     $x['subpatterns'] = $this->_subpatterns;
  1293.     $this->yystack[$this->yyidx + 0]->minor->metadata = $x;
  1294.     $this->_subpatterns = 0;
  1295.     $this->result = $this->yystack[$this->yyidx + 0]->minor;
  1296.     }
  1297. #line 1302 "Parser.php"
  1298. #line 56 "Parser.y"
  1299.         function yy_r1(){
  1300.     throw new PHP_LexerGenerator_Exception('Cannot include start match "' .
  1301.         $this->yystack[$this->yyidx + -2]->minor . '" or end match "' . $this->yystack[$this->yyidx + 0]->minor . '"');
  1302.     }
  1303. #line 1308 "Parser.php"
  1304. #line 60 "Parser.y"
  1305.         function yy_r2(){
  1306.     throw new PHP_LexerGenerator_Exception('Cannot include start match "' .
  1307.         B . '"');
  1308.     }
  1309. #line 1314 "Parser.php"
  1310. #line 64 "Parser.y"
  1311.         function yy_r3(){
  1312.     throw new PHP_LexerGenerator_Exception('Cannot include end match "' . $this->yystack[$this->yyidx + 0]->minor . '"');
  1313.     }
  1314. #line 1319 "Parser.php"
  1315. #line 67 "Parser.y"
  1316.         function yy_r4(){$this->_retvalue = $this->yystack[$this->yyidx + 0]->minor;    }
  1317. #line 1322 "Parser.php"
  1318. #line 68 "Parser.y"
  1319.         function yy_r5(){
  1320.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken($this->yystack[$this->yyidx + -2]->minor->string . '|' . $this->yystack[$this->yyidx + 0]->minor->string, array(
  1321.         'pattern' => $this->yystack[$this->yyidx + -2]->minor['pattern'] . '|' . $this->yystack[$this->yyidx + 0]->minor['pattern']));
  1322.     }
  1323. #line 1328 "Parser.php"
  1324. #line 84 "Parser.y"
  1325.         function yy_r17(){
  1326.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken($this->yystack[$this->yyidx + -1]->minor->string . $this->yystack[$this->yyidx + 0]->minor->string, array(
  1327.         'pattern' => $this->yystack[$this->yyidx + -1]->minor['pattern'] . $this->yystack[$this->yyidx + 0]->minor['pattern']));
  1328.     }
  1329. #line 1334 "Parser.php"
  1330. #line 123 "Parser.y"
  1331.         function yy_r28(){
  1332.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken('[' . $this->yystack[$this->yyidx + -1]->minor->string . ']', array(
  1333.         'pattern' => '[' . $this->yystack[$this->yyidx + -1]->minor['pattern'] . ']'));
  1334.     }
  1335. #line 1340 "Parser.php"
  1336. #line 127 "Parser.y"
  1337.         function yy_r29(){
  1338.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken('[^' . $this->yystack[$this->yyidx + -1]->minor->string . ']', array(
  1339.         'pattern' => '[^' . $this->yystack[$this->yyidx + -1]->minor['pattern'] . ']'));
  1340.     }
  1341. #line 1346 "Parser.php"
  1342. #line 131 "Parser.y"
  1343.         function yy_r30(){
  1344.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken('[' . $this->yystack[$this->yyidx + -2]->minor->string . ']' . $this->yystack[$this->yyidx + 0]->minor, array(
  1345.         'pattern' => '[' . $this->yystack[$this->yyidx + -2]->minor['pattern'] . ']' . $this->yystack[$this->yyidx + 0]->minor));
  1346.     }
  1347. #line 1352 "Parser.php"
  1348. #line 135 "Parser.y"
  1349.         function yy_r31(){
  1350.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken('[^' . $this->yystack[$this->yyidx + -2]->minor->string . ']' . $this->yystack[$this->yyidx + 0]->minor, array(
  1351.         'pattern' => '[^' . $this->yystack[$this->yyidx + -2]->minor['pattern'] . ']' . $this->yystack[$this->yyidx + 0]->minor));
  1352.     }
  1353. #line 1358 "Parser.php"
  1354. #line 140 "Parser.y"
  1355.         function yy_r32(){
  1356.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken($this->yystack[$this->yyidx + 0]->minor, array(
  1357.         'pattern' => $this->yystack[$this->yyidx + 0]->minor));
  1358.     }
  1359. #line 1364 "Parser.php"
  1360. #line 144 "Parser.y"
  1361.         function yy_r33(){
  1362.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken('\\' . $this->yystack[$this->yyidx + 0]->minor, array(
  1363.         'pattern' => $this->yystack[$this->yyidx + 0]->minor));
  1364.     }
  1365. #line 1370 "Parser.php"
  1366. #line 148 "Parser.y"
  1367.         function yy_r34(){
  1368.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken('\\\\' . $this->yystack[$this->yyidx + 0]->minor, array(
  1369.         'pattern' => $this->yystack[$this->yyidx + 0]->minor));
  1370.     }
  1371. #line 1376 "Parser.php"
  1372. #line 152 "Parser.y"
  1373.         function yy_r35(){
  1374.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken('\\\\' . $this->yystack[$this->yyidx + -2]->minor . '-\\' . $this->yystack[$this->yyidx + 0]->minor, array(
  1375.         'pattern' => $this->yystack[$this->yyidx + -2]->minor . '-' . $this->yystack[$this->yyidx + 0]->minor));
  1376.     }
  1377. #line 1382 "Parser.php"
  1378. #line 156 "Parser.y"
  1379.         function yy_r36(){
  1380.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken('\\' . $this->yystack[$this->yyidx + -2]->minor . '-\\\\' . $this->yystack[$this->yyidx + 0]->minor, array(
  1381.         'pattern' => $this->yystack[$this->yyidx + -2]->minor . '-' . $this->yystack[$this->yyidx + 0]->minor));
  1382.     }
  1383. #line 1388 "Parser.php"
  1384. #line 160 "Parser.y"
  1385.         function yy_r37(){
  1386.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken('\\' . $this->yystack[$this->yyidx + -2]->minor . '-\\' . $this->yystack[$this->yyidx + 0]->minor, array(
  1387.         'pattern' => $this->yystack[$this->yyidx + -2]->minor . '-' . $this->yystack[$this->yyidx + 0]->minor));
  1388.     }
  1389. #line 1394 "Parser.php"
  1390. #line 164 "Parser.y"
  1391.         function yy_r38(){
  1392.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken('\\\\' . $this->yystack[$this->yyidx + -2]->minor . '-' . $this->yystack[$this->yyidx + 0]->minor, array(
  1393.         'pattern' => $this->yystack[$this->yyidx + -2]->minor . '-' . $this->yystack[$this->yyidx + 0]->minor));
  1394.     }
  1395. #line 1400 "Parser.php"
  1396. #line 168 "Parser.y"
  1397.         function yy_r39(){
  1398.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken('\\' . $this->yystack[$this->yyidx + -2]->minor . '-' . $this->yystack[$this->yyidx + 0]->minor, array(
  1399.         'pattern' => $this->yystack[$this->yyidx + -2]->minor . '-' . $this->yystack[$this->yyidx + 0]->minor));
  1400.     }
  1401. #line 1406 "Parser.php"
  1402. #line 172 "Parser.y"
  1403.         function yy_r40(){
  1404.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken($this->yystack[$this->yyidx + -2]->minor . '-' . $this->yystack[$this->yyidx + 0]->minor, array(
  1405.         'pattern' => $this->yystack[$this->yyidx + -2]->minor . '-' . $this->yystack[$this->yyidx + 0]->minor));
  1406.     }
  1407. #line 1412 "Parser.php"
  1408. #line 176 "Parser.y"
  1409.         function yy_r41(){
  1410.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken($this->yystack[$this->yyidx + -2]->minor . '-\\' . $this->yystack[$this->yyidx + 0]->minor, array(
  1411.         'pattern' => $this->yystack[$this->yyidx + -2]->minor . '-' . $this->yystack[$this->yyidx + 0]->minor));
  1412.     }
  1413. #line 1418 "Parser.php"
  1414. #line 180 "Parser.y"
  1415.         function yy_r42(){
  1416.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken($this->yystack[$this->yyidx + -2]->minor . '-\\\\' . $this->yystack[$this->yyidx + 0]->minor, array(
  1417.         'pattern' => $this->yystack[$this->yyidx + -2]->minor . '-' . $this->yystack[$this->yyidx + 0]->minor));
  1418.     }
  1419. #line 1424 "Parser.php"
  1420. #line 184 "Parser.y"
  1421.         function yy_r43(){
  1422.     if (((int) substr($this->yystack[$this->yyidx + 0]->minor, 1)) > $this->_subpatterns) {
  1423.         throw new PHP_LexerGenerator_Exception('Back-reference refers to non-existent ' .
  1424.             'sub-pattern ' . substr($this->yystack[$this->yyidx + 0]->minor, 1));
  1425.     }
  1426.     $this->yystack[$this->yyidx + 0]->minor = substr($this->yystack[$this->yyidx + 0]->minor, 1);
  1427.     // adjust back-reference for containing ()
  1428.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken('\\\\' . ($this->yystack[$this->yyidx + 0]->minor + $this->_patternIndex), array(
  1429.         'pattern' => '\\' . ($this->_updatePattern ? ($this->yystack[$this->yyidx + 0]->minor + $this->_patternIndex) : $this->yystack[$this->yyidx + 0]->minor)));
  1430.     }
  1431. #line 1436 "Parser.php"
  1432. #line 194 "Parser.y"
  1433.         function yy_r44(){
  1434.     if (((int) substr($this->yystack[$this->yyidx + 0]->minor, 1)) > $this->_subpatterns) {
  1435.         throw new PHP_LexerGenerator_Exception($this->yystack[$this->yyidx + 0]->minor . ' will be interpreted as an invalid' .
  1436.             ' back-reference, use "\\0' . substr($this->yystack[$this->yyidx + 0]->minor, 1) . ' for octal');
  1437.     }
  1438.     $this->yystack[$this->yyidx + 0]->minor = substr($this->yystack[$this->yyidx + 0]->minor, 1);
  1439.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken('\\\\' . ($this->yystack[$this->yyidx + 0]->minor + $this->_patternIndex), array(
  1440.         'pattern' => '\\' . ($this->_updatePattern ? ($this->yystack[$this->yyidx + 0]->minor + $this->_patternIndex) : $this->yystack[$this->yyidx + 0]->minor)));
  1441.     }
  1442. #line 1447 "Parser.php"
  1443. #line 203 "Parser.y"
  1444.         function yy_r45(){
  1445.     $this->_retvalue = new PHP_LexerGenerator_ParseryyToken($this->yystack[$this->yyidx + -1]->minor->string . '\\' . $this->yystack[$this->yyidx + 0]->minor, ar