Subversion Repositories ALCASAR

Rev

Details | Last modification | View Log

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