/framework/vendor/smarty3/lib/libs/sysplugins/smarty_internal_configfileparser.php
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?>