Хранилища Subversion ant

<?php

/**

* Smarty Internal Plugin Templateparser

*

* This is the template parser.

* It is generated from the internal.templateparser.y file

* @package Smarty

* @subpackage Compiler

* @author Uwe Tews

*/

/**

 * This can be used to store both the string representation of

 * a token, and any useful meta-data associated with the token.

 *

 * meta-data should be stored as an array

 */

class TPC_yyToken implements ArrayAccess

{

    public $string = '';

    public $metadata = array();

    function __construct($s, $m = array())

    {

        if ($s instanceof TPC_yyToken) {

            $this->string = $s->string;

            $this->metadata = $s->metadata;

        } else {

            $this->string = (string) $s;

            if ($m instanceof TPC_yyToken) {

                $this->metadata = $m->metadata;

            } elseif (is_array($m)) {

                $this->metadata = $m;

            }

        }

    }

    function __toString()

    {

        return $this->_string;

    }

    function offsetExists($offset)

    {

        return isset($this->metadata[$offset]);

    }

    function offsetGet($offset)

    {

        return $this->metadata[$offset];

    }

    function offsetSet($offset, $value)

    {

        if ($offset === null) {

            if (isset($value[0])) {

                $x = ($value instanceof TPC_yyToken) ?

                    $value->metadata : $value;

                $this->metadata = array_merge($this->metadata, $x);

                return;

            }

            $offset = count($this->metadata);

        }

        if ($value === null) {

            return;

        }

        if ($value instanceof TPC_yyToken) {

            if ($value->metadata) {

                $this->metadata[$offset] = $value->metadata;

            }

        } elseif ($value) {

            $this->metadata[$offset] = $value;

        }

    }

    function offsetUnset($offset)

    {

        unset($this->metadata[$offset]);

    }

}

/** The following structure represents a single element of the

 * parser's stack.  Information stored includes:

 *

 *   +  The state number for the parser at this level of the stack.

 *

 *   +  The value of the token stored at this level of the stack.

 *      (In other words, the "major" token.)

 *

 *   +  The semantic value stored at this level of the stack.  This is

 *      the information used by the action routines in the grammar.

 *      It is sometimes called the "minor" token.

 */

class TPC_yyStackEntry

{

    public $stateno;       /* The state-number */

    public $major;         /* The major token value.  This is the code

                     ** number for the token at this stack level */

    public $minor; /* The user-supplied minor token value.  This

                     ** is the value of the token  */

};

// code external to the class is included here

// declare_class is output here

#line 12 "internal.configfileparser.y"

class Smarty_Internal_Configfileparser#line 109 "internal.configfileparser.php"

{

/* First off, code is included which follows the "include_class" declaration

** in the input file. */

#line 14 "internal.configfileparser.y"

    // states whether the parse was successful or not

    public $successful = true;

    public $retvalue = 0;

    private $lex;

    private $internalError = false;

    function __construct($lex, $compiler) {

        // set instance object

        self::instance($this);

        $this->lex = $lex;

        $this->smarty = $compiler->smarty;

        $this->compiler = $compiler;

        $this->current_section = null;

        $this->hidden_section = false;

    }

    public static function &instance($new_instance = null)

    {

        static $instance = null;

        if (isset($new_instance) && is_object($new_instance))

            $instance = $new_instance;

        return $instance;

    }

#line 139 "internal.configfileparser.php"

/* Next is all token values, as class constants

*/

/*

** These constants (all generated automatically by the parser generator)

** specify the various kinds of tokens (terminals) that the parser

** understands.

**

** Each symbol here is a terminal symbol in the grammar.

*/

    const TPC_OTHER                          =  1;

    const TPC_COMMENTSTART                   =  2;

    const TPC_NUMBER                         =  3;

    const TPC_OPENB                          =  4;

    const TPC_CLOSEB                         =  5;

    const TPC_DOT                            =  6;

    const TPC_BOOLEANTRUE                    =  7;

    const TPC_BOOLEANFALSE                   =  8;

    const TPC_SI_QSTR                        =  9;

    const TPC_DO_QSTR                        = 10;

    const TPC_EQUAL                          = 11;

    const TPC_SPACE                          = 12;

    const TPC_ID                             = 13;

    const TPC_EOL                            = 14;

    const TPC_ML_QSTR                        = 15;

    const YY_NO_ACTION = 46;

    const YY_ACCEPT_ACTION = 45;

    const YY_ERROR_ACTION = 44;

/* Next are that tables used to determine what action to take based on the

** current state and lookahead token.  These tables are used to implement

** functions that take a state number and lookahead value and return an

** action integer.  

**

** Suppose the action integer is N.  Then the action is determined as

** follows

**

**   0 <= N < self::YYNSTATE                              Shift N.  That is,

**                                                        push the lookahead

**                                                        token onto the stack

**                                                        and goto state N.

**

**   self::YYNSTATE <= N < self::YYNSTATE+self::YYNRULE   Reduce by rule N-YYNSTATE.

**

**   N == self::YYNSTATE+self::YYNRULE                    A syntax error has occurred.

**

**   N == self::YYNSTATE+self::YYNRULE+1                  The parser accepts its

**                                                        input. (and concludes parsing)

**

**   N == self::YYNSTATE+self::YYNRULE+2                  No such action.  Denotes unused

**                                                        slots in the yy_action[] table.

**

** The action table is constructed as a single large static array $yy_action.

** Given state S and lookahead X, the action is computed as

**

**      self::$yy_action[self::$yy_shift_ofst[S] + X ]

**

** If the index value self::$yy_shift_ofst[S]+X is out of range or if the value

** self::$yy_lookahead[self::$yy_shift_ofst[S]+X] is not equal to X or if

** self::$yy_shift_ofst[S] is equal to self::YY_SHIFT_USE_DFLT, it means that

** the action is not in the table and that self::$yy_default[S] should be used instead.  

**

** The formula above is for computing the action when the lookahead is

** a terminal symbol.  If the lookahead is a non-terminal (as occurs after

** a reduce action) then the static $yy_reduce_ofst array is used in place of

** the static $yy_shift_ofst array and self::YY_REDUCE_USE_DFLT is used in place of

** self::YY_SHIFT_USE_DFLT.

**

** The following are the tables generated in this section:

**

**  self::$yy_action        A single table containing all actions.

**  self::$yy_lookahead     A table containing the lookahead for each entry in

**                          yy_action.  Used to detect hash collisions.

**  self::$yy_shift_ofst    For each state, the offset into self::$yy_action for

**                          shifting terminals.

**  self::$yy_reduce_ofst   For each state, the offset into self::$yy_action for

**                          shifting non-terminals after a reduce.

**  self::$yy_default       Default action for each state.

*/

    const YY_SZ_ACTTAB = 32;

static public $yy_action = array(

 /*     0 */    26,   20,   15,    4,   14,    2,   11,    6,   25,   27,

 /*    10 */     8,    5,   14,   10,   18,   26,    9,   16,   45,    3,

 /*    20 */    19,    7,   12,   13,   21,   23,    1,   26,   17,   24,

 /*    30 */    41,   22,

    );

    static public $yy_lookahead = array(

 /*     0 */     1,   14,    3,   21,   22,    2,    6,    4,    9,   10,

 /*    10 */    20,   21,   22,   13,   15,    1,   13,   14,   17,   18,

 /*    20 */    19,    5,   13,    5,   14,   14,   11,    1,   14,   22,

 /*    30 */    23,   19,

);

    const YY_SHIFT_USE_DFLT = -14;

    const YY_SHIFT_MAX = 13;

    static public $yy_shift_ofst = array(

 /*     0 */     3,   -1,   26,    3,   14,   26,    0,   10,  -13,   15,

 /*    10 */    16,    9,   18,   11,

);

    const YY_REDUCE_USE_DFLT = -19;

    const YY_REDUCE_MAX = 5;

    static public $yy_reduce_ofst = array(

 /*     0 */     1,  -10,  -18,   12,    7,    7,

);

    static public $yyExpectedTokens = array(

        /* 0 */ array(2, 4, 13, 14, ),

        /* 1 */ array(1, 3, 9, 10, 15, ),

        /* 2 */ array(1, ),

        /* 3 */ array(2, 4, 13, 14, ),

        /* 4 */ array(1, 14, ),

        /* 5 */ array(1, ),

        /* 6 */ array(6, 13, ),

        /* 7 */ array(14, ),

        /* 8 */ array(14, ),

        /* 9 */ array(11, ),

        /* 10 */ array(5, ),

        /* 11 */ array(13, ),

        /* 12 */ array(5, ),

        /* 13 */ array(14, ),

        /* 14 */ array(),

        /* 15 */ array(),

        /* 16 */ array(),

        /* 17 */ array(),

        /* 18 */ array(),

        /* 19 */ array(),

        /* 20 */ array(),

        /* 21 */ array(),

        /* 22 */ array(),

        /* 23 */ array(),

        /* 24 */ array(),

        /* 25 */ array(),

        /* 26 */ array(),

        /* 27 */ array(),

);

    static public $yy_default = array(

 /*     0 */    44,   44,   44,   28,   44,   36,   44,   44,   44,   44,

 /*    10 */    44,   44,   44,   44,   42,   40,   34,   35,   39,   29,

 /*    20 */    33,   31,   30,   32,   41,   37,   43,   38,

);

/* The next thing included is series of defines which control

** various aspects of the generated parser.

**    self::YYNOCODE      is a number which corresponds

**                        to no legal terminal or nonterminal number.  This

**                        number is used to fill in empty slots of the hash

**                        table.

**    self::YYFALLBACK    If defined, this indicates that one or more tokens

**                        have fall-back values which should be used if the

**                        original value of the token will not parse.

**    self::YYSTACKDEPTH  is the maximum depth of the parser's stack.

**    self::YYNSTATE      the combined number of states.

**    self::YYNRULE       the number of rules in the grammar

**    self::YYERRORSYMBOL is the code number of the error symbol.  If not

**                        defined, then do no error processing.

*/

    const YYNOCODE = 24;

    const YYSTACKDEPTH = 100;

    const YYNSTATE = 28;

    const YYNRULE = 16;

    const YYERRORSYMBOL = 16;

    const YYERRSYMDT = 'yy0';

    const YYFALLBACK = 1;

    /** The next table maps tokens into fallback tokens.  If a construct

     * like the following:

     *

     *      %fallback ID X Y Z.

     *

     * appears in the grammer, then ID becomes a fallback token for X, Y,

     * and Z.  Whenever one of the tokens X, Y, or Z is input to the parser

     * but it does not parse, the type of the token is changed to ID and

     * the parse is retried before an error is thrown.

     */

    static public $yyFallback = array(

    0,  /*          $ => nothing */

    0,  /*      OTHER => nothing */

    1,  /* COMMENTSTART => OTHER */

    1,  /*     NUMBER => OTHER */

    1,  /*      OPENB => OTHER */

    1,  /*     CLOSEB => OTHER */

    1,  /*        DOT => OTHER */

    1,  /* BOOLEANTRUE => OTHER */

    1,  /* BOOLEANFALSE => OTHER */

    1,  /*    SI_QSTR => OTHER */

    1,  /*    DO_QSTR => OTHER */

    1,  /*      EQUAL => OTHER */

    1,  /*      SPACE => OTHER */

    1,  /*         ID => OTHER */

    0,  /*        EOL => nothing */

    0,  /*    ML_QSTR => nothing */

    );

    /**

     * Turn parser tracing on by giving a stream to which to write the trace

     * and a prompt to preface each trace message.  Tracing is turned off

     * by making either argument NULL

     *

     * Inputs:

     *

     * - A stream resource to which trace output should be written.

     *   If NULL, then tracing is turned off.

     * - A prefix string written at the beginning of every

     *   line of trace output.  If NULL, then tracing is

     *   turned off.

     *

     * Outputs:

     *

     * - None.

     * @param resource

     * @param string

     */

    static function Trace($TraceFILE, $zTracePrompt)

    {

        if (!$TraceFILE) {

            $zTracePrompt = 0;

        } elseif (!$zTracePrompt) {

            $TraceFILE = 0;

        }

        self::$yyTraceFILE = $TraceFILE;

        self::$yyTracePrompt = $zTracePrompt;

    }

    /**

     * Output debug information to output (php://output stream)

     */

    static function PrintTrace()

    {

        self::$yyTraceFILE = fopen('php://output', 'w');

        self::$yyTracePrompt = '<br>';

    }

    /**

     * @var resource|0

     */

    static public $yyTraceFILE;

    /**

     * String to prepend to debug output

     * @var string|0

     */

    static public $yyTracePrompt;

    /**

     * @var int

     */

    public $yyidx;                    /* Index of top element in stack */

    /**

     * @var int

     */

    public $yyerrcnt;                 /* Shifts left before out of the error */

    /**

     * @var array

     */

    public $yystack = array();  /* The parser's stack */

    /**

     * For tracing shifts, the names of all terminals and nonterminals

     * are required.  The following table supplies these names

     * @var array

     */

    public $yyTokenName = array(

  '$',             'OTHER',         'COMMENTSTART',  'NUMBER',      

  'OPENB',         'CLOSEB',        'DOT',           'BOOLEANTRUE',

  'BOOLEANFALSE',  'SI_QSTR',       'DO_QSTR',       'EQUAL',      

  'SPACE',         'ID',            'EOL',           'ML_QSTR',    

  'error',         'start',         'config',        'config_element',

  'value',         'text',          'textelement',

    );

    /**

     * For tracing reduce actions, the names of all rules are required.

     * @var array

     */

    static public $yyRuleName = array(

 /*   0 */ "start ::= config",

 /*   1 */ "config ::= config_element",

 /*   2 */ "config ::= config config_element",

 /*   3 */ "config_element ::= OPENB ID CLOSEB EOL",

 /*   4 */ "config_element ::= OPENB DOT ID CLOSEB EOL",

 /*   5 */ "config_element ::= ID EQUAL value EOL",

 /*   6 */ "config_element ::= EOL",

 /*   7 */ "config_element ::= COMMENTSTART text EOL",

 /*   8 */ "value ::= text",

 /*   9 */ "value ::= SI_QSTR",

 /*  10 */ "value ::= DO_QSTR",

 /*  11 */ "value ::= ML_QSTR",

 /*  12 */ "value ::= NUMBER",

 /*  13 */ "text ::= text textelement",

 /*  14 */ "text ::= textelement",

 /*  15 */ "textelement ::= OTHER",

    );

    /**

     * This function returns the symbolic name associated with a token

     * value.

     * @param int

     * @return string

     */

    function tokenName($tokenType)

    {

        if ($tokenType === 0) {

            return 'End of Input';

        }

        if ($tokenType > 0 && $tokenType < count($this->yyTokenName)) {

            return $this->yyTokenName[$tokenType];

        } else {

            return "Unknown";

        }

    }

    /**

     * The following function deletes the value associated with a

     * symbol.  The symbol can be either a terminal or nonterminal.

     * @param int the symbol code

     * @param mixed the symbol's value

     */

    static function yy_destructor($yymajor, $yypminor)

    {

        switch ($yymajor) {

        /* Here is inserted the actions which take place when a

        ** terminal or non-terminal is destroyed.  This can happen

        ** when the symbol is popped from the stack during a

        ** reduce or during error processing or when a parser is

        ** being destroyed before it is finished parsing.

        **

        ** Note: during a reduce, the only symbols destroyed are those

        ** which appear on the RHS of the rule, but which are not used

        ** inside the C code.

        */

            default:  break;   /* If no destructor action specified: do nothing */

        }

    }

    /**

     * Pop the parser's stack once.

     *

     * If there is a destructor routine associated with the token which

     * is popped from the stack, then call it.

     *

     * Return the major token number for the symbol popped.

     * @param TPC_yyParser

     * @return int

     */

    function yy_pop_parser_stack()

    {

        if (!count($this->yystack)) {

            return;

        }

        $yytos = array_pop($this->yystack);

        if (self::$yyTraceFILE && $this->yyidx >= 0) {

            fwrite(self::$yyTraceFILE,

                self::$yyTracePrompt . 'Popping ' . $this->yyTokenName[$yytos->major] .

                    "\n");

        }

        $yymajor = $yytos->major;

        self::yy_destructor($yymajor, $yytos->minor);

        $this->yyidx--;

        return $yymajor;

    }

    /**

     * Deallocate and destroy a parser.  Destructors are all called for

     * all stack elements before shutting the parser down.

     */

    function __destruct()

    {

        while ($this->yyidx >= 0) {

            $this->yy_pop_parser_stack();

        }

        if (is_resource(self::$yyTraceFILE)) {

            fclose(self::$yyTraceFILE);

        }

    }

    /**

     * Based on the current state and parser stack, get a list of all

     * possible lookahead tokens

     * @param int

     * @return array

     */

    function yy_get_expected_tokens($token)

    {

        $state = $this->yystack[$this->yyidx]->stateno;

        $expected = self::$yyExpectedTokens[$state];

        if (in_array($token, self::$yyExpectedTokens[$state], true)) {

            return $expected;

        }

        $stack = $this->yystack;

        $yyidx = $this->yyidx;

        do {

            $yyact = $this->yy_find_shift_action($token);

            if ($yyact >= self::YYNSTATE && $yyact < self::YYNSTATE + self::YYNRULE) {

                // reduce action

                $done = 0;

                do {

                    if ($done++ == 100) {

                        $this->yyidx = $yyidx;

                        $this->yystack = $stack;

                        // too much recursion prevents proper detection

                        // so give up

                        return array_unique($expected);

                    }

                    $yyruleno = $yyact - self::YYNSTATE;

                    $this->yyidx -= self::$yyRuleInfo[$yyruleno]['rhs'];

                    $nextstate = $this->yy_find_reduce_action(

                        $this->yystack[$this->yyidx]->stateno,

                        self::$yyRuleInfo[$yyruleno]['lhs']);

                    if (isset(self::$yyExpectedTokens[$nextstate])) {

                        $expected += self::$yyExpectedTokens[$nextstate];

                            if (in_array($token,

                                  self::$yyExpectedTokens[$nextstate], true)) {

                            $this->yyidx = $yyidx;

                            $this->yystack = $stack;

                            return array_unique($expected);

                        }

                    }

                    if ($nextstate < self::YYNSTATE) {

                        // we need to shift a non-terminal

                        $this->yyidx++;

                        $x = new TPC_yyStackEntry;

                        $x->stateno = $nextstate;

                        $x->major = self::$yyRuleInfo[$yyruleno]['lhs'];

                        $this->yystack[$this->yyidx] = $x;

                        continue 2;

                    } elseif ($nextstate == self::YYNSTATE + self::YYNRULE + 1) {

                        $this->yyidx = $yyidx;

                        $this->yystack = $stack;

                        // the last token was just ignored, we can't accept

                        // by ignoring input, this is in essence ignoring a

                        // syntax error!

                        return array_unique($expected);

                    } elseif ($nextstate === self::YY_NO_ACTION) {

                        $this->yyidx = $yyidx;

                        $this->yystack = $stack;

                        // input accepted, but not shifted (I guess)

                        return $expected;

                    } else {

                        $yyact = $nextstate;

                    }

                } while (true);

            }

            break;

        } while (true);

        return array_unique($expected);

    }

    /**

     * Based on the parser state and current parser stack, determine whether

     * the lookahead token is possible.

     *

     * The parser will convert the token value to an error token if not.  This

     * catches some unusual edge cases where the parser would fail.

     * @param int

     * @return bool

     */

    function yy_is_expected_token($token)

    {

        if ($token === 0) {

            return true; // 0 is not part of this

        }

        $state = $this->yystack[$this->yyidx]->stateno;

        if (in_array($token, self::$yyExpectedTokens[$state], true)) {

            return true;

        }

        $stack = $this->yystack;

        $yyidx = $this->yyidx;

        do {

            $yyact = $this->yy_find_shift_action($token);

            if ($yyact >= self::YYNSTATE && $yyact < self::YYNSTATE + self::YYNRULE) {

                // reduce action

                $done = 0;

                do {

                    if ($done++ == 100) {

                        $this->yyidx = $yyidx;

                        $this->yystack = $stack;

                        // too much recursion prevents proper detection

                        // so give up

                        return true;

                    }

                    $yyruleno = $yyact - self::YYNSTATE;

                    $this->yyidx -= self::$yyRuleInfo[$yyruleno]['rhs'];

                    $nextstate = $this->yy_find_reduce_action(

                        $this->yystack[$this->yyidx]->stateno,

                        self::$yyRuleInfo[$yyruleno]['lhs']);

                    if (isset(self::$yyExpectedTokens[$nextstate]) &&

                          in_array($token, self::$yyExpectedTokens[$nextstate], true)) {

                        $this->yyidx = $yyidx;

                        $this->yystack = $stack;

                        return true;

                    }

                    if ($nextstate < self::YYNSTATE) {

                        // we need to shift a non-terminal

                        $this->yyidx++;

                        $x = new TPC_yyStackEntry;

                        $x->stateno = $nextstate;

                        $x->major = self::$yyRuleInfo[$yyruleno]['lhs'];

                        $this->yystack[$this->yyidx] = $x;

                        continue 2;

                    } elseif ($nextstate == self::YYNSTATE + self::YYNRULE + 1) {

                        $this->yyidx = $yyidx;

                        $this->yystack = $stack;

                        if (!$token) {

                            // end of input: this is valid

                            return true;

                        }

                        // the last token was just ignored, we can't accept

                        // by ignoring input, this is in essence ignoring a

                        // syntax error!

                        return false;

                    } elseif ($nextstate === self::YY_NO_ACTION) {

                        $this->yyidx = $yyidx;

                        $this->yystack = $stack;

                        // input accepted, but not shifted (I guess)

                        return true;

                    } else {

                        $yyact = $nextstate;

                    }

                } while (true);

            }

            break;

        } while (true);

        $this->yyidx = $yyidx;

        $this->yystack = $stack;

        return true;

    }

    /**

     * Find the appropriate action for a parser given the terminal

     * look-ahead token iLookAhead.

     *

     * If the look-ahead token is YYNOCODE, then check to see if the action is

     * independent of the look-ahead.  If it is, return the action, otherwise

     * return YY_NO_ACTION.

     * @param int The look-ahead token

     */

    function yy_find_shift_action($iLookAhead)

    {

        $stateno = $this->yystack[$this->yyidx]->stateno;

        /* if ($this->yyidx < 0) return self::YY_NO_ACTION;  */

        if (!isset(self::$yy_shift_ofst[$stateno])) {

            // no shift actions

            return self::$yy_default[$stateno];

        }

        $i = self::$yy_shift_ofst[$stateno];

        if ($i === self::YY_SHIFT_USE_DFLT) {

            return self::$yy_default[$stateno];

        }

        if ($iLookAhead == self::YYNOCODE) {

            return self::YY_NO_ACTION;

        }

        $i += $iLookAhead;

        if ($i < 0 || $i >= self::YY_SZ_ACTTAB ||

              self::$yy_lookahead[$i] != $iLookAhead) {

            if (count(self::$yyFallback) && $iLookAhead < count(self::$yyFallback)

                   && ($iFallback = self::$yyFallback[$iLookAhead]) != 0) {

                if (self::$yyTraceFILE) {

                    fwrite(self::$yyTraceFILE, self::$yyTracePrompt . "FALLBACK " .

                        $this->yyTokenName[$iLookAhead] . " => " .

                        $this->yyTokenName[$iFallback] . "\n");

                }

                return $this->yy_find_shift_action($iFallback);

            }

            return self::$yy_default[$stateno];

        } else {

            return self::$yy_action[$i];

        }

    }

    /**

     * Find the appropriate action for a parser given the non-terminal

     * look-ahead token $iLookAhead.

     *

     * If the look-ahead token is self::YYNOCODE, then check to see if the action is

     * independent of the look-ahead.  If it is, return the action, otherwise

     * return self::YY_NO_ACTION.

     * @param int Current state number

     * @param int The look-ahead token

     */

    function yy_find_reduce_action($stateno, $iLookAhead)

    {

        /* $stateno = $this->yystack[$this->yyidx]->stateno; */

        if (!isset(self::$yy_reduce_ofst[$stateno])) {

            return self::$yy_default[$stateno];

        }

        $i = self::$yy_reduce_ofst[$stateno];

        if ($i == self::YY_REDUCE_USE_DFLT) {

            return self::$yy_default[$stateno];

        }

        if ($iLookAhead == self::YYNOCODE) {

            return self::YY_NO_ACTION;

        }

        $i += $iLookAhead;

        if ($i < 0 || $i >= self::YY_SZ_ACTTAB ||

              self::$yy_lookahead[$i] != $iLookAhead) {

            return self::$yy_default[$stateno];