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


Classes:
PHP_LexerGenerator
   CodeGen_PECL_Tools_ProtoLexer
   CodeGen_PECL_Tools_ProtoParser
   File_ChessPGN_Lexer
   PHP_LexerGenerator_ParseryyStackEntry
   PHP_LexerGenerator_ParseryyToken
   PHP_LexerGenerator_Regex_Lexer
   PHP_LexerGenerator_Regex_Parser
   PHP_LexerGenerator_Regex_yyStackEntry
   PHP_LexerGenerator_Regex_yyToken
   TestLexer

Class: PHP_LexerGenerator_Regex_Parser

Source Location: /PHP_LexerGenerator-0.4.0/PHP/LexerGenerator/Regex/Parser.php

Class Overview


















Variables






Methods
















Inherited Variables





Inherited Methods














Class Details



[line 104]






[ Top ]







Class Variables



	
	

	
$result = 

	
[line 114]

  


    

  • Access: public
    • 





  

	

  

    

      Type:  
      mixed
    

      

	



	
[ Top ]


	
	

	
$yyerrcnt = 

	
[line 559]

  


    

  • Access: public
    • 





  

	

  

    

      Type:  
      int
    

      

	



	
[ Top ]


	
	

	
$yyExpectedTokens = array(

        /* 0 */ array(1, 2, 5, 7, 10, 11, 13, 14, 15, 16, ),/* 1 */array(1,2,5,7,10,11,13,14,15,16,),/* 2 */array(1,2,5,7,10,11,13,14,15,16,),/* 3 */array(1,2,5,7,10,11,13,14,15,16,),/* 4 */array(1,2,5,7,10,11,13,14,15,16,),/* 5 */array(1,2,5,7,10,11,13,14,15,16,),/* 6 */array(1,2,5,7,10,11,13,14,15,16,),/* 7 */array(1,2,5,7,10,11,13,14,15,16,),/* 8 */array(1,2,5,7,10,11,13,14,15,16,),/* 9 */array(1,2,5,7,10,11,13,14,15,16,),/* 10 */array(1,2,5,7,10,11,13,14,15,16,),/* 11 */array(1,2,5,7,10,11,13,14,15,16,),/* 12 */array(1,2,5,7,10,11,13,14,15,16,),/* 13 */array(1,2,5,7,10,11,13,14,15,16,),/* 14 */array(1,2,7,10,11,13,14,15,16,),/* 15 */array(1,2,6,7,10,11,13,14,15,16,),/* 16 */array(1,2,6,7,10,11,13,14,15,16,),/* 17 */array(1,2,17,19,20,21,22,23,24,25,26,27,),/* 18 */array(9,10,11,13,14,),/* 19 */array(10,11,13,14,),/* 20 */array(8,10,11,13,14,15,),/* 21 */array(8,10,11,13,14,15,),/* 22 */array(10,11,13,14,15,16,),/* 23 */array(10,11,13,14,15,16,),/* 24 */array(20,21,22,23,),/* 25 */array(3,18,),/* 26 */array(18,19,),/* 27 */array(10,11,),/* 28 */array(3,18,),/* 29 */array(10,11,),/* 30 */array(3,18,),/* 31 */array(10,15,),/* 32 */array(3,18,),/* 33 */array(3,18,),/* 34 */array(3,18,),/* 35 */array(3,18,),/* 36 */array(3,18,),/* 37 */array(3,18,),/* 38 */array(3,18,),/* 39 */array(3,18,),/* 40 */array(3,18,),/* 41 */array(4,),/* 42 */array(4,),/* 43 */array(4,),/* 44 */array(4,),/* 45 */array(3,),/* 46 */array(4,),/* 47 */array(4,),/* 48 */array(4,),/* 49 */array(18,),/* 50 */array(18,),/* 51 */array(4,),/* 52 */array(4,),/* 53 */array(4,),/* 54 */array(10,),/* 55 */array(18,),/* 56 */array(4,),/* 57 */array(4,),/* 58 */array(4,),/* 59 */array(4,),/* 60 */array(12,),/* 61 */array(4,),/* 62 */array(4,),/* 63 */array(4,),/* 64 */array(4,),/* 65 */array(4,),/* 66 */array(4,),/* 67 */array(12,),/* 68 */array(12,),/* 69 */array(12,),/* 70 */array(10,),/* 71 */array(),/* 72 */array(),/* 73 */array(),/* 74 */array(),/* 75 */array(),/* 76 */array(),/* 77 */array(),/* 78 */array(),/* 79 */array(),/* 80 */array(),/* 81 */array(),/* 82 */array(),/* 83 */array(),/* 84 */array(),/* 85 */array(),/* 86 */array(),/* 87 */array(),/* 88 */array(),/* 89 */array(),/* 90 */array(),/* 91 */array(),/* 92 */array(),/* 93 */array(),/* 94 */array(),/* 95 */array(),/* 96 */array(),/* 97 */array(),/* 98 */array(),/* 99 */array(),/* 100 */array(),/* 101 */array(),/* 102 */array(),/* 103 */array(),/* 104 */array(),/* 105 */array(),/* 106 */array(),/* 107 */array(),/* 108 */array(),/* 109 */array(),/* 110 */array(),/* 111 */array(),/* 112 */array(),/* 113 */array(),/* 114 */array(),/* 115 */array(),/* 116 */array(),/* 117 */array(),/* 118 */array(),/* 119 */array(),/* 120 */array(),/* 121 */array(),/* 122 */array(),/* 123 */array(),/* 124 */array(),/* 125 */array(),/* 126 */array(),/* 127 */array(),/* 128 */array(),/* 129 */array(),/* 130 */array(),/* 131 */array(),/* 132 */array(),/* 133 */array(),/* 134 */array(),)

	
[line 317]

  


    

  • Access: public
    • 





  

	

  

    

      Type:  
      mixed
    

      

	



	
[ Top ]


	
	

	
$yyFallback = array(

    )

	
[line 502]

  The next table maps tokens into fallback tokens.  If a construct  like the following:
%fallback ID X Y Z.
appears in the grammer, then ID becomes a fallback token for X, Y,  and Z.  Whenever one of the tokens X, Y, or Z is input to the parser  but it does not parse, the type of the token is changed to ID and  the parse is retried before an error is thrown.


    

  • Access: public
    • 





  

	

  

    

      Type:  
      mixed
    

      

	



	
[ Top ]


	
	

	
$yyidx = 

	
[line 555]

  


    

  • Access: public
    • 





  

	

  

    

      Type:  
      int
    

      

	



	
[ Top ]


	
	

	
$yyReduceMap = array(

        0 => 0,

        1 => 1,

        2 => 2,

        3 => 3,

        4 => 4,

        6 => 4,

        7 => 4,

        9 => 4,

        10 => 4,

        12 => 4,

        13 => 4,

        14 => 4,

        15 => 4,

        16 => 4,

        5 => 5,

        17 => 17,

        18 => 17,

        20 => 17,

        21 => 17,

        23 => 17,

        24 => 17,

        25 => 17,

        26 => 17,

        27 => 17,

        28 => 28,

        29 => 29,

        30 => 30,

        31 => 31,

        32 => 32,

        48 => 32,

        50 => 32,

        33 => 33,

        54 => 33,

        34 => 34,

        35 => 35,

        36 => 36,

        37 => 37,

        56 => 37,

        38 => 38,

        58 => 38,

        39 => 39,

        64 => 39,

        40 => 40,

        66 => 40,

        41 => 41,

        60 => 41,

        62 => 41,

        42 => 42,

        43 => 43,

        44 => 44,

        45 => 45,

        46 => 46,

        68 => 46,

        47 => 47,

        70 => 47,

        49 => 49,

        51 => 49,

        52 => 52,

        53 => 53,

        55 => 55,

        57 => 57,

        59 => 59,

        61 => 61,

        63 => 61,

        65 => 65,

        67 => 67,

        69 => 69,

        71 => 71,

        72 => 72,

        73 => 73,

        74 => 74,

        75 => 75,

        76 => 76,

        77 => 77,

        78 => 78,

        79 => 79,

        80 => 80,

        84 => 80,

        81 => 81,

        82 => 82,

        83 => 83,

        85 => 85,

        86 => 86,

        87 => 87,

        88 => 88,

        89 => 89,

        90 => 90,

        91 => 91,

        92 => 92,

    )

	
[line 1147]

  The following table contains a mapping of reduce action to method name  that handles the reduction.
If a rule is not set, it has no handler.


    

  • Access: public
    • 





  

	

  

    

      Type:  
      mixed
    

      

	



	
[ Top ]


	
	

	
$yyRuleInfo = array(

  array( 'lhs' => 29, 'rhs' => 1 ),array('lhs'=>30,'rhs'=>3),array('lhs'=>30,'rhs'=>2),array('lhs'=>30,'rhs'=>2),array('lhs'=>30,'rhs'=>1),array('lhs'=>30,'rhs'=>3),array('lhs'=>31,'rhs'=>1),array('lhs'=>31,'rhs'=>1),array('lhs'=>31,'rhs'=>1),array('lhs'=>31,'rhs'=>1),array('lhs'=>31,'rhs'=>1),array('lhs'=>31,'rhs'=>1),array('lhs'=>31,'rhs'=>1),array('lhs'=>31,'rhs'=>1),array('lhs'=>31,'rhs'=>1),array('lhs'=>31,'rhs'=>1),array('lhs'=>31,'rhs'=>1),array('lhs'=>31,'rhs'=>2),array('lhs'=>31,'rhs'=>2),array('lhs'=>31,'rhs'=>2),array('lhs'=>31,'rhs'=>2),array('lhs'=>31,'rhs'=>2),array('lhs'=>31,'rhs'=>2),array('lhs'=>31,'rhs'=>2),array('lhs'=>31,'rhs'=>2),array('lhs'=>31,'rhs'=>2),array('lhs'=>31,'rhs'=>2),array('lhs'=>31,'rhs'=>2),array('lhs'=>33,'rhs'=>3),array('lhs'=>33,'rhs'=>4),array('lhs'=>33,'rhs'=>4),array('lhs'=>33,'rhs'=>5),array('lhs'=>43,'rhs'=>1),array('lhs'=>43,'rhs'=>1),array('lhs'=>43,'rhs'=>3),array('lhs'=>43,'rhs'=>3),array('lhs'=>43,'rhs'=>3),array('lhs'=>43,'rhs'=>1),array('lhs'=>43,'rhs'=>1),array('lhs'=>43,'rhs'=>2),array('lhs'=>43,'rhs'=>2),array('lhs'=>43,'rhs'=>2),array('lhs'=>43,'rhs'=>4),array('lhs'=>43,'rhs'=>4),array('lhs'=>43,'rhs'=>4),array('lhs'=>43,'rhs'=>4),array('lhs'=>43,'rhs'=>2),array('lhs'=>43,'rhs'=>2),array('lhs'=>32,'rhs'=>1),array('lhs'=>32,'rhs'=>2),array('lhs'=>32,'rhs'=>1),array('lhs'=>32,'rhs'=>2),array('lhs'=>32,'rhs'=>1),array('lhs'=>32,'rhs'=>2),array('lhs'=>32,'rhs'=>1),array('lhs'=>32,'rhs'=>2),array('lhs'=>32,'rhs'=>1),array('lhs'=>32,'rhs'=>2),array('lhs'=>32,'rhs'=>1),array('lhs'=>32,'rhs'=>2),array('lhs'=>32,'rhs'=>2),array('lhs'=>32,'rhs'=>3),array('lhs'=>32,'rhs'=>2),array('lhs'=>32,'rhs'=>3),array('lhs'=>32,'rhs'=>2),array('lhs'=>32,'rhs'=>3),array('lhs'=>32,'rhs'=>2),array('lhs'=>32,'rhs'=>3),array('lhs'=>32,'rhs'=>2),array('lhs'=>32,'rhs'=>3),array('lhs'=>32,'rhs'=>2),array('lhs'=>32,'rhs'=>3),array('lhs'=>34,'rhs'=>3),array('lhs'=>34,'rhs'=>5),array('lhs'=>35,'rhs'=>4),array('lhs'=>35,'rhs'=>5),array('lhs'=>42,'rhs'=>7),array('lhs'=>42,'rhs'=>6),array('lhs'=>42,'rhs'=>4),array('lhs'=>42,'rhs'=>5),array('lhs'=>42,'rhs'=>4),array('lhs'=>42,'rhs'=>5),array('lhs'=>36,'rhs'=>4),array('lhs'=>36,'rhs'=>4),array('lhs'=>37,'rhs'=>4),array('lhs'=>37,'rhs'=>4),array('lhs'=>38,'rhs'=>4),array('lhs'=>38,'rhs'=>5),array('lhs'=>38,'rhs'=>3),array('lhs'=>38,'rhs'=>4),array('lhs'=>39,'rhs'=>4),array('lhs'=>40,'rhs'=>3),array('lhs'=>41,'rhs'=>3),)

	
[line 1045]

  The following table contains information about every rule that  is used during the reduce.
 array(
  array(
   int $lhs;         Symbol on the left-hand side of the rule
   int $nrhs;     Number of right-hand side symbols in the rule
  ),...
 );


    

  • Access: public
    • 





  

	

  

    

      Type:  
      mixed
    

      

	



	
[ Top ]


	
	

	
$yyRuleName = array(

 /*   0 */ "start ::= pattern",

 /*   1 */ "pattern ::= MATCHSTART basic_pattern MATCHEND",

 /*   2 */ "pattern ::= MATCHSTART basic_pattern",

 /*   3 */ "pattern ::= basic_pattern MATCHEND",

 /*   4 */ "pattern ::= basic_pattern",

 /*   5 */ "pattern ::= pattern BAR pattern",

 /*   6 */ "basic_pattern ::= basic_text",

 /*   7 */ "basic_pattern ::= character_class",

 /*   8 */ "basic_pattern ::= assertion",

 /*   9 */ "basic_pattern ::= grouping",

 /*  10 */ "basic_pattern ::= lookahead",

 /*  11 */ "basic_pattern ::= lookbehind",

 /*  12 */ "basic_pattern ::= subpattern",

 /*  13 */ "basic_pattern ::= onceonly",

 /*  14 */ "basic_pattern ::= comment",

 /*  15 */ "basic_pattern ::= recur",

 /*  16 */ "basic_pattern ::= conditional",

 /*  17 */ "basic_pattern ::= basic_pattern basic_text",

 /*  18 */ "basic_pattern ::= basic_pattern character_class",

 /*  19 */ "basic_pattern ::= basic_pattern assertion",

 /*  20 */ "basic_pattern ::= basic_pattern grouping",

 /*  21 */ "basic_pattern ::= basic_pattern lookahead",

 /*  22 */ "basic_pattern ::= basic_pattern lookbehind",

 /*  23 */ "basic_pattern ::= basic_pattern subpattern",

 /*  24 */ "basic_pattern ::= basic_pattern onceonly",

 /*  25 */ "basic_pattern ::= basic_pattern comment",

 /*  26 */ "basic_pattern ::= basic_pattern recur",

 /*  27 */ "basic_pattern ::= basic_pattern conditional",

 /*  28 */ "character_class ::= OPENCHARCLASS character_class_contents CLOSECHARCLASS",

 /*  29 */ "character_class ::= OPENCHARCLASS NEGATE character_class_contents CLOSECHARCLASS",

 /*  30 */ "character_class ::= OPENCHARCLASS character_class_contents CLOSECHARCLASS MULTIPLIER",

 /*  31 */ "character_class ::= OPENCHARCLASS NEGATE character_class_contents CLOSECHARCLASS MULTIPLIER",

 /*  32 */ "character_class_contents ::= TEXT",

 /*  33 */ "character_class_contents ::= ESCAPEDBACKSLASH",

 /*  34 */ "character_class_contents ::= ESCAPEDBACKSLASH HYPHEN TEXT",

 /*  35 */ "character_class_contents ::= TEXT HYPHEN TEXT",

 /*  36 */ "character_class_contents ::= TEXT HYPHEN ESCAPEDBACKSLASH",

 /*  37 */ "character_class_contents ::= BACKREFERENCE",

 /*  38 */ "character_class_contents ::= COULDBEBACKREF",

 /*  39 */ "character_class_contents ::= character_class_contents CONTROLCHAR",

 /*  40 */ "character_class_contents ::= character_class_contents ESCAPEDBACKSLASH",

 /*  41 */ "character_class_contents ::= character_class_contents TEXT",

 /*  42 */ "character_class_contents ::= character_class_contents ESCAPEDBACKSLASH HYPHEN CONTROLCHAR",

 /*  43 */ "character_class_contents ::= character_class_contents ESCAPEDBACKSLASH HYPHEN TEXT",

 /*  44 */ "character_class_contents ::= character_class_contents TEXT HYPHEN ESCAPEDBACKSLASH",

 /*  45 */ "character_class_contents ::= character_class_contents TEXT HYPHEN TEXT",

 /*  46 */ "character_class_contents ::= character_class_contents BACKREFERENCE",

 /*  47 */ "character_class_contents ::= character_class_contents COULDBEBACKREF",

 /*  48 */ "basic_text ::= TEXT",

 /*  49 */ "basic_text ::= TEXT MULTIPLIER",

 /*  50 */ "basic_text ::= FULLSTOP",

 /*  51 */ "basic_text ::= FULLSTOP MULTIPLIER",

 /*  52 */ "basic_text ::= CONTROLCHAR",

 /*  53 */ "basic_text ::= CONTROLCHAR MULTIPLIER",

 /*  54 */ "basic_text ::= ESCAPEDBACKSLASH",

 /*  55 */ "basic_text ::= ESCAPEDBACKSLASH MULTIPLIER",

 /*  56 */ "basic_text ::= BACKREFERENCE",

 /*  57 */ "basic_text ::= BACKREFERENCE MULTIPLIER",

 /*  58 */ "basic_text ::= COULDBEBACKREF",

 /*  59 */ "basic_text ::= COULDBEBACKREF MULTIPLIER",

 /*  60 */ "basic_text ::= basic_text TEXT",

 /*  61 */ "basic_text ::= basic_text TEXT MULTIPLIER",

 /*  62 */ "basic_text ::= basic_text FULLSTOP",

 /*  63 */ "basic_text ::= basic_text FULLSTOP MULTIPLIER",

 /*  64 */ "basic_text ::= basic_text CONTROLCHAR",

 /*  65 */ "basic_text ::= basic_text CONTROLCHAR MULTIPLIER",

 /*  66 */ "basic_text ::= basic_text ESCAPEDBACKSLASH",

 /*  67 */ "basic_text ::= basic_text ESCAPEDBACKSLASH MULTIPLIER",

 /*  68 */ "basic_text ::= basic_text BACKREFERENCE",

 /*  69 */ "basic_text ::= basic_text BACKREFERENCE MULTIPLIER",

 /*  70 */ "basic_text ::= basic_text COULDBEBACKREF",

 /*  71 */ "basic_text ::= basic_text COULDBEBACKREF MULTIPLIER",

 /*  72 */ "assertion ::= OPENASSERTION INTERNALOPTIONS CLOSEPAREN",

 /*  73 */ "assertion ::= OPENASSERTION INTERNALOPTIONS COLON pattern CLOSEPAREN",

 /*  74 */ "grouping ::= OPENASSERTION COLON pattern CLOSEPAREN",

 /*  75 */ "grouping ::= OPENASSERTION COLON pattern CLOSEPAREN MULTIPLIER",

 /*  76 */ "conditional ::= OPENASSERTION OPENPAREN TEXT CLOSEPAREN pattern CLOSEPAREN MULTIPLIER",

 /*  77 */ "conditional ::= OPENASSERTION OPENPAREN TEXT CLOSEPAREN pattern CLOSEPAREN",

 /*  78 */ "conditional ::= OPENASSERTION lookahead pattern CLOSEPAREN",

 /*  79 */ "conditional ::= OPENASSERTION lookahead pattern CLOSEPAREN MULTIPLIER",

 /*  80 */ "conditional ::= OPENASSERTION lookbehind pattern CLOSEPAREN",

 /*  81 */ "conditional ::= OPENASSERTION lookbehind pattern CLOSEPAREN MULTIPLIER",

 /*  82 */ "lookahead ::= OPENASSERTION POSITIVELOOKAHEAD pattern CLOSEPAREN",

 /*  83 */ "lookahead ::= OPENASSERTION NEGATIVELOOKAHEAD pattern CLOSEPAREN",

 /*  84 */ "lookbehind ::= OPENASSERTION POSITIVELOOKBEHIND pattern CLOSEPAREN",

 /*  85 */ "lookbehind ::= OPENASSERTION NEGATIVELOOKBEHIND pattern CLOSEPAREN",

 /*  86 */ "subpattern ::= OPENASSERTION PATTERNNAME pattern CLOSEPAREN",

 /*  87 */ "subpattern ::= OPENASSERTION PATTERNNAME pattern CLOSEPAREN MULTIPLIER",

 /*  88 */ "subpattern ::= OPENPAREN pattern CLOSEPAREN",

 /*  89 */ "subpattern ::= OPENPAREN pattern CLOSEPAREN MULTIPLIER",

 /*  90 */ "onceonly ::= OPENASSERTION ONCEONLY pattern CLOSEPAREN",

 /*  91 */ "comment ::= OPENASSERTION COMMENT CLOSEPAREN",

 /*  92 */ "recur ::= OPENASSERTION RECUR CLOSEPAREN",

    )

	
[line 588]

  For tracing reduce actions, the names of all rules are required.


    

  • Access: public
    • 





  

	

  

    

      Type:  
      array
    

      

	



	
[ Top ]


	
	

	
$yystack = array()

	
[line 563]

  


    

  • Access: public
    • 





  

	

  

    

      Type:  
      array
    

      

	



	
[ Top ]


	
	

	
$yyTokenName = array( 

  '$',             'OPENPAREN',     'OPENASSERTION',  'BAR',         

  'MULTIPLIER',    'MATCHSTART',    'MATCHEND',      'OPENCHARCLASS',

  'CLOSECHARCLASS',  'NEGATE',        'TEXT',          'ESCAPEDBACKSLASH',

  'HYPHEN',        'BACKREFERENCE',  'COULDBEBACKREF',  'CONTROLCHAR', 

  'FULLSTOP',      'INTERNALOPTIONS',  'CLOSEPAREN',    'COLON',       

  'POSITIVELOOKAHEAD',  'NEGATIVELOOKAHEAD',  'POSITIVELOOKBEHIND',  'NEGATIVELOOKBEHIND',

  'PATTERNNAME',   'ONCEONLY',      'COMMENT',       'RECUR',       

  'error',         'start',         'pattern',       'basic_pattern',

  'basic_text',    'character_class',  'assertion',     'grouping',    

  'lookahead',     'lookbehind',    'subpattern',    'onceonly',    

  'comment',       'recur',         'conditional',   'character_class_contents',

    )

	
[line 570]

  For tracing shifts, the names of all terminals and nonterminals
are required.  The following table supplies these names


    

  • Access: public
    • 





  

	

  

    

      Type:  
      array
    

      

	



	
[ Top ]


	
	

	
$yyTraceFILE = 

	
[line 546]

  


    

  • Access: public
    • 





  

	

  

    

      Type:  
      resource|0
    

      

	



	
[ Top ]


	
	

	
$yyTracePrompt = 

	
[line 551]

  String to prepend to debug output


    

  • Access: public
    • 





  

	

  

    

      Type:  
      string|0
    

      

	



	
[ Top ]


	
	

	
$yy_action = array(

 /*     0 */   229,   45,   15,   23,  104,  106,  107,  109,  108,  118,

 /*    10 */   119,  129,  128,  130,   36,   15,   23,  104,  106,  107,

 /*    20 */   109,  108,  118,  119,  129,  128,  130,   39,   15,   23,

 /*    30 */   104,  106,  107,  109,  108,  118,  119,  129,  128,  130,

 /*    40 */    25,   15,   23,  104,  106,  107,  109,  108,  118,  119,

 /*    50 */   129,  128,  130,   32,   15,   23,  104,  106,  107,  109,

 /*    60 */   108,  118,  119,  129,  128,  130,   28,   15,   23,  104,

 /*    70 */   106,  107,  109,  108,  118,  119,  129,  128,  130,   35,

 /*    80 */    15,   23,  104,  106,  107,  109,  108,  118,  119,  129,

 /*    90 */   128,  130,   92,   15,   23,  104,  106,  107,  109,  108,

 /*   100 */   118,  119,  129,  128,  130,   38,   15,   23,  104,  106,

 /*   110 */   107,  109,  108,  118,  119,  129,  128,  130,   40,   15,

 /*   120 */    23,  104,  106,  107,  109,  108,  118,  119,  129,  128,

 /*   130 */   130,   33,   15,   23,  104,  106,  107,  109,  108,  118,

 /*   140 */   119,  129,  128,  130,   30,   15,   23,  104,  106,  107,

 /*   150 */   109,  108,  118,  119,  129,  128,  130,   37,   15,   23,

 /*   160 */   104,  106,  107,  109,  108,  118,  119,  129,  128,  130,

 /*   170 */    34,   15,   23,  104,  106,  107,  109,  108,  118,  119,

 /*   180 */   129,  128,  130,   16,   23,  104,  106,  107,  109,  108,

 /*   190 */   118,  119,  129,  128,  130,   54,   24,   22,   72,   76,

 /*   200 */    85,   84,   82,   81,   80,   97,  134,  125,   93,   12,

 /*   210 */    12,   26,   83,    2,    5,    1,   11,    4,   10,   13,

 /*   220 */    49,   50,    9,   17,   46,   98,   14,   12,   18,  113,

 /*   230 */   124,   52,   43,   79,   44,   57,   42,   41,    9,   17,

 /*   240 */   127,   12,   53,   91,   18,  126,   12,   52,   43,  120,

 /*   250 */    44,   57,   42,   41,    9,   17,   47,   12,   31,  117,

 /*   260 */    18,   88,   99,   52,   43,   75,   44,   57,   42,   41,

 /*   270 */     9,   17,   51,   19,   67,   69,   18,  101,   87,   52,

 /*   280 */    43,   12,   44,   57,   42,   41,  132,   64,   63,  103,

 /*   290 */    62,   58,   66,   65,   59,   12,   60,   68,   90,  111,

 /*   300 */   116,  122,   61,  100,   60,   68,   12,  111,  116,  122,

 /*   310 */    71,    5,    1,   11,    4,   67,   69,   12,  101,   87,

 /*   320 */    12,  102,   12,   12,  112,    6,  105,  131,   78,    7,

 /*   330 */     8,   95,   77,   74,   70,   56,  123,   48,  133,   73,

 /*   340 */    27,  114,   86,   55,  115,   89,  110,  121,    3,   94,

 /*   350 */    21,   29,   96,   20,

    )

	
[line 223]

  


    

  • Access: public
    • 





  

	

  

    

      Type:  
      mixed
    

      

	



	
[ Top ]


	
	

	
$yy_default = array(

 /*     0 */   228,  228,  228,  228,  228,  228,  228,  228,  228,  228,

 /*    10 */   228,  228,  228,  228,  228,  139,  137,  228,  228,  228,

 /*    20 */   228,  228,  152,  141,  228,  228,  228,  228,  228,  228,

 /*    30 */   228,  228,  228,  228,  228,  228,  228,  228,  228,  228,

 /*    40 */   228,  185,  187,  189,  191,  135,  212,  215,  221,  228,

 /*    50 */   228,  213,  183,  209,  228,  228,  223,  193,  205,  163,

 /*    60 */   176,  164,  203,  201,  195,  197,  199,  167,  175,  168,

 /*    70 */   228,  217,  153,  204,  206,  190,  154,  218,  216,  214,

 /*    80 */   159,  158,  157,  169,  156,  155,  202,  173,  225,  196,

 /*    90 */   226,  136,  140,  227,  186,  222,  188,  160,  220,  200,

 /*   100 */   198,  172,  219,  211,  142,  180,  143,  144,  146,  145,

 /*   110 */   224,  181,  207,  170,  194,  166,  182,  138,  147,  148,

 /*   120 */   184,  210,  174,  165,  171,  162,  177,  178,  150,  149,

 /*   130 */   151,  179,  192,  208,  161,

)

	
[line 454]

  


    

  • Access: public
    • 





  

	

  

    

      Type:  
      mixed
    

      

	



	
[ Top ]


	
	

	
$yy_lookahead = array(

 /*     0 */    29,   30,   31,   32,   33,   34,   35,   36,   37,   38,

 /*    10 */    39,   40,   41,   42,   30,   31,   32,   33,   34,   35,

 /*    20 */    36,   37,   38,   39,   40,   41,   42,   30,   31,   32,

 /*    30 */    33,   34,   35,   36,   37,   38,   39,   40,   41,   42,

 /*    40 */    30,   31,   32,   33,   34,   35,   36,   37,   38,   39,

 /*    50 */    40,   41,   42,   30,   31,   32,   33,   34,   35,   36,

 /*    60 */    37,   38,   39,   40,   41,   42,   30,   31,   32,   33,

 /*    70 */    34,   35,   36,   37,   38,   39,   40,   41,   42,   30,

 /*    80 */    31,   32,   33,   34,   35,   36,   37,   38,   39,   40,

 /*    90 */    41,   42,   30,   31,   32,   33,   34,   35,   36,   37,

 /*   100 */    38,   39,   40,   41,   42,   30,   31,   32,   33,   34,

 /*   110 */    35,   36,   37,   38,   39,   40,   41,   42,   30,   31,

 /*   120 */    32,   33,   34,   35,   36,   37,   38,   39,   40,   41,

 /*   130 */    42,   30,   31,   32,   33,   34,   35,   36,   37,   38,

 /*   140 */    39,   40,   41,   42,   30,   31,   32,   33,   34,   35,

 /*   150 */    36,   37,   38,   39,   40,   41,   42,   30,   31,   32,

 /*   160 */    33,   34,   35,   36,   37,   38,   39,   40,   41,   42,

 /*   170 */    30,   31,   32,   33,   34,   35,   36,   37,   38,   39,

 /*   180 */    40,   41,   42,   31,   32,   33,   34,   35,   36,   37,

 /*   190 */    38,   39,   40,   41,   42,    1,    2,   32,   33,   34,

 /*   200 */    35,   36,   37,   38,   39,   40,   41,   42,   18,    3,

 /*   210 */     3,   17,   10,   19,   20,   21,   22,   23,   24,   25,

 /*   220 */    26,   27,    1,    2,   18,   18,    5,    3,    7,   10,

 /*   230 */    11,   10,   11,    4,   13,   14,   15,   16,    1,    2,

 /*   240 */    10,    3,   18,    6,    7,   15,    3,   10,   11,    4,

 /*   250 */    13,   14,   15,   16,    1,    2,   18,    3,   12,    6,

 /*   260 */     7,   18,    4,   10,   11,    4,   13,   14,   15,   16,

 /*   270 */     1,    2,   18,    9,   10,   11,    7,   13,   14,   10,

 /*   280 */    11,    3,   13,   14,   15,   16,    4,   10,   11,    4,

 /*   290 */    13,   14,   15,   16,    8,    3,   10,   11,   18,   13,

 /*   300 */    14,   15,    8,    4,   10,   11,    3,   13,   14,   15,

 /*   310 */    18,   20,   21,   22,   23,   10,   11,    3,   13,   14,

 /*   320 */     3,   18,    3,    3,   18,   19,   10,   11,    4,   36,

 /*   330 */    37,    4,   18,    4,   12,   18,    4,   18,   18,    4,

 /*   340 */    12,    4,    4,   10,    4,    4,    4,    4,   18,    4,

 /*   350 */    43,   12,    4,   43,

)

	
[line 261]

  


    

  • Access: public
    • 





  

	

  

    

      Type:  
      mixed
    

      

	



	
[ Top ]


	
	

	
$yy_reduce_ofst = array(

 /*     0 */   -29,  127,  114,  101,  140,   88,   10,   -3,   23,   36,

 /*    10 */    49,   75,   62,  -16,  152,  165,  165,  293,  310,  307,

)

	
[line 313]

  


    

  • Access: public
    • 





  

	

  

    

      Type:  
      mixed
    

      

	



	
[ Top ]


	
	

	
$yy_shift_ofst = array(

 /*     0 */   221,  221,  221,  221,  221,  221,  221,  221,  221,  221,

 /*    10 */   221,  221,  221,  221,  269,  253,  237,  194,  264,  305,

 /*    20 */   286,  294,  277,  277,  291,  320,  306,  316,  317,  219,

 /*    30 */   224,  230,  238,  206,  207,  319,  243,  314,  303,  254,

 /*    40 */   292,  345,  348,  261,  282,  278,  285,  324,  327,  280,

 /*    50 */   190,  229,  245,  343,  333,  330,  342,  337,  329,  332,

 /*    60 */   328,  340,  335,  338,  341,  299,  258,  339,  246,  322,

 /*    70 */   202,

)

	
[line 301]

  


    

  • Access: public
    • 





  

	

  

    

      Type:  
      mixed
    

      

	



	
[ Top ]










Method Detail



	
	
doParse   [line 1811]

	

    

    

		void doParse(
int
$yymajor, mixed
$yytokenvalue, mixed
2)
    

    


	
		The main parser program.
The first argument is the major token number.  The second is  the token value string as scanned from the input.




        
Parameters:

    

    

          

        mixed  
        2  
        — 
        any extra arguments that should be passed to handlers
      

          

        int  
        $yymajor  
        — 
        the token number
      

          

        mixed  
        $yytokenvalue  
        — 
        the token value
      

        

    


        
[ Top ]

  

  
  
	
	
__construct (Constructor)   [line 115]

	

    

    

		PHP_LexerGenerator_Regex_Parser __construct(

$lex)
    

    


	
		



        
Parameters:

    

    

          

          
        $lex  
        — 
        
      

        

    


        
[ Top ]

  

  
  
	
	
__destruct (Destructor)   [line 756]

	

    

    

		void __destruct(
)
    

    


	
		Deallocate and destroy a parser.  Destructors are all called for  all stack elements before shutting the parser down.




        
[ Top ]

  

  
  
	
	
PrintTrace   [line 537]

	

    

    

		void PrintTrace(
)
    

    


	
		Output debug information to output (php://output stream)




        
[ Top ]

  

  
  
	
	
reset   [line 123]

	

    

    

		void reset(

$patternIndex, [
$updatePattern = false])
    

    


	
		



        
Parameters:

    

    

          

          
        $patternIndex  
        — 
        
      

          

          
        $updatePattern  
        — 
        
      

        

    


        
[ Top ]

  

  
  
	
	
tokenName   [line 690]

	

    

    

		string tokenName(
int
$tokenType)
    

    


	
		This function returns the symbolic name associated with a token  value.




        
Parameters:

    

    

          

        int  
        $tokenType  
        — 
        
      

        

    


        
[ Top ]

  

  
  
	
	
Trace   [line 523]

	

    

    

		void Trace(
resource
$TraceFILE, string
$zTracePrompt)
    

    


	
		Turn parser tracing on by giving a stream to which to write the trace  and a prompt to preface each trace message.  Tracing is turned off  by making either argument NULL
Inputs:
  • A stream resource to which trace output should be written.
   If NULL, then tracing is turned off.
  • A prefix string written at the beginning of every
   line of trace output.  If NULL, then tracing is
   turned off.
  Outputs:
  • None.




        
Parameters:

    

    

          

        resource  
        $TraceFILE  
        — 
        
      

          

        string  
        $zTracePrompt  
        — 
        
      

        

    


        
[ Top ]

  

  
  
	
	
yy_accept   [line 1789]

	

    

    

		void yy_accept(
)
    

    


	
		The following is executed when the parser accepts
%parse_accept code is inserted here




        
[ Top ]

  

  
  
	
	
yy_destructor   [line 708]

	

    

    

		void yy_destructor(
int
$yymajor, mixed
$yypminor)
    

    


	
		The following function deletes the value associated with a  symbol.  The symbol can be either a terminal or nonterminal.




        
Parameters:

    

    

          

        int  
        $yymajor  
        — 
        the symbol code
      

          

        mixed  
        $yypminor  
        — 
        the symbol's value
      

        

    


        
[ Top ]

  

  
  
	
	
yy_find_reduce_action   [line 971]

	

    

    

		void yy_find_reduce_action(
int
$stateno, int
$iLookAhead)
    

    


	
		Find the appropriate action for a parser given the non-terminal  look-ahead token $iLookAhead.
If the look-ahead token is self::YYNOCODE, then check to see if the action is  independent of the look-ahead.  If it is, return the action, otherwise  return self::YY_NO_ACTION.




        
Parameters:

    

    

          

        int  
        $stateno  
        — 
        Current state number
      

          

        int  
        $iLookAhead  
        — 
        The look-ahead token
      

        

    


        
[ Top ]

  

  
  
	
	
yy_find_shift_action   [line 927]

	

    

    

		void yy_find_shift_action(
int
$iLookAhead)
    

    


	
		Find the appropriate action for a parser given the terminal  look-ahead token iLookAhead.
If the look-ahead token is YYNOCODE, then check to see if the action is  independent of the look-ahead.  If it is, return the action, otherwise  return YY_NO_ACTION.




        
Parameters:

    

    

          

        int  
        $iLookAhead  
        — 
        The look-ahead token
      

        

    


        
[ Top ]

  

  
  
	
	
yy_get_expected_tokens   [line 772]

	

    

    

		array yy_get_expected_tokens(
int
$token)
    

    


	
		Based on the current state and parser stack, get a list of all
possible lookahead tokens




        
Parameters:

    

    

          

        int  
        $token  
        — 
        
      

        

    


        
[ Top ]

  

  
  
	
	
yy_is_expected_token   [line 847]

	

    

    

		bool yy_is_expected_token(
int
$token)
    

    


	
		Based on the parser state and current parser stack, determine whether  the lookahead token is possible.
The parser will convert the token value to an error token if not.  This  catches some unusual edge cases where the parser would fail.




        
Parameters:

    

    

          

        int  
        $token  
        — 
        
      

        

    


        
[ Top ]

  

  
  
	
	
yy_parse_failed   [line 1745]

	

    

    

		void yy_parse_failed(
)
    

    


	
		The following code executes when the parse fails
Code from %parse_fail is inserted here




        
[ Top ]

  

  
  
	
	
yy_pop_parser_stack   [line 735]

	

    

    

		int yy_pop_parser_stack(
PHP_LexerGenerator_Regex_yyParser
0)
    

    


	
		Pop the parser's stack once.
If there is a destructor routine associated with the token which  is popped from the stack, then call it.
Return the major token number for the symbol popped.




        
Parameters:

    

    

          

        PHP_LexerGenerator_Regex_yyParser  
        0  
        — 
        
      

        

    


        
[ Top ]

  

  
  
	
	
yy_r0   [line 1245]

	

    

    

		void yy_r0(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r1   [line 1255]

	

    

    

		void yy_r1(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r2   [line 1261]

	

    

    

		void yy_r2(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r3   [line 1267]

	

    

    

		void yy_r3(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r4   [line 1272]

	

    

    

		void yy_r4(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r5   [line 1275]

	

    

    

		void yy_r5(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r17   [line 1281]

	

    

    

		void yy_r17(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r28   [line 1287]

	

    

    

		void yy_r28(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r29   [line 1293]

	

    

    

		void yy_r29(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r30   [line 1299]

	

    

    

		void yy_r30(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r31   [line 1305]

	

    

    

		void yy_r31(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r32   [line 1311]

	

    

    

		void yy_r32(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r33   [line 1317]

	

    

    

		void yy_r33(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r34   [line 1323]

	

    

    

		void yy_r34(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r35   [line 1329]

	

    

    

		void yy_r35(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r36   [line 1335]

	

    

    

		void yy_r36(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r37   [line 1341]

	

    

    

		void yy_r37(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r38   [line 1353]

	

    

    

		void yy_r38(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r39   [line 1364]

	

    

    

		void yy_r39(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r40   [line 1370]

	

    

    

		void yy_r40(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r41   [line 1376]

	

    

    

		void yy_r41(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r42   [line 1382]

	

    

    

		void yy_r42(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r43   [line 1388]

	

    

    

		void yy_r43(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r44   [line 1394]

	

    

    

		void yy_r44(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r45   [line 1400]

	

    

    

		void yy_r45(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r46   [line 1406]

	

    

    

		void yy_r46(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r47   [line 1417]

	

    

    

		void yy_r47(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r49   [line 1428]

	

    

    

		void yy_r49(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r52   [line 1434]

	

    

    

		void yy_r52(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r53   [line 1440]

	

    

    

		void yy_r53(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r55   [line 1446]

	

    

    

		void yy_r55(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r57   [line 1452]

	

    

    

		void yy_r57(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r59   [line 1464]

	

    

    

		void yy_r59(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r61   [line 1475]

	

    

    

		void yy_r61(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r65   [line 1481]

	

    

    

		void yy_r65(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r67   [line 1487]

	

    

    

		void yy_r67(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r69   [line 1493]

	

    

    

		void yy_r69(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r71   [line 1504]

	

    

    

		void yy_r71(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r72   [line 1515]

	

    

    

		void yy_r72(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r73   [line 1521]

	

    

    

		void yy_r73(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r74   [line 1527]

	

    

    

		void yy_r74(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r75   [line 1533]

	

    

    

		void yy_r75(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r76   [line 1539]

	

    

    

		void yy_r76(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r77   [line 1555]

	

    

    

		void yy_r77(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r78   [line 1571]

	

    

    

		void yy_r78(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r79   [line 1577]

	

    

    

		void yy_r79(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r80   [line 1583]

	

    

    

		void yy_r80(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r81   [line 1589]

	

    

    

		void yy_r81(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r82   [line 1595]

	

    

    

		void yy_r82(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r83   [line 1601]

	

    

    

		void yy_r83(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r85   [line 1607]

	

    

    

		void yy_r85(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r86   [line 1613]

	

    

    

		void yy_r86(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r87   [line 1619]

	

    

    

		void yy_r87(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r88   [line 1625]

	

    

    

		void yy_r88(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r89   [line 1632]

	

    

    

		void yy_r89(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r90   [line 1639]

	

    

    

		void yy_r90(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r91   [line 1645]

	

    

    

		void yy_r91(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_r92   [line 1651]

	

    

    

		void yy_r92(
)
    

    


	
		



        
[ Top ]

  

  
  
	
	
yy_reduce   [line 1690]

	

    

    

		void yy_reduce(
int
$yyruleno)
    

    


	
		Perform a reduce action and the shift that must immediately  follow the reduce.
For a rule such as:
 A ::= B blah C. { dosomething(); }
This function will first call the action, if any, ("dosomething();" in our  example), and then it will pop three states from the stack,  one for each entry on the right-hand side of the expression  (B, blah, and C in our example rule), and then push the result of the action  back on to the stack with the resulting state reduced to (as described in the .out  file)




        
Parameters:

    

    

          

        int  
        $yyruleno  
        — 
        Number of the rule by which to reduce
      

        

    


        
[ Top ]

  

  
  
	
	
yy_shift   [line 1000]

	

    

    

		void yy_shift(
int
$yyNewState, int
$yyMajor, mixed
$yypMinor)
    

    


	
		Perform a shift action.




        
Parameters:

    

    

          

        int  
        $yyNewState  
        — 
        The new state to shift in
      

          

        int  
        $yyMajor  
        — 
        The major token to shift in
      

          

        mixed  
        $yypMinor  
        — 
        the minor token to shift in
      

        

    


        
[ Top ]

  

  
  
	
	
yy_syntax_error   [line 1764]

	

    

    

		void yy_syntax_error(
int
$yymajor, mixed
$TOKEN)
    

    


	
		The following code executes when a syntax error first occurs.
%syntax_error code is inserted here




        
Parameters:

    

    

          

        int  
        $yymajor  
        — 
        The major type of the error token
      

          

        mixed  
        $TOKEN  
        — 
        The minor type of the error token
      

        

    


        
[ Top ]

  

  
  



        

		    

		    Documentation generated on Mon, 11 Mar 2019 15:40:43 -0400 by phpDocumentor 1.4.4. PEAR Logo Copyright ©  PHP Group 2004.