Fixing the SyntaxHighlighter 3.0.83 Parser Bug

    /**
     * Applies all regular expression to the code and stores all found
     * matches in the `this.matches` array.
     * @param {Array} regexList     List of regular expressions.
     * @param {String} code         Source code.
     * @return {Array}              Returns list of matches.
     */
    findMatches: function(regexList, code)
    {
        var result = [];
        
        if (regexList != null)
            for (var i = 0; i < regexList.length; i++) 
                // BUG: length returns len+1 for array if methods added to prototype chain (oising@gmail.com)
                if (typeof (regexList[i]) == "object")
                    result = result.concat(getMatches(code, regexList[i]));
        
        // sort and remove nested the matches
        return this.removeNestedMatches(result.sort(matchesSortCallback));
    },
    
    /**
     * Checks to see if any of the matches are inside of other matches. 
     * This process would get rid of highligted strings inside comments, 
     * keywords inside strings and so on.
     */
    removeNestedMatches: function(matches)
    {
        // Optimized by Jose Prado (http://joseprado.com)
        for (var i = 0; i < matches.length; i++) 
        { 
            if (matches[i] === null)
                continue;
            
            var itemI = matches[i],
                itemIEndPos = itemI.index + itemI.length
                ;
            
            for (var j = i + 1; j < matches.length && matches[i] !== null; j++) 
            {
                var itemJ = matches[j];
                
                if (itemJ === null) 
                    continue;
                else if (itemJ.index > itemIEndPos) 
                    break;
                else if (itemJ.index == itemI.index && itemJ.length > itemI.length)
                    matches[i] = null;
                else if (itemJ.index >= itemI.index && itemJ.index < itemIEndPos) 
                    matches[j] = null;
            }
        }
        
        return matches;
    },
/**
 * Executes given regular expression on provided code and returns all
 * matches that are found.
 * 
 * @param {String} code    Code to execute regular expression on.
 * @param {Object} regex   Regular expression item info from <code>regexList</code> collection.
 * @return {Array}         Returns a list of Match objects.
 */ 
function getMatches(code, regexInfo)
{
    function defaultAdd(match, regexInfo)
    {
        return match[0];
    };
    
    var index = 0,
        match = null,
        matches = [],
        func = regexInfo.func ? regexInfo.func : defaultAdd
        ;
    
    while((match = regexInfo.regex.exec(code)) != null)
    {
        var resultMatch = func(match, regexInfo);
        
        if (typeof(resultMatch) == 'string')
            resultMatch = [new sh.Match(resultMatch, match.index, regexInfo.css)];

        matches = matches.concat(resultMatch);
    }
    
    return matches;
};

    /* Combines functionality of old findMatches(), getMatches() and removeNestedMatches()
     * functions. Parse a string of code using an array of regular expressions.
     * 
     * @param {Array} regexList     List of regular expressions.
     * @param {String} code         Source code.
     * @return {Array}              Returns list of matches.
     */
    findMatchesNew: function(regexList, code)                   // Rev:20110216_1700
    {
        var matches = [];                                       // Return value. Array of Match objects.
        if (!regexList) return matches;                         // If regexlist is not defined, we're done.
        var nregex = regexList.length;                          // Loop end value.
        var pos = 0;                                            // Position within code string to begin regex search.
        var re, minIndex, resultMatch, func, match;             // Some locals.
        function defaultAdd(m, r) { return m[0]; };             // Dummy brush modify result function.
        var nextMatch = true;                                   // Prime the pump.
        while(nextMatch) {                                      // One regex match per loop. Advance pos through code.
            nextMatch = null;                                   // Assume this will be the last time through.
            minIndex = code.length + 1;                         // Reset min-match-index to impossibly large value.
            for (var i = 0; i < nregex; i++) {                  // Loop though all regexes at this pos.
                if (typeof(re = regexList[i]) === "object" && re.regex.global) { // Process only 'g'-flagged regexes.
                    re.regex.lastIndex = pos;                   // Start search at same pos for each regex.
                    if ((match = re.regex.exec(code)) !== null) {// Check if this regex matches anywhere?
                        if (match.index === pos) {              // Yes. Check if matched on first char?
                            nextMatch = {r: re, m: match};      // Yes. This is unconditionally our next match.
                            break;                              // Exit "try-all-regexes" for loop.
                        } // Otherwise we matched, but not on the first char. Need to run all regexes to find best.
                        if (match.index < minIndex) {           // Check if we have a new best match?
                            minIndex = match.index;             // Yes, set the bar a little lower.
                            nextMatch = {r: re, m: match};      // Save needed items for Match object.
                        }       
                    }
                } // End if re is object.
            } // End for loop.
            if (nextMatch) {                                    // Check if one of the regexes matched?
                func = nextMatch.r.func ? nextMatch.r.func : defaultAdd;
                resultMatch = func(nextMatch.m, nextMatch.r);   // Allow brush option to customize result.
                if (typeof(resultMatch) === 'string')           // Check if we need a new Match object?
                    resultMatch = new sh.Match(resultMatch, nextMatch.m.index, nextMatch.r.css); // Yes.
                matches.push(resultMatch);                      // Place this match on top of the stack.
                pos = nextMatch.r.regex.lastIndex;              // Adjust pos forward to end of this match.
            }
        } // End while loop.
        return matches;                                         // return array of regex matches
    },