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