    /**
     * This class parses the XTemplate syntax and calls abstract methods to process the parts.
     * @private
     */
    Ext.define('Ext.XTemplateParser', {
        constructor: function (config) {
            Ext.apply(this, config);
        },

        /**
         * @property {Number} level The 'for' loop context level. This is adjusted up by one
         * prior to calling {@link #doFor} and down by one after calling the corresponding
         * {@link #doEnd} that closes the loop. This will be 1 on the first {@link #doFor}
         * call.
         */

        /**
         * This method is called to process a piece of raw text from the tpl.
         * @param {String} text
         * @method doText
         */
        // doText: function (text)

        /**
         * This method is called to process expressions (like `{[expr]}`).
         * @param {String} expr The body of the expression (inside "{[" and "]}").
         * @method doExpr
         */
        // doExpr: function (expr)

        /**
         * This method is called to process simple tags (like `{tag}`).
         * @method doTag
         */
        // doTag: function (tag)

        /**
         * This method is called to process `<tpl else>`.
         * @method doElse
         */
        // doElse: function ()

        /**
         * This method is called to process `{% text %}`.
         * @param {String} text
         * @method doEval
         */
        // doEval: function (text)

        /**
         * This method is called to process `<tpl if="action">`. If there are other attributes,
         * these are passed in the actions object.
         * @param {String} action
         * @param {Object} actions Other actions keyed by the attribute name (such as 'exec').
         * @method doIf
         */
        // doIf: function (action, actions)

        /**
         * This method is called to process `<tpl elseif="action">`. If there are other attributes,
         * these are passed in the actions object.
         * @param {String} action
         * @param {Object} actions Other actions keyed by the attribute name (such as 'exec').
         * @method doElseIf
         */
        // doElseIf: function (action, actions)

        /**
         * This method is called to process `<tpl switch="action">`. If there are other attributes,
         * these are passed in the actions object.
         * @param {String} action
         * @param {Object} actions Other actions keyed by the attribute name (such as 'exec').
         * @method doSwitch
         */
        // doSwitch: function (action, actions)

        /**
         * This method is called to process `<tpl case="action">`. If there are other attributes,
         * these are passed in the actions object.
         * @param {String} action
         * @param {Object} actions Other actions keyed by the attribute name (such as 'exec').
         * @method doCase
         */
        // doCase: function (action, actions)

        /**
         * This method is called to process `<tpl default>`.
         * @method doDefault
         */
        // doDefault: function ()

        /**
         * This method is called to process `</tpl>`. It is given the action type that started
         * the tpl and the set of additional actions.
         * @param {String} type The type of action that is being ended.
         * @param {Object} actions The other actions keyed by the attribute name (such as 'exec').
         * @method doEnd
         */
        // doEnd: function (type, actions)

        /**
         * This method is called to process `<tpl for="action">`. If there are other attributes,
         * these are passed in the actions object.
         * @param {String} action
         * @param {Object} actions Other actions keyed by the attribute name (such as 'exec').
         * @method doFor
         */
        // doFor: function (action, actions)

        /**
         * This method is called to process `<tpl exec="action">`. If there are other attributes,
         * these are passed in the actions object.
         * @param {String} action
         * @param {Object} actions Other actions keyed by the attribute name.
         * @method doExec
         */
        // doExec: function (action, actions)

        /**
         * This method is called to process an empty `<tpl>`. This is unlikely to need to be
         * implemented, so a default (do nothing) version is provided.
         * @method
         */
        doTpl: Ext.emptyFn,

        parse: function (str) {
            var me = this,
                len = str.length,
                aliases = { elseif: 'elif' },
                topRe = me.topRe,
                actionsRe = me.actionsRe,
                index, stack, s, m, t, prev, frame, subMatch, begin, end, actions;

            me.level = 0;
            me.stack = stack = [];

            for (index = 0; index < len; index = end) {
                topRe.lastIndex = index;
                m = topRe.exec(str);

                if (!m) {
                    me.doText(str.substring(index, len));
                    break;
                }

                begin = m.index;
                end = topRe.lastIndex;

                if (index < begin) {
                    me.doText(str.substring(index, begin));
                }

                if (m[1]) {
                    end = str.indexOf('%}', begin+2);
                    me.doEval(str.substring(begin+2, end));
                    end += 2;
                } else if (m[2]) {
                    end = str.indexOf(']}', begin+2);
                    me.doExpr(str.substring(begin+2, end));
                    end += 2;
                } else if (m[3]) { // if ('{' token)
                    me.doTag(m[3]);
                } else if (m[4]) { // content of a <tpl xxxxxx> tag
                    actions = null;
                    while ((subMatch = actionsRe.exec(m[4])) !== null) {
                        s = subMatch[2] || subMatch[3];
                        if (s) {
                            s = Ext.String.htmlDecode(s); // decode attr value
                            t = subMatch[1];
                            t = aliases[t] || t;
                            actions = actions || {};
                            prev = actions[t];

                            if (typeof prev == 'string') {
                                actions[t] = [prev, s];
                            } else if (prev) {
                                actions[t].push(s);
                            } else {
                                actions[t] = s;
                            }
                        }
                    }

                    if (!actions) {
                        if (me.elseRe.test(m[4])) {
                            me.doElse();
                        } else if (me.defaultRe.test(m[4])) {
                            me.doDefault();
                        } else {
                            me.doTpl();
                            stack.push({ type: 'tpl' });
                        }
                    }
                    else if (actions['if']) {
                        me.doIf(actions['if'], actions)
                        stack.push({ type: 'if' });
                    }
                    else if (actions['switch']) {
                        me.doSwitch(actions['switch'], actions)
                        stack.push({ type: 'switch' });
                    }
                    else if (actions['case']) {
                        me.doCase(actions['case'], actions);
                    }
                    else if (actions['elif']) {
                        me.doElseIf(actions['elif'], actions);
                    }
                    else if (actions['for']) {
                        ++me.level;
                        me.doFor(actions['for'], actions);
                        stack.push({ type: 'for', actions: actions });
                    }
                    else if (actions.exec) {
                        me.doExec(actions.exec, actions);
                        stack.push({ type: 'exec', actions: actions });
                    }
                    /*
                    else {
                        // todo - error
                    }
                    /**/
                } else {
                    frame = stack.pop();
                    me.doEnd(frame.type, frame.actions);
                    if (frame.type == 'for') {
                        --me.level;
                    }
                }
            }
        },

        // Internal regexes

        topRe:     /(?:(\{\%)|(\{\[)|\{([^{}]*)\})|(?:<tpl([^>]*)\>)|(?:<\/tpl>)/g,
        actionsRe: /\s*(elif|elseif|if|for|exec|switch|case|eval)\s*\=\s*(?:(?:["]([^"]*)["])|(?:[']([^']*)[']))\s*/g,
        defaultRe: /^\s*default\s*$/,
        elseRe:    /^\s*else\s*$/
    });