PageRenderTime 54ms CodeModel.GetById 14ms app.highlight 32ms RepoModel.GetById 2ms app.codeStats 0ms

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

http://zoop.googlecode.com/
PHP | 864 lines | 747 code | 44 blank | 73 comment | 121 complexity | b400541e3a981e51b76d7307574f6846 MD5 | raw file
  1<?php
  2/**
  3* Smarty Internal Plugin Configfileparser
  4*
  5* This is the config file parser.
  6* It is generated from the internal.configfileparser.y file
  7* @package Smarty
  8* @subpackage Compiler
  9* @author Uwe Tews
 10*/
 11
 12class TPC_yyToken implements ArrayAccess
 13{
 14    public $string = '';
 15    public $metadata = array();
 16
 17    function __construct($s, $m = array())
 18    {
 19        if ($s instanceof TPC_yyToken) {
 20            $this->string = $s->string;
 21            $this->metadata = $s->metadata;
 22        } else {
 23            $this->string = (string) $s;
 24            if ($m instanceof TPC_yyToken) {
 25                $this->metadata = $m->metadata;
 26            } elseif (is_array($m)) {
 27                $this->metadata = $m;
 28            }
 29        }
 30    }
 31
 32    function __toString()
 33    {
 34        return $this->_string;
 35    }
 36
 37    function offsetExists($offset)
 38    {
 39        return isset($this->metadata[$offset]);
 40    }
 41
 42    function offsetGet($offset)
 43    {
 44        return $this->metadata[$offset];
 45    }
 46
 47    function offsetSet($offset, $value)
 48    {
 49        if ($offset === null) {
 50            if (isset($value[0])) {
 51                $x = ($value instanceof TPC_yyToken) ?
 52                    $value->metadata : $value;
 53                $this->metadata = array_merge($this->metadata, $x);
 54                return;
 55            }
 56            $offset = count($this->metadata);
 57        }
 58        if ($value === null) {
 59            return;
 60        }
 61        if ($value instanceof TPC_yyToken) {
 62            if ($value->metadata) {
 63                $this->metadata[$offset] = $value->metadata;
 64            }
 65        } elseif ($value) {
 66            $this->metadata[$offset] = $value;
 67        }
 68    }
 69
 70    function offsetUnset($offset)
 71    {
 72        unset($this->metadata[$offset]);
 73    }
 74}
 75
 76class TPC_yyStackEntry
 77{
 78    public $stateno;       /* The state-number */
 79    public $major;         /* The major token value.  This is the code
 80                     ** number for the token at this stack level */
 81    public $minor; /* The user-supplied minor token value.  This
 82                     ** is the value of the token  */
 83};
 84
 85
 86#line 12 "smarty_internal_configfileparser.y"
 87class Smarty_Internal_Configfileparser#line 79 "smarty_internal_configfileparser.php"
 88{
 89#line 14 "smarty_internal_configfileparser.y"
 90
 91    // states whether the parse was successful or not
 92    public $successful = true;
 93    public $retvalue = 0;
 94    private $lex;
 95    private $internalError = false;
 96
 97    function __construct($lex, $compiler) {
 98        // set instance object
 99        self::instance($this); 
100        $this->lex = $lex;
101        $this->smarty = $compiler->smarty; 
102        $this->compiler = $compiler;
103    }
104    public static function &instance($new_instance = null)
105    {
106        static $instance = null;
107        if (isset($new_instance) && is_object($new_instance))
108            $instance = $new_instance;
109        return $instance;
110    }
111
112    private function parse_bool($str) {
113        if (in_array(strtolower($str) ,array('on','yes','true'))) {
114            $res = true;
115        } else {
116            assert(in_array(strtolower($str), array('off','no','false')));
117            $res = false;
118        }
119        return $res;
120    }
121
122    private static $escapes_single = Array('\\' => '\\',
123                                          '\'' => '\'');
124    private static function parse_single_quoted_string($qstr) {
125        $escaped_string = substr($qstr, 1, strlen($qstr)-2); //remove outer quotes
126
127        $ss = preg_split('/(\\\\.)/', $escaped_string, -1, PREG_SPLIT_DELIM_CAPTURE);
128
129        $str = "";
130        foreach ($ss as $s) {
131            if (strlen($s) === 2 && $s[0] === '\\') {
132                if (isset(self::$escapes_single[$s[1]])) {
133                    $s = self::$escapes_single[$s[1]];
134                }
135             }
136
137             $str .= $s;
138        }
139
140        return $str;
141    }
142
143    private static function parse_double_quoted_string($qstr) {
144        $inner_str = substr($qstr, 1, strlen($qstr)-2);
145        return stripcslashes($inner_str);
146    }
147
148    private static function parse_tripple_double_quoted_string($qstr) {
149        $inner_str = substr($qstr, 3, strlen($qstr)-6);
150        return stripcslashes($inner_str);
151    }
152
153    private function set_var(Array $var, Array &$target_array) {
154        $key = $var["key"];
155        $value = $var["value"];
156
157        if ($this->smarty->config_overwrite || !isset($target_array['vars'][$key])) {
158            $target_array['vars'][$key] = $value;
159        } else {
160            settype($target_array['vars'][$key], 'array');
161            $target_array['vars'][$key][] = $value;
162        }
163    }
164
165    private function add_global_vars(Array $vars) {
166        if (!isset($this->compiler->config_data['vars'])) {
167	    $this->compiler->config_data['vars'] = Array();
168        }
169        foreach ($vars as $var) {
170            $this->set_var($var, $this->compiler->config_data);
171        }
172    }
173
174    private function add_section_vars($section_name, Array $vars) {
175        if (!isset($this->compiler->config_data['sections'][$section_name]['vars'])) {
176            $this->compiler->config_data['sections'][$section_name]['vars'] = Array();
177        }
178        foreach ($vars as $var) {
179            $this->set_var($var, $this->compiler->config_data['sections'][$section_name]);
180        }
181    }
182#line 175 "smarty_internal_configfileparser.php"
183
184    const TPC_OPENB                          =  1;
185    const TPC_SECTION                        =  2;
186    const TPC_CLOSEB                         =  3;
187    const TPC_DOT                            =  4;
188    const TPC_ID                             =  5;
189    const TPC_EQUAL                          =  6;
190    const TPC_FLOAT                          =  7;
191    const TPC_INT                            =  8;
192    const TPC_BOOL                           =  9;
193    const TPC_SINGLE_QUOTED_STRING           = 10;
194    const TPC_DOUBLE_QUOTED_STRING           = 11;
195    const TPC_TRIPPLE_DOUBLE_QUOTED_STRING   = 12;
196    const TPC_NAKED_STRING                   = 13;
197    const TPC_NEWLINE                        = 14;
198    const TPC_COMMENTSTART                   = 15;
199    const YY_NO_ACTION = 54;
200    const YY_ACCEPT_ACTION = 53;
201    const YY_ERROR_ACTION = 52;
202
203    const YY_SZ_ACTTAB = 35;
204static public $yy_action = array(
205 /*     0 */    26,   27,   21,   30,   29,   28,   31,   16,   53,    8,
206 /*    10 */    19,    2,   20,   11,   24,   23,   20,   11,   17,   15,
207 /*    20 */     3,   14,   13,   18,    4,    6,    5,    1,   12,   22,
208 /*    30 */     9,   47,   10,   25,    7,
209    );
210    static public $yy_lookahead = array(
211 /*     0 */     7,    8,    9,   10,   11,   12,   13,    5,   17,   18,
212 /*    10 */    14,   20,   14,   15,   22,   23,   14,   15,    2,    2,
213 /*    20 */    20,    4,   13,   14,    6,    3,    3,   20,    1,   24,
214 /*    30 */    22,   25,   22,   21,   19,
215);
216    const YY_SHIFT_USE_DFLT = -8;
217    const YY_SHIFT_MAX = 17;
218    static public $yy_shift_ofst = array(
219 /*     0 */    -8,    2,    2,    2,   -7,   -2,   -2,   27,   -8,   -8,
220 /*    10 */    -8,    9,   17,   -4,   16,   23,   18,   22,
221);
222    const YY_REDUCE_USE_DFLT = -10;
223    const YY_REDUCE_MAX = 10;
224    static public $yy_reduce_ofst = array(
225 /*     0 */    -9,   -8,   -8,   -8,    5,   10,    8,   12,   15,    0,
226 /*    10 */     7,
227);
228    static public $yyExpectedTokens = array(
229        /* 0 */ array(),
230        /* 1 */ array(5, 14, 15, ),
231        /* 2 */ array(5, 14, 15, ),
232        /* 3 */ array(5, 14, 15, ),
233        /* 4 */ array(7, 8, 9, 10, 11, 12, 13, ),
234        /* 5 */ array(14, 15, ),
235        /* 6 */ array(14, 15, ),
236        /* 7 */ array(1, ),
237        /* 8 */ array(),
238        /* 9 */ array(),
239        /* 10 */ array(),
240        /* 11 */ array(13, 14, ),
241        /* 12 */ array(2, 4, ),
242        /* 13 */ array(14, ),
243        /* 14 */ array(2, ),
244        /* 15 */ array(3, ),
245        /* 16 */ array(6, ),
246        /* 17 */ array(3, ),
247        /* 18 */ array(),
248        /* 19 */ array(),
249        /* 20 */ array(),
250        /* 21 */ array(),
251        /* 22 */ array(),
252        /* 23 */ array(),
253        /* 24 */ array(),
254        /* 25 */ array(),
255        /* 26 */ array(),
256        /* 27 */ array(),
257        /* 28 */ array(),
258        /* 29 */ array(),
259        /* 30 */ array(),
260        /* 31 */ array(),
261);
262    static public $yy_default = array(
263 /*     0 */    40,   36,   33,   37,   52,   52,   52,   32,   35,   40,
264 /*    10 */    40,   52,   52,   52,   52,   52,   52,   52,   50,   51,
265 /*    20 */    49,   44,   41,   39,   38,   34,   42,   43,   47,   46,
266 /*    30 */    45,   48,
267);
268    const YYNOCODE = 26;
269    const YYSTACKDEPTH = 100;
270    const YYNSTATE = 32;
271    const YYNRULE = 20;
272    const YYERRORSYMBOL = 16;
273    const YYERRSYMDT = 'yy0';
274    const YYFALLBACK = 0;
275    static public $yyFallback = array(
276    );
277    static function Trace($TraceFILE, $zTracePrompt)
278    {
279        if (!$TraceFILE) {
280            $zTracePrompt = 0;
281        } elseif (!$zTracePrompt) {
282            $TraceFILE = 0;
283        }
284        self::$yyTraceFILE = $TraceFILE;
285        self::$yyTracePrompt = $zTracePrompt;
286    }
287
288    static function PrintTrace()
289    {
290        self::$yyTraceFILE = fopen('php://output', 'w');
291        self::$yyTracePrompt = '<br>';
292    }
293
294    static public $yyTraceFILE;
295    static public $yyTracePrompt;
296    public $yyidx;                    /* Index of top element in stack */
297    public $yyerrcnt;                 /* Shifts left before out of the error */
298    public $yystack = array();  /* The parser's stack */
299
300    public $yyTokenName = array( 
301  '$',             'OPENB',         'SECTION',       'CLOSEB',      
302  'DOT',           'ID',            'EQUAL',         'FLOAT',       
303  'INT',           'BOOL',          'SINGLE_QUOTED_STRING',  'DOUBLE_QUOTED_STRING',
304  'TRIPPLE_DOUBLE_QUOTED_STRING',  'NAKED_STRING',  'NEWLINE',       'COMMENTSTART',
305  'error',         'start',         'global_vars',   'sections',    
306  'var_list',      'section',       'newline',       'var',         
307  'value',       
308    );
309
310    static public $yyRuleName = array(
311 /*   0 */ "start ::= global_vars sections",
312 /*   1 */ "global_vars ::= var_list",
313 /*   2 */ "sections ::= sections section",
314 /*   3 */ "sections ::=",
315 /*   4 */ "section ::= OPENB SECTION CLOSEB newline var_list",
316 /*   5 */ "section ::= OPENB DOT SECTION CLOSEB newline var_list",
317 /*   6 */ "var_list ::= var_list newline",
318 /*   7 */ "var_list ::= var_list var",
319 /*   8 */ "var_list ::=",
320 /*   9 */ "var ::= ID EQUAL value",
321 /*  10 */ "value ::= FLOAT",
322 /*  11 */ "value ::= INT",
323 /*  12 */ "value ::= BOOL",
324 /*  13 */ "value ::= SINGLE_QUOTED_STRING",
325 /*  14 */ "value ::= DOUBLE_QUOTED_STRING",
326 /*  15 */ "value ::= TRIPPLE_DOUBLE_QUOTED_STRING",
327 /*  16 */ "value ::= NAKED_STRING",
328 /*  17 */ "newline ::= NEWLINE",
329 /*  18 */ "newline ::= COMMENTSTART NEWLINE",
330 /*  19 */ "newline ::= COMMENTSTART NAKED_STRING NEWLINE",
331    );
332
333    function tokenName($tokenType)
334    {
335        if ($tokenType === 0) {
336            return 'End of Input';
337        }
338        if ($tokenType > 0 && $tokenType < count($this->yyTokenName)) {
339            return $this->yyTokenName[$tokenType];
340        } else {
341            return "Unknown";
342        }
343    }
344
345    static function yy_destructor($yymajor, $yypminor)
346    {
347        switch ($yymajor) {
348            default:  break;   /* If no destructor action specified: do nothing */
349        }
350    }
351
352    function yy_pop_parser_stack()
353    {
354        if (!count($this->yystack)) {
355            return;
356        }
357        $yytos = array_pop($this->yystack);
358        if (self::$yyTraceFILE && $this->yyidx >= 0) {
359            fwrite(self::$yyTraceFILE,
360                self::$yyTracePrompt . 'Popping ' . $this->yyTokenName[$yytos->major] .
361                    "\n");
362        }
363        $yymajor = $yytos->major;
364        self::yy_destructor($yymajor, $yytos->minor);
365        $this->yyidx--;
366        return $yymajor;
367    }
368
369    function __destruct()
370    {
371        while ($this->yyidx >= 0) {
372            $this->yy_pop_parser_stack();
373        }
374        if (is_resource(self::$yyTraceFILE)) {
375            fclose(self::$yyTraceFILE);
376        }
377    }
378
379    function yy_get_expected_tokens($token)
380    {
381        $state = $this->yystack[$this->yyidx]->stateno;
382        $expected = self::$yyExpectedTokens[$state];
383        if (in_array($token, self::$yyExpectedTokens[$state], true)) {
384            return $expected;
385        }
386        $stack = $this->yystack;
387        $yyidx = $this->yyidx;
388        do {
389            $yyact = $this->yy_find_shift_action($token);
390            if ($yyact >= self::YYNSTATE && $yyact < self::YYNSTATE + self::YYNRULE) {
391                // reduce action
392                $done = 0;
393                do {
394                    if ($done++ == 100) {
395                        $this->yyidx = $yyidx;
396                        $this->yystack = $stack;
397                        // too much recursion prevents proper detection
398                        // so give up
399                        return array_unique($expected);
400                    }
401                    $yyruleno = $yyact - self::YYNSTATE;
402                    $this->yyidx -= self::$yyRuleInfo[$yyruleno]['rhs'];
403                    $nextstate = $this->yy_find_reduce_action(
404                        $this->yystack[$this->yyidx]->stateno,
405                        self::$yyRuleInfo[$yyruleno]['lhs']);
406                    if (isset(self::$yyExpectedTokens[$nextstate])) {
407                        $expected += self::$yyExpectedTokens[$nextstate];
408                            if (in_array($token,
409                                  self::$yyExpectedTokens[$nextstate], true)) {
410                            $this->yyidx = $yyidx;
411                            $this->yystack = $stack;
412                            return array_unique($expected);
413                        }
414                    }
415                    if ($nextstate < self::YYNSTATE) {
416                        // we need to shift a non-terminal
417                        $this->yyidx++;
418                        $x = new TPC_yyStackEntry;
419                        $x->stateno = $nextstate;
420                        $x->major = self::$yyRuleInfo[$yyruleno]['lhs'];
421                        $this->yystack[$this->yyidx] = $x;
422                        continue 2;
423                    } elseif ($nextstate == self::YYNSTATE + self::YYNRULE + 1) {
424                        $this->yyidx = $yyidx;
425                        $this->yystack = $stack;
426                        // the last token was just ignored, we can't accept
427                        // by ignoring input, this is in essence ignoring a
428                        // syntax error!
429                        return array_unique($expected);
430                    } elseif ($nextstate === self::YY_NO_ACTION) {
431                        $this->yyidx = $yyidx;
432                        $this->yystack = $stack;
433                        // input accepted, but not shifted (I guess)
434                        return $expected;
435                    } else {
436                        $yyact = $nextstate;
437                    }
438                } while (true);
439            }
440            break;
441        } while (true);
442        return array_unique($expected);
443    }
444
445    function yy_is_expected_token($token)
446    {
447        if ($token === 0) {
448            return true; // 0 is not part of this
449        }
450        $state = $this->yystack[$this->yyidx]->stateno;
451        if (in_array($token, self::$yyExpectedTokens[$state], true)) {
452            return true;
453        }
454        $stack = $this->yystack;
455        $yyidx = $this->yyidx;
456        do {
457            $yyact = $this->yy_find_shift_action($token);
458            if ($yyact >= self::YYNSTATE && $yyact < self::YYNSTATE + self::YYNRULE) {
459                // reduce action
460                $done = 0;
461                do {
462                    if ($done++ == 100) {
463                        $this->yyidx = $yyidx;
464                        $this->yystack = $stack;
465                        // too much recursion prevents proper detection
466                        // so give up
467                        return true;
468                    }
469                    $yyruleno = $yyact - self::YYNSTATE;
470                    $this->yyidx -= self::$yyRuleInfo[$yyruleno]['rhs'];
471                    $nextstate = $this->yy_find_reduce_action(
472                        $this->yystack[$this->yyidx]->stateno,
473                        self::$yyRuleInfo[$yyruleno]['lhs']);
474                    if (isset(self::$yyExpectedTokens[$nextstate]) &&
475                          in_array($token, self::$yyExpectedTokens[$nextstate], true)) {
476                        $this->yyidx = $yyidx;
477                        $this->yystack = $stack;
478                        return true;
479                    }
480                    if ($nextstate < self::YYNSTATE) {
481                        // we need to shift a non-terminal
482                        $this->yyidx++;
483                        $x = new TPC_yyStackEntry;
484                        $x->stateno = $nextstate;
485                        $x->major = self::$yyRuleInfo[$yyruleno]['lhs'];
486                        $this->yystack[$this->yyidx] = $x;
487                        continue 2;
488                    } elseif ($nextstate == self::YYNSTATE + self::YYNRULE + 1) {
489                        $this->yyidx = $yyidx;
490                        $this->yystack = $stack;
491                        if (!$token) {
492                            // end of input: this is valid
493                            return true;
494                        }
495                        // the last token was just ignored, we can't accept
496                        // by ignoring input, this is in essence ignoring a
497                        // syntax error!
498                        return false;
499                    } elseif ($nextstate === self::YY_NO_ACTION) {
500                        $this->yyidx = $yyidx;
501                        $this->yystack = $stack;
502                        // input accepted, but not shifted (I guess)
503                        return true;
504                    } else {
505                        $yyact = $nextstate;
506                    }
507                } while (true);
508            }
509            break;
510        } while (true);
511        $this->yyidx = $yyidx;
512        $this->yystack = $stack;
513        return true;
514    }
515
516   function yy_find_shift_action($iLookAhead)
517    {
518        $stateno = $this->yystack[$this->yyidx]->stateno;
519     
520        /* if ($this->yyidx < 0) return self::YY_NO_ACTION;  */
521        if (!isset(self::$yy_shift_ofst[$stateno])) {
522            // no shift actions
523            return self::$yy_default[$stateno];
524        }
525        $i = self::$yy_shift_ofst[$stateno];
526        if ($i === self::YY_SHIFT_USE_DFLT) {
527            return self::$yy_default[$stateno];
528        }
529        if ($iLookAhead == self::YYNOCODE) {
530            return self::YY_NO_ACTION;
531        }
532        $i += $iLookAhead;
533        if ($i < 0 || $i >= self::YY_SZ_ACTTAB ||
534              self::$yy_lookahead[$i] != $iLookAhead) {
535            if (count(self::$yyFallback) && $iLookAhead < count(self::$yyFallback)
536                   && ($iFallback = self::$yyFallback[$iLookAhead]) != 0) {
537                if (self::$yyTraceFILE) {
538                    fwrite(self::$yyTraceFILE, self::$yyTracePrompt . "FALLBACK " .
539                        $this->yyTokenName[$iLookAhead] . " => " .
540                        $this->yyTokenName[$iFallback] . "\n");
541                }
542                return $this->yy_find_shift_action($iFallback);
543            }
544            return self::$yy_default[$stateno];
545        } else {
546            return self::$yy_action[$i];
547        }
548    }
549
550    function yy_find_reduce_action($stateno, $iLookAhead)
551    {
552        /* $stateno = $this->yystack[$this->yyidx]->stateno; */
553
554        if (!isset(self::$yy_reduce_ofst[$stateno])) {
555            return self::$yy_default[$stateno];
556        }
557        $i = self::$yy_reduce_ofst[$stateno];
558        if ($i == self::YY_REDUCE_USE_DFLT) {
559            return self::$yy_default[$stateno];
560        }
561        if ($iLookAhead == self::YYNOCODE) {
562            return self::YY_NO_ACTION;
563        }
564        $i += $iLookAhead;
565        if ($i < 0 || $i >= self::YY_SZ_ACTTAB ||
566              self::$yy_lookahead[$i] != $iLookAhead) {
567            return self::$yy_default[$stateno];
568        } else {
569            return self::$yy_action[$i];
570        }
571    }
572
573    function yy_shift($yyNewState, $yyMajor, $yypMinor)
574    {
575        $this->yyidx++;
576        if ($this->yyidx >= self::YYSTACKDEPTH) {
577            $this->yyidx--;
578            if (self::$yyTraceFILE) {
579                fprintf(self::$yyTraceFILE, "%sStack Overflow!\n", self::$yyTracePrompt);
580            }
581            while ($this->yyidx >= 0) {
582                $this->yy_pop_parser_stack();
583            }
584            return;
585        }
586        $yytos = new TPC_yyStackEntry;
587        $yytos->stateno = $yyNewState;
588        $yytos->major = $yyMajor;
589        $yytos->minor = $yypMinor;
590        array_push($this->yystack, $yytos);
591        if (self::$yyTraceFILE && $this->yyidx > 0) {
592            fprintf(self::$yyTraceFILE, "%sShift %d\n", self::$yyTracePrompt,
593                $yyNewState);
594            fprintf(self::$yyTraceFILE, "%sStack:", self::$yyTracePrompt);
595            for($i = 1; $i <= $this->yyidx; $i++) {
596                fprintf(self::$yyTraceFILE, " %s",
597                    $this->yyTokenName[$this->yystack[$i]->major]);
598            }
599            fwrite(self::$yyTraceFILE,"\n");
600        }
601    }
602
603    static public $yyRuleInfo = array(
604  array( 'lhs' => 17, 'rhs' => 2 ),
605  array( 'lhs' => 18, 'rhs' => 1 ),
606  array( 'lhs' => 19, 'rhs' => 2 ),
607  array( 'lhs' => 19, 'rhs' => 0 ),
608  array( 'lhs' => 21, 'rhs' => 5 ),
609  array( 'lhs' => 21, 'rhs' => 6 ),
610  array( 'lhs' => 20, 'rhs' => 2 ),
611  array( 'lhs' => 20, 'rhs' => 2 ),
612  array( 'lhs' => 20, 'rhs' => 0 ),
613  array( 'lhs' => 23, 'rhs' => 3 ),
614  array( 'lhs' => 24, 'rhs' => 1 ),
615  array( 'lhs' => 24, 'rhs' => 1 ),
616  array( 'lhs' => 24, 'rhs' => 1 ),
617  array( 'lhs' => 24, 'rhs' => 1 ),
618  array( 'lhs' => 24, 'rhs' => 1 ),
619  array( 'lhs' => 24, 'rhs' => 1 ),
620  array( 'lhs' => 24, 'rhs' => 1 ),
621  array( 'lhs' => 22, 'rhs' => 1 ),
622  array( 'lhs' => 22, 'rhs' => 2 ),
623  array( 'lhs' => 22, 'rhs' => 3 ),
624    );
625
626    static public $yyReduceMap = array(
627        0 => 0,
628        2 => 0,
629        3 => 0,
630        17 => 0,
631        18 => 0,
632        19 => 0,
633        1 => 1,
634        4 => 4,
635        5 => 5,
636        6 => 6,
637        7 => 7,
638        8 => 8,
639        9 => 9,
640        10 => 10,
641        11 => 11,
642        12 => 12,
643        13 => 13,
644        14 => 14,
645        15 => 15,
646        16 => 16,
647    );
648#line 127 "smarty_internal_configfileparser.y"
649    function yy_r0(){ $this->_retvalue = null;     }
650#line 645 "smarty_internal_configfileparser.php"
651#line 130 "smarty_internal_configfileparser.y"
652    function yy_r1(){ $this->add_global_vars($this->yystack[$this->yyidx + 0]->minor); $this->_retvalue = null;     }
653#line 648 "smarty_internal_configfileparser.php"
654#line 136 "smarty_internal_configfileparser.y"
655    function yy_r4(){ $this->add_section_vars($this->yystack[$this->yyidx + -3]->minor, $this->yystack[$this->yyidx + 0]->minor); $this->_retvalue = null;     }
656#line 651 "smarty_internal_configfileparser.php"
657#line 137 "smarty_internal_configfileparser.y"
658    function yy_r5(){ if ($this->smarty->config_read_hidden) { $this->add_section_vars($this->yystack[$this->yyidx + -3]->minor, $this->yystack[$this->yyidx + 0]->minor); } $this->_retvalue = null;     }
659#line 654 "smarty_internal_configfileparser.php"
660#line 140 "smarty_internal_configfileparser.y"
661    function yy_r6(){ $this->_retvalue = $this->yystack[$this->yyidx + -1]->minor;     }
662#line 657 "smarty_internal_configfileparser.php"
663#line 141 "smarty_internal_configfileparser.y"
664    function yy_r7(){ $this->_retvalue = array_merge($this->yystack[$this->yyidx + -1]->minor, Array($this->yystack[$this->yyidx + 0]->minor));     }
665#line 660 "smarty_internal_configfileparser.php"
666#line 142 "smarty_internal_configfileparser.y"
667    function yy_r8(){ $this->_retvalue = Array();     }
668#line 663 "smarty_internal_configfileparser.php"
669#line 146 "smarty_internal_configfileparser.y"
670    function yy_r9(){ $this->_retvalue = Array("key" => $this->yystack[$this->yyidx + -2]->minor, "value" => $this->yystack[$this->yyidx + 0]->minor);     }
671#line 666 "smarty_internal_configfileparser.php"
672#line 148 "smarty_internal_configfileparser.y"
673    function yy_r10(){ $this->_retvalue = (float) $this->yystack[$this->yyidx + 0]->minor;     }
674#line 669 "smarty_internal_configfileparser.php"
675#line 149 "smarty_internal_configfileparser.y"
676    function yy_r11(){ $this->_retvalue = (int) $this->yystack[$this->yyidx + 0]->minor;     }
677#line 672 "smarty_internal_configfileparser.php"
678#line 150 "smarty_internal_configfileparser.y"
679    function yy_r12(){ $this->_retvalue = $this->parse_bool($this->yystack[$this->yyidx + 0]->minor);     }
680#line 675 "smarty_internal_configfileparser.php"
681#line 151 "smarty_internal_configfileparser.y"
682    function yy_r13(){ $this->_retvalue = self::parse_single_quoted_string($this->yystack[$this->yyidx + 0]->minor);     }
683#line 678 "smarty_internal_configfileparser.php"
684#line 152 "smarty_internal_configfileparser.y"
685    function yy_r14(){ $this->_retvalue = self::parse_double_quoted_string($this->yystack[$this->yyidx + 0]->minor);     }
686#line 681 "smarty_internal_configfileparser.php"
687#line 153 "smarty_internal_configfileparser.y"
688    function yy_r15(){ $this->_retvalue = self::parse_tripple_double_quoted_string($this->yystack[$this->yyidx + 0]->minor);     }
689#line 684 "smarty_internal_configfileparser.php"
690#line 154 "smarty_internal_configfileparser.y"
691    function yy_r16(){ $this->_retvalue = $this->yystack[$this->yyidx + 0]->minor;     }
692#line 687 "smarty_internal_configfileparser.php"
693
694    private $_retvalue;
695
696    function yy_reduce($yyruleno)
697    {
698        $yymsp = $this->yystack[$this->yyidx];
699        if (self::$yyTraceFILE && $yyruleno >= 0 
700              && $yyruleno < count(self::$yyRuleName)) {
701            fprintf(self::$yyTraceFILE, "%sReduce (%d) [%s].\n",
702                self::$yyTracePrompt, $yyruleno,
703                self::$yyRuleName[$yyruleno]);
704        }
705
706        $this->_retvalue = $yy_lefthand_side = null;
707        if (array_key_exists($yyruleno, self::$yyReduceMap)) {
708            // call the action
709            $this->_retvalue = null;
710            $this->{'yy_r' . self::$yyReduceMap[$yyruleno]}();
711            $yy_lefthand_side = $this->_retvalue;
712        }
713        $yygoto = self::$yyRuleInfo[$yyruleno]['lhs'];
714        $yysize = self::$yyRuleInfo[$yyruleno]['rhs'];
715        $this->yyidx -= $yysize;
716        for($i = $yysize; $i; $i--) {
717            // pop all of the right-hand side parameters
718            array_pop($this->yystack);
719        }
720        $yyact = $this->yy_find_reduce_action($this->yystack[$this->yyidx]->stateno, $yygoto);
721        if ($yyact < self::YYNSTATE) {
722            if (!self::$yyTraceFILE && $yysize) {
723                $this->yyidx++;
724                $x = new TPC_yyStackEntry;
725                $x->stateno = $yyact;
726                $x->major = $yygoto;
727                $x->minor = $yy_lefthand_side;
728                $this->yystack[$this->yyidx] = $x;
729            } else {
730                $this->yy_shift($yyact, $yygoto, $yy_lefthand_side);
731            }
732        } elseif ($yyact == self::YYNSTATE + self::YYNRULE + 1) {
733            $this->yy_accept();
734        }
735    }
736
737    function yy_parse_failed()
738    {
739        if (self::$yyTraceFILE) {
740            fprintf(self::$yyTraceFILE, "%sFail!\n", self::$yyTracePrompt);
741        }
742        while ($this->yyidx >= 0) {
743            $this->yy_pop_parser_stack();
744        }
745    }
746
747    function yy_syntax_error($yymajor, $TOKEN)
748    {
749#line 120 "smarty_internal_configfileparser.y"
750
751    $this->internalError = true;
752    $this->yymajor = $yymajor;
753    $this->compiler->trigger_config_file_error();
754#line 750 "smarty_internal_configfileparser.php"
755    }
756
757    function yy_accept()
758    {
759        if (self::$yyTraceFILE) {
760            fprintf(self::$yyTraceFILE, "%sAccept!\n", self::$yyTracePrompt);
761        }
762        while ($this->yyidx >= 0) {
763            $stack = $this->yy_pop_parser_stack();
764        }
765#line 112 "smarty_internal_configfileparser.y"
766
767    $this->successful = !$this->internalError;
768    $this->internalError = false;
769    $this->retvalue = $this->_retvalue;
770    //echo $this->retvalue."\n\n";
771#line 768 "smarty_internal_configfileparser.php"
772    }
773
774    function doParse($yymajor, $yytokenvalue)
775    {
776        $yyerrorhit = 0;   /* True if yymajor has invoked an error */
777        
778        if ($this->yyidx === null || $this->yyidx < 0) {
779            $this->yyidx = 0;
780            $this->yyerrcnt = -1;
781            $x = new TPC_yyStackEntry;
782            $x->stateno = 0;
783            $x->major = 0;
784            $this->yystack = array();
785            array_push($this->yystack, $x);
786        }
787        $yyendofinput = ($yymajor==0);
788        
789        if (self::$yyTraceFILE) {
790            fprintf(self::$yyTraceFILE, "%sInput %s\n",
791                self::$yyTracePrompt, $this->yyTokenName[$yymajor]);
792        }
793        
794        do {
795            $yyact = $this->yy_find_shift_action($yymajor);
796            if ($yymajor < self::YYERRORSYMBOL &&
797                  !$this->yy_is_expected_token($yymajor)) {
798                // force a syntax error
799                $yyact = self::YY_ERROR_ACTION;
800            }
801            if ($yyact < self::YYNSTATE) {
802                $this->yy_shift($yyact, $yymajor, $yytokenvalue);
803                $this->yyerrcnt--;
804                if ($yyendofinput && $this->yyidx >= 0) {
805                    $yymajor = 0;
806                } else {
807                    $yymajor = self::YYNOCODE;
808                }
809            } elseif ($yyact < self::YYNSTATE + self::YYNRULE) {
810                $this->yy_reduce($yyact - self::YYNSTATE);
811            } elseif ($yyact == self::YY_ERROR_ACTION) {
812                if (self::$yyTraceFILE) {
813                    fprintf(self::$yyTraceFILE, "%sSyntax Error!\n",
814                        self::$yyTracePrompt);
815                }
816                if (self::YYERRORSYMBOL) {
817                    if ($this->yyerrcnt < 0) {
818                        $this->yy_syntax_error($yymajor, $yytokenvalue);
819                    }
820                    $yymx = $this->yystack[$this->yyidx]->major;
821                    if ($yymx == self::YYERRORSYMBOL || $yyerrorhit ){
822                        if (self::$yyTraceFILE) {
823                            fprintf(self::$yyTraceFILE, "%sDiscard input token %s\n",
824                                self::$yyTracePrompt, $this->yyTokenName[$yymajor]);
825                        }
826                        $this->yy_destructor($yymajor, $yytokenvalue);
827                        $yymajor = self::YYNOCODE;
828                    } else {
829                        while ($this->yyidx >= 0 &&
830                                 $yymx != self::YYERRORSYMBOL &&
831        ($yyact = $this->yy_find_shift_action(self::YYERRORSYMBOL)) >= self::YYNSTATE
832                              ){
833                            $this->yy_pop_parser_stack();
834                        }
835                        if ($this->yyidx < 0 || $yymajor==0) {
836                            $this->yy_destructor($yymajor, $yytokenvalue);
837                            $this->yy_parse_failed();
838                            $yymajor = self::YYNOCODE;
839                        } elseif ($yymx != self::YYERRORSYMBOL) {
840                            $u2 = 0;
841                            $this->yy_shift($yyact, self::YYERRORSYMBOL, $u2);
842                        }
843                    }
844                    $this->yyerrcnt = 3;
845                    $yyerrorhit = 1;
846                } else {
847                    if ($this->yyerrcnt <= 0) {
848                        $this->yy_syntax_error($yymajor, $yytokenvalue);
849                    }
850                    $this->yyerrcnt = 3;
851                    $this->yy_destructor($yymajor, $yytokenvalue);
852                    if ($yyendofinput) {
853                        $this->yy_parse_failed();
854                    }
855                    $yymajor = self::YYNOCODE;
856                }
857            } else {
858                $this->yy_accept();
859                $yymajor = self::YYNOCODE;
860            }            
861        } while ($yymajor != self::YYNOCODE && $this->yyidx >= 0);
862    }
863}
864?>