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     /**

    23      * Source

    24      *

    25      * @var string

    26      */

    27     public $data;

    28     /**

    29      * byte counter

    30      *

    31      * @var int

    32      */

    33     public $counter;

    34     /**

    35      * token number

    36      *

    37      * @var int

    38      */

    39     public $token;

    40     /**

    41      * token value

    42      *

    43      * @var string

    44      */

    45     public $value;

    46     /**

    47      * current line

    48      *

    49      * @var int

    50      */

    51     public $line;

    52     /**

    53      * tag start line

    54      *

    55      * @var

    56      */

    57     public $taglineno;

    58     /**

    59      * php code type

    60      *

    61      * @var string

    62      */

    63     public $phpType = '';

    64     /**

    65      * escaped left delimiter

    66      *

    67      * @var string

    68      */

    69     public $ldel = '';

    70     /**

    71      * escaped left delimiter length

    72      *

    73      * @var int

    74      */

    75     public $ldel_length = 0;

    76     /**

    77      * escaped right delimiter

    78      *

    79      * @var string

    80      */

    81     public $rdel = '';

    82     /**

    83      * escaped right delimiter length

    84      *

    85      * @var int

    86      */

    87     public $rdel_length = 0;

    88     /**

    89      * state number

    90      *

    91      * @var int

    92      */

    93     public $state = 1;

    94     /**

    95      * Smarty object

    96      *

    97      * @var Smarty

    98      */

    99     public $smarty = null;

   100     /**

   101      * compiler object

   102      *

   103      * @var Smarty_Internal_TemplateCompilerBase

   104      */

   105     public $compiler = null;

   106     /**

   107      * literal tag nesting level

   108      *

   109      * @var int

   110      */

   111     private $literal_cnt = 0;

   112 

   113     /**

   114      * PHP start tag string

   115      *

   116      * @var string

   117      */

   118 

   119     /**

   120      * trace file

   121      *

   122      * @var resource

   123      */

   124     public $yyTraceFILE;

   125 

   126     /**

   127      * trace prompt

   128      *

   129      * @var string

   130      */

   131     public $yyTracePrompt;

   132 

   133     /**

   134     * XML flag true while processing xml

   135     *

   136     * @var bool

   137     */

   138     public $is_xml = false;

   139 

   140     /**

   141      * state names

   142      *

   143      * @var array

   144      */

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

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

   147 

   148     /**

   149      * storage for assembled token patterns

   150      *

   151      * @var string

   152      */

   153     private $yy_global_pattern1 = null;

   154 

   155     private $yy_global_pattern2 = null;

   156 

   157     private $yy_global_pattern3 = null;

   158 

   159     private $yy_global_pattern4 = null;

   160 

   161     private $yy_global_pattern5 = null;

   162 

   163     private $yy_global_pattern6 = null;

   164 

   165     private $yy_global_pattern7 = null;

   166 

   167     private $yy_global_pattern8 = null;

   168 

   169     /**

   170      * token names

   171      *

   172      * @var array

   173      */

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

   175                                                'NOT'             => '(!,not)',

   176                                                'OPENP'           => '(',

   177                                                'CLOSEP'          => ')',

   178                                                'OPENB'           => '[',

   179                                                'CLOSEB'          => ']',

   180                                                'PTR'             => '->',

   181                                                'APTR'            => '=>',

   182                                                'EQUAL'           => '=',

   183                                                'NUMBER'          => 'number',

   184                                                'UNIMATH'         => '+" , "-',

   185                                                'MATH'            => '*" , "/" , "%',

   186                                                'INCDEC'          => '++" , "--',

   187                                                'SPACE'           => ' ',

   188                                                'DOLLAR'          => '$',

   189                                                'SEMICOLON'       => ';',

   190                                                'COLON'           => ':',

   191                                                'DOUBLECOLON'     => '::',

   192                                                'AT'              => '@',

   193                                                'HATCH'           => '#',

   194                                                'QUOTE'           => '"',

   195                                                'BACKTICK'        => '`',

   196                                                'VERT'            => '"|" modifier',

   197                                                'DOT'             => '.',

   198                                                'COMMA'           => '","',

   199                                                'QMARK'           => '"?"',

   200                                                'ID'              => 'id, name',

   201                                                'TEXT'            => 'text',

   202                                                'LDELSLASH'       => '{/..} closing tag',

   203                                                'LDEL'            => '{...} Smarty tag',

   204                                                'COMMENT'         => 'comment',

   205                                                'AS'              => 'as',

   206                                                'TO'              => 'to',

   207                                                'PHP'             => '"<?php", "<%", "{php}" tag',

   208                                                'LOGOP'           => '"<", "==" ... logical operator',

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

   210                                                'SCOND'           => '"is even" ... if condition',

   211     );

   212 

   213     /**

   214      * constructor

   215      *

   216      * @param   string                             $data template source

   217      * @param Smarty_Internal_TemplateCompilerBase $compiler

   218      */

   219     function __construct($data, Smarty_Internal_TemplateCompilerBase $compiler)

   220     {

   221         $this->data = $data;

   222         $this->counter = 0;

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

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

   225         }

   226         $this->line = 1;

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

   228         $this->compiler = $compiler;

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

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

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

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

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

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

   235     }

   236 

   237    public function PrintTrace()

   238    {

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

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

   241    }

   242 

   243    /*

   244     * Check if this tag is autoliteral

   245     */

   246    public function isAutoLiteral ()

   247    {

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

   249    }

   250 

   251      /*!lex2php

   252      %input $this->data

   253      %counter $this->counter

   254      %token $this->token

   255      %value $this->value

   256      %line $this->line

   257      linebreak = ~[\t ]*[\r\n]+[\t ]*~

   258      text = ~[\S\s]~

   259      textdoublequoted = ~([^"\\]*?)((?:\\.[^"\\]*?)*?)(?=(SMARTYldel|\$|`\$|"))~

   260      namespace = ~([0-9]*[a-zA-Z_]\w*)?(\\[0-9]*[a-zA-Z_]\w*)+~

   261      all = ~[\S\s]+~

   262      emptyjava = ~[{][}]~

   263      phpstart = ~(<[?]((php\s+|=)|\s+))|(<[%])|(<[?]xml\s+)|(<script\s+language\s*=\s*["']?\s*php\s*["']?\s*>)|([?][>])|([%][>])|(SMARTYldel\s*php(.*?)SMARTYrdel)|(SMARTYldel\s*[/]phpSMARTYrdel)~

   264      slash = ~[/]~

   265      ldel = ~SMARTYldel\s*~

   266      rdel = ~\s*SMARTYrdel~

   267      nocacherdel = ~(\s+nocache)?\s*SMARTYrdel~

   268      notblockid = ~(?:(?!block)[0-9]*[a-zA-Z_]\w*)~

   269      smartyblockchildparent = ~[\$]smarty\.block\.(child|parent)~

   270      integer = ~\d+~

   271      hex =  ~0[xX][0-9a-fA-F]+~

   272      math = ~\s*([*]{1,2}|[%/^&]|[<>]{2})\s*~

   273      comment = ~SMARTYldel[*]~

   274      incdec = ~([+]|[-]){2}~

   275      unimath = ~\s*([+]|[-])\s*~

   276      openP = ~\s*[(]\s*~

   277      closeP = ~\s*[)]~

   278      openB = ~\[\s*~

   279      closeB = ~\s*\]~

   280      dollar = ~[$]~

   281      dot = ~[.]~

   282      comma = ~\s*[,]\s*~

   283      doublecolon = ~[:]{2}~

   284      colon = ~\s*[:]\s*~

   285      at = ~[@]~

   286      hatch = ~[#]~

   287      semicolon = ~\s*[;]\s*~

   288      equal = ~\s*[=]\s*~

   289      space = ~\s+~

   290      ptr = ~\s*[-][>]\s*~

   291      aptr = ~\s*[=][>]\s*~

   292      singlequotestring = ~'[^'\\]*(?:\\.[^'\\]*)*'~

   293      backtick = ~[`]~

   294      vert = ~[|]~

   295      qmark = ~\s*[?]\s*~

   296      constant = ~([_]+[A-Z0-9][0-9A-Z_]*|[A-Z][0-9A-Z_]*)(?![0-9A-Z_]*[a-z])~

   297      attr = ~\s+[0-9]*[a-zA-Z_][a-zA-Z0-9_\-:]*\s*[=]\s*~

   298      id = ~[0-9]*[a-zA-Z_]\w*~

   299      literal = ~literal~

   300      strip = ~strip~

   301      lop = ~\s*(([!=][=]{1,2})|([<][=>]?)|([>][=]?)|[&|]{2})\s*~

   302      tlop = ~\s+(eq|ne|neq|gt|ge|gte|lt|le|lte|mod|and|or|xor|(is\s+(not\s+)?(odd|even|div)\s+by))\s+~

   303      scond = ~\s+is\s+(not\s+)?(odd|even)~

   304      isin = ~\s+is\s+in\s+~

   305      as = ~\s+as\s+~

   306      to = ~\s+to\s+~

   307      step = ~\s+step\s+~

   308      block = ~block~

   309      if = ~(if|elseif|else if|while)\s+~

   310      for = ~for\s+~

   311      foreach = ~foreach(?![^\s])~

   312      setfilter = ~setfilter\s+~

   313      instanceof = ~\s+instanceof\s+~

   314      not = ~([!]\s*)|(not\s+)~

   315      typecast = ~[(](int(eger)?|bool(ean)?|float|double|real|string|binary|array|object)[)]\s*~

   316      double_quote = ~["]~

   317      single_quote = ~[']~

   318      */

   319      /*!lex2php

   320      %statename TEXT

   321      emptyjava {

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

   323      }

   324      comment {

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

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

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

   328         } else {

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

   330         }

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

   332         return false;

   333      }

   334      phpstart {

   335        $obj = new Smarty_Internal_Compile_Private_Php();

   336        $obj->parsePhp($this);

   337      }

   338      ldel literal rdel {

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

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

   341        } else {

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

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

   344         }

   345      }

   346      ldel {

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

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

   349        } else {

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

   351           return true;

   352        }

   353      }

   354      rdel {

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

   356      }

   357      text {

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

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

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

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

   362        }

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

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

   365      }

   366      */

   367      /*!lex2php

   368      %statename TAG

   369      ldel if {

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

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

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

   373      }

   374      ldel for {

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

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

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

   378      }

   379      ldel foreach {

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

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

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

   383      }

   384      ldel setfilter {

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

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

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

   388      }

   389      ldel id nocacherdel {

   390           $this->yypopstate();

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

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

   393      }

   394      ldel slash notblockid rdel {

   395          $this->yypopstate();

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

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

   398      }

   399      ldel dollar id nocacherdel {

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

   401             $this->yypopstate();

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

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

   404          } else {

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

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

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

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

   409          }

   410      }

   411      ldel slash {

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

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

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

   415      }

   416      ldel {

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

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

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

   420      }

   421      */

   422      /*!lex2php

   423      %statename TAGBODY     

   424      rdel {

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

   426        $this->yypopstate();

   427      }

   428      double_quote {

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

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

   431      }

   432      singlequotestring {

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

   434      }

   435      smartyblockchildparent {

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

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

   438      }

   439      dollar id {

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

   441      }

   442      dollar {

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

   444      }

   445      isin {

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

   447      }

   448      as {

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

   450      }

   451      to {

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

   453      }

   454      step {

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

   456      }

   457      instanceof {

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

   459      }

   460      lop {

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

   462      }

   463      tlop {

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

   465      }

   466      scond {

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

   468      }

   469      not{

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

   471      }

   472      typecast {

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

   474      }

   475      openP {

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

   477      }

   478      closeP {

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

   480      }

   481      openB {

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

   483      }

   484      closeB {

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

   486      }

   487      ptr {

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

   489      }

   490      aptr {

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

   492      }

   493      equal {

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

   495      }

   496      incdec {

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

   498      }

   499      unimath {

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

   501      }

   502      math {

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

   504      }

   505      at {

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

   507      }

   508      hatch {

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

   510      }

   511      attr {

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

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

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

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

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

   517        } else {

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

   519        }

   520      }

   521      namespace {

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

   523      }

   524      id {

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

   526      }

   527      integer {

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

   529      }

   530      backtick {

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

   532        $this->yypopstate();

   533      }

   534      vert {

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

   536      }

   537      dot {

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

   539      }

   540      comma {

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

   542      }

   543      semicolon {

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

   545      }

   546      doublecolon {

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

   548      }

   549      colon {

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

   551      }

   552      qmark {

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

   554      }

   555      hex {

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

   557      }

   558      space {

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

   560      }

   561      ldel {

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

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

   564        } else {

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

   566           return true;

   567        }

   568      }

   569      text {

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

   571      }

   572      */

   573 

   574      /*!lex2php

   575      %statename LITERAL

   576      ldel literal rdel {

   577        $this->literal_cnt++;

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

   579      }

   580      ldel slash literal rdel {

   581        if ($this->literal_cnt) {

   582          $this->literal_cnt--;

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

   584        } else {

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

   586          $this->yypopstate();

   587        }

   588      }

   589      text {

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

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

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

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

   594        } else {

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

   596        }

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

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

   599      }

   600      */

   601      /*!lex2php

   602      %statename DOUBLEQUOTEDSTRING

   603      ldel literal rdel {

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

   605      }

   606      ldel slash literal rdel {

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

   608      }

   609      ldel slash {

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

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

   612        } else {

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

   614           return true;

   615        }

   616      }

   617      ldel id {

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

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

   620        } else {

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

   622           return true;

   623        }

   624      }

   625      ldel {

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

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

   628        } else {

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

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

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

   632        }

   633      }

   634      double_quote {

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

   636        $this->yypopstate();

   637      }

   638      backtick dollar {

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

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

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

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

   643      }

   644      dollar id {

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

   646      }

   647      dollar {

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

   649      }

   650      textdoublequoted {

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

   652      }

   653      text {

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

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

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

   657      }

   658      */

   659      /*!lex2php

   660      %statename CHILDBODY

   661      ldel strip rdel {

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

   663           return false;

   664        } else {

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

   666        }

   667      }

   668      ldel slash strip rdel {

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

   670           return false;

   671        } else {

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

   673        }

   674      }

   675      ldel block  {

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

   677           return false;

   678        } else {

   679          $this->yypopstate();

   680          return true;

   681        }

   682      }

   683      text {

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

   685        preg_match("~SMARTYldel\s*(([/])?strip\s*SMARTYrdel|block\s+)~i",$this->data,$match,PREG_OFFSET_CAPTURE,$this->counter);

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

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

   688        }

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

   690        return false;

   691      }

   692 

   693      */

   694      /*!lex2php

   695      %statename CHILDBLOCK

   696      ldel literal rdel {

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

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

   699        } else {

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

   701          $this->yypushstate(self::CHILDLITERAL);

   702         }

   703      }

   704      ldel block {

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

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

   707        } else {

   708          $this->yypopstate();

   709          return true;

   710        }

   711      }

   712      ldel slash block {

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

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

   715        } else {

   716          $this->yypopstate();

   717          return true;

   718        }

   719      }

   720      ldel smartyblockchildparent {

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

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

   723        } else {

   724          $this->yypopstate();

   725          return true;

   726        }

   727      }

   728      text {

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

   730        preg_match("~SMARTYldel\s*(literal\s*SMARTYrdel|([/])?block(\s|SMARTYrdel)|[\$]smarty\.block\.(child|parent))~i",$this->data,$match,PREG_OFFSET_CAPTURE,$this->counter);

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

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

   733        }

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

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

   736      }

   737      */

   738      /*!lex2php

   739      %statename CHILDLITERAL

   740      ldel literal rdel {

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

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

   743        } else {

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

   745          $this->yypushstate(self::CHILDLITERAL);

   746        }

   747      }

   748      ldel slash literal rdel {

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

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

   751        } else {

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

   753          $this->yypopstate();

   754        }

   755      }

   756      text {

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

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

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

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

   761        } else {

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

   763        }

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

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

   766      }

   767      */

   768  }

   769 

   770