PageRenderTime 43ms CodeModel.GetById 16ms app.highlight 21ms RepoModel.GetById 1ms app.codeStats 0ms

/framework/vendor/smarty3/lib/libs/sysplugins/smarty_internal_configfilelexer.php

http://zoop.googlecode.com/
PHP | 526 lines | 419 code | 70 blank | 37 comment | 50 complexity | f6bdd88b1f7cccd5754821ad5bb97c72 MD5 | raw file
  1<?php
  2/**
  3* Smarty Internal Plugin Configfilelexer
  4*
  5* This is the lexer to break the config file source into tokens 
  6* @package Smarty
  7* @subpackage Config
  8* @author Uwe Tews 
  9*/
 10/**
 11* Smarty Internal Plugin Configfilelexer
 12*/
 13class Smarty_Internal_Configfilelexer
 14{
 15
 16    public $data;
 17    public $counter;
 18    public $token;
 19    public $value;
 20    public $node;
 21    public $line;
 22    private $state = 1;
 23    public $smarty_token_names = array (		// Text for parser error messages
 24   				);
 25    				
 26    				
 27    function __construct($data, $smarty)
 28    {
 29        // set instance object
 30        self::instance($this); 
 31        $this->data = $data . "\n"; //now all lines are \n-terminated
 32        $this->counter = 0;
 33        $this->line = 1;
 34        $this->smarty = $smarty; 
 35     }
 36    public static function &instance($new_instance = null)
 37    {
 38        static $instance = null;
 39        if (isset($new_instance) && is_object($new_instance))
 40            $instance = $new_instance;
 41        return $instance;
 42    } 
 43
 44
 45
 46    private $_yy_state = 1;
 47    private $_yy_stack = array();
 48
 49    function yylex()
 50    {
 51        return $this->{'yylex' . $this->_yy_state}();
 52    }
 53
 54    function yypushstate($state)
 55    {
 56        array_push($this->_yy_stack, $this->_yy_state);
 57        $this->_yy_state = $state;
 58    }
 59
 60    function yypopstate()
 61    {
 62        $this->_yy_state = array_pop($this->_yy_stack);
 63    }
 64
 65    function yybegin($state)
 66    {
 67        $this->_yy_state = $state;
 68    }
 69
 70
 71
 72
 73    function yylex1()
 74    {
 75        $tokenMap = array (
 76              1 => 0,
 77              2 => 0,
 78              3 => 0,
 79              4 => 0,
 80              5 => 0,
 81              6 => 0,
 82              7 => 0,
 83            );
 84        if ($this->counter >= strlen($this->data)) {
 85            return false; // end of input
 86        }
 87        $yy_global_pattern = "/^(#)|^(\\[)|^(\\])|^(=)|^([ \t\r]+)|^(\n)|^([0-9]*[a-zA-Z_]\\w*)/";
 88
 89        do {
 90            if (preg_match($yy_global_pattern, substr($this->data, $this->counter), $yymatches)) {
 91                $yysubmatches = $yymatches;
 92                $yymatches = array_filter($yymatches, 'strlen'); // remove empty sub-patterns
 93                if (!count($yymatches)) {
 94                    throw new Exception('Error: lexing failed because a rule matched' .
 95                        'an empty string.  Input "' . substr($this->data,
 96                        $this->counter, 5) . '... state START');
 97                }
 98                next($yymatches); // skip global match
 99                $this->token = key($yymatches); // token number
100                if ($tokenMap[$this->token]) {
101                    // extract sub-patterns for passing to lex function
102                    $yysubmatches = array_slice($yysubmatches, $this->token + 1,
103                        $tokenMap[$this->token]);
104                } else {
105                    $yysubmatches = array();
106                }
107                $this->value = current($yymatches); // token value
108                $r = $this->{'yy_r1_' . $this->token}($yysubmatches);
109                if ($r === null) {
110                    $this->counter += strlen($this->value);
111                    $this->line += substr_count($this->value, "\n");
112                    // accept this token
113                    return true;
114                } elseif ($r === true) {
115                    // we have changed state
116                    // process this token in the new state
117                    return $this->yylex();
118                } elseif ($r === false) {
119                    $this->counter += strlen($this->value);
120                    $this->line += substr_count($this->value, "\n");
121                    if ($this->counter >= strlen($this->data)) {
122                        return false; // end of input
123                    }
124                    // skip this token
125                    continue;
126                }            } else {
127                throw new Exception('Unexpected input at line' . $this->line .
128                    ': ' . $this->data[$this->counter]);
129            }
130            break;
131        } while (true);
132
133    } // end function
134
135
136    const START = 1;
137    function yy_r1_1($yy_subpatterns)
138    {
139
140    $this->token = Smarty_Internal_Configfileparser::TPC_COMMENTSTART;
141    $this->yypushstate(self::COMMENT);
142    }
143    function yy_r1_2($yy_subpatterns)
144    {
145
146    $this->token = Smarty_Internal_Configfileparser::TPC_OPENB;
147    $this->yypushstate(self::SECTION);
148    }
149    function yy_r1_3($yy_subpatterns)
150    {
151
152    $this->token = Smarty_Internal_Configfileparser::TPC_CLOSEB;
153    }
154    function yy_r1_4($yy_subpatterns)
155    {
156
157    $this->token = Smarty_Internal_Configfileparser::TPC_EQUAL;
158    $this->yypushstate(self::VALUE);
159    }
160    function yy_r1_5($yy_subpatterns)
161    {
162
163    return false;
164    }
165    function yy_r1_6($yy_subpatterns)
166    {
167
168    $this->token = Smarty_Internal_Configfileparser::TPC_NEWLINE;
169    }
170    function yy_r1_7($yy_subpatterns)
171    {
172
173    $this->token = Smarty_Internal_Configfileparser::TPC_ID;
174    }
175
176
177
178    function yylex2()
179    {
180        $tokenMap = array (
181              1 => 0,
182              2 => 0,
183              3 => 0,
184              4 => 0,
185              5 => 0,
186              6 => 0,
187              7 => 0,
188              8 => 0,
189              9 => 0,
190            );
191        if ($this->counter >= strlen($this->data)) {
192            return false; // end of input
193        }
194        $yy_global_pattern = "/^([ \t\r]+)|^(\\d+\\.\\d+(?=[ \t\r]*[\n#]))|^(\\d+(?=[ \t\r]*[\n#]))|^('[^'\\\\]*(?:\\\\.[^'\\\\]*)*'(?=[ \t\r]*[\n#]))|^(\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\"(?=[ \t\r]*[\n#]))|^(\"\"\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\"\"\"(?=[ \t\r]*[\n#]))|^([a-zA-Z]+(?=[ \t\r]*[\n#]))|^([^\n]+?(?=[ \t\r]*\n))|^(\n)/";
195
196        do {
197            if (preg_match($yy_global_pattern, substr($this->data, $this->counter), $yymatches)) {
198                $yysubmatches = $yymatches;
199                $yymatches = array_filter($yymatches, 'strlen'); // remove empty sub-patterns
200                if (!count($yymatches)) {
201                    throw new Exception('Error: lexing failed because a rule matched' .
202                        'an empty string.  Input "' . substr($this->data,
203                        $this->counter, 5) . '... state VALUE');
204                }
205                next($yymatches); // skip global match
206                $this->token = key($yymatches); // token number
207                if ($tokenMap[$this->token]) {
208                    // extract sub-patterns for passing to lex function
209                    $yysubmatches = array_slice($yysubmatches, $this->token + 1,
210                        $tokenMap[$this->token]);
211                } else {
212                    $yysubmatches = array();
213                }
214                $this->value = current($yymatches); // token value
215                $r = $this->{'yy_r2_' . $this->token}($yysubmatches);
216                if ($r === null) {
217                    $this->counter += strlen($this->value);
218                    $this->line += substr_count($this->value, "\n");
219                    // accept this token
220                    return true;
221                } elseif ($r === true) {
222                    // we have changed state
223                    // process this token in the new state
224                    return $this->yylex();
225                } elseif ($r === false) {
226                    $this->counter += strlen($this->value);
227                    $this->line += substr_count($this->value, "\n");
228                    if ($this->counter >= strlen($this->data)) {
229                        return false; // end of input
230                    }
231                    // skip this token
232                    continue;
233                }            } else {
234                throw new Exception('Unexpected input at line' . $this->line .
235                    ': ' . $this->data[$this->counter]);
236            }
237            break;
238        } while (true);
239
240    } // end function
241
242
243    const VALUE = 2;
244    function yy_r2_1($yy_subpatterns)
245    {
246
247    return false;
248    }
249    function yy_r2_2($yy_subpatterns)
250    {
251
252    $this->token = Smarty_Internal_Configfileparser::TPC_FLOAT;
253    $this->yypopstate();
254    }
255    function yy_r2_3($yy_subpatterns)
256    {
257
258    $this->token = Smarty_Internal_Configfileparser::TPC_INT;
259    $this->yypopstate();
260    }
261    function yy_r2_4($yy_subpatterns)
262    {
263
264    $this->token = Smarty_Internal_Configfileparser::TPC_SINGLE_QUOTED_STRING;
265    $this->yypopstate();
266    }
267    function yy_r2_5($yy_subpatterns)
268    {
269
270    $this->token = Smarty_Internal_Configfileparser::TPC_DOUBLE_QUOTED_STRING;
271    $this->yypopstate();
272    }
273    function yy_r2_6($yy_subpatterns)
274    {
275
276    $this->token = Smarty_Internal_Configfileparser::TPC_TRIPPLE_DOUBLE_QUOTED_STRING;
277    $this->yypopstate();
278    }
279    function yy_r2_7($yy_subpatterns)
280    {
281
282    if (!$this->smarty->config_booleanize || !in_array(strtolower($this->value), Array("true", "false", "on", "off", "yes", "no")) ) {
283        $this->yypopstate();
284        $this->yypushstate(self::NAKED_STRING_VALUE);
285        return true; //reprocess in new state
286    } else {
287        $this->token = Smarty_Internal_Configfileparser::TPC_BOOL;
288        $this->yypopstate();
289    }
290    }
291    function yy_r2_8($yy_subpatterns)
292    {
293
294    $this->token = Smarty_Internal_Configfileparser::TPC_NAKED_STRING;
295    $this->yypopstate();
296    }
297    function yy_r2_9($yy_subpatterns)
298    {
299
300    $this->token = Smarty_Internal_Configfileparser::TPC_NAKED_STRING;
301    $this->value = "";
302    $this->yypopstate();
303    }
304
305
306
307    function yylex3()
308    {
309        $tokenMap = array (
310              1 => 0,
311            );
312        if ($this->counter >= strlen($this->data)) {
313            return false; // end of input
314        }
315        $yy_global_pattern = "/^([^\n]+?(?=[ \t\r]*\n))/";
316
317        do {
318            if (preg_match($yy_global_pattern, substr($this->data, $this->counter), $yymatches)) {
319                $yysubmatches = $yymatches;
320                $yymatches = array_filter($yymatches, 'strlen'); // remove empty sub-patterns
321                if (!count($yymatches)) {
322                    throw new Exception('Error: lexing failed because a rule matched' .
323                        'an empty string.  Input "' . substr($this->data,
324                        $this->counter, 5) . '... state NAKED_STRING_VALUE');
325                }
326                next($yymatches); // skip global match
327                $this->token = key($yymatches); // token number
328                if ($tokenMap[$this->token]) {
329                    // extract sub-patterns for passing to lex function
330                    $yysubmatches = array_slice($yysubmatches, $this->token + 1,
331                        $tokenMap[$this->token]);
332                } else {
333                    $yysubmatches = array();
334                }
335                $this->value = current($yymatches); // token value
336                $r = $this->{'yy_r3_' . $this->token}($yysubmatches);
337                if ($r === null) {
338                    $this->counter += strlen($this->value);
339                    $this->line += substr_count($this->value, "\n");
340                    // accept this token
341                    return true;
342                } elseif ($r === true) {
343                    // we have changed state
344                    // process this token in the new state
345                    return $this->yylex();
346                } elseif ($r === false) {
347                    $this->counter += strlen($this->value);
348                    $this->line += substr_count($this->value, "\n");
349                    if ($this->counter >= strlen($this->data)) {
350                        return false; // end of input
351                    }
352                    // skip this token
353                    continue;
354                }            } else {
355                throw new Exception('Unexpected input at line' . $this->line .
356                    ': ' . $this->data[$this->counter]);
357            }
358            break;
359        } while (true);
360
361    } // end function
362
363
364    const NAKED_STRING_VALUE = 3;
365    function yy_r3_1($yy_subpatterns)
366    {
367
368    $this->token = Smarty_Internal_Configfileparser::TPC_NAKED_STRING;
369    $this->yypopstate();
370    }
371
372
373
374    function yylex4()
375    {
376        $tokenMap = array (
377              1 => 0,
378              2 => 0,
379              3 => 0,
380            );
381        if ($this->counter >= strlen($this->data)) {
382            return false; // end of input
383        }
384        $yy_global_pattern = "/^([ \t\r]+)|^([^\n]+?(?=[ \t\r]*\n))|^(\n)/";
385
386        do {
387            if (preg_match($yy_global_pattern, substr($this->data, $this->counter), $yymatches)) {
388                $yysubmatches = $yymatches;
389                $yymatches = array_filter($yymatches, 'strlen'); // remove empty sub-patterns
390                if (!count($yymatches)) {
391                    throw new Exception('Error: lexing failed because a rule matched' .
392                        'an empty string.  Input "' . substr($this->data,
393                        $this->counter, 5) . '... state COMMENT');
394                }
395                next($yymatches); // skip global match
396                $this->token = key($yymatches); // token number
397                if ($tokenMap[$this->token]) {
398                    // extract sub-patterns for passing to lex function
399                    $yysubmatches = array_slice($yysubmatches, $this->token + 1,
400                        $tokenMap[$this->token]);
401                } else {
402                    $yysubmatches = array();
403                }
404                $this->value = current($yymatches); // token value
405                $r = $this->{'yy_r4_' . $this->token}($yysubmatches);
406                if ($r === null) {
407                    $this->counter += strlen($this->value);
408                    $this->line += substr_count($this->value, "\n");
409                    // accept this token
410                    return true;
411                } elseif ($r === true) {
412                    // we have changed state
413                    // process this token in the new state
414                    return $this->yylex();
415                } elseif ($r === false) {
416                    $this->counter += strlen($this->value);
417                    $this->line += substr_count($this->value, "\n");
418                    if ($this->counter >= strlen($this->data)) {
419                        return false; // end of input
420                    }
421                    // skip this token
422                    continue;
423                }            } else {
424                throw new Exception('Unexpected input at line' . $this->line .
425                    ': ' . $this->data[$this->counter]);
426            }
427            break;
428        } while (true);
429
430    } // end function
431
432
433    const COMMENT = 4;
434    function yy_r4_1($yy_subpatterns)
435    {
436
437    return false;
438    }
439    function yy_r4_2($yy_subpatterns)
440    {
441
442    $this->token = Smarty_Internal_Configfileparser::TPC_NAKED_STRING;
443    }
444    function yy_r4_3($yy_subpatterns)
445    {
446
447    $this->token = Smarty_Internal_Configfileparser::TPC_NEWLINE;
448    $this->yypopstate();
449    }
450
451
452
453    function yylex5()
454    {
455        $tokenMap = array (
456              1 => 0,
457              2 => 0,
458            );
459        if ($this->counter >= strlen($this->data)) {
460            return false; // end of input
461        }
462        $yy_global_pattern = "/^(\\.)|^(.*?(?=[\.=[\]\r\n]))/";
463
464        do {
465            if (preg_match($yy_global_pattern, substr($this->data, $this->counter), $yymatches)) {
466                $yysubmatches = $yymatches;
467                $yymatches = array_filter($yymatches, 'strlen'); // remove empty sub-patterns
468                if (!count($yymatches)) {
469                    throw new Exception('Error: lexing failed because a rule matched' .
470                        'an empty string.  Input "' . substr($this->data,
471                        $this->counter, 5) . '... state SECTION');
472                }
473                next($yymatches); // skip global match
474                $this->token = key($yymatches); // token number
475                if ($tokenMap[$this->token]) {
476                    // extract sub-patterns for passing to lex function
477                    $yysubmatches = array_slice($yysubmatches, $this->token + 1,
478                        $tokenMap[$this->token]);
479                } else {
480                    $yysubmatches = array();
481                }
482                $this->value = current($yymatches); // token value
483                $r = $this->{'yy_r5_' . $this->token}($yysubmatches);
484                if ($r === null) {
485                    $this->counter += strlen($this->value);
486                    $this->line += substr_count($this->value, "\n");
487                    // accept this token
488                    return true;
489                } elseif ($r === true) {
490                    // we have changed state
491                    // process this token in the new state
492                    return $this->yylex();
493                } elseif ($r === false) {
494                    $this->counter += strlen($this->value);
495                    $this->line += substr_count($this->value, "\n");
496                    if ($this->counter >= strlen($this->data)) {
497                        return false; // end of input
498                    }
499                    // skip this token
500                    continue;
501                }            } else {
502                throw new Exception('Unexpected input at line' . $this->line .
503                    ': ' . $this->data[$this->counter]);
504            }
505            break;
506        } while (true);
507
508    } // end function
509
510
511    const SECTION = 5;
512    function yy_r5_1($yy_subpatterns)
513    {
514
515    $this->token = Smarty_Internal_Configfileparser::TPC_DOT;
516    }
517    function yy_r5_2($yy_subpatterns)
518    {
519
520    $this->token = Smarty_Internal_Configfileparser::TPC_SECTION;
521    $this->yypopstate();
522    }
523
524
525}
526?>