library/smarty/libs/sysplugins/smarty_internal_configfilelexer.php
changeset 0 4869aea77e21
equal deleted inserted replaced
-1:000000000000 0:4869aea77e21
       
     1 <?php
       
     2 /**
       
     3  * Smarty Internal Plugin Configfilelexer
       
     4  *
       
     5  * This is the lexer to break the config file source into tokens
       
     6  *
       
     7  * @package    Smarty
       
     8  * @subpackage Config
       
     9  * @author     Uwe Tews
       
    10  */
       
    11 
       
    12 /**
       
    13  * Smarty_Internal_Configfilelexer
       
    14  *
       
    15  * This is the config file lexer.
       
    16  * It is generated from the smarty_internal_configfilelexer.plex file
       
    17  *
       
    18  * @package    Smarty
       
    19  * @subpackage Compiler
       
    20  * @author     Uwe Tews
       
    21  */
       
    22 class Smarty_Internal_Configfilelexer {
       
    23     /**
       
    24      * Source
       
    25      *
       
    26      * @var string
       
    27      */
       
    28     public $data;
       
    29 
       
    30     /**
       
    31      * byte counter
       
    32      *
       
    33      * @var int
       
    34      */
       
    35     public $counter;
       
    36 
       
    37     /**
       
    38      * token number
       
    39      *
       
    40      * @var int
       
    41      */
       
    42     public $token;
       
    43 
       
    44     /**
       
    45      * token value
       
    46      *
       
    47      * @var string
       
    48      */
       
    49     public $value;
       
    50 
       
    51     /**
       
    52      * current line
       
    53      *
       
    54      * @var int
       
    55      */
       
    56     public $line;
       
    57 
       
    58     /**
       
    59      * state number
       
    60      *
       
    61      * @var int
       
    62      */
       
    63     public $state = 1;
       
    64 
       
    65     /**
       
    66      * Smarty object
       
    67      *
       
    68      * @var Smarty
       
    69      */
       
    70     public $smarty = null;
       
    71 
       
    72     /**
       
    73      * compiler object
       
    74      *
       
    75      * @var Smarty_Internal_Config_File_Compiler
       
    76      */
       
    77     private $compiler = null;
       
    78 
       
    79     /**
       
    80      * copy of config_booleanize
       
    81      *
       
    82      * @var bool
       
    83      */
       
    84     private $configBooleanize = false;
       
    85 
       
    86     /**
       
    87      * trace file
       
    88      *
       
    89      * @var resource
       
    90      */
       
    91     public $yyTraceFILE;
       
    92 
       
    93     /**
       
    94      * trace prompt
       
    95      *
       
    96      * @var string
       
    97      */
       
    98     public $yyTracePrompt;
       
    99 
       
   100     /**
       
   101      * state names
       
   102      *
       
   103      * @var array
       
   104      */
       
   105     public $state_name = array(1 => 'START', 2 => 'VALUE', 3 => 'NAKED_STRING_VALUE', 4 => 'COMMENT', 5 => 'SECTION',
       
   106         6 => 'TRIPPLE');
       
   107 
       
   108     /**
       
   109      * storage for assembled token patterns
       
   110      *
       
   111      * @var sring
       
   112      */
       
   113     private $yy_global_pattern1 = null;
       
   114 
       
   115     private $yy_global_pattern2 = null;
       
   116 
       
   117     private $yy_global_pattern3 = null;
       
   118 
       
   119     private $yy_global_pattern4 = null;
       
   120 
       
   121     private $yy_global_pattern5 = null;
       
   122 
       
   123     private $yy_global_pattern6 = null;
       
   124 
       
   125     /**
       
   126      * token names
       
   127      *
       
   128      * @var array
       
   129      */
       
   130     public $smarty_token_names = array(        // Text for parser error messages
       
   131     );
       
   132 
       
   133     /**
       
   134      * constructor
       
   135      *
       
   136      * @param   string $data template source
       
   137      * @param Smarty_Internal_Config_File_Compiler $compiler
       
   138      */
       
   139     function __construct($data, Smarty_Internal_Config_File_Compiler $compiler) {
       
   140         // set instance object
       
   141         self::instance($this);
       
   142         $this->data = $data . "\n"; //now all lines are \n-terminated
       
   143         $this->counter = 0;
       
   144         if (preg_match('/^\xEF\xBB\xBF/', $this->data, $match)) {
       
   145             $this->counter += strlen($match[0]);
       
   146         }
       
   147         $this->line = 1;
       
   148         $this->compiler = $compiler;
       
   149         $this->smarty = $compiler->smarty;
       
   150         $this->configBooleanize = $this->smarty->config_booleanize;
       
   151     }
       
   152 
       
   153     public static function &instance($new_instance = null) {
       
   154         static $instance = null;
       
   155         if (isset($new_instance) && is_object($new_instance)) {
       
   156             $instance = $new_instance;
       
   157         }
       
   158         return $instance;
       
   159     }
       
   160 
       
   161     public function PrintTrace() {
       
   162         $this->yyTraceFILE = fopen('php://output', 'w');
       
   163         $this->yyTracePrompt = '<br>';
       
   164     }
       
   165 
       
   166     private $_yy_state = 1;
       
   167 
       
   168     private $_yy_stack = array();
       
   169 
       
   170     public function yylex() {
       
   171         return $this->{'yylex' . $this->_yy_state}();
       
   172     }
       
   173 
       
   174     public function yypushstate($state) {
       
   175         if ($this->yyTraceFILE) {
       
   176             fprintf($this->yyTraceFILE, "%sState push %s\n", $this->yyTracePrompt, isset($this->state_name[$this->_yy_state]) ? $this->state_name[$this->_yy_state] : $this->_yy_state);
       
   177         }
       
   178         array_push($this->_yy_stack, $this->_yy_state);
       
   179         $this->_yy_state = $state;
       
   180         if ($this->yyTraceFILE) {
       
   181             fprintf($this->yyTraceFILE, "%snew State %s\n", $this->yyTracePrompt, isset($this->state_name[$this->_yy_state]) ? $this->state_name[$this->_yy_state] : $this->_yy_state);
       
   182         }
       
   183     }
       
   184 
       
   185     public function yypopstate() {
       
   186         if ($this->yyTraceFILE) {
       
   187             fprintf($this->yyTraceFILE, "%sState pop %s\n", $this->yyTracePrompt, isset($this->state_name[$this->_yy_state]) ? $this->state_name[$this->_yy_state] : $this->_yy_state);
       
   188         }
       
   189         $this->_yy_state = array_pop($this->_yy_stack);
       
   190         if ($this->yyTraceFILE) {
       
   191             fprintf($this->yyTraceFILE, "%snew State %s\n", $this->yyTracePrompt, isset($this->state_name[$this->_yy_state]) ? $this->state_name[$this->_yy_state] : $this->_yy_state);
       
   192         }
       
   193     }
       
   194 
       
   195     public function yybegin($state) {
       
   196         $this->_yy_state = $state;
       
   197         if ($this->yyTraceFILE) {
       
   198             fprintf($this->yyTraceFILE, "%sState set %s\n", $this->yyTracePrompt, isset($this->state_name[$this->_yy_state]) ? $this->state_name[$this->_yy_state] : $this->_yy_state);
       
   199         }
       
   200     }
       
   201 
       
   202     public function yylex1() {
       
   203         if (!isset($this->yy_global_pattern1)) {
       
   204             $this->yy_global_pattern1 = "/\G(#|;)|\G(\\[)|\G(\\])|\G(=)|\G([ \t\r]+)|\G(\n)|\G([0-9]*[a-zA-Z_]\\w*)|\G([\S\s])/isS";
       
   205         }
       
   206         if ($this->counter >= strlen($this->data)) {
       
   207             return false; // end of input
       
   208         }
       
   209 
       
   210         do {
       
   211             if (preg_match($this->yy_global_pattern1, $this->data, $yymatches, null, $this->counter)) {
       
   212                 $yysubmatches = $yymatches;
       
   213                 if (strlen($yysubmatches[0]) < 200) {
       
   214                     $yymatches = preg_grep("/(.|\s)+/", $yysubmatches);
       
   215                 } else {
       
   216                     $yymatches = array_filter($yymatches, 'strlen');
       
   217                 }
       
   218                 if (empty($yymatches)) {
       
   219                     throw new Exception('Error: lexing failed because a rule matched' . ' an empty string.  Input "' . substr($this->data, $this->counter, 5) . '... state START');
       
   220                 }
       
   221                 next($yymatches); // skip global match
       
   222                 $this->token = key($yymatches); // token number
       
   223                 $this->value = current($yymatches); // token value
       
   224                 $r = $this->{'yy_r1_' . $this->token}();
       
   225                 if ($r === null) {
       
   226                     $this->counter += strlen($this->value);
       
   227                     $this->line += substr_count($this->value, "\n");
       
   228                     // accept this token
       
   229                     return true;
       
   230                 } elseif ($r === true) {
       
   231                     // we have changed state
       
   232                     // process this token in the new state
       
   233                     return $this->yylex();
       
   234                 } elseif ($r === false) {
       
   235                     $this->counter += strlen($this->value);
       
   236                     $this->line += substr_count($this->value, "\n");
       
   237                     if ($this->counter >= strlen($this->data)) {
       
   238                         return false; // end of input
       
   239                     }
       
   240                     // skip this token
       
   241                     continue;
       
   242                 }
       
   243             } else {
       
   244                 throw new Exception('Unexpected input at line' . $this->line . ': ' . $this->data[$this->counter]);
       
   245             }
       
   246             break;
       
   247         } while (true);
       
   248     } // end function
       
   249 
       
   250     const START = 1;
       
   251 
       
   252     function yy_r1_1() {
       
   253 
       
   254         $this->token = Smarty_Internal_Configfileparser::TPC_COMMENTSTART;
       
   255         $this->yypushstate(self::COMMENT);
       
   256     }
       
   257 
       
   258     function yy_r1_2() {
       
   259 
       
   260         $this->token = Smarty_Internal_Configfileparser::TPC_OPENB;
       
   261         $this->yypushstate(self::SECTION);
       
   262     }
       
   263 
       
   264     function yy_r1_3() {
       
   265 
       
   266         $this->token = Smarty_Internal_Configfileparser::TPC_CLOSEB;
       
   267     }
       
   268 
       
   269     function yy_r1_4() {
       
   270 
       
   271         $this->token = Smarty_Internal_Configfileparser::TPC_EQUAL;
       
   272         $this->yypushstate(self::VALUE);
       
   273     }
       
   274 
       
   275     function yy_r1_5() {
       
   276 
       
   277         return false;
       
   278     }
       
   279 
       
   280     function yy_r1_6() {
       
   281 
       
   282         $this->token = Smarty_Internal_Configfileparser::TPC_NEWLINE;
       
   283     }
       
   284 
       
   285     function yy_r1_7() {
       
   286 
       
   287         $this->token = Smarty_Internal_Configfileparser::TPC_ID;
       
   288     }
       
   289 
       
   290     function yy_r1_8() {
       
   291 
       
   292         $this->token = Smarty_Internal_Configfileparser::TPC_OTHER;
       
   293     }
       
   294 
       
   295     public function yylex2() {
       
   296         if (!isset($this->yy_global_pattern2)) {
       
   297             $this->yy_global_pattern2 = "/\G([ \t\r]+)|\G(\\d+\\.\\d+(?=[ \t\r]*[\n#;]))|\G(\\d+(?=[ \t\r]*[\n#;]))|\G(\"\"\")|\G('[^'\\\\]*(?:\\\\.[^'\\\\]*)*'(?=[ \t\r]*[\n#;]))|\G(\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\"(?=[ \t\r]*[\n#;]))|\G([a-zA-Z]+(?=[ \t\r]*[\n#;]))|\G([^\n]+?(?=[ \t\r]*\n))|\G(\n)/isS";
       
   298         }
       
   299         if ($this->counter >= strlen($this->data)) {
       
   300             return false; // end of input
       
   301         }
       
   302 
       
   303         do {
       
   304             if (preg_match($this->yy_global_pattern2, $this->data, $yymatches, null, $this->counter)) {
       
   305                 $yysubmatches = $yymatches;
       
   306                 if (strlen($yysubmatches[0]) < 200) {
       
   307                     $yymatches = preg_grep("/(.|\s)+/", $yysubmatches);
       
   308                 } else {
       
   309                     $yymatches = array_filter($yymatches, 'strlen');
       
   310                 }
       
   311                 if (empty($yymatches)) {
       
   312                     throw new Exception('Error: lexing failed because a rule matched' . ' an empty string.  Input "' . substr($this->data, $this->counter, 5) . '... state VALUE');
       
   313                 }
       
   314                 next($yymatches); // skip global match
       
   315                 $this->token = key($yymatches); // token number
       
   316                 $this->value = current($yymatches); // token value
       
   317                 $r = $this->{'yy_r2_' . $this->token}();
       
   318                 if ($r === null) {
       
   319                     $this->counter += strlen($this->value);
       
   320                     $this->line += substr_count($this->value, "\n");
       
   321                     // accept this token
       
   322                     return true;
       
   323                 } elseif ($r === true) {
       
   324                     // we have changed state
       
   325                     // process this token in the new state
       
   326                     return $this->yylex();
       
   327                 } elseif ($r === false) {
       
   328                     $this->counter += strlen($this->value);
       
   329                     $this->line += substr_count($this->value, "\n");
       
   330                     if ($this->counter >= strlen($this->data)) {
       
   331                         return false; // end of input
       
   332                     }
       
   333                     // skip this token
       
   334                     continue;
       
   335                 }
       
   336             } else {
       
   337                 throw new Exception('Unexpected input at line' . $this->line . ': ' . $this->data[$this->counter]);
       
   338             }
       
   339             break;
       
   340         } while (true);
       
   341     } // end function
       
   342 
       
   343     const VALUE = 2;
       
   344 
       
   345     function yy_r2_1() {
       
   346 
       
   347         return false;
       
   348     }
       
   349 
       
   350     function yy_r2_2() {
       
   351 
       
   352         $this->token = Smarty_Internal_Configfileparser::TPC_FLOAT;
       
   353         $this->yypopstate();
       
   354     }
       
   355 
       
   356     function yy_r2_3() {
       
   357 
       
   358         $this->token = Smarty_Internal_Configfileparser::TPC_INT;
       
   359         $this->yypopstate();
       
   360     }
       
   361 
       
   362     function yy_r2_4() {
       
   363 
       
   364         $this->token = Smarty_Internal_Configfileparser::TPC_TRIPPLE_QUOTES;
       
   365         $this->yypushstate(self::TRIPPLE);
       
   366     }
       
   367 
       
   368     function yy_r2_5() {
       
   369 
       
   370         $this->token = Smarty_Internal_Configfileparser::TPC_SINGLE_QUOTED_STRING;
       
   371         $this->yypopstate();
       
   372     }
       
   373 
       
   374     function yy_r2_6() {
       
   375 
       
   376         $this->token = Smarty_Internal_Configfileparser::TPC_DOUBLE_QUOTED_STRING;
       
   377         $this->yypopstate();
       
   378     }
       
   379 
       
   380     function yy_r2_7() {
       
   381 
       
   382         if (!$this->configBooleanize || !in_array(strtolower($this->value), Array("true", "false", "on", "off", "yes",
       
   383                 "no"))
       
   384         ) {
       
   385             $this->yypopstate();
       
   386             $this->yypushstate(self::NAKED_STRING_VALUE);
       
   387             return true; //reprocess in new state
       
   388         } else {
       
   389             $this->token = Smarty_Internal_Configfileparser::TPC_BOOL;
       
   390             $this->yypopstate();
       
   391         }
       
   392     }
       
   393 
       
   394     function yy_r2_8() {
       
   395 
       
   396         $this->token = Smarty_Internal_Configfileparser::TPC_NAKED_STRING;
       
   397         $this->yypopstate();
       
   398     }
       
   399 
       
   400     function yy_r2_9() {
       
   401 
       
   402         $this->token = Smarty_Internal_Configfileparser::TPC_NAKED_STRING;
       
   403         $this->value = "";
       
   404         $this->yypopstate();
       
   405     }
       
   406 
       
   407     public function yylex3() {
       
   408         if (!isset($this->yy_global_pattern3)) {
       
   409             $this->yy_global_pattern3 = "/\G([^\n]+?(?=[ \t\r]*\n))/isS";
       
   410         }
       
   411         if ($this->counter >= strlen($this->data)) {
       
   412             return false; // end of input
       
   413         }
       
   414 
       
   415         do {
       
   416             if (preg_match($this->yy_global_pattern3, $this->data, $yymatches, null, $this->counter)) {
       
   417                 $yysubmatches = $yymatches;
       
   418                 if (strlen($yysubmatches[0]) < 200) {
       
   419                     $yymatches = preg_grep("/(.|\s)+/", $yysubmatches);
       
   420                 } else {
       
   421                     $yymatches = array_filter($yymatches, 'strlen');
       
   422                 }
       
   423                 if (empty($yymatches)) {
       
   424                     throw new Exception('Error: lexing failed because a rule matched' . ' an empty string.  Input "' . substr($this->data, $this->counter, 5) . '... state NAKED_STRING_VALUE');
       
   425                 }
       
   426                 next($yymatches); // skip global match
       
   427                 $this->token = key($yymatches); // token number
       
   428                 $this->value = current($yymatches); // token value
       
   429                 $r = $this->{'yy_r3_' . $this->token}();
       
   430                 if ($r === null) {
       
   431                     $this->counter += strlen($this->value);
       
   432                     $this->line += substr_count($this->value, "\n");
       
   433                     // accept this token
       
   434                     return true;
       
   435                 } elseif ($r === true) {
       
   436                     // we have changed state
       
   437                     // process this token in the new state
       
   438                     return $this->yylex();
       
   439                 } elseif ($r === false) {
       
   440                     $this->counter += strlen($this->value);
       
   441                     $this->line += substr_count($this->value, "\n");
       
   442                     if ($this->counter >= strlen($this->data)) {
       
   443                         return false; // end of input
       
   444                     }
       
   445                     // skip this token
       
   446                     continue;
       
   447                 }
       
   448             } else {
       
   449                 throw new Exception('Unexpected input at line' . $this->line . ': ' . $this->data[$this->counter]);
       
   450             }
       
   451             break;
       
   452         } while (true);
       
   453     } // end function
       
   454 
       
   455     const NAKED_STRING_VALUE = 3;
       
   456 
       
   457     function yy_r3_1() {
       
   458 
       
   459         $this->token = Smarty_Internal_Configfileparser::TPC_NAKED_STRING;
       
   460         $this->yypopstate();
       
   461     }
       
   462 
       
   463     public function yylex4() {
       
   464         if (!isset($this->yy_global_pattern4)) {
       
   465             $this->yy_global_pattern4 = "/\G([ \t\r]+)|\G([^\n]+?(?=[ \t\r]*\n))|\G(\n)/isS";
       
   466         }
       
   467         if ($this->counter >= strlen($this->data)) {
       
   468             return false; // end of input
       
   469         }
       
   470 
       
   471         do {
       
   472             if (preg_match($this->yy_global_pattern4, $this->data, $yymatches, null, $this->counter)) {
       
   473                 $yysubmatches = $yymatches;
       
   474                 if (strlen($yysubmatches[0]) < 200) {
       
   475                     $yymatches = preg_grep("/(.|\s)+/", $yysubmatches);
       
   476                 } else {
       
   477                     $yymatches = array_filter($yymatches, 'strlen');
       
   478                 }
       
   479                 if (empty($yymatches)) {
       
   480                     throw new Exception('Error: lexing failed because a rule matched' . ' an empty string.  Input "' . substr($this->data, $this->counter, 5) . '... state COMMENT');
       
   481                 }
       
   482                 next($yymatches); // skip global match
       
   483                 $this->token = key($yymatches); // token number
       
   484                 $this->value = current($yymatches); // token value
       
   485                 $r = $this->{'yy_r4_' . $this->token}();
       
   486                 if ($r === null) {
       
   487                     $this->counter += strlen($this->value);
       
   488                     $this->line += substr_count($this->value, "\n");
       
   489                     // accept this token
       
   490                     return true;
       
   491                 } elseif ($r === true) {
       
   492                     // we have changed state
       
   493                     // process this token in the new state
       
   494                     return $this->yylex();
       
   495                 } elseif ($r === false) {
       
   496                     $this->counter += strlen($this->value);
       
   497                     $this->line += substr_count($this->value, "\n");
       
   498                     if ($this->counter >= strlen($this->data)) {
       
   499                         return false; // end of input
       
   500                     }
       
   501                     // skip this token
       
   502                     continue;
       
   503                 }
       
   504             } else {
       
   505                 throw new Exception('Unexpected input at line' . $this->line . ': ' . $this->data[$this->counter]);
       
   506             }
       
   507             break;
       
   508         } while (true);
       
   509     } // end function
       
   510 
       
   511     const COMMENT = 4;
       
   512 
       
   513     function yy_r4_1() {
       
   514 
       
   515         return false;
       
   516     }
       
   517 
       
   518     function yy_r4_2() {
       
   519 
       
   520         $this->token = Smarty_Internal_Configfileparser::TPC_NAKED_STRING;
       
   521     }
       
   522 
       
   523     function yy_r4_3() {
       
   524 
       
   525         $this->token = Smarty_Internal_Configfileparser::TPC_NEWLINE;
       
   526         $this->yypopstate();
       
   527     }
       
   528 
       
   529     public function yylex5() {
       
   530         if (!isset($this->yy_global_pattern5)) {
       
   531             $this->yy_global_pattern5 = "/\G(\\.)|\G(.*?(?=[\.=[\]\r\n]))/isS";
       
   532         }
       
   533         if ($this->counter >= strlen($this->data)) {
       
   534             return false; // end of input
       
   535         }
       
   536 
       
   537         do {
       
   538             if (preg_match($this->yy_global_pattern5, $this->data, $yymatches, null, $this->counter)) {
       
   539                 $yysubmatches = $yymatches;
       
   540                 if (strlen($yysubmatches[0]) < 200) {
       
   541                     $yymatches = preg_grep("/(.|\s)+/", $yysubmatches);
       
   542                 } else {
       
   543                     $yymatches = array_filter($yymatches, 'strlen');
       
   544                 }
       
   545                 if (empty($yymatches)) {
       
   546                     throw new Exception('Error: lexing failed because a rule matched' . ' an empty string.  Input "' . substr($this->data, $this->counter, 5) . '... state SECTION');
       
   547                 }
       
   548                 next($yymatches); // skip global match
       
   549                 $this->token = key($yymatches); // token number
       
   550                 $this->value = current($yymatches); // token value
       
   551                 $r = $this->{'yy_r5_' . $this->token}();
       
   552                 if ($r === null) {
       
   553                     $this->counter += strlen($this->value);
       
   554                     $this->line += substr_count($this->value, "\n");
       
   555                     // accept this token
       
   556                     return true;
       
   557                 } elseif ($r === true) {
       
   558                     // we have changed state
       
   559                     // process this token in the new state
       
   560                     return $this->yylex();
       
   561                 } elseif ($r === false) {
       
   562                     $this->counter += strlen($this->value);
       
   563                     $this->line += substr_count($this->value, "\n");
       
   564                     if ($this->counter >= strlen($this->data)) {
       
   565                         return false; // end of input
       
   566                     }
       
   567                     // skip this token
       
   568                     continue;
       
   569                 }
       
   570             } else {
       
   571                 throw new Exception('Unexpected input at line' . $this->line . ': ' . $this->data[$this->counter]);
       
   572             }
       
   573             break;
       
   574         } while (true);
       
   575     } // end function
       
   576 
       
   577     const SECTION = 5;
       
   578 
       
   579     function yy_r5_1() {
       
   580 
       
   581         $this->token = Smarty_Internal_Configfileparser::TPC_DOT;
       
   582     }
       
   583 
       
   584     function yy_r5_2() {
       
   585 
       
   586         $this->token = Smarty_Internal_Configfileparser::TPC_SECTION;
       
   587         $this->yypopstate();
       
   588     }
       
   589 
       
   590     public function yylex6() {
       
   591         if (!isset($this->yy_global_pattern6)) {
       
   592             $this->yy_global_pattern6 = "/\G(\"\"\"(?=[ \t\r]*[\n#;]))|\G([\S\s])/isS";
       
   593         }
       
   594         if ($this->counter >= strlen($this->data)) {
       
   595             return false; // end of input
       
   596         }
       
   597 
       
   598         do {
       
   599             if (preg_match($this->yy_global_pattern6, $this->data, $yymatches, null, $this->counter)) {
       
   600                 $yysubmatches = $yymatches;
       
   601                 if (strlen($yysubmatches[0]) < 200) {
       
   602                     $yymatches = preg_grep("/(.|\s)+/", $yysubmatches);
       
   603                 } else {
       
   604                     $yymatches = array_filter($yymatches, 'strlen');
       
   605                 }
       
   606                 if (empty($yymatches)) {
       
   607                     throw new Exception('Error: lexing failed because a rule matched' . ' an empty string.  Input "' . substr($this->data, $this->counter, 5) . '... state TRIPPLE');
       
   608                 }
       
   609                 next($yymatches); // skip global match
       
   610                 $this->token = key($yymatches); // token number
       
   611                 $this->value = current($yymatches); // token value
       
   612                 $r = $this->{'yy_r6_' . $this->token}();
       
   613                 if ($r === null) {
       
   614                     $this->counter += strlen($this->value);
       
   615                     $this->line += substr_count($this->value, "\n");
       
   616                     // accept this token
       
   617                     return true;
       
   618                 } elseif ($r === true) {
       
   619                     // we have changed state
       
   620                     // process this token in the new state
       
   621                     return $this->yylex();
       
   622                 } elseif ($r === false) {
       
   623                     $this->counter += strlen($this->value);
       
   624                     $this->line += substr_count($this->value, "\n");
       
   625                     if ($this->counter >= strlen($this->data)) {
       
   626                         return false; // end of input
       
   627                     }
       
   628                     // skip this token
       
   629                     continue;
       
   630                 }
       
   631             } else {
       
   632                 throw new Exception('Unexpected input at line' . $this->line . ': ' . $this->data[$this->counter]);
       
   633             }
       
   634             break;
       
   635         } while (true);
       
   636     } // end function
       
   637 
       
   638     const TRIPPLE = 6;
       
   639 
       
   640     function yy_r6_1() {
       
   641 
       
   642         $this->token = Smarty_Internal_Configfileparser::TPC_TRIPPLE_QUOTES_END;
       
   643         $this->yypopstate();
       
   644         $this->yypushstate(self::START);
       
   645     }
       
   646 
       
   647     function yy_r6_2() {
       
   648 
       
   649         $to = strlen($this->data);
       
   650         preg_match("/\"\"\"[ \t\r]*[\n#;]/", $this->data, $match, PREG_OFFSET_CAPTURE, $this->counter);
       
   651         if (isset($match[0][1])) {
       
   652             $to = $match[0][1];
       
   653         } else {
       
   654             $this->compiler->trigger_template_error("missing or misspelled literal closing tag");
       
   655         }
       
   656         $this->value = substr($this->data, $this->counter, $to - $this->counter);
       
   657         $this->token = Smarty_Internal_Configfileparser::TPC_TRIPPLE_TEXT;
       
   658     }
       
   659 
       
   660 }