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,