1 <?php

     2 /**

     3  * Smarty Internal Plugin Templatelexer

     4  * This is the lexer to break the template source into tokens

     5  *

     6  * @package    Smarty

     7  * @subpackage Compiler

     8  * @author     Uwe Tews

     9  */

    10 

    11 /**

    12  * Smarty_Internal_Templatelexer

    13  * This is the template file lexer.

    14  * It is generated from the smarty_internal_templatelexer.plex file

    15  *

    16  * @package    Smarty

    17  * @subpackage Compiler

    18  * @author     Uwe Tews

    19  */

    20 class Smarty_Internal_Templatelexer {

    21     /**

    22      * Source

    23      *

    24      * @var string

    25      */

    26     public $data;

    27 

    28     /**

    29      * byte counter

    30      *

    31      * @var int

    32      */

    33     public $counter;

    34 

    35     /**

    36      * token number

    37      *

    38      * @var int

    39      */

    40     public $token;

    41 

    42     /**

    43      * token value

    44      *

    45      * @var string

    46      */

    47     public $value;

    48 

    49     /**

    50      * current line

    51      *

    52      * @var int

    53      */

    54     public $line;

    55 

    56     /**

    57      * tag start line

    58      *

    59      * @var

    60      */

    61     public $taglineno;

    62 

    63     /**

    64      * php code type

    65      *

    66      * @var string

    67      */

    68     public $phpType = '';

    69 

    70     /**

    71      * escaped left delimiter

    72      *

    73      * @var string

    74      */

    75     public $ldel = '';

    76 

    77     /**

    78      * escaped left delimiter length

    79      *

    80      * @var int

    81      */

    82     public $ldel_length = 0;

    83 

    84     /**

    85      * escaped right delimiter

    86      *

    87      * @var string

    88      */

    89     public $rdel = '';

    90 

    91     /**

    92      * escaped right delimiter length

    93      *

    94      * @var int

    95      */

    96     public $rdel_length = 0;

    97 

    98     /**

    99      * state number

   100      *

   101      * @var int

   102      */

   103     public $state = 1;

   104 

   105     /**

   106      * Smarty object

   107      *

   108      * @var Smarty

   109      */

   110     public $smarty = null;

   111 

   112     /**

   113      * compiler object

   114      *

   115      * @var Smarty_Internal_TemplateCompilerBase

   116      */

   117     public $compiler = null;

   118 

   119     /**

   120      * literal tag nesting level

   121      *

   122      * @var int

   123      */

   124     private $literal_cnt = 0;

   125 

   126     /**

   127      * PHP start tag string

   128      *

   129      * @var string

   130      */

   131 

   132     /**

   133      * trace file

   134      *

   135      * @var resource

   136      */

   137     public $yyTraceFILE;

   138 

   139     /**

   140      * trace prompt

   141      *

   142      * @var string

   143      */

   144     public $yyTracePrompt;

   145 

   146     /**

   147      * XML flag true while processing xml

   148      *

   149      * @var bool

   150      */

   151     public $is_xml = false;

   152 

   153     /**

   154      * state names

   155      *

   156      * @var array

   157      */

   158     public $state_name = array(1 => 'TEXT', 2 => 'TAG', 3 => 'TAGBODY', 4 => 'LITERAL', 5 => 'DOUBLEQUOTEDSTRING',

   159         6 => 'CHILDBODY', 7 => 'CHILDBLOCK', 8 => 'CHILDLITERAL');

   160 

   161     /**

   162      * storage for assembled token patterns

   163      *

   164      * @var string

   165      */

   166     private $yy_global_pattern1 = null;

   167 

   168     private $yy_global_pattern2 = null;

   169 

   170     private $yy_global_pattern3 = null;

   171 

   172     private $yy_global_pattern4 = null;

   173 

   174     private $yy_global_pattern5 = null;

   175 

   176     private $yy_global_pattern6 = null;

   177 

   178     private $yy_global_pattern7 = null;

   179 

   180     private $yy_global_pattern8 = null;

   181 

   182     /**

   183      * token names

   184      *

   185      * @var array

   186      */

   187     public $smarty_token_names = array(        // Text for parser error messages

   188         'NOT' => '(!,not)', 'OPENP' => '(', 'CLOSEP' => ')', 'OPENB' => '[', 'CLOSEB' => ']', 'PTR' => '->',

   189         'APTR' => '=>', 'EQUAL' => '=', 'NUMBER' => 'number', 'UNIMATH' => '+" , "-', 'MATH' => '*" , "/" , "%',

   190         'INCDEC' => '++" , "--', 'SPACE' => ' ', 'DOLLAR' => '$', 'SEMICOLON' => ';', 'COLON' => ':',

   191         'DOUBLECOLON' => '::', 'AT' => '@', 'HATCH' => '#', 'QUOTE' => '"', 'BACKTICK' => '`', 'VERT' => '"|" modifier',

   192         'DOT' => '.', 'COMMA' => '","', 'QMARK' => '"?"', 'ID' => 'id, name', 'TEXT' => 'text',

   193         'LDELSLASH' => '{/..} closing tag', 'LDEL' => '{...} Smarty tag', 'COMMENT' => 'comment', 'AS' => 'as',

   194         'TO' => 'to', 'PHP' => '"<?php", "<%", "{php}" tag', 'LOGOP' => '"<", "==" ... logical operator',

   195         'TLOGOP' => '"lt", "eq" ... logical operator; "is div by" ... if condition',

   196         'SCOND' => '"is even" ... if condition',);

   197 

   198     /**

   199      * constructor

   200      *

   201      * @param   string $data template source

   202      * @param Smarty_Internal_TemplateCompilerBase $compiler

   203      */

   204     function __construct($data, Smarty_Internal_TemplateCompilerBase $compiler) {

   205         $this->data = $data;

   206         $this->counter = 0;

   207         if (preg_match('~^\xEF\xBB\xBF~i', $this->data, $match)) {

   208             $this->counter += strlen($match[0]);

   209         }

   210         $this->line = 1;

   211         $this->smarty = $compiler->smarty;

   212         $this->compiler = $compiler;

   213         $this->ldel = preg_quote($this->smarty->left_delimiter, '~');

   214         $this->ldel_length = strlen($this->smarty->left_delimiter);

   215         $this->rdel = preg_quote($this->smarty->right_delimiter, '~');

   216         $this->rdel_length = strlen($this->smarty->right_delimiter);

   217         $this->smarty_token_names['LDEL'] = $this->smarty->left_delimiter;

   218         $this->smarty_token_names['RDEL'] = $this->smarty->right_delimiter;

   219     }

   220 

   221     public function PrintTrace() {

   222         $this->yyTraceFILE = fopen('php://output', 'w');

   223         $this->yyTracePrompt = '<br>';

   224     }

   225 

   226     /*

   227      * Check if this tag is autoliteral

   228      */

   229     public function isAutoLiteral() {

   230         return $this->smarty->auto_literal && isset($this->value[$this->ldel_length]) ? strpos(" \n\t\r", $this->value[$this->ldel_length]) !== false : false;

   231     }

   232 

   233     private $_yy_state = 1;

   234 

   235     private $_yy_stack = array();

   236 

   237     public function yylex() {

   238         return $this->{'yylex' . $this->_yy_state}();

   239     }

   240 

   241     public function yypushstate($state) {

   242         if ($this->yyTraceFILE) {

   243             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);

   244         }

   245         array_push($this->_yy_stack, $this->_yy_state);

   246         $this->_yy_state = $state;

   247         if ($this->yyTraceFILE) {

   248             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);

   249         }

   250     }

   251 

   252     public function yypopstate() {

   253         if ($this->yyTraceFILE) {

   254             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);

   255         }

   256         $this->_yy_state = array_pop($this->_yy_stack);

   257         if ($this->yyTraceFILE) {

   258             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);

   259         }

   260     }

   261 

   262     public function yybegin($state) {

   263         $this->_yy_state = $state;

   264         if ($this->yyTraceFILE) {

   265             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);

   266         }

   267     }

   268 

   269     public function yylex1() {

   270         if (!isset($this->yy_global_pattern1)) {

   271             $this->yy_global_pattern1 = "/\G([{][}])|\G(" . $this->ldel . "[*])|\G((<[?]((php\\s+|=)|\\s+))|(<[%])|(<[?]xml\\s+)|(<script\\s+language\\s*=\\s*[\"']?\\s*php\\s*[\"']?\\s*>)|([?][>])|([%][>])|(" . $this->ldel . "\\s*php(.*?)" . $this->rdel . ")|(" . $this->ldel . "\\s*[\/]php" . $this->rdel . "))|\G(" . $this->ldel . "\\s*literal\\s*" . $this->rdel . ")|\G(" . $this->ldel . "\\s*)|\G(\\s*" . $this->rdel . ")|\G([\S\s])/isS";

   272         }

   273         if ($this->counter >= strlen($this->data)) {

   274             return false; // end of input

   275         }

   276 

   277         do {

   278             if (preg_match($this->yy_global_pattern1, $this->data, $yymatches, null, $this->counter)) {

   279                 $yysubmatches = $yymatches;

   280                 if (strlen($yysubmatches[0]) < 200) {

   281                     $yymatches = preg_grep("/(.|\s)+/", $yysubmatches);

   282                 } else {

   283                     $yymatches = array_filter($yymatches, 'strlen');

   284                 }

   285                 if (empty($yymatches)) {

   286                     throw new Exception('Error: lexing failed because a rule matched' . ' an empty string.  Input "' . substr($this->data, $this->counter, 5) . '... state TEXT');

   287                 }

   288                 next($yymatches); // skip global match

   289                 $this->token = key($yymatches); // token number

   290                 $this->value = current($yymatches); // token value

   291                 $r = $this->{'yy_r1_' . $this->token}();

   292                 if ($r === null) {

   293                     $this->counter += strlen($this->value);

   294                     $this->line += substr_count($this->value, "\n");

   295                     // accept this token

   296                     return true;

   297                 } elseif ($r === true) {

   298                     // we have changed state

   299                     // process this token in the new state

   300                     return $this->yylex();

   301                 } elseif ($r === false) {

   302                     $this->counter += strlen($this->value);

   303                     $this->line += substr_count($this->value, "\n");

   304                     if ($this->counter >= strlen($this->data)) {

   305                         return false; // end of input

   306                     }

   307                     // skip this token

   308                     continue;

   309                 }

   310             } else {

   311                 throw new Exception('Unexpected input at line' . $this->line . ': ' . $this->data[$this->counter]);

   312             }

   313             break;

   314         } while (true);

   315     } // end function

   316 

   317     const TEXT = 1;

   318 

   319     function yy_r1_1() {

   320 

   321         $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   322     }

   323 

   324     function yy_r1_2() {

   325 

   326         preg_match("~[*]{$this->rdel}~", $this->data, $match, PREG_OFFSET_CAPTURE, $this->counter);

   327         if (isset($match[0][1])) {

   328             $to = $match[0][1] + strlen($match[0][0]);

   329         } else {

   330             $this->compiler->trigger_template_error("missing or misspelled comment closing tag '*{$this->smarty->right_delimiter}'");

   331         }

   332         $this->value = substr($this->data, $this->counter, $to - $this->counter);

   333         return false;

   334     }

   335 

   336     function yy_r1_3() {

   337 

   338         $obj = new Smarty_Internal_Compile_Private_Php();

   339         $obj->parsePhp($this);

   340     }

   341 

   342     function yy_r1_15() {

   343 

   344         if ($this->smarty->auto_literal && isset($this->value[$this->ldel_length]) ? strpos(" \n\t\r", $this->value[$this->ldel_length]) !== false : false) {

   345             $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   346         } else {

   347             $this->token = Smarty_Internal_Templateparser::TP_LITERALSTART;

   348             $this->yypushstate(self::LITERAL);

   349         }

   350     }

   351 

   352     function yy_r1_16() {

   353 

   354         if ($this->smarty->auto_literal && isset($this->value[$this->ldel_length]) ? strpos(" \n\t\r", $this->value[$this->ldel_length]) !== false : false) {

   355             $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   356         } else {

   357             $this->yypushstate(self::TAG);

   358             return true;

   359         }

   360     }

   361 

   362     function yy_r1_17() {

   363 

   364         $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   365     }

   366 

   367     function yy_r1_18() {

   368 

   369         $to = strlen($this->data);

   370         preg_match("~($this->ldel)|([<]script\s+language\s*=\s*[\"\']?\s*php\s*[\"\']?\s*[>])|([<][?])|([<][%])|([?][>])|([%][>])~i", $this->data, $match, PREG_OFFSET_CAPTURE, $this->counter);

   371         if (isset($match[0][1])) {

   372             $to = $match[0][1];

   373         }

   374         $this->value = substr($this->data, $this->counter, $to - $this->counter);

   375         $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   376     }

   377 

   378     public function yylex2() {

   379         if (!isset($this->yy_global_pattern2)) {

   380             $this->yy_global_pattern2 = "/\G(" . $this->ldel . "\\s*(if|elseif|else if|while)\\s+)|\G(" . $this->ldel . "\\s*for\\s+)|\G(" . $this->ldel . "\\s*foreach(?![^\s]))|\G(" . $this->ldel . "\\s*setfilter\\s+)|\G(" . $this->ldel . "\\s*[0-9]*[a-zA-Z_]\\w*(\\s+nocache)?\\s*" . $this->rdel . ")|\G(" . $this->ldel . "\\s*[\/](?:(?!block)[0-9]*[a-zA-Z_]\\w*)\\s*" . $this->rdel . ")|\G(" . $this->ldel . "\\s*[$][0-9]*[a-zA-Z_]\\w*(\\s+nocache)?\\s*" . $this->rdel . ")|\G(" . $this->ldel . "\\s*[\/])|\G(" . $this->ldel . "\\s*)/isS";

   381         }

   382         if ($this->counter >= strlen($this->data)) {

   383             return false; // end of input

   384         }

   385 

   386         do {

   387             if (preg_match($this->yy_global_pattern2, $this->data, $yymatches, null, $this->counter)) {

   388                 $yysubmatches = $yymatches;

   389                 if (strlen($yysubmatches[0]) < 200) {

   390                     $yymatches = preg_grep("/(.|\s)+/", $yysubmatches);

   391                 } else {

   392                     $yymatches = array_filter($yymatches, 'strlen');

   393                 }

   394                 if (empty($yymatches)) {

   395                     throw new Exception('Error: lexing failed because a rule matched' . ' an empty string.  Input "' . substr($this->data, $this->counter, 5) . '... state TAG');

   396                 }

   397                 next($yymatches); // skip global match

   398                 $this->token = key($yymatches); // token number

   399                 $this->value = current($yymatches); // token value

   400                 $r = $this->{'yy_r2_' . $this->token}();

   401                 if ($r === null) {

   402                     $this->counter += strlen($this->value);

   403                     $this->line += substr_count($this->value, "\n");

   404                     // accept this token

   405                     return true;

   406                 } elseif ($r === true) {

   407                     // we have changed state

   408                     // process this token in the new state

   409                     return $this->yylex();

   410                 } elseif ($r === false) {

   411                     $this->counter += strlen($this->value);

   412                     $this->line += substr_count($this->value, "\n");

   413                     if ($this->counter >= strlen($this->data)) {

   414                         return false; // end of input

   415                     }

   416                     // skip this token

   417                     continue;

   418                 }

   419             } else {

   420                 throw new Exception('Unexpected input at line' . $this->line . ': ' . $this->data[$this->counter]);

   421             }

   422             break;

   423         } while (true);

   424     } // end function

   425 

   426     const TAG = 2;

   427 

   428     function yy_r2_1() {

   429 

   430         $this->token = Smarty_Internal_Templateparser::TP_LDELIF;

   431         $this->yybegin(self::TAGBODY);

   432         $this->taglineno = $this->line;

   433     }

   434 

   435     function yy_r2_3() {

   436 

   437         $this->token = Smarty_Internal_Templateparser::TP_LDELFOR;

   438         $this->yybegin(self::TAGBODY);

   439         $this->taglineno = $this->line;

   440     }

   441 

   442     function yy_r2_4() {

   443 

   444         $this->token = Smarty_Internal_Templateparser::TP_LDELFOREACH;

   445         $this->yybegin(self::TAGBODY);

   446         $this->taglineno = $this->line;

   447     }

   448 

   449     function yy_r2_5() {

   450 

   451         $this->token = Smarty_Internal_Templateparser::TP_LDELSETFILTER;

   452         $this->yybegin(self::TAGBODY);

   453         $this->taglineno = $this->line;

   454     }

   455 

   456     function yy_r2_6() {

   457 

   458         $this->yypopstate();

   459         $this->token = Smarty_Internal_Templateparser::TP_SIMPLETAG;

   460         $this->taglineno = $this->line;

   461     }

   462 

   463     function yy_r2_8() {

   464 

   465         $this->yypopstate();

   466         $this->token = Smarty_Internal_Templateparser::TP_CLOSETAG;

   467         $this->taglineno = $this->line;

   468     }

   469 

   470     function yy_r2_9() {

   471 

   472         if ($this->_yy_stack[count($this->_yy_stack) - 1] == self::TEXT) {

   473             $this->yypopstate();

   474             $this->token = Smarty_Internal_Templateparser::TP_SIMPLEOUTPUT;

   475             $this->taglineno = $this->line;

   476         } else {

   477             $this->value = $this->smarty->left_delimiter;

   478             $this->token = Smarty_Internal_Templateparser::TP_LDEL;

   479             $this->yybegin(self::TAGBODY);

   480             $this->taglineno = $this->line;

   481         }

   482     }

   483 

   484     function yy_r2_11() {

   485 

   486         $this->token = Smarty_Internal_Templateparser::TP_LDELSLASH;

   487         $this->yybegin(self::TAGBODY);

   488         $this->taglineno = $this->line;

   489     }

   490 

   491     function yy_r2_12() {

   492 

   493         $this->token = Smarty_Internal_Templateparser::TP_LDEL;

   494         $this->yybegin(self::TAGBODY);

   495         $this->taglineno = $this->line;

   496     }

   497 

   498     public function yylex3() {

   499         if (!isset($this->yy_global_pattern3)) {

   500             $this->yy_global_pattern3 = "/\G(\\s*" . $this->rdel . ")|\G([\"])|\G('[^'\\\\]*(?:\\\\.[^'\\\\]*)*')|\G([$]smarty\\.block\\.(child|parent))|\G([$][0-9]*[a-zA-Z_]\\w*)|\G([$])|\G(\\s+is\\s+in\\s+)|\G(\\s+as\\s+)|\G(\\s+to\\s+)|\G(\\s+step\\s+)|\G(\\s+instanceof\\s+)|\G(\\s*(([!=][=]{1,2})|([<][=>]?)|([>][=]?)|[&|]{2})\\s*)|\G(\\s+(eq|ne|neq|gt|ge|gte|lt|le|lte|mod|and|or|xor|(is\\s+(not\\s+)?(odd|even|div)\\s+by))\\s+)|\G(\\s+is\\s+(not\\s+)?(odd|even))|\G(([!]\\s*)|(not\\s+))|\G([(](int(eger)?|bool(ean)?|float|double|real|string|binary|array|object)[)]\\s*)|\G(\\s*[(]\\s*)|\G(\\s*[)])|\G(\\[\\s*)|\G(\\s*\\])|\G(\\s*[-][>]\\s*)|\G(\\s*[=][>]\\s*)|\G(\\s*[=]\\s*)|\G(([+]|[-]){2})|\G(\\s*([+]|[-])\\s*)|\G(\\s*([*]{1,2}|[%\/^&]|[<>]{2})\\s*)|\G([@])|\G([#])|\G(\\s+[0-9]*[a-zA-Z_][a-zA-Z0-9_\-:]*\\s*[=]\\s*)|\G(([0-9]*[a-zA-Z_]\\w*)?(\\\\[0-9]*[a-zA-Z_]\\w*)+)|\G([0-9]*[a-zA-Z_]\\w*)|\G(\\d+)|\G([`])|\G([|])|\G([.])|\G(\\s*[,]\\s*)|\G(\\s*[;]\\s*)|\G([:]{2})|\G(\\s*[:]\\s*)|\G(\\s*[?]\\s*)|\G(0[xX][0-9a-fA-F]+)|\G(\\s+)|\G(" . $this->ldel . "\\s*)|\G([\S\s])/isS";

   501         }

   502         if ($this->counter >= strlen($this->data)) {

   503             return false; // end of input

   504         }

   505 

   506         do {

   507             if (preg_match($this->yy_global_pattern3, $this->data, $yymatches, null, $this->counter)) {

   508                 $yysubmatches = $yymatches;

   509                 if (strlen($yysubmatches[0]) < 200) {

   510                     $yymatches = preg_grep("/(.|\s)+/", $yysubmatches);

   511                 } else {

   512                     $yymatches = array_filter($yymatches, 'strlen');

   513                 }

   514                 if (empty($yymatches)) {

   515                     throw new Exception('Error: lexing failed because a rule matched' . ' an empty string.  Input "' . substr($this->data, $this->counter, 5) . '... state TAGBODY     ');

   516                 }

   517                 next($yymatches); // skip global match

   518                 $this->token = key($yymatches); // token number

   519                 $this->value = current($yymatches); // token value

   520                 $r = $this->{'yy_r3_' . $this->token}();

   521                 if ($r === null) {

   522                     $this->counter += strlen($this->value);

   523                     $this->line += substr_count($this->value, "\n");

   524                     // accept this token

   525                     return true;

   526                 } elseif ($r === true) {

   527                     // we have changed state

   528                     // process this token in the new state

   529                     return $this->yylex();

   530                 } elseif ($r === false) {

   531                     $this->counter += strlen($this->value);

   532                     $this->line += substr_count($this->value, "\n");

   533                     if ($this->counter >= strlen($this->data)) {

   534                         return false; // end of input

   535                     }

   536                     // skip this token

   537                     continue;

   538                 }

   539             } else {

   540                 throw new Exception('Unexpected input at line' . $this->line . ': ' . $this->data[$this->counter]);

   541             }

   542             break;

   543         } while (true);

   544     } // end function

   545 

   546     const TAGBODY = 3;

   547 

   548     function yy_r3_1() {

   549 

   550         $this->token = Smarty_Internal_Templateparser::TP_RDEL;

   551         $this->yypopstate();

   552     }

   553 

   554     function yy_r3_2() {

   555 

   556         $this->token = Smarty_Internal_Templateparser::TP_QUOTE;

   557         $this->yypushstate(self::DOUBLEQUOTEDSTRING);

   558     }

   559 

   560     function yy_r3_3() {

   561 

   562         $this->token = Smarty_Internal_Templateparser::TP_SINGLEQUOTESTRING;

   563     }

   564 

   565     function yy_r3_4() {

   566 

   567         $this->token = Smarty_Internal_Templateparser::TP_SMARTYBLOCKCHILDPARENT;

   568         $this->taglineno = $this->line;

   569     }

   570 

   571     function yy_r3_6() {

   572 

   573         $this->token = Smarty_Internal_Templateparser::TP_DOLLARID;

   574     }

   575 

   576     function yy_r3_7() {

   577 

   578         $this->token = Smarty_Internal_Templateparser::TP_DOLLAR;

   579     }

   580 

   581     function yy_r3_8() {

   582 

   583         $this->token = Smarty_Internal_Templateparser::TP_ISIN;

   584     }

   585 

   586     function yy_r3_9() {

   587 

   588         $this->token = Smarty_Internal_Templateparser::TP_AS;

   589     }

   590 

   591     function yy_r3_10() {

   592 

   593         $this->token = Smarty_Internal_Templateparser::TP_TO;

   594     }

   595 

   596     function yy_r3_11() {

   597 

   598         $this->token = Smarty_Internal_Templateparser::TP_STEP;

   599     }

   600 

   601     function yy_r3_12() {

   602 

   603         $this->token = Smarty_Internal_Templateparser::TP_INSTANCEOF;

   604     }

   605 

   606     function yy_r3_13() {

   607 

   608         $this->token = Smarty_Internal_Templateparser::TP_LOGOP;

   609     }

   610 

   611     function yy_r3_18() {

   612 

   613         $this->token = Smarty_Internal_Templateparser::TP_TLOGOP;

   614     }

   615 

   616     function yy_r3_23() {

   617 

   618         $this->token = Smarty_Internal_Templateparser::TP_SINGLECOND;

   619     }

   620 

   621     function yy_r3_26() {

   622 

   623         $this->token = Smarty_Internal_Templateparser::TP_NOT;

   624     }

   625 

   626     function yy_r3_29() {

   627 

   628         $this->token = Smarty_Internal_Templateparser::TP_TYPECAST;

   629     }

   630 

   631     function yy_r3_33() {

   632 

   633         $this->token = Smarty_Internal_Templateparser::TP_OPENP;

   634     }

   635 

   636     function yy_r3_34() {

   637 

   638         $this->token = Smarty_Internal_Templateparser::TP_CLOSEP;

   639     }

   640 

   641     function yy_r3_35() {

   642 

   643         $this->token = Smarty_Internal_Templateparser::TP_OPENB;

   644     }

   645 

   646     function yy_r3_36() {

   647 

   648         $this->token = Smarty_Internal_Templateparser::TP_CLOSEB;

   649     }

   650 

   651     function yy_r3_37() {

   652 

   653         $this->token = Smarty_Internal_Templateparser::TP_PTR;

   654     }

   655 

   656     function yy_r3_38() {

   657 

   658         $this->token = Smarty_Internal_Templateparser::TP_APTR;

   659     }

   660 

   661     function yy_r3_39() {

   662 

   663         $this->token = Smarty_Internal_Templateparser::TP_EQUAL;

   664     }

   665 

   666     function yy_r3_40() {

   667 

   668         $this->token = Smarty_Internal_Templateparser::TP_INCDEC;

   669     }

   670 

   671     function yy_r3_42() {

   672 

   673         $this->token = Smarty_Internal_Templateparser::TP_UNIMATH;

   674     }

   675 

   676     function yy_r3_44() {

   677 

   678         $this->token = Smarty_Internal_Templateparser::TP_MATH;

   679     }

   680 

   681     function yy_r3_46() {

   682 

   683         $this->token = Smarty_Internal_Templateparser::TP_AT;

   684     }

   685 

   686     function yy_r3_47() {

   687 

   688         $this->token = Smarty_Internal_Templateparser::TP_HATCH;

   689     }

   690 

   691     function yy_r3_48() {

   692 

   693         // resolve conflicts with shorttag and right_delimiter starting with '='

   694         if (substr($this->data, $this->counter + strlen($this->value) - 1, $this->rdel_length) == $this->smarty->right_delimiter) {

   695             preg_match("~\s+~", $this->value, $match);

   696             $this->value = $match[0];

   697             $this->token = Smarty_Internal_Templateparser::TP_SPACE;

   698         } else {

   699             $this->token = Smarty_Internal_Templateparser::TP_ATTR;

   700         }

   701     }

   702 

   703     function yy_r3_49() {

   704 

   705         $this->token = Smarty_Internal_Templateparser::TP_NAMESPACE;

   706     }

   707 

   708     function yy_r3_52() {

   709 

   710         $this->token = Smarty_Internal_Templateparser::TP_ID;

   711     }

   712 

   713     function yy_r3_53() {

   714 

   715         $this->token = Smarty_Internal_Templateparser::TP_INTEGER;

   716     }

   717 

   718     function yy_r3_54() {

   719 

   720         $this->token = Smarty_Internal_Templateparser::TP_BACKTICK;

   721         $this->yypopstate();

   722     }

   723 

   724     function yy_r3_55() {

   725 

   726         $this->token = Smarty_Internal_Templateparser::TP_VERT;

   727     }

   728 

   729     function yy_r3_56() {

   730 

   731         $this->token = Smarty_Internal_Templateparser::TP_DOT;

   732     }

   733 

   734     function yy_r3_57() {

   735 

   736         $this->token = Smarty_Internal_Templateparser::TP_COMMA;

   737     }

   738 

   739     function yy_r3_58() {

   740 

   741         $this->token = Smarty_Internal_Templateparser::TP_SEMICOLON;

   742     }

   743 

   744     function yy_r3_59() {

   745 

   746         $this->token = Smarty_Internal_Templateparser::TP_DOUBLECOLON;

   747     }

   748 

   749     function yy_r3_60() {

   750 

   751         $this->token = Smarty_Internal_Templateparser::TP_COLON;

   752     }

   753 

   754     function yy_r3_61() {

   755 

   756         $this->token = Smarty_Internal_Templateparser::TP_QMARK;

   757     }

   758 

   759     function yy_r3_62() {

   760 

   761         $this->token = Smarty_Internal_Templateparser::TP_HEX;

   762     }

   763 

   764     function yy_r3_63() {

   765 

   766         $this->token = Smarty_Internal_Templateparser::TP_SPACE;

   767     }

   768 

   769     function yy_r3_64() {

   770 

   771         if ($this->smarty->auto_literal && isset($this->value[$this->ldel_length]) ? strpos(" \n\t\r", $this->value[$this->ldel_length]) !== false : false) {

   772             $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   773         } else {

   774             $this->yypushstate(self::TAG);

   775             return true;

   776         }

   777     }

   778 

   779     function yy_r3_65() {

   780 

   781         $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   782     }

   783 

   784     public function yylex4() {

   785         if (!isset($this->yy_global_pattern4)) {

   786             $this->yy_global_pattern4 = "/\G(" . $this->ldel . "\\s*literal\\s*" . $this->rdel . ")|\G(" . $this->ldel . "\\s*[\/]literal\\s*" . $this->rdel . ")|\G([\S\s])/isS";

   787         }

   788         if ($this->counter >= strlen($this->data)) {

   789             return false; // end of input

   790         }

   791 

   792         do {

   793             if (preg_match($this->yy_global_pattern4, $this->data, $yymatches, null, $this->counter)) {

   794                 $yysubmatches = $yymatches;

   795                 if (strlen($yysubmatches[0]) < 200) {

   796                     $yymatches = preg_grep("/(.|\s)+/", $yysubmatches);

   797                 } else {

   798                     $yymatches = array_filter($yymatches, 'strlen');

   799                 }

   800                 if (empty($yymatches)) {

   801                     throw new Exception('Error: lexing failed because a rule matched' . ' an empty string.  Input "' . substr($this->data, $this->counter, 5) . '... state LITERAL');

   802                 }

   803                 next($yymatches); // skip global match

   804                 $this->token = key($yymatches); // token number

   805                 $this->value = current($yymatches); // token value

   806                 $r = $this->{'yy_r4_' . $this->token}();

   807                 if ($r === null) {

   808                     $this->counter += strlen($this->value);

   809                     $this->line += substr_count($this->value, "\n");

   810                     // accept this token

   811                     return true;

   812                 } elseif ($r === true) {

   813                     // we have changed state

   814                     // process this token in the new state

   815                     return $this->yylex();

   816                 } elseif ($r === false) {

   817                     $this->counter += strlen($this->value);

   818                     $this->line += substr_count($this->value, "\n");

   819                     if ($this->counter >= strlen($this->data)) {

   820                         return false; // end of input

   821                     }

   822                     // skip this token

   823                     continue;

   824                 }

   825             } else {

   826                 throw new Exception('Unexpected input at line' . $this->line . ': ' . $this->data[$this->counter]);

   827             }

   828             break;

   829         } while (true);

   830     } // end function

   831 

   832     const LITERAL = 4;

   833 

   834     function yy_r4_1() {

   835 

   836         $this->literal_cnt++;

   837         $this->token = Smarty_Internal_Templateparser::TP_LITERAL;

   838     }

   839 

   840     function yy_r4_2() {

   841 

   842         if ($this->literal_cnt) {

   843             $this->literal_cnt--;

   844             $this->token = Smarty_Internal_Templateparser::TP_LITERAL;

   845         } else {

   846             $this->token = Smarty_Internal_Templateparser::TP_LITERALEND;

   847             $this->yypopstate();

   848         }

   849     }

   850 

   851     function yy_r4_3() {

   852 

   853         $to = strlen($this->data);

   854         preg_match("~{$this->ldel}[/]?literal{$this->rdel}~i", $this->data, $match, PREG_OFFSET_CAPTURE, $this->counter);

   855         if (isset($match[0][1])) {

   856             $to = $match[0][1];

   857         } else {

   858             $this->compiler->trigger_template_error("missing or misspelled literal closing tag");

   859         }

   860         $this->value = substr($this->data, $this->counter, $to - $this->counter);

   861         $this->token = Smarty_Internal_Templateparser::TP_LITERAL;

   862     }

   863 

   864     public function yylex5() {

   865         if (!isset($this->yy_global_pattern5)) {

   866             $this->yy_global_pattern5 = "/\G(" . $this->ldel . "\\s*literal\\s*" . $this->rdel . ")|\G(" . $this->ldel . "\\s*[\/]literal\\s*" . $this->rdel . ")|\G(" . $this->ldel . "\\s*[\/])|\G(" . $this->ldel . "\\s*[0-9]*[a-zA-Z_]\\w*)|\G(" . $this->ldel . "\\s*)|\G([\"])|\G([`][$])|\G([$][0-9]*[a-zA-Z_]\\w*)|\G([$])|\G(([^\"\\\\]*?)((?:\\\\.[^\"\\\\]*?)*?)(?=(" . $this->ldel . "|\\$|`\\$|\")))|\G([\S\s])/isS";

   867         }

   868         if ($this->counter >= strlen($this->data)) {

   869             return false; // end of input

   870         }

   871 

   872         do {

   873             if (preg_match($this->yy_global_pattern5, $this->data, $yymatches, null, $this->counter)) {

   874                 $yysubmatches = $yymatches;

   875                 if (strlen($yysubmatches[0]) < 200) {

   876                     $yymatches = preg_grep("/(.|\s)+/", $yysubmatches);

   877                 } else {

   878                     $yymatches = array_filter($yymatches, 'strlen');

   879                 }

   880                 if (empty($yymatches)) {

   881                     throw new Exception('Error: lexing failed because a rule matched' . ' an empty string.  Input "' . substr($this->data, $this->counter, 5) . '... state DOUBLEQUOTEDSTRING');

   882                 }

   883                 next($yymatches); // skip global match

   884                 $this->token = key($yymatches); // token number

   885                 $this->value = current($yymatches); // token value

   886                 $r = $this->{'yy_r5_' . $this->token}();

   887                 if ($r === null) {

   888                     $this->counter += strlen($this->value);

   889                     $this->line += substr_count($this->value, "\n");

   890                     // accept this token

   891                     return true;

   892                 } elseif ($r === true) {

   893                     // we have changed state

   894                     // process this token in the new state

   895                     return $this->yylex();

   896                 } elseif ($r === false) {

   897                     $this->counter += strlen($this->value);

   898                     $this->line += substr_count($this->value, "\n");

   899                     if ($this->counter >= strlen($this->data)) {

   900                         return false; // end of input

   901                     }

   902                     // skip this token

   903                     continue;

   904                 }

   905             } else {

   906                 throw new Exception('Unexpected input at line' . $this->line . ': ' . $this->data[$this->counter]);

   907             }

   908             break;

   909         } while (true);

   910     } // end function

   911 

   912     const DOUBLEQUOTEDSTRING = 5;

   913 

   914     function yy_r5_1() {

   915 

   916         $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   917     }

   918 

   919     function yy_r5_2() {

   920 

   921         $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   922     }

   923 

   924     function yy_r5_3() {

   925 

   926         if ($this->smarty->auto_literal && isset($this->value[$this->ldel_length]) ? strpos(" \n\t\r", $this->value[$this->ldel_length]) !== false : false) {

   927             $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   928         } else {

   929             $this->yypushstate(self::TAG);

   930             return true;

   931         }

   932     }

   933 

   934     function yy_r5_4() {

   935 

   936         if ($this->smarty->auto_literal && isset($this->value[$this->ldel_length]) ? strpos(" \n\t\r", $this->value[$this->ldel_length]) !== false : false) {

   937             $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   938         } else {

   939             $this->yypushstate(self::TAG);

   940             return true;

   941         }

   942     }

   943 

   944     function yy_r5_5() {

   945 

   946         if ($this->smarty->auto_literal && isset($this->value[$this->ldel_length]) ? strpos(" \n\t\r", $this->value[$this->ldel_length]) !== false : false) {

   947             $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   948         } else {

   949             $this->token = Smarty_Internal_Templateparser::TP_LDEL;

   950             $this->taglineno = $this->line;

   951             $this->yypushstate(self::TAGBODY);

   952         }

   953     }

   954 

   955     function yy_r5_6() {

   956 

   957         $this->token = Smarty_Internal_Templateparser::TP_QUOTE;

   958         $this->yypopstate();

   959     }

   960 

   961     function yy_r5_7() {

   962 

   963         $this->token = Smarty_Internal_Templateparser::TP_BACKTICK;

   964         $this->value = substr($this->value, 0, -1);

   965         $this->yypushstate(self::TAGBODY);

   966         $this->taglineno = $this->line;

   967     }

   968 

   969     function yy_r5_8() {

   970 

   971         $this->token = Smarty_Internal_Templateparser::TP_DOLLARID;

   972     }

   973 

   974     function yy_r5_9() {

   975 

   976         $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   977     }

   978 

   979     function yy_r5_10() {

   980 

   981         $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   982     }

   983 

   984     function yy_r5_14() {

   985 

   986         $to = strlen($this->data);

   987         $this->value = substr($this->data, $this->counter, $to - $this->counter);

   988         $this->token = Smarty_Internal_Templateparser::TP_TEXT;

   989     }

   990 

   991     public function yylex6() {

   992         if (!isset($this->yy_global_pattern6)) {

   993             $this->yy_global_pattern6 = "/\G(" . $this->ldel . "\\s*strip\\s*" . $this->rdel . ")|\G(" . $this->ldel . "\\s*[\/]strip\\s*" . $this->rdel . ")|\G(" . $this->ldel . "\\s*block)|\G([\S\s])/isS";

   994         }

   995         if ($this->counter >= strlen($this->data)) {

   996             return false; // end of input

   997         }

   998 

   999         do {

  1000             if (preg_match($this->yy_global_pattern6, $this->data, $yymatches, null, $this->counter)) {

  1001                 $yysubmatches = $yymatches;

  1002                 if (strlen($yysubmatches[0]) < 200) {

  1003                     $yymatches = preg_grep("/(.|\s)+/", $yysubmatches);

  1004                 } else {

  1005                     $yymatches = array_filter($yymatches, 'strlen');

  1006                 }

  1007                 if (empty($yymatches)) {

  1008                     throw new Exception('Error: lexing failed because a rule matched' . ' an empty string.  Input "' . substr($this->data, $this->counter, 5) . '... state CHILDBODY');

  1009                 }

  1010                 next($yymatches); // skip global match

  1011                 $this->token = key($yymatches); // token number

  1012                 $this->value = current($yymatches); // token value

  1013                 $r = $this->{'yy_r6_' . $this->token}();

  1014                 if ($r === null) {

  1015                     $this->counter += strlen($this->value);

  1016                     $this->line += substr_count($this->value, "\n");

  1017                     // accept this token

  1018                     return true;

  1019                 } elseif ($r === true) {

  1020                     // we have changed state

  1021                     // process this token in the new state

  1022                     return $this->yylex();

  1023                 } elseif ($r === false) {

  1024                     $this->counter += strlen($this->value);

  1025                     $this->line += substr_count($this->value, "\n");

  1026                     if ($this->counter >= strlen($this->data)) {

  1027                         return false; // end of input

  1028                     }

  1029                     // skip this token

  1030                     continue;

  1031                 }

  1032             } else {

  1033                 throw new Exception('Unexpected input at line' . $this->line . ': ' . $this->data[$this->counter]);

  1034             }

  1035             break;

  1036         } while (true);

  1037     } // end function

  1038 

  1039     const CHILDBODY = 6;

  1040 

  1041     function yy_r6_1() {

  1042 

  1043         if ($this->smarty->auto_literal && isset($this->value[$this->ldel_length]) ? strpos(" \n\t\r", $this->value[$this->ldel_length]) !== false : false) {

  1044             return false;

  1045         } else {

  1046             $this->token = Smarty_Internal_Templateparser::TP_STRIPON;

  1047         }

  1048     }

  1049 

  1050     function yy_r6_2() {

  1051 

  1052         if ($this->smarty->auto_literal && isset($this->value[$this->ldel_length]) ? strpos(" \n\t\r", $this->value[$this->ldel_length]) !== false : false) {

  1053             return false;

  1054         } else {

  1055             $this->token = Smarty_Internal_Templateparser::TP_STRIPOFF;

  1056         }

  1057     }

  1058 

  1059     function yy_r6_3() {

  1060 

  1061         if ($this->smarty->auto_literal && isset($this->value[$this->ldel_length]) ? strpos(" \n\t\r", $this->value[$this->ldel_length]) !== false : false) {

  1062             return false;

  1063         } else {

  1064             $this->yypopstate();

  1065             return true;

  1066         }

  1067     }

  1068 

  1069     function yy_r6_4() {

  1070 

  1071         $to = strlen($this->data);

  1072         preg_match("~" . $this->ldel . "\s*(([/])?strip\s*" . $this->rdel . "|block\s+)~i", $this->data, $match, PREG_OFFSET_CAPTURE, $this->counter);

  1073         if (isset($match[0][1])) {

  1074             $to = $match[0][1];

  1075         }

  1076         $this->value = substr($this->data, $this->counter, $to - $this->counter);

  1077         return false;

  1078     }

  1079 

  1080     public function yylex7() {

  1081         if (!isset($this->yy_global_pattern7)) {

  1082             $this->yy_global_pattern7 = "/\G(" . $this->ldel . "\\s*literal\\s*" . $this->rdel . ")|\G(" . $this->ldel . "\\s*block)|\G(" . $this->ldel . "\\s*[\/]block)|\G(" . $this->ldel . "\\s*[$]smarty\\.block\\.(child|parent))|\G([\S\s])/isS";

  1083         }

  1084         if ($this->counter >= strlen($this->data)) {

  1085             return false; // end of input

  1086         }

  1087 

  1088         do {

  1089             if (preg_match($this->yy_global_pattern7, $this->data, $yymatches, null, $this->counter)) {

  1090                 $yysubmatches = $yymatches;

  1091                 if (strlen($yysubmatches[0]) < 200) {

  1092                     $yymatches = preg_grep("/(.|\s)+/", $yysubmatches);

  1093                 } else {

  1094                     $yymatches = array_filter($yymatches, 'strlen');

  1095                 }

  1096                 if (empty($yymatches)) {

  1097                     throw new Exception('Error: lexing failed because a rule matched' . ' an empty string.  Input "' . substr($this->data, $this->counter, 5) . '... state CHILDBLOCK');

  1098                 }

  1099                 next($yymatches); // skip global match

  1100                 $this->token = key($yymatches); // token number

  1101                 $this->value = current($yymatches); // token value

  1102                 $r = $this->{'yy_r7_' . $this->token}();

  1103                 if ($r === null) {

  1104                     $this->counter += strlen($this->value);

  1105                     $this->line += substr_count($this->value, "\n");

  1106                     // accept this token

  1107                     return true;

  1108                 } elseif ($r === true) {

  1109                     // we have changed state

  1110                     // process this token in the new state

  1111                     return $this->yylex();

  1112                 } elseif ($r === false) {

  1113                     $this->counter += strlen($this->value);

  1114                     $this->line += substr_count($this->value, "\n");

  1115                     if ($this->counter >= strlen($this->data)) {

  1116                         return false; // end of input

  1117                     }

  1118                     // skip this token

  1119                     continue;

  1120                 }

  1121             } else {

  1122                 throw new Exception('Unexpected input at line' . $this->line . ': ' . $this->data[$this->counter]);

  1123             }

  1124             break;

  1125         } while (true);

  1126     } // end function

  1127 

  1128     const CHILDBLOCK = 7;

  1129 

  1130     function yy_r7_1() {

  1131 

  1132         if ($this->smarty->auto_literal && isset($this->value[$this->ldel_length]) ? strpos(" \n\t\r", $this->value[$this->ldel_length]) !== false : false) {

  1133             $this->token = Smarty_Internal_Templateparser::TP_BLOCKSOURCE;

  1134         } else {

  1135             $this->token = Smarty_Internal_Templateparser::TP_BLOCKSOURCE;