Subversion-Projekte lars-tiefland.laravel_shop

Revision

Details | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
148 lars 1 
<?php
2 
/*
3 
 * This file is part of Smarty.
4 
 *
5 
 * (c) 2015 Uwe Tews
6 
 *
7 
 * For the full copyright and license information, please view the LICENSE
8 
 * file that was distributed with this source code.
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 
 *
17 
 * @author Uwe Tews <uwe.tews@googlemail.com>
18 
 */
19 
class Smarty_Internal_Templatelexer
20 
{
21 
    /**
22 
     * Source
23 
     *
24 
     * @var string
25 
     */
26 
    public $data;
27 
 
28 
    /**
29 
     * Source length
30 
     *
31 
     * @var int
32 
     */
33 
    public $dataLength = null;
34 
 
35 
    /**
36 
     * byte counter
37 
     *
38 
     * @var int
39 
     */
40 
    public $counter;
41 
 
42 
    /**
43 
     * token number
44 
     *
45 
     * @var int
46 
     */
47 
    public $token;
48 
 
49 
    /**
50 
     * token value
51 
     *
52 
     * @var string
53 
     */
54 
    public $value;
55 
 
56 
    /**
57 
     * current line
58 
     *
59 
     * @var int
60 
     */
61 
    public $line;
62 
 
63 
    /**
64 
     * tag start line
65 
     *
66 
     * @var
67 
     */
68 
    public $taglineno;
69 
 
70 
    /**
71 
     * php code type
72 
     *
73 
     * @var string
74 
     */
75 
    public $phpType = '';
76 
 
77 
   /**
78 
     * state number
79 
     *
80 
     * @var int
81 
     */
82 
    public $state = 1;
83 
 
84 
    /**
85 
     * Smarty object
86 
     *
87 
     * @var Smarty
88 
     */
89 
    public $smarty = null;
90 
 
91 
    /**
92 
     * compiler object
93 
     *
94 
     * @var Smarty_Internal_TemplateCompilerBase
95 
     */
96 
    public $compiler = null;
97 
 
98 
    /**
99 
     * trace file
100 
     *
101 
     * @var resource
102 
     */
103 
    public $yyTraceFILE;
104 
 
105 
    /**
106 
     * trace prompt
107 
     *
108 
     * @var string
109 
     */
110 
    public $yyTracePrompt;
111 
 
112 
    /**
113 
     * XML flag true while processing xml
114 
     *
115 
     * @var bool
116 
     */
117 
    public $is_xml = false;
118 
 
119 
    /**
120 
     * state names
121 
     *
122 
     * @var array
123 
     */
124 
    public $state_name = array(1 => 'TEXT', 2 => 'TAG', 3 => 'TAGBODY', 4 => 'LITERAL', 5 => 'DOUBLEQUOTEDSTRING',);
125 
 
126 
    /**
127 
     * token names
128 
     *
129 
     * @var array
130 
     */
131 
    public $smarty_token_names = array(        // Text for parser error messages
132 
                                               'NOT'         => '(!,not)',
133 
                                               'OPENP'       => '(',
134 
                                               'CLOSEP'      => ')',
135 
                                               'OPENB'       => '[',
136 
                                               'CLOSEB'      => ']',
137 
                                               'PTR'         => '->',
138 
                                               'APTR'        => '=>',
139 
                                               'EQUAL'       => '=',
140 
                                               'NUMBER'      => 'number',
141 
                                               'UNIMATH'     => '+" , "-',
142 
                                               'MATH'        => '*" , "/" , "%',
143 
                                               'INCDEC'      => '++" , "--',
144 
                                               'SPACE'       => ' ',
145 
                                               'DOLLAR'      => '$',
146 
                                               'SEMICOLON'   => ';',
147 
                                               'COLON'       => ':',
148 
                                               'DOUBLECOLON' => '::',
149 
                                               'AT'          => '@',
150 
                                               'HATCH'       => '#',
151 
                                               'QUOTE'       => '"',
152 
                                               'BACKTICK'    => '`',
153 
                                               'VERT'        => '"|" modifier',
154 
                                               'DOT'         => '.',
155 
                                               'COMMA'       => '","',
156 
                                               'QMARK'       => '"?"',
157 
                                               'ID'          => 'id, name',
158 
                                               'TEXT'        => 'text',
159 
                                               'LDELSLASH'   => '{/..} closing tag',
160 
                                               'LDEL'        => '{...} Smarty tag',
161 
                                               'COMMENT'     => 'comment',
162 
                                               'AS'          => 'as',
163 
                                               'TO'          => 'to',
164 
                                               'LOGOP'       => '"<", "==" ... logical operator',
165 
                                               'TLOGOP'      => '"lt", "eq" ... logical operator; "is div by" ... if condition',
166 
                                               'SCOND'       => '"is even" ... if condition',
167 
    );
168 
 
169 
    /**
170 
     * literal tag nesting level
171 
     *
172 
     * @var int
173 
     */
174 
    private $literal_cnt = 0;
175 
 
176 
    /**
177 
     * preg token pattern for state TEXT
178 
     *
179 
     * @var string
180 
     */
181 
    private $yy_global_pattern1 = null;
182 
 
183 
    /**
184 
     * preg token pattern for state TAG
185 
     *
186 
     * @var string
187 
     */
188 
    private $yy_global_pattern2 = null;
189 
 
190 
    /**
191 
     * preg token pattern for state TAGBODY
192 
     *
193 
     * @var string
194 
     */
195 
    private $yy_global_pattern3 = null;
196 
 
197 
    /**
198 
     * preg token pattern for state LITERAL
199 
     *
200 
     * @var string
201 
     */
202 
    private $yy_global_pattern4 = null;
203 
 
204 
    /**
205 
     * preg token pattern for state DOUBLEQUOTEDSTRING
206 
     *
207 
     * @var null
208 
     */
209 
    private $yy_global_pattern5 = null;
210 
 
211 
    /**
212 
     * preg token pattern for text
213 
     *
214 
     * @var null
215 
     */
216 
    private $yy_global_text = null;
217 
 
218 
    /**
219 
     * preg token pattern for literal
220 
     *
221 
     * @var null
222 
     */
223 
    private $yy_global_literal = null;
224 
 
225 
    /**
226 
     * constructor
227 
     *
228 
     * @param   string                             $source template source
229 
     * @param Smarty_Internal_TemplateCompilerBase $compiler
230 
     */
231 
    public function __construct($source, Smarty_Internal_TemplateCompilerBase $compiler)
232 
    {
233 
        $this->data = $source;
234 
        $this->dataLength = strlen($this->data);
235 
        $this->counter = 0;
236 
        if (preg_match('/^\xEF\xBB\xBF/i', $this->data, $match)) {
237 
            $this->counter += strlen($match[0]);
238 
        }
239 
        $this->line = 1;
240 
        $this->smarty = $compiler->template->smarty;
241 
        $this->compiler = $compiler;
242 
        $this->compiler->initDelimiterPreg();
243 
        $this->smarty_token_names['LDEL'] = $this->smarty->getLeftDelimiter();
244 
        $this->smarty_token_names['RDEL'] = $this->smarty->getRightDelimiter();
245 
    }
246 
 
247 
    /**
248 
     * open lexer/parser trace file
249 
     *
250 
     */
251 
    public function PrintTrace()
252 
    {
253 
        $this->yyTraceFILE = fopen('php://output', 'w');
254 
        $this->yyTracePrompt = '<br>';
255 
    }
256 
 
257 
   /**
258 
     * replace placeholders with runtime preg  code
259 
     *
260 
     * @param string $preg
261 
     *
262 
     * @return string
263 
     */
264 
   public function replace($preg)
265 
   {
266 
        return $this->compiler->replaceDelimiter($preg);
267 
   }
268 
 
269 
    /**
270 
     * check if current value is an autoliteral left delimiter
271 
     *
272 
     * @return bool
273 
     */
274 
    public function isAutoLiteral()
275 
    {
276 
        return $this->smarty->getAutoLiteral() && isset($this->value[ $this->compiler->getLdelLength() ]) ?
277 
            strpos(" \n\t\r", $this->value[ $this->compiler->getLdelLength() ]) !== false : false;
278 
    }
279 
 
280 
     /*!lex2php
281 
     %input $this->data
282 
     %counter $this->counter
283 
     %token $this->token
284 
     %value $this->value
285 
     %line $this->line
286 
     userliteral = ~(SMARTYldel)SMARTYautoliteral\s+SMARTYliteral~
287 
     char = ~[\S\s]~
288 
     textdoublequoted = ~([^"\\]*?)((?:\\.[^"\\]*?)*?)(?=((SMARTYldel)SMARTYal|\$|`\$|"SMARTYliteral))~
289 
     namespace = ~([0-9]*[a-zA-Z_]\w*)?(\\[0-9]*[a-zA-Z_]\w*)+~
290 
     emptyjava = ~[{][}]~
291 
     slash = ~[/]~
292 
     ldel = ~(SMARTYldel)SMARTYal~
293 
     rdel = ~\s*SMARTYrdel~
294 
     nocacherdel = ~(\s+nocache)?\s*SMARTYrdel~
295 
     smartyblockchildparent = ~[\$]smarty\.block\.(child|parent)~
296 
     integer = ~\d+~
297 
     hex =  ~0[xX][0-9a-fA-F]+~
298 
     math = ~\s*([*]{1,2}|[%/^&]|[<>]{2})\s*~
299 
     comment = ~(SMARTYldel)SMARTYal[*]~
300 
     incdec = ~([+]|[-]){2}~
301 
     unimath = ~\s*([+]|[-])\s*~
302 
     openP = ~\s*[(]\s*~
303 
     closeP = ~\s*[)]~
304 
     openB = ~\[\s*~
305 
     closeB = ~\s*\]~
306 
     dollar = ~[$]~
307 
     dot = ~[.]~
308 
     comma = ~\s*[,]\s*~
309 
     doublecolon = ~[:]{2}~
310 
     colon = ~\s*[:]\s*~
311 
     at = ~[@]~
312 
     hatch = ~[#]~
313 
     semicolon = ~\s*[;]\s*~
314 
     equal = ~\s*[=]\s*~
315 
     space = ~\s+~
316 
     ptr = ~\s*[-][>]\s*~
317 
     aptr = ~\s*[=][>]\s*~
318 
     singlequotestring = ~'[^'\\]*(?:\\.[^'\\]*)*'~
319 
     backtick = ~[`]~
320 
     vert = ~[|][@]?~
321 
     qmark = ~\s*[?]\s*~
322 
     constant = ~[_]+[A-Z0-9][0-9A-Z_]*|[A-Z][0-9A-Z_]*(?![0-9A-Z_]*[a-z])~
323 
     attr = ~\s+[0-9]*[a-zA-Z_][a-zA-Z0-9_\-:]*\s*[=]\s*~
324 
     id = ~[0-9]*[a-zA-Z_]\w*~
325 
     literal = ~literal~
326 
     strip = ~strip~
327 
     lop = ~\s*([!=][=]{1,2}|[<][=>]?|[>][=]?|[&|]{2})\s*~
328 
     slop = ~\s+(eq|ne|neq|gt|ge|gte|lt|le|lte|mod|and|or|xor)\s+~
329 
     tlop = ~\s+is\s+(not\s+)?(odd|even|div)\s+by\s+~
330 
     scond = ~\s+is\s+(not\s+)?(odd|even)~
331 
     isin = ~\s+is\s+in\s+~
332 
     as = ~\s+as\s+~
333 
     to = ~\s+to\s+~
334 
     step = ~\s+step\s+~
335 
     if = ~(if|elseif|else if|while)\s+~
336 
     for = ~for\s+~
337 
     makenocache = ~make_nocache\s+~
338 
     array = ~array~
339 
     foreach = ~foreach(?![^\s])~
340 
     setfilter = ~setfilter\s+~
341 
     instanceof = ~\s+instanceof\s+~
342 
     not = ~[!]\s*|not\s+~
343 
     typecast = ~[(](int(eger)?|bool(ean)?|float|double|real|string|binary|array|object)[)]\s*~
344 
     double_quote = ~["]~
345 
     */
346 
     /*!lex2php
347 
     %statename TEXT
348 
     emptyjava {
349 
        $this->token = Smarty_Internal_Templateparser::TP_TEXT;
350 
     }
351 
     comment {
352 
       $to = $this->dataLength;
353 
       preg_match("/[*]{$this->compiler->getRdelPreg()}[\n]?/",$this->data,$match,PREG_OFFSET_CAPTURE,$this->counter);
354 
        if (isset($match[0][1])) {
355 
            $to = $match[0][1] + strlen($match[0][0]);
356 
        } else {
357 
            $this->compiler->trigger_template_error ("missing or misspelled comment closing tag '{$this->smarty->getRightDelimiter()}'");
358 
        }
359 
        $this->value = substr($this->data,$this->counter,$to-$this->counter);
360 
        return false;
361 
     }
362 
     userliteral {
363 
        $this->token = Smarty_Internal_Templateparser::TP_TEXT;
364 
     }
365 
     ldel literal rdel {
366 
        $this->token = Smarty_Internal_Templateparser::TP_LITERALSTART;
367 
        $this->yypushstate(self::LITERAL);
368 
     }
369 
     ldel slash literal rdel {
370 
        $this->token = Smarty_Internal_Templateparser::TP_LITERALEND;
371 
        $this->yypushstate(self::LITERAL);
372 
     }
373 
     ldel {
374 
        $this->yypushstate(self::TAG);
375 
        return true;
376 
     }
377 
     char {
378 
       if (!isset($this->yy_global_text)) {
379 
           $this->yy_global_text = $this->replace('/(SMARTYldel)SMARTYal/isS');
380 
       }
381 
       $to = $this->dataLength;
382 
       preg_match($this->yy_global_text, $this->data,$match,PREG_OFFSET_CAPTURE,$this->counter);
383 
       if (isset($match[0][1])) {
384 
         $to = $match[0][1];
385 
       }
386 
       $this->value = substr($this->data,$this->counter,$to-$this->counter);
387 
       $this->token = Smarty_Internal_Templateparser::TP_TEXT;
388 
     }
389 
     */
390 
     /*!lex2php
391 
     %statename TAG
392 
     ldel if {
393 
        $this->token = Smarty_Internal_Templateparser::TP_LDELIF;
394 
        $this->yybegin(self::TAGBODY);
395 
        $this->taglineno = $this->line;
396 
     }
397 
     ldel for {
398 
        $this->token = Smarty_Internal_Templateparser::TP_LDELFOR;
399 
        $this->yybegin(self::TAGBODY);
400 
        $this->taglineno = $this->line;
401 
     }
402 
     ldel foreach {
403 
        $this->token = Smarty_Internal_Templateparser::TP_LDELFOREACH;
404 
        $this->yybegin(self::TAGBODY);
405 
        $this->taglineno = $this->line;
406 
     }
407 
     ldel setfilter {
408 
        $this->token = Smarty_Internal_Templateparser::TP_LDELSETFILTER;
409 
        $this->yybegin(self::TAGBODY);
410 
        $this->taglineno = $this->line;
411 
     }
412 
     ldel makenocache {
413 
        $this->token = Smarty_Internal_Templateparser::TP_LDELMAKENOCACHE;
414 
        $this->yybegin(self::TAGBODY);
415 
        $this->taglineno = $this->line;
416 
     }
417 
     ldel id nocacherdel {
418 
        $this->yypopstate();
419 
        $this->token = Smarty_Internal_Templateparser::TP_SIMPLETAG;
420 
        $this->taglineno = $this->line;
421 
     }
422 
     ldel smartyblockchildparent rdel {
423 
         $this->yypopstate();
424 
         $this->token = Smarty_Internal_Templateparser::TP_SMARTYBLOCKCHILDPARENT;
425 
         $this->taglineno = $this->line;
426 
     }
427 
     ldel slash id rdel {
428 
        $this->yypopstate();
429 
        $this->token = Smarty_Internal_Templateparser::TP_CLOSETAG;
430 
        $this->taglineno = $this->line;
431 
     }
432 
     ldel dollar id nocacherdel {
433 
        if ($this->_yy_stack[count($this->_yy_stack)-1] === self::TEXT) {
434 
            $this->yypopstate();
435 
            $this->token = Smarty_Internal_Templateparser::TP_SIMPELOUTPUT;
436 
            $this->taglineno = $this->line;
437 
        } else {
438 
            $this->value = $this->smarty->getLeftDelimiter();
439 
            $this->token = Smarty_Internal_Templateparser::TP_LDEL;
440 
            $this->yybegin(self::TAGBODY);
441 
            $this->taglineno = $this->line;
442 
        }
443 
     }
444 
     ldel slash {
445 
        $this->token = Smarty_Internal_Templateparser::TP_LDELSLASH;
446 
        $this->yybegin(self::TAGBODY);
447 
        $this->taglineno = $this->line;
448 
     }
449 
     ldel {
450 
        $this->token = Smarty_Internal_Templateparser::TP_LDEL;
451 
        $this->yybegin(self::TAGBODY);
452 
        $this->taglineno = $this->line;
453 
     }
454 
     */
455 
     /*!lex2php
456 
     %statename TAGBODY
457 
     rdel {
458 
        $this->token = Smarty_Internal_Templateparser::TP_RDEL;
459 
        $this->yypopstate();
460 
     }
461 
     ldel {
462 
        $this->yypushstate(self::TAG);
463 
        return true;
464 
     }
465 
     double_quote {
466 
        $this->token = Smarty_Internal_Templateparser::TP_QUOTE;
467 
        $this->yypushstate(self::DOUBLEQUOTEDSTRING);
468 
        $this->compiler->enterDoubleQuote();
469 
     }
470 
     singlequotestring {
471 
        $this->token = Smarty_Internal_Templateparser::TP_SINGLEQUOTESTRING;
472 
     }
473 
     dollar id {
474 
        $this->token = Smarty_Internal_Templateparser::TP_DOLLARID;
475 
     }
476 
     dollar {
477 
        $this->token = Smarty_Internal_Templateparser::TP_DOLLAR;
478 
     }
479 
     isin {
480 
        $this->token = Smarty_Internal_Templateparser::TP_ISIN;
481 
     }
482 
     as {
483 
        $this->token = Smarty_Internal_Templateparser::TP_AS;
484 
     }
485 
     to {
486 
        $this->token = Smarty_Internal_Templateparser::TP_TO;
487 
     }
488 
     step {
489 
        $this->token = Smarty_Internal_Templateparser::TP_STEP;
490 
     }
491 
     instanceof {
492 
        $this->token = Smarty_Internal_Templateparser::TP_INSTANCEOF;
493 
     }
494 
     lop {
495 
        $this->token = Smarty_Internal_Templateparser::TP_LOGOP;
496 
     }
497 
     slop {
498 
        $this->token = Smarty_Internal_Templateparser::TP_SLOGOP;
499 
     }
500 
     tlop {
501 
        $this->token = Smarty_Internal_Templateparser::TP_TLOGOP;
502 
     }
503 
     scond {
504 
        $this->token = Smarty_Internal_Templateparser::TP_SINGLECOND;
505 
     }
506 
     not{
507 
        $this->token = Smarty_Internal_Templateparser::TP_NOT;
508 
     }
509 
     typecast {
510 
        $this->token = Smarty_Internal_Templateparser::TP_TYPECAST;
511 
     }
512 
     openP {
513 
        $this->token = Smarty_Internal_Templateparser::TP_OPENP;
514 
     }
515 
     closeP {
516 
        $this->token = Smarty_Internal_Templateparser::TP_CLOSEP;
517 
     }
518 
     openB {
519 
        $this->token = Smarty_Internal_Templateparser::TP_OPENB;
520 
     }
521 
     closeB {
522 
        $this->token = Smarty_Internal_Templateparser::TP_CLOSEB;
523 
     }
524 
     ptr {
525 
        $this->token = Smarty_Internal_Templateparser::TP_PTR;
526 
     }
527 
     aptr {
528 
        $this->token = Smarty_Internal_Templateparser::TP_APTR;
529 
     }
530 
     equal {
531 
        $this->token = Smarty_Internal_Templateparser::TP_EQUAL;
532 
     }
533 
     incdec {
534 
        $this->token = Smarty_Internal_Templateparser::TP_INCDEC;
535 
     }
536 
     unimath {
537 
        $this->token = Smarty_Internal_Templateparser::TP_UNIMATH;
538 
     }
539 
     math {
540 
        $this->token = Smarty_Internal_Templateparser::TP_MATH;
541 
     }
542 
     at {
543 
        $this->token = Smarty_Internal_Templateparser::TP_AT;
544 
     }
545 
     array openP {
546 
        $this->token = Smarty_Internal_Templateparser::TP_ARRAYOPEN;
547 
     }
548 
     hatch {
549 
        $this->token = Smarty_Internal_Templateparser::TP_HATCH;
550 
     }
551 
     attr {
552 
        // resolve conflicts with shorttag and right_delimiter starting with '='
553 
        if (substr($this->data, $this->counter + strlen($this->value) - 1, $this->compiler->getRdelLength()) === $this->smarty->getRightDelimiter()) {
554 
            preg_match('/\s+/',$this->value,$match);
555 
            $this->value = $match[0];
556 
            $this->token = Smarty_Internal_Templateparser::TP_SPACE;
557 
        } else {
558 
            $this->token = Smarty_Internal_Templateparser::TP_ATTR;
559 
        }
560 
     }
561 
     namespace {
562 
        $this->token = Smarty_Internal_Templateparser::TP_NAMESPACE;
563 
     }
564 
     id {
565 
        $this->token = Smarty_Internal_Templateparser::TP_ID;
566 
     }
567 
     integer {
568 
        $this->token = Smarty_Internal_Templateparser::TP_INTEGER;
569 
     }
570 
     backtick {
571 
        $this->token = Smarty_Internal_Templateparser::TP_BACKTICK;
572 
        $this->yypopstate();
573 
     }
574 
     vert {
575 
        $this->token = Smarty_Internal_Templateparser::TP_VERT;
576 
     }
577 
     dot {
578 
        $this->token = Smarty_Internal_Templateparser::TP_DOT;
579 
     }
580 
     comma {
581 
        $this->token = Smarty_Internal_Templateparser::TP_COMMA;
582 
     }
583 
     semicolon {
584 
        $this->token = Smarty_Internal_Templateparser::TP_SEMICOLON;
585 
     }
586 
     doublecolon {
587 
        $this->token = Smarty_Internal_Templateparser::TP_DOUBLECOLON;
588 
     }
589 
     colon {
590 
        $this->token = Smarty_Internal_Templateparser::TP_COLON;
591 
     }
592 
     qmark {
593 
        $this->token = Smarty_Internal_Templateparser::TP_QMARK;
594 
     }
595 
     hex {
596 
        $this->token = Smarty_Internal_Templateparser::TP_HEX;
597 
     }
598 
     space {
599 
        $this->token = Smarty_Internal_Templateparser::TP_SPACE;
600 
     }
601 
     char {
602 
        $this->token = Smarty_Internal_Templateparser::TP_TEXT;
603 
     }
604 
     */
605 
 
606 
     /*!lex2php
607 
     %statename LITERAL
608 
     ldel literal rdel {
609 
        $this->literal_cnt++;
610 
        $this->token = Smarty_Internal_Templateparser::TP_LITERAL;
611 
     }
612 
     ldel slash literal rdel {
613 
        if ($this->literal_cnt) {
614 
             $this->literal_cnt--;
615 
            $this->token = Smarty_Internal_Templateparser::TP_LITERAL;
616 
        } else {
617 
            $this->token = Smarty_Internal_Templateparser::TP_LITERALEND;
618 
            $this->yypopstate();
619 
        }
620 
     }
621 
     char {
622 
       if (!isset($this->yy_global_literal)) {
623 
           $this->yy_global_literal = $this->replace('/(SMARTYldel)SMARTYal[\/]?literalSMARTYrdel/isS');
624 
       }
625 
       $to = $this->dataLength;
626 
       preg_match($this->yy_global_literal, $this->data,$match,PREG_OFFSET_CAPTURE,$this->counter);
627 
       if (isset($match[0][1])) {
628 
         $to = $match[0][1];
629 
       } else {
630 
          $this->compiler->trigger_template_error ("missing or misspelled literal closing tag");
631 
       }
632 
       $this->value = substr($this->data,$this->counter,$to-$this->counter);
633 
       $this->token = Smarty_Internal_Templateparser::TP_LITERAL;
634 
     }
635 
     */
636 
     /*!lex2php
637 
     %statename DOUBLEQUOTEDSTRING
638 
     userliteral {
639 
        $this->token = Smarty_Internal_Templateparser::TP_TEXT;
640 
     }
641 
     ldel literal rdel {
642 
        $this->token = Smarty_Internal_Templateparser::TP_TEXT;
643 
     }
644 
     ldel slash literal rdel {
645 
        $this->token = Smarty_Internal_Templateparser::TP_TEXT;
646 
     }
647 
     ldel slash {
648 
        $this->yypushstate(self::TAG);
649 
        return true;
650 
     }
651 
     ldel id {
652 
        $this->yypushstate(self::TAG);
653 
        return true;
654 
     }
655 
     ldel {
656 
        $this->token = Smarty_Internal_Templateparser::TP_LDEL;
657 
        $this->taglineno = $this->line;
658 
        $this->yypushstate(self::TAGBODY);
659 
     }
660 
     double_quote {
661 
        $this->token = Smarty_Internal_Templateparser::TP_QUOTE;
662 
        $this->yypopstate();
663 
     }
664 
     backtick dollar {
665 
        $this->token = Smarty_Internal_Templateparser::TP_BACKTICK;
666 
        $this->value = substr($this->value,0,-1);
667 
        $this->yypushstate(self::TAGBODY);
668 
        $this->taglineno = $this->line;
669 
     }
670 
     dollar id {
671 
        $this->token = Smarty_Internal_Templateparser::TP_DOLLARID;
672 
     }
673 
     dollar {
674 
        $this->token = Smarty_Internal_Templateparser::TP_TEXT;
675 
     }
676 
     textdoublequoted {
677 
        $this->token = Smarty_Internal_Templateparser::TP_TEXT;
678 
     }
679 
     char {
680 
        $to = $this->dataLength;
681 
        $this->value = substr($this->data,$this->counter,$to-$this->counter);
682 
        $this->token = Smarty_Internal_Templateparser::TP_TEXT;
683 
     }
684 
    */
685 
  }
686 
 
687