libs/sysplugins/smarty_internal_configfileparser.php Quellcode

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




Korrekturen, Hinweise und Ergänzungen

Bitte scheuen Sie sich nicht und melden Sie, was auf dieser Seite sachlich falsch oder irreführend ist, was ergänzt werden sollte, was fehlt usw. Dazu bitte oben aus dem Menü Seite den Eintrag Support Forum wählen. Es ist eine kostenlose Anmeldung erforderlich, um Anmerkungen zu posten. Unpassende Postings, Spam usw. werden kommentarlos entfernt.