| // Copyright (C) 2006 Google Inc.␊ |
| //␊ |
| // Licensed under the Apache License, Version 2.0 (the "License");␊ |
| // you may not use this file except in compliance with the License.␊ |
| // You may obtain a copy of the License at␊ |
| //␊ |
| // http://www.apache.org/licenses/LICENSE-2.0␊ |
| //␊ |
| // Unless required by applicable law or agreed to in writing, software␊ |
| // distributed under the License is distributed on an "AS IS" BASIS,␊ |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.␊ |
| // See the License for the specific language governing permissions and␊ |
| // limitations under the License.␊ |
| ␊ |
| ␊ |
| /**␊ |
| * @fileoverview␊ |
| * some functions for browser-side pretty printing of code contained in html.␊ |
| *␊ |
| * The lexer should work on a number of languages including C and friends,␊ |
| * Java, Python, Bash, SQL, HTML, XML, CSS, Javascript, and Makefiles.␊ |
| * It works passably on Ruby, PHP and Awk and a decent subset of Perl, but,␊ |
| * because of commenting conventions, doesn't work on Smalltalk, Lisp-like, or␊ |
| * CAML-like languages.␊ |
| *␊ |
| * If there's a language not mentioned here, then I don't know it, and don't␊ |
| * know whether it works. If it has a C-like, Bash-like, or XML-like syntax␊ |
| * then it should work passably.␊ |
| *␊ |
| * Usage:␊ |
| * 1) include this source file in an html page via␊ |
| * <script type="text/javascript" src="/path/to/prettify.js"></script>␊ |
| * 2) define style rules. See the example page for examples.␊ |
| * 3) mark the <pre> and <code> tags in your source with class=prettyprint.␊ |
| * You can also use the (html deprecated) <xmp> tag, but the pretty printer␊ |
| * needs to do more substantial DOM manipulations to support that, so some␊ |
| * css styles may not be preserved.␊ |
| * That's it. I wanted to keep the API as simple as possible, so there's no␊ |
| * need to specify which language the code is in.␊ |
| *␊ |
| * Change log:␊ |
| * cbeust, 2006/08/22␊ |
| * Java annotations (start with "@") are now captured as literals ("lit")␊ |
| */␊ |
| ␊ |
| var PR_keywords = new Object();␊ |
| /** initialize the keyword list for our target languages. */␊ |
| (function () {␊ |
| var CPP_KEYWORDS = (␊ |
| "bool break case catch char class const const_cast continue default " +␊ |
| "delete deprecated dllexport dllimport do double dynamic_cast else enum " +␊ |
| "explicit extern false float for friend goto if inline int long mutable " +␊ |
| "naked namespace new noinline noreturn nothrow novtable operator private " +␊ |
| "property protected public register reinterpret_cast return selectany " +␊ |
| "short signed sizeof static static_cast struct switch template this " +␊ |
| "thread throw true try typedef typeid typename union unsigned using " +␊ |
| "declaration, using directive uuid virtual void volatile while typeof");␊ |
| var JAVA_KEYWORDS = (␊ |
| "abstract default goto package synchronized boolean do if private this " +␊ |
| "break double implements protected throw byte else import public throws " +␊ |
| "case enum instanceof return transient catch extends int short try char " +␊ |
| "final interface static void class finally long strictfp volatile const " +␊ |
| "float native super while continue for new switch");␊ |
| var PYTHON_KEYWORDS = (␊ |
| "and assert break class continue def del elif else except exec finally " +␊ |
| "for from global if import in is lambda not or pass print raise return " +␊ |
| "try while yield False True None");␊ |
| var JSCRIPT_KEYWORDS = (␊ |
| "abstract boolean break byte case catch char class const continue " +␊ |
| "debugger default delete do double else enum export extends false final " +␊ |
| "finally float for function goto if implements import in instanceof int " +␊ |
| "interface long native new null package private protected public return " +␊ |
| "short static super switch synchronized this throw throws transient " +␊ |
| "true try typeof var void volatile while with NaN Infinity");␊ |
| var PERL_KEYWORDS = (␊ |
| "foreach require sub unless until use elsif BEGIN END");␊ |
| var SH_KEYWORDS = (␊ |
| "if then do else fi end");␊ |
| var RUBY_KEYWORDS = (␊ |
| "if then elsif else end begin do rescue ensure while for class module " +␊ |
| "def yield raise until unless and or not when case super undef break " +␊ |
| "next redo retry in return alias defined");␊ |
| var KEYWORDS = [CPP_KEYWORDS, JAVA_KEYWORDS, JSCRIPT_KEYWORDS, PERL_KEYWORDS,␊ |
| PYTHON_KEYWORDS, RUBY_KEYWORDS, SH_KEYWORDS];␊ |
| for (var k = 0; k < KEYWORDS.length; k++) {␊ |
| var kw = KEYWORDS[k].split(' ');␊ |
| for (var i = 0; i < kw.length; i++) {␊ |
| if (kw[i]) { PR_keywords[kw[i]] = true; }␊ |
| }␊ |
| }␊ |
| }).call(this);␊ |
| ␊ |
| // token style names. correspond to css classes␊ |
| /** token style for a string literal */␊ |
| var PR_STRING = 'str';␊ |
| /** token style for a keyword */␊ |
| var PR_KEYWORD = 'kwd';␊ |
| /** token style for a comment */␊ |
| var PR_COMMENT = 'com';␊ |
| /** token style for a type */␊ |
| var PR_TYPE = 'typ';␊ |
| /** token style for a literal value. e.g. 1, null, true. */␊ |
| var PR_LITERAL = 'lit';␊ |
| /** token style for a punctuation string. */␊ |
| var PR_PUNCTUATION = 'pun';␊ |
| /** token style for a punctuation string. */␊ |
| var PR_PLAIN = 'pln';␊ |
| ␊ |
| /** token style for an sgml tag. */␊ |
| var PR_TAG = 'tag';␊ |
| /** token style for a markup declaration such as a DOCTYPE. */␊ |
| var PR_DECLARATION = 'dec';␊ |
| /** token style for embedded source. */␊ |
| var PR_SOURCE = 'src';␊ |
| /** token style for an sgml attribute name. */␊ |
| var PR_ATTRIB_NAME = 'atn';␊ |
| /** token style for an sgml attribute value. */␊ |
| var PR_ATTRIB_VALUE = 'atv';␊ |
| ␊ |
| /** the position of the end of a token during. A division of a string into␊ |
| * n tokens can be represented as a series n - 1 token ends, as long as␊ |
| * runs of whitespace warrant their own token.␊ |
| * @private␊ |
| */␊ |
| function PR_TokenEnd(end, style) {␊ |
| if (undefined === style) { throw new Error('BAD'); }␊ |
| if ('number' != typeof(end)) { throw new Error('BAD'); }␊ |
| this.end = end;␊ |
| this.style = style;␊ |
| }␊ |
| PR_TokenEnd.prototype.toString = function () {␊ |
| return '[PR_TokenEnd ' + this.end +␊ |
| (this.style ? ':' + this.style : '') + ']';␊ |
| };␊ |
| ␊ |
| ␊ |
| /** a chunk of text with a style. These are used to represent both the output␊ |
| * from the lexing functions as well as intermediate results.␊ |
| * @constructor␊ |
| * @param token the token text␊ |
| * @param style one of the token styles defined in designdoc-template, or null␊ |
| * for a styleless token, such as an embedded html tag.␊ |
| * @private␊ |
| */␊ |
| function PR_Token(token, style) {␊ |
| if (undefined === style) { throw new Error('BAD'); }␊ |
| this.token = token;␊ |
| this.style = style;␊ |
| }␊ |
| ␊ |
| PR_Token.prototype.toString = function () {␊ |
| return '[PR_Token ' + this.token + (this.style ? ':' + this.style : '') + ']';␊ |
| };␊ |
| ␊ |
| ␊ |
| /** a helper class that decodes common html entities used to escape source and␊ |
| * markup punctuation characters in html.␊ |
| * @constructor␊ |
| * @private␊ |
| */␊ |
| function PR_DecodeHelper() {␊ |
| this.next = 0;␊ |
| this.ch = '\0';␊ |
| }␊ |
| ␊ |
| PR_DecodeHelper.prototype.decode = function (s, i) {␊ |
| var next = i + 1;␊ |
| var ch = s.charAt(i);␊ |
| if ('&' == ch) {␊ |
| var semi = s.indexOf(';', next);␊ |
| if (semi >= 0 && semi < next + 4) {␊ |
| var entityName = s.substring(next, semi).toLowerCase();␊ |
| next = semi + 1;␊ |
| if ('lt' == entityName) {␊ |
| ch = '<';␊ |
| } else if ('gt' == entityName) {␊ |
| ch = '>';␊ |
| } else if ('quot' == entityName) {␊ |
| ch = '"';␊ |
| } else if ('apos' == entityName) {␊ |
| ch = '\'';␊ |
| } else if ('amp' == entityName) {␊ |
| ch = '&';␊ |
| } else {␊ |
| next = i + 1;␊ |
| }␊ |
| }␊ |
| }␊ |
| this.next = next;␊ |
| this.ch = ch;␊ |
| return this.ch;␊ |
| }␊ |
| ␊ |
| ␊ |
| // some string utilities␊ |
| function PR_isWordChar(ch) {␊ |
| return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');␊ |
| }␊ |
| ␊ |
| function PR_isIdentifierStart(ch) {␊ |
| return PR_isWordChar(ch) || ch == '_' || ch == '$' || ch == '@';␊ |
| }␊ |
| ␊ |
| function PR_isIdentifierPart(ch) {␊ |
| return PR_isIdentifierStart(ch) || PR_isDigitChar(ch);␊ |
| }␊ |
| ␊ |
| function PR_isSpaceChar(ch) {␊ |
| return "\t \r\n".indexOf(ch) >= 0;␊ |
| }␊ |
| ␊ |
| function PR_isDigitChar(ch) {␊ |
| return ch >= '0' && ch <= '9';␊ |
| }␊ |
| ␊ |
| function PR_trim(s) {␊ |
| var i = 0, j = s.length - 1;␊ |
| while (i <= j && PR_isSpaceChar(s.charAt(i))) { ++i; }␊ |
| while (j > i && PR_isSpaceChar(s.charAt(j))) { --j; }␊ |
| return s.substring(i, j + 1);␊ |
| }␊ |
| ␊ |
| function PR_startsWith(s, prefix) {␊ |
| return s.length >= prefix.length && prefix == s.substring(0, prefix.length);␊ |
| }␊ |
| ␊ |
| function PR_endsWith(s, suffix) {␊ |
| return s.length >= suffix.length &&␊ |
| suffix == s.substring(s.length - suffix.length, s.length);␊ |
| }␊ |
| ␊ |
| /** true iff prefix matches the first prefix characters in chars[0:len].␊ |
| * @private␊ |
| */␊ |
| function PR_prefixMatch(chars, len, prefix) {␊ |
| if (len < prefix.length) { return false; }␊ |
| for (var i = 0, n = prefix.length; i < n; ++i) {␊ |
| if (prefix.charAt(i) != chars[i]) { return false; }␊ |
| }␊ |
| return true;␊ |
| }␊ |
| ␊ |
| /** used to convert html special characters embedded in XMP tags into html. */␊ |
| function PR_textToHtml(str) {␊ |
| return str.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>');␊ |
| }␊ |
| ␊ |
| ␊ |
| /** split markup into chunks of html tags (style null) and␊ |
| * plain text (style {@link #PR_PLAIN}).␊ |
| *␊ |
| * @param s a String of html.␊ |
| * @return an Array of PR_Tokens of style PR_PLAIN and null.␊ |
| * @private␊ |
| */␊ |
| function PR_chunkify(s) {␊ |
| var chunks = new Array();␊ |
| var state = 0;␊ |
| var start = 0;␊ |
| var pos = -1;␊ |
| for (var i = 0, n = s.length; i < n; ++i) {␊ |
| var ch = s.charAt(i);␊ |
| switch (state) {␊ |
| case 0:␊ |
| if ('<' == ch) { state = 1; }␊ |
| break;␊ |
| case 1:␊ |
| pos = i - 1;␊ |
| if ('/' == ch) { state = 2; }␊ |
| else if (PR_isWordChar(ch)) { state = 3; }␊ |
| else if ('<' == ch) { state = 1; }␊ |
| else { state = 0; }␊ |
| break;␊ |
| case 2:␊ |
| if (PR_isWordChar(ch)) { state = 3; }␊ |
| else if ('<' == ch) { state = 1; }␊ |
| else { state = 0; }␊ |
| break;␊ |
| case 3:␊ |
| if ('>' == ch) {␊ |
| if (pos > start) {␊ |
| chunks.push(new PR_Token(s.substring(start, pos), PR_PLAIN));␊ |
| }␊ |
| chunks.push(new PR_Token(s.substring(pos, i + 1), null));␊ |
| start = i + 1;␊ |
| pos = -1;␊ |
| state = 0;␊ |
| }␊ |
| break;␊ |
| }␊ |
| }␊ |
| if (s.length > start) {␊ |
| chunks.push(new PR_Token(s.substring(start, s.length), PR_PLAIN));␊ |
| }␊ |
| return chunks;␊ |
| }␊ |
| ␊ |
| /** splits chunks around entities.␊ |
| * @private␊ |
| */␊ |
| function PR_splitEntities(chunks) {␊ |
| var chunksOut = new Array();␊ |
| var state = 0;␊ |
| for (var ci = 0, nc = chunks.length; ci < nc; ++ci) {␊ |
| var chunk = chunks[ci];␊ |
| if (PR_PLAIN != chunk.style) {␊ |
| chunksOut.push(chunk);␊ |
| continue;␊ |
| }␊ |
| var s = chunk.token;␊ |
| var pos = 0;␊ |
| var start;␊ |
| for (var i = 0; i < s.length; ++i) {␊ |
| var ch = s.charAt(i);␊ |
| switch (state) {␊ |
| case 0:␊ |
| if ('&' == ch) { state = 1; }␊ |
| break;␊ |
| case 1:␊ |
| if ('#' == ch || PR_isWordChar(ch)) {␊ |
| start = i - 1;␊ |
| state = 2;␊ |
| } else {␊ |
| state = 0;␊ |
| }␊ |
| break;␊ |
| case 2:␊ |
| if (';' == ch) {␊ |
| if (start > pos) {␊ |
| chunksOut.push(␊ |
| new PR_Token(s.substring(pos, start), chunk.style));␊ |
| }␊ |
| chunksOut.push(new PR_Token(s.substring(start, i + 1), null));␊ |
| pos = i + 1;␊ |
| state = 0;␊ |
| }␊ |
| break;␊ |
| }␊ |
| }␊ |
| if (s.length > pos) {␊ |
| chunksOut.push(pos ?␊ |
| new PR_Token(s.substring(pos, s.length), chunk.style) :␊ |
| chunk);␊ |
| }␊ |
| }␊ |
| return chunksOut;␊ |
| }␊ |
| ␊ |
| /** walk the tokenEnds list and the chunk list in parallel to generate a list␊ |
| * of split tokens.␊ |
| * @private␊ |
| */␊ |
| function PR_splitChunks(chunks, tokenEnds) {␊ |
| var tokens = new Array(); // the output␊ |
| ␊ |
| var ci = 0; // index into chunks␊ |
| // position of beginning of amount written so far in absolute space.␊ |
| var posAbs = 0;␊ |
| // position of amount written so far in chunk space␊ |
| var posChunk = 0;␊ |
| ␊ |
| // current chunk␊ |
| var chunk = new PR_Token('', null);␊ |
| ␊ |
| for (var ei = 0, ne = tokenEnds.length; ei < ne; ++ei) {␊ |
| var tokenEnd = tokenEnds[ei];␊ |
| var end = tokenEnd.end;␊ |
| ␊ |
| var tokLen = end - posAbs;␊ |
| var remainingInChunk = chunk.token.length - posChunk;␊ |
| ␊ |
| // FIX Nicolas LASSALLE : remainingInChunk and tokLen can both be equals so that the while is infinite !␊ |
| if (remainingInChunk != tokLen) {␊ |
| while (remainingInChunk <= tokLen) {␊ |
| if (remainingInChunk > 0) {␊ |
| tokens.push(␊ |
| new PR_Token(chunk.token.substring(posChunk, chunk.token.length),␊ |
| null == chunk.style ? null : tokenEnd.style));␊ |
| }␊ |
| posAbs += remainingInChunk;␊ |
| posChunk = 0;␊ |
| if (ci < chunks.length) { chunk = chunks[ci++]; }␊ |
| ␊ |
| tokLen = end - posAbs;␊ |
| remainingInChunk = chunk.token.length - posChunk;␊ |
| }␊ |
| }␊ |
| ␊ |
| if (tokLen) {␊ |
| tokens.push(␊ |
| new PR_Token(chunk.token.substring(posChunk, posChunk + tokLen),␊ |
| tokenEnd.style));␊ |
| posAbs += tokLen;␊ |
| posChunk += tokLen;␊ |
| }␊ |
| }␊ |
| ␊ |
| return tokens;␊ |
| }␊ |
| ␊ |
| /** splits markup tokens into declarations, tags, and source chunks.␊ |
| * @private␊ |
| */␊ |
| function PR_splitMarkup(chunks) {␊ |
| // A state machine to split out declarations, tags, etc.␊ |
| // This state machine deals with absolute space in the text, indexed by k,␊ |
| // and position in the current chunk, indexed by pos and tokenStart to␊ |
| // generate a list of the ends of tokens.␊ |
| // Absolute space is calculated by considering the chunks as appended into␊ |
| // one big string, as they were before being split.␊ |
| ␊ |
| // Known failure cases␊ |
| // Server side scripting sections such as <?...?> in attributes.␊ |
| // i.e. <span class="<? foo ?>">␊ |
| // Handling this would require a stack, and we don't use PHP.␊ |
| ␊ |
| // The output: a list of pairs of PR_TokenEnd instances␊ |
| var tokenEnds = new Array();␊ |
| ␊ |
| var state = 0; // FSM state variable␊ |
| var k = 0; // position in absolute space of the start of the current chunk␊ |
| var tokenStart = -1; // the start of the current token␊ |
| ␊ |
| // Try to find a closing tag for any open <style> or <script> tags␊ |
| // We can't do this at a later stage because then the following case␊ |
| // would fail:␊ |
| // <script>document.writeln('<!--');</script>␊ |
| ␊ |
| // We use tokenChars[:tokenCharsI] to accumulate the tag name so that we␊ |
| // can check whether to enter into a no scripting section when the tag ends.␊ |
| var tokenChars = new Array(12);␊ |
| var tokenCharsI = 0;␊ |
| // if non null, the tag prefix that we need to see to break out.␊ |
| var endScriptTag = null;␊ |
| var decodeHelper = new PR_DecodeHelper();␊ |
| ␊ |
| for (var ci = 0, nc = chunks.length; ci < nc; ++ci) {␊ |
| var chunk = chunks[ci];␊ |
| if (PR_PLAIN != chunk.style) {␊ |
| k += chunk.token.length;␊ |
| continue;␊ |
| }␊ |
| ␊ |
| var s = chunk.token;␊ |
| var pos = 0; // the position past the last character processed so far in s␊ |
| ␊ |
| for (var i = 0, n = s.length; i < n; /* i = next at bottom */) {␊ |
| decodeHelper.decode(s, i);␊ |
| var ch = decodeHelper.ch;␊ |
| var next = decodeHelper.next;␊ |
| ␊ |
| var tokenStyle = null;␊ |
| switch (state) {␊ |
| case 0:␊ |
| if ('<' == ch) { state = 1; }␊ |
| break;␊ |
| case 1:␊ |
| tokenCharsI = 0;␊ |
| if ('/' == ch) { // only consider close tags if we're in script/style␊ |
| state = 7;␊ |
| } else if (null == endScriptTag) {␊ |
| if ('!' == ch) {␊ |
| state = 2;␊ |
| } else if (PR_isWordChar(ch)) {␊ |
| state = 8;␊ |
| } else if ('?' == ch) {␊ |
| state = 9;␊ |
| } else if ('%' == ch) {␊ |
| state = 11;␊ |
| } else if ('<' != ch) {␊ |
| state = 0;␊ |
| }␊ |
| } else if ('<' != ch) {␊ |
| state = 0;␊ |
| }␊ |
| break;␊ |
| case 2:␊ |
| if ('-' == ch) {␊ |
| state = 4;␊ |
| } else if (PR_isWordChar(ch)) {␊ |
| state = 3;␊ |
| } else if ('<' == ch) {␊ |
| state = 1;␊ |
| } else {␊ |
| state = 0;␊ |
| }␊ |
| break;␊ |
| case 3:␊ |
| if ('>' == ch) {␊ |
| state = 0;␊ |
| tokenStyle = PR_DECLARATION;␊ |
| }␊ |
| break;␊ |
| case 4:␊ |
| if ('-' == ch) { state = 5; }␊ |
| break;␊ |
| case 5:␊ |
| if ('-' == ch) { state = 6; }␊ |
| break;␊ |
| case 6:␊ |
| if ('>' == ch) {␊ |
| state = 0;␊ |
| tokenStyle = PR_COMMENT;␊ |
| } else if ('-' == ch) {␊ |
| state = 6;␊ |
| } else {␊ |
| state = 4;␊ |
| }␊ |
| break;␊ |
| case 7:␊ |
| if (PR_isWordChar(ch)) {␊ |
| state = 8;␊ |
| } else if ('<' == ch) {␊ |
| state = 1;␊ |
| } else {␊ |
| state = 0;␊ |
| }␊ |
| break;␊ |
| case 8:␊ |
| if ('>' == ch) {␊ |
| state = 0;␊ |
| tokenStyle = PR_TAG;␊ |
| }␊ |
| break;␊ |
| case 9:␊ |
| if ('?' == ch) { state = 10; }␊ |
| break;␊ |
| case 10:␊ |
| if ('>' == ch) {␊ |
| state = 0;␊ |
| tokenStyle = PR_SOURCE;␊ |
| } else if ('?' != ch) {␊ |
| state = 9;␊ |
| }␊ |
| break;␊ |
| case 11:␊ |
| if ('%' == ch) { state = 12; }␊ |
| break;␊ |
| case 12:␊ |
| if ('>' == ch) {␊ |
| state = 0;␊ |
| tokenStyle = PR_SOURCE;␊ |
| } else if ('%' != ch) {␊ |
| state = 11;␊ |
| }␊ |
| break;␊ |
| }␊ |
| ␊ |
| if (tokenCharsI < tokenChars.length) {␊ |
| tokenChars[tokenCharsI++] = ch.toLowerCase();␊ |
| }␊ |
| if (1 == state) { tokenStart = k + i; }␊ |
| i = next;␊ |
| if (tokenStyle != null) {␊ |
| if (null != tokenStyle) {␊ |
| if (endScriptTag) {␊ |
| if (PR_prefixMatch(tokenChars, tokenCharsI, endScriptTag)) {␊ |
| endScriptTag = null;␊ |
| }␊ |
| } else {␊ |
| if (PR_prefixMatch(tokenChars, tokenCharsI, 'script')) {␊ |
| endScriptTag = '/script';␊ |
| } else if (PR_prefixMatch(tokenChars, tokenCharsI, 'style')) {␊ |
| endScriptTag = '/style';␊ |
| } else if (PR_prefixMatch(tokenChars, tokenCharsI, 'xmp')) {␊ |
| endScriptTag = '/xmp';␊ |
| }␊ |
| }␊ |
| // disallow the tag if endScriptTag is set and this was not an open␊ |
| // tag.␊ |
| if (endScriptTag && tokenCharsI && '/' == tokenChars[0]) {␊ |
| tokenStyle = null;␊ |
| }␊ |
| }␊ |
| if (null != tokenStyle) {␊ |
| tokenEnds.push(new PR_TokenEnd(tokenStart, PR_PLAIN));␊ |
| tokenEnds.push(new PR_TokenEnd(k + next, tokenStyle));␊ |
| }␊ |
| }␊ |
| }␊ |
| k += chunk.token.length;␊ |
| }␊ |
| tokenEnds.push(new PR_TokenEnd(k, PR_PLAIN));␊ |
| ␊ |
| return tokenEnds;␊ |
| }␊ |
| ␊ |
| /** splits the given string into comment, string, and "other" tokens.␊ |
| * @return an array of PR_Tokens with style in␊ |
| * (PR_STRING, PR_COMMENT, PR_PLAIN, null)␊ |
| * The result array may contain spurious zero length tokens. Ignore them.␊ |
| *␊ |
| * @private␊ |
| */␊ |
| function PR_splitStringAndCommentTokens(chunks) {␊ |
| // a state machine to split out comments, strings, and other stuff␊ |
| var tokenEnds = new Array(); // positions of ends of tokens in absolute space␊ |
| var state = 0; // FSM state variable␊ |
| var delim = -1; // string delimiter␊ |
| var k = 0; // absolute position of beginning of current chunk␊ |
| for (var ci = 0, nc = chunks.length; ci < nc; ++ci) {␊ |
| var chunk = chunks[ci];␊ |
| var s = chunk.token;␊ |
| if (PR_PLAIN == chunk.style) {␊ |
| for (var i = 0, n = s.length; i < n; ++i) {␊ |
| var ch = s.charAt(i);␊ |
| if (0 == state) {␊ |
| if (ch == '"' || ch == '\'' || ch == '`') {␊ |
| tokenEnds.push(new PR_TokenEnd(k + i, PR_PLAIN));␊ |
| state = 1;␊ |
| delim = ch;␊ |
| } else if (ch == '/') {␊ |
| state = 3;␊ |
| } else if (ch == '#') {␊ |
| tokenEnds.push(new PR_TokenEnd(k + i, PR_PLAIN));␊ |
| state = 4;␊ |
| }␊ |
| } else if (1 == state) {␊ |
| if (ch == delim) {␊ |
| state = 0;␊ |
| tokenEnds.push(new PR_TokenEnd(k + i + 1, PR_STRING));␊ |
| } else if (ch == '\\') {␊ |
| state = 2;␊ |
| }␊ |
| } else if (2 == state) {␊ |
| state = 1;␊ |
| } else if (3 == state) {␊ |
| if (ch == '/') {␊ |
| state = 4;␊ |
| tokenEnds.push(new PR_TokenEnd(k + i - 1, PR_PLAIN));␊ |
| } else if (ch == '*') {␊ |
| state = 5;␊ |
| tokenEnds.push(new PR_TokenEnd(k + i - 1, PR_PLAIN));␊ |
| } else {␊ |
| state = 0;␊ |
| // next loop will reenter state 0 without same value of i, so␊ |
| // ch will be reconsidered as start of new token.␊ |
| --i;␊ |
| }␊ |
| } else if (4 == state) {␊ |
| if (ch == '\r' || ch == '\n') {␊ |
| state = 0;␊ |
| tokenEnds.push(new PR_TokenEnd(k + i, PR_COMMENT));␊ |
| }␊ |
| } else if (5 == state) {␊ |
| if (ch == '*') {␊ |
| state = 6;␊ |
| }␊ |
| } else if (6 == state) {␊ |
| if (ch == '/') {␊ |
| state = 0;␊ |
| tokenEnds.push(new PR_TokenEnd(k + i + 1, PR_COMMENT));␊ |
| } else if (ch != '*') {␊ |
| state = 5;␊ |
| }␊ |
| }␊ |
| }␊ |
| }␊ |
| k += s.length;␊ |
| }␊ |
| tokenEnds.push(new PR_TokenEnd(k, PR_PLAIN)); // a token ends at the end␊ |
| ␊ |
| return PR_splitChunks(chunks, tokenEnds);␊ |
| }␊ |
| ␊ |
| /** used by lexSource to split a non string, non comment token.␊ |
| * @private␊ |
| */␊ |
| function PR_splitNonStringNonCommentToken(s, outlist) {␊ |
| var pos = 0;␊ |
| var state = 0;␊ |
| for (var i = 0; i <= s.length; i++) {␊ |
| var ch = s.charAt(i);␊ |
| // the next state.␊ |
| // if set to -1 then it will cause a reentry to state 0 without consuming␊ |
| // another character.␊ |
| var nstate = state;␊ |
| ␊ |
| if (i == s.length) {␊ |
| // nstate will not be equal to state, so it will append the token␊ |
| nstate = -2;␊ |
| } else {␊ |
| switch (state) {␊ |
| case 0: // whitespace state␊ |
| if (PR_isIdentifierStart(ch)) {␊ |
| nstate = 1;␊ |
| } else if (PR_isDigitChar(ch)) {␊ |
| nstate = 2;␊ |
| } else if (!PR_isSpaceChar(ch)) {␊ |
| nstate = 3;␊ |
| }␊ |
| if (nstate && pos < i) {␊ |
| var t = s.substring(pos, i);␊ |
| outlist.push(new PR_Token(t, PR_PLAIN));␊ |
| pos = i;␊ |
| }␊ |
| break;␊ |
| case 1: // identifier state␊ |
| if (!PR_isIdentifierPart(ch)) {␊ |
| nstate = -1;␊ |
| }␊ |
| break;␊ |
| case 2: // number literal state␊ |
| // handle numeric literals like␊ |
| // 0x7f 300UL 100_000␊ |
| ␊ |
| // this does not treat floating point values as a single literal␊ |
| // 0.1 and 3e-6␊ |
| // are each split into multiple tokens␊ |
| if (!(PR_isDigitChar(ch) || PR_isWordChar(ch) || ch == '_')) {␊ |
| nstate = -1;␊ |
| }␊ |
| break;␊ |
| case 3: // punctuation state␊ |
| if (PR_isIdentifierStart(ch) || PR_isDigitChar(ch) ||␊ |
| PR_isSpaceChar(ch)) {␊ |
| nstate = -1;␊ |
| }␊ |
| break;␊ |
| }␊ |
| }␊ |
| ␊ |
| if (nstate != state) {␊ |
| if (nstate < 0) {␊ |
| if (i > pos) {␊ |
| var t = s.substring(pos, i);␊ |
| var ch0 = t.charAt(0);␊ |
| var style;␊ |
| if (PR_isIdentifierStart(ch0)) {␊ |
| if (PR_keywords[t]) {␊ |
| style = PR_KEYWORD;␊ |
| } else if (ch0 === '@') {␊ |
| style = PR_LITERAL;␊ |
| } else {␊ |
| // Treat any word that starts with an uppercase character and␊ |
| // contains at least one lowercase character as a type, or␊ |
| // ends with _t.␊ |
| // This works perfectly for Java, pretty well for C++, and␊ |
| // passably for Python. The _t catches C structs.␊ |
| var isType = false;␊ |
| if (ch0 >= 'A' && ch0 <= 'Z') {␊ |
| for (var j = 1; j < t.length; j++) {␊ |
| var ch1 = t.charAt(j);␊ |
| if (ch1 >= 'a' && ch1 <= 'z') {␊ |
| isType = true;␊ |
| break;␊ |
| }␊ |
| }␊ |
| if (!isType && t.length >= 2 &&␊ |
| t.substring(t.length - 2) == '_t') {␊ |
| isType = true;␊ |
| }␊ |
| }␊ |
| style = isType ? PR_TYPE : PR_PLAIN;␊ |
| }␊ |
| } else if (PR_isDigitChar(ch0)) {␊ |
| style = PR_LITERAL;␊ |
| } else if (!PR_isSpaceChar(ch0)) {␊ |
| style = PR_PUNCTUATION;␊ |
| } else {␊ |
| style = PR_PLAIN;␊ |
| }␊ |
| pos = i;␊ |
| outlist.push(new PR_Token(t, style));␊ |
| }␊ |
| ␊ |
| state = 0;␊ |
| if (nstate == -1) {␊ |
| // don't increment. This allows us to use state 0 to redispatch based␊ |
| // on the current character.␊ |
| i--;␊ |
| continue;␊ |
| }␊ |
| }␊ |
| state = nstate;␊ |
| }␊ |
| }␊ |
| }␊ |
| ␊ |
| /** split a group of chunks of markup.␊ |
| * @private␊ |
| */␊ |
| function PR_tokenizeMarkup(chunks) {␊ |
| if (!(chunks && chunks.length)) { return chunks; }␊ |
| ␊ |
| var tokenEnds = PR_splitMarkup(chunks);␊ |
| return PR_splitChunks(chunks, tokenEnds);␊ |
| }␊ |
| ␊ |
| /** split tags attributes and their values out from the tag name, and␊ |
| * recursively lex source chunks.␊ |
| * @private␊ |
| */␊ |
| function PR_splitTagAttributes(tokens) {␊ |
| var tokensOut = new Array();␊ |
| var state = 0;␊ |
| var stateStyle = PR_TAG;␊ |
| var delim = null; // attribute delimiter for quoted value state.␊ |
| var decodeHelper = new PR_DecodeHelper();␊ |
| for (var ci = 0; ci < tokens.length; ++ci) {␊ |
| var tok = tokens[ci];␊ |
| if (PR_TAG == tok.style) {␊ |
| var s = tok.token;␊ |
| var start = 0;␊ |
| for (var i = 0; i < s.length; /* i = next at bottom */) {␊ |
| decodeHelper.decode(s, i);␊ |
| var ch = decodeHelper.ch;␊ |
| var next = decodeHelper.next;␊ |
| ␊ |
| var emitEnd = null; // null or position of end of chunk to emit.␊ |
| var nextStyle = null; // null or next value of stateStyle␊ |
| if (ch == '>') {␊ |
| if (PR_TAG != stateStyle) {␊ |
| emitEnd = i;␊ |
| nextStyle = PR_TAG;␊ |
| }␊ |
| } else {␊ |
| switch (state) {␊ |
| case 0:␊ |
| if ('<' == ch) { state = 1; }␊ |
| break;␊ |
| case 1:␊ |
| if (PR_isSpaceChar(ch)) { state = 2; }␊ |
| break;␊ |
| case 2:␊ |
| if (!PR_isSpaceChar(ch)) {␊ |
| nextStyle = PR_ATTRIB_NAME;␊ |
| emitEnd = i;␊ |
| state = 3;␊ |
| }␊ |
| break;␊ |
| case 3:␊ |
| if ('=' == ch) {␊ |
| emitEnd = i;␊ |
| nextStyle = PR_TAG;␊ |
| state = 5;␊ |
| } else if (PR_isSpaceChar(ch)) {␊ |
| emitEnd = i;␊ |
| nextStyle = PR_TAG;␊ |
| state = 4;␊ |
| }␊ |
| break;␊ |
| case 4:␊ |
| if ('=' == ch) {␊ |
| state = 5;␊ |
| } else if (!PR_isSpaceChar(ch)) {␊ |
| emitEnd = i;␊ |
| nextStyle = PR_ATTRIB_NAME;␊ |
| state = 3;␊ |
| }␊ |
| break;␊ |
| case 5:␊ |
| if ('"' == ch || '\'' == ch) {␊ |
| emitEnd = i;␊ |
| nextStyle = PR_ATTRIB_VALUE;␊ |
| state = 6;␊ |
| delim = ch;␊ |
| } else if (!PR_isSpaceChar(ch)) {␊ |
| emitEnd = i;␊ |
| nextStyle = PR_ATTRIB_VALUE;␊ |
| state = 7;␊ |
| }␊ |
| break;␊ |
| case 6:␊ |
| if (ch == delim) {␊ |
| emitEnd = next;␊ |
| nextStyle = PR_TAG;␊ |
| state = 2;␊ |
| }␊ |
| break;␊ |
| case 7:␊ |
| if (PR_isSpaceChar(ch)) {␊ |
| emitEnd = i;␊ |
| nextStyle = PR_TAG;␊ |
| state = 2;␊ |
| }␊ |
| break;␊ |
| }␊ |
| }␊ |
| if (emitEnd) {␊ |
| if (emitEnd > start) {␊ |
| tokensOut.push(␊ |
| new PR_Token(s.substring(start, emitEnd), stateStyle));␊ |
| start = emitEnd;␊ |
| }␊ |
| stateStyle = nextStyle;␊ |
| }␊ |
| i = next;␊ |
| }␊ |
| if (s.length > start) {␊ |
| tokensOut.push(new PR_Token(s.substring(start, s.length), stateStyle));␊ |
| }␊ |
| } else {␊ |
| if (tok.style) {␊ |
| state = 0;␊ |
| stateStyle = PR_TAG;␊ |
| }␊ |
| tokensOut.push(tok);␊ |
| }␊ |
| }␊ |
| return tokensOut;␊ |
| }␊ |
| ␊ |
| /** identify regions of markup that are really source code, and recursivley␊ |
| * lex them.␊ |
| * @private␊ |
| */␊ |
| function PR_splitSourceNodes(tokens) {␊ |
| var tokensOut = new Array();␊ |
| // when we see a <script> tag, store '/' here so that we know to end the␊ |
| // source processing␊ |
| var endScriptTag = null;␊ |
| var decodeHelper = new PR_DecodeHelper();␊ |
| ␊ |
| var sourceChunks = null;␊ |
| ␊ |
| for (var ci = 0, nc = tokens.length; ci < nc; ++ci) {␊ |
| var tok = tokens[ci];␊ |
| if (null == tok.style) {␊ |
| tokens.push(tok);␊ |
| continue;␊ |
| }␊ |
| ␊ |
| var s = tok.token;␊ |
| ␊ |
| if (null == endScriptTag) {␊ |
| if (PR_SOURCE == tok.style) {␊ |
| // split off any starting and trailing <?, <%␊ |
| if ('<' == decodeHelper.decode(s, 0)) {␊ |
| decodeHelper.decode(s, decodeHelper.next);␊ |
| if ('%' == decodeHelper.ch || '?' == decodeHelper.ch) {␊ |
| endScriptTag = decodeHelper.ch;␊ |
| tokensOut.push(new PR_Token(s.substring(0, decodeHelper.next),␊ |
| PR_TAG));␊ |
| s = s.substring(decodeHelper.next, s.length);␊ |
| }␊ |
| }␊ |
| } else if (PR_TAG == tok.style) {␊ |
| if ('<' == decodeHelper.decode(s, 0) &&␊ |
| '/' != s.charAt(decodeHelper.next)) {␊ |
| var tagContent = s.substring(decodeHelper.next).toLowerCase();␊ |
| // FIXME(msamuel): this does not mirror exactly the code in␊ |
| // in PR_splitMarkup that defers splitting tags inside script and␊ |
| // style blocks.␊ |
| if (PR_startsWith(tagContent, 'script') ||␊ |
| PR_startsWith(tagContent, 'style') ||␊ |
| PR_startsWith(tagContent, 'xmp')) {␊ |
| endScriptTag = '/';␊ |
| }␊ |
| }␊ |
| }␊ |
| }␊ |
| ␊ |
| if (null != endScriptTag) {␊ |
| var endTok = null;␊ |
| if (PR_SOURCE == tok.style) {␊ |
| if (endScriptTag == '%' || endScriptTag == '?') {␊ |
| var pos = s.lastIndexOf(endScriptTag);␊ |
| if (pos >= 0 && '>' == decodeHelper.decode(s, pos + 1) &&␊ |
| s.length == decodeHelper.next) {␊ |
| endTok = new PR_Token(s.substring(pos, s.length), PR_TAG);␊ |
| s = s.substring(0, pos);␊ |
| }␊ |
| }␊ |
| if (null == sourceChunks) { sourceChunks = new Array(); }␊ |
| sourceChunks.push(new PR_Token(s, PR_PLAIN));␊ |
| } else if (PR_PLAIN == tok.style) {␊ |
| if (null == sourceChunks) { sourceChunks = new Array(); }␊ |
| sourceChunks.push(tok);␊ |
| } else if (PR_TAG == tok.style) {␊ |
| // if it starts with </ then it must be the end tag.␊ |
| if ('<' == decodeHelper.decode(tok.token, 0) &&␊ |
| tok.token.length > decodeHelper.next &&␊ |
| '/' == decodeHelper.decode(tok.token, decodeHelper.next)) {␊ |
| endTok = tok;␊ |
| } else {␊ |
| tokensOut.push(tok);␊ |
| }␊ |
| } else {␊ |
| if (sourceChunks) {␊ |
| sourceChunks.push(tok);␊ |
| } else {␊ |
| // push remaining tag and attribute tokens from the opening tag␊ |
| tokensOut.push(tok);␊ |
| }␊ |
| }␊ |
| if (endTok) {␊ |
| if (sourceChunks) {␊ |
| var sourceTokens = PR_lexSource(sourceChunks);␊ |
| tokensOut.push(new PR_Token('<span class=embsrc>', null));␊ |
| for (var si = 0, ns = sourceTokens.length; si < ns; ++si) {␊ |
| tokensOut.push(sourceTokens[si]);␊ |
| }␊ |
| tokensOut.push(new PR_Token('</span>', null));␊ |
| sourceChunks = null;␊ |
| }␊ |
| tokensOut.push(endTok);␊ |
| endScriptTag = null;␊ |
| }␊ |
| } else {␊ |
| tokensOut.push(tok);␊ |
| }␊ |
| }␊ |
| return tokensOut;␊ |
| }␊ |
| ␊ |
| /** splits the quotes from an attribute value.␊ |
| * ['"foo"'] -> ['"', 'foo', '"']␊ |
| * @private␊ |
| */␊ |
| function PR_splitAttributeQuotes(tokens) {␊ |
| var firstPlain = null, lastPlain = null;␊ |
| for (var i = 0; i < tokens.length; ++i) {␊ |
| if (PR_PLAIN == tokens[i].style) {␊ |
| firstPlain = i;␊ |
| break;␊ |
| }␊ |
| }␊ |
| for (var i = tokens.length; --i >= 0;) {␊ |
| if (PR_PLAIN == tokens[i].style) {␊ |
| lastPlain = i;␊ |
| break;␊ |
| }␊ |
| }␊ |
| if (null == firstPlain) { return tokens; }␊ |
| ␊ |
| var decodeHelper = new PR_DecodeHelper();␊ |
| var fs = tokens[firstPlain].token;␊ |
| var fc = decodeHelper.decode(fs, 0);␊ |
| if ('"' != fc && '\'' != fc) {␊ |
| return tokens;␊ |
| }␊ |
| var fpos = decodeHelper.next;␊ |
| ␊ |
| var ls = tokens[lastPlain].token;␊ |
| var lpos = ls.lastIndexOf('&');␊ |
| if (lpos < 0) { lpos = ls.length - 1; }␊ |
| var lc = decodeHelper.decode(ls, lpos);␊ |
| if (lc != fc || decodeHelper.next != ls.length) {␊ |
| lc = null;␊ |
| lpos = ls.length;␊ |
| }␊ |
| ␊ |
| var tokensOut = new Array();␊ |
| for (var i = 0; i < firstPlain; ++i) {␊ |
| tokensOut.push(tokens[i]);␊ |
| }␊ |
| tokensOut.push(new PR_Token(fs.substring(0, fpos), PR_ATTRIB_VALUE));␊ |
| if (lastPlain == firstPlain) {␊ |
| tokensOut.push(new PR_Token(fs.substring(fpos, lpos), PR_PLAIN));␊ |
| } else {␊ |
| tokensOut.push(new PR_Token(fs.substring(fpos, fs.length), PR_PLAIN));␊ |
| for (var i = firstPlain + 1; i < lastPlain; ++i) {␊ |
| tokensOut.push(tokens[i]);␊ |
| }␊ |
| if (lc) {␊ |
| tokens.push(new PR_Token(ls.substring(0, lpos), PR_PLAIN));␊ |
| } else {␊ |
| tokens.push(tokens[lastPlain]);␊ |
| }␊ |
| }␊ |
| if (lc) {␊ |
| tokensOut.push(new PR_Token(ls.substring(lpos, ls.length), PR_PLAIN));␊ |
| }␊ |
| for (var i = lastPlain + 1; i < tokens.length; ++i) {␊ |
| tokensOut.push(tokens[i]);␊ |
| }␊ |
| return tokensOut;␊ |
| }␊ |
| ␊ |
| /** identify attribute values that really contain source code and recursively␊ |
| * lex them.␊ |
| * @private␊ |
| */␊ |
| function PR_splitSourceAttributes(tokens) {␊ |
| var tokensOut = new Array();␊ |
| ␊ |
| var sourceChunks = null;␊ |
| var inSource = false;␊ |
| var name = '';␊ |
| ␊ |
| for (var ci = 0, nc = tokens.length; ci < nc; ++ci) {␊ |
| var tok = tokens[ci];␊ |
| var outList = tokensOut;␊ |
| if (PR_TAG == tok.style) {␊ |
| if (inSource) {␊ |
| inSource = false;␊ |
| name = '';␊ |
| if (sourceChunks) {␊ |
| tokensOut.push(new PR_Token('<span class=embsrc>', null));␊ |
| var sourceTokens =␊ |
| PR_lexSource(PR_splitAttributeQuotes(sourceChunks));␊ |
| for (var si = 0, ns = sourceTokens.length; si < ns; ++si) {␊ |
| tokensOut.push(sourceTokens[si]);␊ |
| }␊ |
| tokensOut.push(new PR_Token('</span>', null));␊ |
| sourceChunks = null;␊ |
| }␊ |
| } else if (name && tok.token.indexOf('=') >= 0) {␊ |
| var nameLower = name.toLowerCase();␊ |
| if (PR_startsWith(nameLower, 'on') || 'style' == nameLower) {␊ |
| inSource = true;␊ |
| }␊ |
| } else {␊ |
| name = '';␊ |
| }␊ |
| } else if (PR_ATTRIB_NAME == tok.style) {␊ |
| name += tok.token;␊ |
| } else if (PR_ATTRIB_VALUE == tok.style) {␊ |
| if (inSource) {␊ |
| if (null == sourceChunks) { sourceChunks = new Array(); }␊ |
| outList = sourceChunks;␊ |
| tok = new PR_Token(tok.token, PR_PLAIN);␊ |
| }␊ |
| } else {␊ |
| if (sourceChunks) {␊ |
| outList = sourceChunks;␊ |
| }␊ |
| }␊ |
| outList.push(tok);␊ |
| }␊ |
| return tokensOut;␊ |
| }␊ |
| ␊ |
| /** returns a list of PR_Token objects given chunks of source code.␊ |
| *␊ |
| * This code assumes that < tokens are html escaped, but " are not.␊ |
| * It will do a resonable job with <, but will not recognize an "␊ |
| * as starting a string.␊ |
| *␊ |
| * This code treats ", ', and ` as string delimiters, and \ as a string escape.␊ |
| * It does not recognize double delimiter escapes, or perl's qq() style␊ |
| * strings.␊ |
| *␊ |
| * It recognizes C, C++, and shell style comments.␊ |
| *␊ |
| * @param chunks PR_Tokens with style in (null, PR_PLAIN)␊ |
| */␊ |
| function PR_lexSource(chunks) {␊ |
| // positions of ends of tokens in order␊ |
| var tokensIn = PR_splitStringAndCommentTokens(chunks);␊ |
| ␊ |
| // split entities out of so that we know to treat them as single units.␊ |
| tokensIn = PR_splitEntities(tokensIn);␊ |
| ␊ |
| // split non comment|string tokens on whitespace and word boundaries␊ |
| var tokensOut = new Array();␊ |
| for (var i = 0; i < tokensIn.length; ++i) {␊ |
| var tok = tokensIn[i];␊ |
| var t = tok.token;␊ |
| var s = tok.style;␊ |
| ␊ |
| if (PR_PLAIN == s) {␊ |
| PR_splitNonStringNonCommentToken(t, tokensOut);␊ |
| continue;␊ |
| }␊ |
| tokensOut.push(tok);␊ |
| }␊ |
| ␊ |
| return tokensOut;␊ |
| }␊ |
| ␊ |
| /** returns a list of PR_Token objects given a string of markup.␊ |
| *␊ |
| * This code assumes that < tokens are html escaped, but " are not.␊ |
| * It will do a resonable job with <, but will not recognize an "␊ |
| * as starting a string.␊ |
| *␊ |
| * This code recognizes a number of constructs.␊ |
| * <!-- ... --> comment␊ |
| * <!\w ... > declaration␊ |
| * <\w ... > tag␊ |
| * </\w ... > tag␊ |
| * <?...?> embedded source␊ |
| * &[#\w]...; entity␊ |
| *␊ |
| * It does not recognizes %foo; entities.␊ |
| *␊ |
| * It will recurse into any <style>, <script>, and on* attributes using␊ |
| * PR_lexSource.␊ |
| */␊ |
| function PR_lexMarkup(chunks) {␊ |
| // This function works as follows:␊ |
| // 1) Start by splitting the markup into text and tag chunks␊ |
| // Input: String s␊ |
| // Output: List<PR_Token> where style in (PR_PLAIN, null)␊ |
| // 2) Then split the text chunks further into comments, declarations,␊ |
| // tags, etc.␊ |
| // After each split, consider whether the token is the start of an␊ |
| // embedded source section, i.e. is an open <script> tag. If it is,␊ |
| // find the corresponding close token, and don't bother to lex in between.␊ |
| // Input: List<String>␊ |
| // Output: List<PR_Token> with style in (PR_TAG, PR_PLAIN, PR_SOURCE, null)␊ |
| // 3) Finally go over each tag token and split out attribute names and values.␊ |
| // Input: List<PR_Token>␊ |
| // Output: List<PR_Token> where style in␊ |
| // (PR_TAG, PR_PLAIN, PR_SOURCE, NAME, VALUE, null)␊ |
| var tokensOut = PR_tokenizeMarkup(chunks);␊ |
| tokensOut = PR_splitTagAttributes(tokensOut);␊ |
| tokensOut = PR_splitSourceNodes(tokensOut);␊ |
| tokensOut = PR_splitSourceAttributes(tokensOut);␊ |
| return tokensOut;␊ |
| }␊ |
| ␊ |
| /** classify the string as either source or markup and lex appropriately. */␊ |
| function PR_lexOne(s) {␊ |
| var chunks = PR_chunkify(s);␊ |
| // treat it as markup if the first non whitespace character is a < and the␊ |
| // last non-whitespace character is a >␊ |
| var isMarkup = false;␊ |
| for (var i = 0; i < chunks.length; ++i) {␊ |
| if (PR_PLAIN == chunks[i].style) {␊ |
| if (PR_startsWith(PR_trim(chunks[i].token), '<')) {␊ |
| for (var j = chunks.length; --j >= 0;) {␊ |
| if (PR_PLAIN == chunks[j].style) {␊ |
| isMarkup = PR_endsWith(PR_trim(chunks[j].token), '>');␊ |
| break;␊ |
| }␊ |
| }␊ |
| }␊ |
| break;␊ |
| }␊ |
| }␊ |
| return isMarkup ? PR_lexMarkup(chunks) : PR_lexSource(chunks);␊ |
| }␊ |
| ␊ |
| /** pretty print a chunk of code.␊ |
| *␊ |
| * @param s code as html␊ |
| * @return code as html, but prettier␊ |
| */␊ |
| function prettyPrintOne(s) {␊ |
| try {␊ |
| var tokens = PR_lexOne(s);␊ |
| var out = '';␊ |
| var lastStyle = null;␊ |
| for (var i = 0; i < tokens.length; i++) {␊ |
| var t = tokens[i];␊ |
| if (t.style != lastStyle) {␊ |
| if (lastStyle != null) {␊ |
| out += '</span>';␊ |
| }␊ |
| if (t.style != null) {␊ |
| out += '<span class=' + t.style + '>';␊ |
| }␊ |
| lastStyle = t.style;␊ |
| }␊ |
| var html = t.token;␊ |
| if (null != t.style) {␊ |
| // This interacts badly with the wiki which introduces paragraph tags␊ |
| // int pre blocks for some strange reason.␊ |
| // It's necessary for IE though which seems to lose the preformattedness␊ |
| // of <pre> tags when their innerHTML is assigned.␊ |
| html = html.replace(/(?:\r\n?)|\n/g, '<br>').replace(/ /g, ' ');␊ |
| }␊ |
| out += html;␊ |
| }␊ |
| if (lastStyle != null) {␊ |
| out += '</span>';␊ |
| }␊ |
| return out;␊ |
| } catch (e) {␊ |
| //alert(e.stack); // DISABLE in production␊ |
| return s;␊ |
| }␊ |
| }␊ |
| ␊ |
| /** find all the < pre > and < code > tags in the DOM with class=prettyprint and␊ |
| * prettify them.␊ |
| */␊ |
| function prettyPrint() {␊ |
| // fetch a list of nodes to rewrite␊ |
| var codeSegments = [␊ |
| document.getElementsByTagName('pre'),␊ |
| document.getElementsByTagName('code'),␊ |
| document.getElementsByTagName('xmp') ];␊ |
| var elements = [];␊ |
| for (var i = 0; i < codeSegments.length; ++i) {␊ |
| for (var j = 0; j < codeSegments[i].length; ++j) {␊ |
| elements.push(codeSegments[i][j]);␊ |
| }␊ |
| }␊ |
| codeSegments = null;␊ |
| ␊ |
| // the loop is broken into a series of continuations to make sure that we␊ |
| // don't make the browser unresponsive when rewriting a large page.␊ |
| var k = 0;␊ |
| ␊ |
| function doWork() {␊ |
| var endTime = new Date().getTime() + 250;␊ |
| for (; k < elements.length && new Date().getTime() < endTime; k++) {␊ |
| var cs = elements[k];␊ |
| if (cs.className && cs.className.indexOf('prettyprint') >= 0) {␊ |
| ␊ |
| // make sure this is not nested in an already prettified element␊ |
| var nested = false;␊ |
| for (var p = cs.parentNode; p != null; p = p.parentNode) {␊ |
| if ((p.tagName == 'pre' || p.tagName == 'code' ||␊ |
| p.tagName == 'xmp') &&␊ |
| p.className && p.className.indexOf('prettyprint') >= 0) {␊ |
| nested = true;␊ |
| break;␊ |
| }␊ |
| }␊ |
| if (!nested) {␊ |
| // XMP tags contain unescaped entities so require special handling.␊ |
| var isRawContent = 'XMP' == cs.tagName;␊ |
| ␊ |
| // fetch the content as a snippet of properly escaped HTML␊ |
| var content = cs.innerHTML;␊ |
| if (isRawContent) {␊ |
| content = PR_textToHtml(content);␊ |
| }␊ |
| ␊ |
| // do the pretty printing␊ |
| var newContent = prettyPrintOne(content);␊ |
| ␊ |
| // push the prettified html back into the tag.␊ |
| if (!isRawContent) {␊ |
| // just replace the old html with the new␊ |
| cs.innerHTML = newContent;␊ |
| } else {␊ |
| // we need to change the tag to a <pre> since <xmp>s do not allow␊ |
| // embedded tags such as the span tags used to attach styles to␊ |
| // sections of source code.␊ |
| var pre = document.createElement('PRE');␊ |
| for (var i = 0; i < cs.attributes.length; ++i) {␊ |
| var a = cs.attributes[i];␊ |
| if (a.specified) {␊ |
| pre.setAttribute(a.name, a.value);␊ |
| }␊ |
| }␊ |
| pre.innerHTML = newContent;␊ |
| // remove the old␊ |
| cs.parentNode.replaceChild(pre, cs);␊ |
| }␊ |
| }␊ |
| }␊ |
| }␊ |
| if (k < elements.length) {␊ |
| // finish up in a continuation␊ |
| setTimeout(doWork, 250);␊ |
| }␊ |
| }␊ |
| ␊ |
| doWork();␊ |
| }␊ |
| ␊ |
accountmanagementengine