21 | I'm sorry, but this little experiment only functions properly in 22 | Safari 4 or Chrome. 23 |
24 |25 | Try it anyway 26 |
27 |var sys = require('sys');
36 | var events = require("events"),
37 | Buffer = require('buffer').Buffer;
38 |
39 | // execute fn (in the local process), finalized by invocation of callback
40 | function execute(ctx, fn, callback) {
41 | var result;
42 | try {
43 | result = fn(ctx, callback);
44 | } catch (err) {
45 | // fn caused some trouble
46 | return callback(err);
47 | }
48 | if (result === callback || result === exports.LATER) {
49 | // fn is async and will invoke callback when done
50 | return callback;
51 | } else if (result === undefined) {
52 | // undefined (no) return value means the context is to be returned
53 | result = ctx;
54 | }
55 | callback(null, result);
56 | }
57 |
58 | exports.LATER = 1;
59 |
60 | if (!Array.prototype.map) {
61 | Array.prototype.map = function(fun /*, thisp*/) {
62 | var len = this.length >>> 0;
63 | var res = new Array(len);
64 | var thisp = arguments[1];
65 |
66 | for (var i = 0; i < len; i++) {
67 | if (i in this) {
68 | res[i] = fun.call(thisp, this[i], i, this);
69 | }
70 | }
71 | return res;
72 | };
73 | }
74 | if (!Array.prototype.filter) {
75 | Array.prototype.filter = function (block /*, thisp */) {
76 | var values = [];
77 | var thisp = arguments[1];
78 | for (var i = 0; i < this.length; i++) {
79 | if (block.call(thisp, this[i])) {
80 | values.push(this[i]);
81 | }
82 | }
83 | return values;
84 | };
85 | }
86 |
87 | [-1]{0}',
2455 | '[0]{current}',
2456 | '[1]{2}',
2457 | '' + href + " " + 2464 | 'on line ' + e.line + ', column ' + (e.column + 1) + ':
' + 2465 | template.replace(/\[(-?\d)\]/g, function (_, i) { 2466 | return (parseInt(e.line) + parseInt(i)) || ''; 2467 | }).replace(/\{(\d)\}/g, function (_, i) { 2468 | return e.extract[parseInt(i)] || ''; 2469 | }).replace(/\{current\}/, e.extract[1].slice(0, e.column) + 2470 | '' + 2471 | e.extract[1].slice(e.column) + 2472 | ''); 2473 | // CSS for error messages 2474 | createCSS([ 2475 | '.less-error-message span {', 2476 | 'margin-right: 15px;', 2477 | '}', 2478 | '.less-error-message pre {', 2479 | 'color: #ee4444;', 2480 | 'padding: 4px 0;', 2481 | 'margin: 0;', 2482 | '}', 2483 | '.less-error-message pre.ctx {', 2484 | 'color: #dd7777;', 2485 | '}', 2486 | '.less-error-message h3 {', 2487 | 'padding: 15px 0 5px 0;', 2488 | 'margin: 0;', 2489 | '}', 2490 | '.less-error-message a {', 2491 | 'color: #10a', 2492 | '}', 2493 | '.less-error-message .error {', 2494 | 'color: red;', 2495 | 'font-weight: bold;', 2496 | 'padding-bottom: 2px;', 2497 | 'border-bottom: 1px dashed red;', 2498 | '}' 2499 | ].join('\n'), { title: 'error-message' }); 2500 | 2501 | elem.style.cssText = [ 2502 | "font-family: Arial, sans-serif", 2503 | "border: 1px solid #e00", 2504 | "background-color: #eee", 2505 | "border-radius: 5px", 2506 | "-webkit-border-radius: 5px", 2507 | "-moz-border-radius: 5px", 2508 | "color: #e00", 2509 | "padding: 15px", 2510 | "margin-bottom: 15px" 2511 | ].join(';'); 2512 | 2513 | if (less.env == 'development') { 2514 | timer = setInterval(function () { 2515 | if (document.body) { 2516 | if (document.getElementById(id)) { 2517 | document.body.replaceChild(elem, document.getElementById(id)); 2518 | } else { 2519 | document.body.insertBefore(elem, document.body.firstChild); 2520 | } 2521 | clearInterval(timer); 2522 | } 2523 | }, 10); 2524 | } 2525 | } 2526 | 2527 | })(window); -------------------------------------------------------------------------------- /main.js: -------------------------------------------------------------------------------- 1 | (function(exports){ 2 | // ------------------------------------------------------------------------- 3 | // utils 4 | 5 | function prop(obj, name, getter, setter) { 6 | var m = {}; 7 | if (getter) m.get = getter; 8 | if (setter) m.set = setter; 9 | Object.defineProperty(obj, name, m); 10 | } 11 | 12 | /*function getSelectionState() { 13 | var sel = window.getSelection(); 14 | // the Selection object returned is volatile -- make a copy of its state 15 | // See https://developer.mozilla.org/en/DOM/selection for details 16 | return { 17 | anchorNode: sel.anchorNode, // the node in which the selection begins. 18 | anchorOffset: sel.anchorOffset, // number of characters that the selection's 19 | // anchor is offset within the anchorNode. 20 | focusNode: sel.focusNode, // node in which the selection ends. 21 | focusOffset: sel.focusOffset, // number of characters that the selection's 22 | // focus is offset within the focusNode. 23 | baseNode: sel.baseNode, 24 | baseOffset: sel.baseOffset, 25 | isCollapsed: sel.isCollapsed, // whether the selection's start and end 26 | // points are at the same position. 27 | type: sel.type, 28 | extentNode: sel.extentNode, 29 | extentOffset: sel.extentOffset, 30 | //rangeCount: sel.rangeCount, // number of ranges in the selection. 31 | }; 32 | }*/ 33 | 34 | if (!Array.prototype.unique) 35 | Array.prototype.unique = function () { 36 | var buf = [], value; 37 | for (var i=0,L=this.length;i20 | * 21 | * For a fairly comprehensive set of languages see the 22 | * README 23 | * file that came with this source. At a minimum, the lexer should work on a 24 | * number of languages including C and friends, Java, Python, Bash, SQL, HTML, 25 | * XML, CSS, Javascript, and Makefiles. It works passably on Ruby, PHP and Awk 26 | * and a subset of Perl, but, because of commenting conventions, doesn't work on 27 | * Smalltalk, Lisp-like, or CAML-like languages without an explicit lang class. 28 | *
29 | * Usage:
} and {@code } tags in your source with
34 | * {@code class=prettyprint.}
35 | * You can also use the (html deprecated) {@code } tag, but the pretty
36 | * printer needs to do more substantial DOM manipulations to support that, so
37 | * some css styles may not be preserved.
38 | * </ol>
39 | * That's it. I wanted to keep the API as simple as possible, so there's no
40 | * need to specify which language the code is in, but if you wish, you can add
41 | * another class to the {@code <pre>} or {@code <code>} element to specify the
42 | * language, as in {@code <pre class="prettyprint lang-java">}. Any class that
43 | * starts with "lang-" followed by a file extension, specifies the file type.
44 | * See the "lang-*.js" files in this directory for code that implements
45 | * per-language file handlers.
46 | * <p>
47 | * Change log:<br>
48 | * cbeust, 2006/08/22
49 | * <blockquote>
50 | * Java annotations (start with "@") are now captured as literals ("lit")
51 | * </blockquote>
52 | * @requires console
53 | * @overrides window
54 | */
55 |
56 | // JSLint declarations
57 | /*global console, document, navigator, setTimeout, window */
58 |
59 | /**
60 | * Split {@code prettyPrint} into multiple timeouts so as not to interfere with
61 | * UI events.
62 | * If set to {@code false}, {@code prettyPrint()} is synchronous.
63 | */
64 | window['PR_SHOULD_USE_CONTINUATION'] = true;
65 |
66 | /** the number of characters between tab columns */
67 | window['PR_TAB_WIDTH'] = 8;
68 |
69 | /** Walks the DOM returning a properly escaped version of innerHTML.
70 | * @param {Node} node
71 | * @param {Array.<string>} out output buffer that receives chunks of HTML.
72 | */
73 | window['PR_normalizedHtml']
74 |
75 | /** Contains functions for creating and registering new language handlers.
76 | * @type {Object}
77 | */
78 | = window['PR']
79 |
80 | /** Pretty print a chunk of code.
81 | *
82 | * @param {string} sourceCodeHtml code as html
83 | * @return {string} code as html, but prettier
84 | */
85 | = window['prettyPrintOne']
86 | /** Find all the {@code <pre>} and {@code <code>} tags in the DOM with
87 | * {@code class=prettyprint} and prettify them.
88 | * @param {Function?} opt_whenDone if specified, called when the last entry
89 | * has been finished.
90 | */
91 | = window['prettyPrint'] = void 0;
92 |
93 | /** browser detection. @extern @returns false if not IE, otherwise the major version. */
94 | window['_pr_isIE6'] = function () {
95 | var ieVersion = navigator && navigator.userAgent &&
96 | navigator.userAgent.match(/\bMSIE ([678])\./);
97 | ieVersion = ieVersion ? +ieVersion[1] : false;
98 | window['_pr_isIE6'] = function () { return ieVersion; };
99 | return ieVersion;
100 | };
101 |
102 |
103 | (function () {
104 | // Keyword lists for various languages.
105 | var FLOW_CONTROL_KEYWORDS =
106 | "break continue do else for if return while ";
107 | var C_KEYWORDS = FLOW_CONTROL_KEYWORDS + "auto case char const default " +
108 | "double enum extern float goto int long register short signed sizeof " +
109 | "static struct switch typedef union unsigned void volatile ";
110 | var COMMON_KEYWORDS = C_KEYWORDS + "catch class delete false import " +
111 | "new operator private protected public this throw true try typeof ";
112 | var CPP_KEYWORDS = COMMON_KEYWORDS + "alignof align_union asm axiom bool " +
113 | "concept concept_map const_cast constexpr decltype " +
114 | "dynamic_cast explicit export friend inline late_check " +
115 | "mutable namespace nullptr reinterpret_cast static_assert static_cast " +
116 | "template typeid typename using virtual wchar_t where ";
117 | var JAVA_KEYWORDS = COMMON_KEYWORDS +
118 | "abstract boolean byte extends final finally implements import " +
119 | "instanceof null native package strictfp super synchronized throws " +
120 | "transient ";
121 | var CSHARP_KEYWORDS = JAVA_KEYWORDS +
122 | "as base by checked decimal delegate descending event " +
123 | "fixed foreach from group implicit in interface internal into is lock " +
124 | "object out override orderby params partial readonly ref sbyte sealed " +
125 | "stackalloc string select uint ulong unchecked unsafe ushort var ";
126 | var JSCRIPT_KEYWORDS = COMMON_KEYWORDS +
127 | "debugger eval export function get null set undefined var with " +
128 | "Infinity NaN ";
129 | var PERL_KEYWORDS = "caller delete die do dump elsif eval exit foreach for " +
130 | "goto if import last local my next no our print package redo require " +
131 | "sub undef unless until use wantarray while BEGIN END ";
132 | var PYTHON_KEYWORDS = FLOW_CONTROL_KEYWORDS + "and as assert class def del " +
133 | "elif except exec finally from global import in is lambda " +
134 | "nonlocal not or pass print raise try with yield " +
135 | "False True None ";
136 | var RUBY_KEYWORDS = FLOW_CONTROL_KEYWORDS + "alias and begin case class def" +
137 | " defined elsif end ensure false in module next nil not or redo rescue " +
138 | "retry self super then true undef unless until when yield BEGIN END ";
139 | var SH_KEYWORDS = FLOW_CONTROL_KEYWORDS + "case done elif esac eval fi " +
140 | "function in local set then until ";
141 | var ALL_KEYWORDS = (
142 | CPP_KEYWORDS + CSHARP_KEYWORDS + JSCRIPT_KEYWORDS + PERL_KEYWORDS +
143 | PYTHON_KEYWORDS + RUBY_KEYWORDS + SH_KEYWORDS);
144 |
145 | // token style names. correspond to css classes
146 | /** token style for a string literal */
147 | var PR_STRING = 'str';
148 | /** token style for a keyword */
149 | var PR_KEYWORD = 'kwd';
150 | /** token style for a comment */
151 | var PR_COMMENT = 'com';
152 | /** token style for a type */
153 | var PR_TYPE = 'typ';
154 | /** token style for a literal value. e.g. 1, null, true. */
155 | var PR_LITERAL = 'lit';
156 | /** token style for a punctuation string. */
157 | var PR_PUNCTUATION = 'pun';
158 | /** token style for a punctuation string. */
159 | var PR_PLAIN = 'pln';
160 |
161 | /** token style for an sgml tag. */
162 | var PR_TAG = 'tag';
163 | /** token style for a markup declaration such as a DOCTYPE. */
164 | var PR_DECLARATION = 'dec';
165 | /** token style for embedded source. */
166 | var PR_SOURCE = 'src';
167 | /** token style for an sgml attribute name. */
168 | var PR_ATTRIB_NAME = 'atn';
169 | /** token style for an sgml attribute value. */
170 | var PR_ATTRIB_VALUE = 'atv';
171 |
172 | /**
173 | * A class that indicates a section of markup that is not code, e.g. to allow
174 | * embedding of line numbers within code listings.
175 | */
176 | var PR_NOCODE = 'nocode';
177 |
178 | /** A set of tokens that can precede a regular expression literal in
179 | * javascript.
180 | * http://www.mozilla.org/js/language/js20/rationale/syntax.html has the full
181 | * list, but I've removed ones that might be problematic when seen in
182 | * languages that don't support regular expression literals.
183 | *
184 | * <p>Specifically, I've removed any keywords that can't precede a regexp
185 | * literal in a syntactically legal javascript program, and I've removed the
186 | * "in" keyword since it's not a keyword in many languages, and might be used
187 | * as a count of inches.
188 | *
189 | * <p>The link a above does not accurately describe EcmaScript rules since
190 | * it fails to distinguish between (a=++/b/i) and (a++/b/i) but it works
191 | * very well in practice.
192 | *
193 | * @private
194 | */
195 | var REGEXP_PRECEDER_PATTERN = function () {
196 | var preceders = [
197 | "!", "!=", "!==", "#", "%", "%=", "&", "&&", "&&=",
198 | "&=", "(", "*", "*=", /* "+", */ "+=", ",", /* "-", */ "-=",
199 | "->", /*".", "..", "...", handled below */ "/", "/=", ":", "::", ";",
200 | "<", "<<", "<<=", "<=", "=", "==", "===", ">",
201 | ">=", ">>", ">>=", ">>>", ">>>=", "?", "@", "[",
202 | "^", "^=", "^^", "^^=", "{", "|", "|=", "||",
203 | "||=", "~" /* handles =~ and !~ */,
204 | "break", "case", "continue", "delete",
205 | "do", "else", "finally", "instanceof",
206 | "return", "throw", "try", "typeof"
207 | ];
208 | var pattern = '(?:^^|[+-]';
209 | for (var i = 0; i < preceders.length; ++i) {
210 | pattern += '|' + preceders[i].replace(/([^=<>:&a-z])/g, '\\$1');
211 | }
212 | pattern += ')\\s*'; // matches at end, and matches empty string
213 | return pattern;
214 | // CAVEAT: this does not properly handle the case where a regular
215 | // expression immediately follows another since a regular expression may
216 | // have flags for case-sensitivity and the like. Having regexp tokens
217 | // adjacent is not valid in any language I'm aware of, so I'm punting.
218 | // TODO: maybe style special characters inside a regexp as punctuation.
219 | }();
220 |
221 | // Define regexps here so that the interpreter doesn't have to create an
222 | // object each time the function containing them is called.
223 | // The language spec requires a new object created even if you don't access
224 | // the $1 members.
225 | var pr_amp = /&/g;
226 | var pr_lt = /</g;
227 | var pr_gt = />/g;
228 | var pr_quot = /\"/g;
229 | /** like textToHtml but escapes double quotes to be attribute safe. */
230 | function attribToHtml(str) {
231 | return str.replace(pr_amp, '&')
232 | .replace(pr_lt, '<')
233 | .replace(pr_gt, '>')
234 | .replace(pr_quot, '"');
235 | }
236 |
237 | /** escapest html special characters to html. */
238 | function textToHtml(str) {
239 | return str.replace(pr_amp, '&')
240 | .replace(pr_lt, '<')
241 | .replace(pr_gt, '>');
242 | }
243 |
244 |
245 | var pr_ltEnt = /</g;
246 | var pr_gtEnt = />/g;
247 | var pr_aposEnt = /'/g;
248 | var pr_quotEnt = /"/g;
249 | var pr_ampEnt = /&/g;
250 | var pr_nbspEnt = / /g;
251 | /** unescapes html to plain text. */
252 | function htmlToText(html) {
253 | var pos = html.indexOf('&');
254 | if (pos < 0) { return html; }
255 | // Handle numeric entities specially. We can't use functional substitution
256 | // since that doesn't work in older versions of Safari.
257 | // These should be rare since most browsers convert them to normal chars.
258 | for (--pos; (pos = html.indexOf('&#', pos + 1)) >= 0;) {
259 | var end = html.indexOf(';', pos);
260 | if (end >= 0) {
261 | var num = html.substring(pos + 3, end);
262 | var radix = 10;
263 | if (num && num.charAt(0) === 'x') {
264 | num = num.substring(1);
265 | radix = 16;
266 | }
267 | var codePoint = parseInt(num, radix);
268 | if (!isNaN(codePoint)) {
269 | html = (html.substring(0, pos) + String.fromCharCode(codePoint) +
270 | html.substring(end + 1));
271 | }
272 | }
273 | }
274 |
275 | return html.replace(pr_ltEnt, '<')
276 | .replace(pr_gtEnt, '>')
277 | .replace(pr_aposEnt, "'")
278 | .replace(pr_quotEnt, '"')
279 | .replace(pr_nbspEnt, ' ')
280 | .replace(pr_ampEnt, '&');
281 | }
282 |
283 | /** is the given node's innerHTML normally unescaped? */
284 | function isRawContent(node) {
285 | return 'XMP' === node.tagName;
286 | }
287 |
288 | var newlineRe = /[\r\n]/g;
289 | /**
290 | * Are newlines and adjacent spaces significant in the given node's innerHTML?
291 | */
292 | function isPreformatted(node, content) {
293 | // PRE means preformatted, and is a very common case, so don't create
294 | // unnecessary computed style objects.
295 | if ('PRE' === node.tagName) { return true; }
296 | if (!newlineRe.test(content)) { return true; } // Don't care
297 | var whitespace = '';
298 | // For disconnected nodes, IE has no currentStyle.
299 | if (node.currentStyle) {
300 | whitespace = node.currentStyle.whiteSpace;
301 | } else if (window.getComputedStyle) {
302 | // Firefox makes a best guess if node is disconnected whereas Safari
303 | // returns the empty string.
304 | whitespace = window.getComputedStyle(node, null).whiteSpace;
305 | }
306 | return !whitespace || whitespace === 'pre';
307 | }
308 |
309 | function normalizedHtml(node, out, opt_sortAttrs) {
310 | switch (node.nodeType) {
311 | case 1: // an element
312 | var name = node.tagName.toLowerCase();
313 |
314 | out.push('<', name);
315 | var attrs = node.attributes;
316 | var n = attrs.length;
317 | if (n) {
318 | if (opt_sortAttrs) {
319 | var sortedAttrs = [];
320 | for (var i = n; --i >= 0;) { sortedAttrs[i] = attrs[i]; }
321 | sortedAttrs.sort(function (a, b) {
322 | return (a.name < b.name) ? -1 : a.name === b.name ? 0 : 1;
323 | });
324 | attrs = sortedAttrs;
325 | }
326 | for (var i = 0; i < n; ++i) {
327 | var attr = attrs[i];
328 | if (!attr.specified) { continue; }
329 | out.push(' ', attr.name.toLowerCase(),
330 | '="', attribToHtml(attr.value), '"');
331 | }
332 | }
333 | out.push('>');
334 | for (var child = node.firstChild; child; child = child.nextSibling) {
335 | normalizedHtml(child, out, opt_sortAttrs);
336 | }
337 | if (node.firstChild || !/^(?:br|link|img)$/.test(name)) {
338 | out.push('<\/', name, '>');
339 | }
340 | break;
341 | case 3: case 4: // text
342 | out.push(textToHtml(node.nodeValue));
343 | break;
344 | }
345 | }
346 |
347 | /**
348 | * Given a group of {@link RegExp}s, returns a {@code RegExp} that globally
349 | * matches the union o the sets o strings matched d by the input RegExp.
350 | * Since it matches globally, if the input strings have a start-of-input
351 | * anchor (/^.../), it is ignored for the purposes of unioning.
352 | * @param {Array.<RegExp>} regexs non multiline, non-global regexs.
353 | * @return {RegExp} a global regex.
354 | */
355 | function combinePrefixPatterns(regexs) {
356 | var capturedGroupIndex = 0;
357 |
358 | var needToFoldCase = false;
359 | var ignoreCase = false;
360 | for (var i = 0, n = regexs.length; i < n; ++i) {
361 | var regex = regexs[i];
362 | if (regex.ignoreCase) {
363 | ignoreCase = true;
364 | } else if (/[a-z]/i.test(regex.source.replace(
365 | /\\u[0-9a-f]{4}|\\x[0-9a-f]{2}|\\[^ux]/gi, ''))) {
366 | needToFoldCase = true;
367 | ignoreCase = false;
368 | break;
369 | }
370 | }
371 |
372 | function decodeEscape(charsetPart) {
373 | if (charsetPart.charAt(0) !== '\\') { return charsetPart.charCodeAt(0); }
374 | switch (charsetPart.charAt(1)) {
375 | case 'b': return 8;
376 | case 't': return 9;
377 | case 'n': return 0xa;
378 | case 'v': return 0xb;
379 | case 'f': return 0xc;
380 | case 'r': return 0xd;
381 | case 'u': case 'x':
382 | return parseInt(charsetPart.substring(2), 16)
383 | || charsetPart.charCodeAt(1);
384 | case '0': case '1': case '2': case '3': case '4':
385 | case '5': case '6': case '7':
386 | return parseInt(charsetPart.substring(1), 8);
387 | default: return charsetPart.charCodeAt(1);
388 | }
389 | }
390 |
391 | function encodeEscape(charCode) {
392 | if (charCode < 0x20) {
393 | return (charCode < 0x10 ? '\\x0' : '\\x') + charCode.toString(16);
394 | }
395 | var ch = String.fromCharCode(charCode);
396 | if (ch === '\\' || ch === '-' || ch === '[' || ch === ']') {
397 | ch = '\\' + ch;
398 | }
399 | return ch;
400 | }
401 |
402 | function caseFoldCharset(charSet) {
403 | var charsetParts = charSet.substring(1, charSet.length - 1).match(
404 | new RegExp(
405 | '\\\\u[0-9A-Fa-f]{4}'
406 | + '|\\\\x[0-9A-Fa-f]{2}'
407 | + '|\\\\[0-3][0-7]{0,2}'
408 | + '|\\\\[0-7]{1,2}'
409 | + '|\\\\[\\s\\S]'
410 | + '|-'
411 | + '|[^-\\\\]',
412 | 'g'));
413 | var groups = [];
414 | var ranges = [];
415 | var inverse = charsetParts[0] === '^';
416 | for (var i = inverse ? 1 : 0, n = charsetParts.length; i < n; ++i) {
417 | var p = charsetParts[i];
418 | switch (p) {
419 | case '\\B': case '\\b':
420 | case '\\D': case '\\d':
421 | case '\\S': case '\\s':
422 | case '\\W': case '\\w':
423 | groups.push(p);
424 | continue;
425 | }
426 | var start = decodeEscape(p);
427 | var end;
428 | if (i + 2 < n && '-' === charsetParts[i + 1]) {
429 | end = decodeEscape(charsetParts[i + 2]);
430 | i += 2;
431 | } else {
432 | end = start;
433 | }
434 | ranges.push([start, end]);
435 | // If the range might intersect letters, then expand it.
436 | if (!(end < 65 || start > 122)) {
437 | if (!(end < 65 || start > 90)) {
438 | ranges.push([Math.max(65, start) | 32, Math.min(end, 90) | 32]);
439 | }
440 | if (!(end < 97 || start > 122)) {
441 | ranges.push([Math.max(97, start) & ~32, Math.min(end, 122) & ~32]);
442 | }
443 | }
444 | }
445 |
446 | // [[1, 10], [3, 4], [8, 12], [14, 14], [16, 16], [17, 17]]
447 | // -> [[1, 12], [14, 14], [16, 17]]
448 | ranges.sort(function (a, b) { return (a[0] - b[0]) || (b[1] - a[1]); });
449 | var consolidatedRanges = [];
450 | var lastRange = [NaN, NaN];
451 | for (var i = 0; i < ranges.length; ++i) {
452 | var range = ranges[i];
453 | if (range[0] <= lastRange[1] + 1) {
454 | lastRange[1] = Math.max(lastRange[1], range[1]);
455 | } else {
456 | consolidatedRanges.push(lastRange = range);
457 | }
458 | }
459 |
460 | var out = ['['];
461 | if (inverse) { out.push('^'); }
462 | out.push.apply(out, groups);
463 | for (var i = 0; i < consolidatedRanges.length; ++i) {
464 | var range = consolidatedRanges[i];
465 | out.push(encodeEscape(range[0]));
466 | if (range[1] > range[0]) {
467 | if (range[1] + 1 > range[0]) { out.push('-'); }
468 | out.push(encodeEscape(range[1]));
469 | }
470 | }
471 | out.push(']');
472 | return out.join('');
473 | }
474 |
475 | function allowAnywhereFoldCaseAndRenumberGroups(regex) {
476 | // Split into character sets, escape sequences, punctuation strings
477 | // like ('(', '(?:', ')', '^'), and runs of characters that do not
478 | // include any of the above.
479 | var parts = regex.source.match(
480 | new RegExp(
481 | '(?:'
482 | + '\\[(?:[^\\x5C\\x5D]|\\\\[\\s\\S])*\\]' // a character set
483 | + '|\\\\u[A-Fa-f0-9]{4}' // a unicode escape
484 | + '|\\\\x[A-Fa-f0-9]{2}' // a hex escape
485 | + '|\\\\[0-9]+' // a back-reference or octal escape
486 | + '|\\\\[^ux0-9]' // other escape sequence
487 | + '|\\(\\?[:!=]' // start of a non-capturing group
488 | + '|[\\(\\)\\^]' // start/emd of a group, or line start
489 | + '|[^\\x5B\\x5C\\(\\)\\^]+' // run of other characters
490 | + ')',
491 | 'g'));
492 | var n = parts.length;
493 |
494 | // Maps captured group numbers to the number they will occupy in
495 | // the output or to -1 if that has not been determined, or to
496 | // undefined if they need not be capturing in the output.
497 | var capturedGroups = [];
498 |
499 | // Walk over and identify back references to build the capturedGroups
500 | // mapping.
501 | for (var i = 0, groupIndex = 0; i < n; ++i) {
502 | var p = parts[i];
503 | if (p === '(') {
504 | // groups are 1-indexed, so max group index is count of '('
505 | ++groupIndex;
506 | } else if ('\\' === p.charAt(0)) {
507 | var decimalValue = +p.substring(1);
508 | if (decimalValue && decimalValue <= groupIndex) {
509 | capturedGroups[decimalValue] = -1;
510 | }
511 | }
512 | }
513 |
514 | // Renumber groups and reduce capturing groups to non-capturing groups
515 | // where possible.
516 | for (var i = 1; i < capturedGroups.length; ++i) {
517 | if (-1 === capturedGroups[i]) {
518 | capturedGroups[i] = ++capturedGroupIndex;
519 | }
520 | }
521 | for (var i = 0, groupIndex = 0; i < n; ++i) {
522 | var p = parts[i];
523 | if (p === '(') {
524 | ++groupIndex;
525 | if (capturedGroups[groupIndex] === undefined) {
526 | parts[i] = '(?:';
527 | }
528 | } else if ('\\' === p.charAt(0)) {
529 | var decimalValue = +p.substring(1);
530 | if (decimalValue && decimalValue <= groupIndex) {
531 | parts[i] = '\\' + capturedGroups[groupIndex];
532 | }
533 | }
534 | }
535 |
536 | // Remove any prefix anchors so that the output will match anywhere.
537 | // ^^ really does mean an anchored match though.
538 | for (var i = 0, groupIndex = 0; i < n; ++i) {
539 | if ('^' === parts[i] && '^' !== parts[i + 1]) { parts[i] = ''; }
540 | }
541 |
542 | // Expand letters to groupts to handle mixing of case-sensitive and
543 | // case-insensitive patterns if necessary.
544 | if (regex.ignoreCase && needToFoldCase) {
545 | for (var i = 0; i < n; ++i) {
546 | var p = parts[i];
547 | var ch0 = p.charAt(0);
548 | if (p.length >= 2 && ch0 === '[') {
549 | parts[i] = caseFoldCharset(p);
550 | } else if (ch0 !== '\\') {
551 | // TODO: handle letters in numeric escapes.
552 | parts[i] = p.replace(
553 | /[a-zA-Z]/g,
554 | function (ch) {
555 | var cc = ch.charCodeAt(0);
556 | return '[' + String.fromCharCode(cc & ~32, cc | 32) + ']';
557 | });
558 | }
559 | }
560 | }
561 |
562 | return parts.join('');
563 | }
564 |
565 | var rewritten = [];
566 | for (var i = 0, n = regexs.length; i < n; ++i) {
567 | var regex = regexs[i];
568 | if (regex.global || regex.multiline) { throw new Error('' + regex); }
569 | rewritten.push(
570 | '(?:' + allowAnywhereFoldCaseAndRenumberGroups(regex) + ')');
571 | }
572 |
573 | return new RegExp(rewritten.join('|'), ignoreCase ? 'gi' : 'g');
574 | }
575 |
576 | var PR_innerHtmlWorks = null;
577 | function getInnerHtml(node) {
578 | // inner html is hopelessly broken in Safari 2.0.4 when the content is
579 | // an html description of well formed XML and the containing tag is a PRE
580 | // tag, so we detect that case and emulate innerHTML.
581 | if (null === PR_innerHtmlWorks) {
582 | var testNode = document.createElement('PRE');
583 | testNode.appendChild(
584 | document.createTextNode('<!DOCTYPE foo PUBLIC "foo bar">\n<foo />'));
585 | PR_innerHtmlWorks = !/</.test(testNode.innerHTML);
586 | }
587 |
588 | if (PR_innerHtmlWorks) {
589 | var content = node.innerHTML;
590 | // XMP tags contain unescaped entities so require special handling.
591 | if (isRawContent(node)) {
592 | content = textToHtml(content);
593 | } else if (!isPreformatted(node, content)) {
594 | content = content.replace(/(<br\s*\/?>)[\r\n]+/g, '$1')
595 | .replace(/(?:[\r\n]+[ \t]*)+/g, ' ');
596 | }
597 | return content;
598 | }
599 |
600 | var out = [];
601 | for (var child = node.firstChild; child; child = child.nextSibling) {
602 | normalizedHtml(child, out);
603 | }
604 | return out.join('');
605 | }
606 |
607 | /** returns a function that expand tabs to spaces. This function can be fed
608 | * successive chunks of text, and will maintain its own internal state to
609 | * keep track of how tabs are expanded.
610 | * @return {function (string) : string} a function that takes
611 | * plain text and return the text with tabs expanded.
612 | * @private
613 | */
614 | function makeTabExpander(tabWidth) {
615 | var SPACES = ' ';
616 | var charInLine = 0;
617 |
618 | return function (plainText) {
619 | // walk over each character looking for tabs and newlines.
620 | // On tabs, expand them. On newlines, reset charInLine.
621 | // Otherwise increment charInLine
622 | var out = null;
623 | var pos = 0;
624 | for (var i = 0, n = plainText.length; i < n; ++i) {
625 | var ch = plainText.charAt(i);
626 |
627 | switch (ch) {
628 | case '\t':
629 | if (!out) { out = []; }
630 | out.push(plainText.substring(pos, i));
631 | // calculate how much space we need in front of this part
632 | // nSpaces is the amount of padding -- the number of spaces needed
633 | // to move us to the next column, where columns occur at factors of
634 | // tabWidth.
635 | var nSpaces = tabWidth - (charInLine % tabWidth);
636 | charInLine += nSpaces;
637 | for (; nSpaces >= 0; nSpaces -= SPACES.length) {
638 | out.push(SPACES.substring(0, nSpaces));
639 | }
640 | pos = i + 1;
641 | break;
642 | case '\n':
643 | charInLine = 0;
644 | break;
645 | default:
646 | ++charInLine;
647 | }
648 | }
649 | if (!out) { return plainText; }
650 | out.push(plainText.substring(pos));
651 | return out.join('');
652 | };
653 | }
654 |
655 | var pr_chunkPattern = new RegExp(
656 | '[^<]+' // A run of characters other than '<'
657 | + '|<\!--[\\s\\S]*?--\>' // an HTML comment
658 | + '|<!\\[CDATA\\[[\\s\\S]*?\\]\\]>' // a CDATA section
659 | // a probable tag that should not be highlighted
660 | + '|<\/?[a-zA-Z](?:[^>\"\']|\'[^\']*\'|\"[^\"]*\")*>'
661 | + '|<', // A '<' that does not begin a larger chunk
662 | 'g');
663 | var pr_commentPrefix = /^<\!--/;
664 | var pr_cdataPrefix = /^<!\[CDATA\[/;
665 | var pr_brPrefix = /^<br\b/i;
666 | var pr_tagNameRe = /^<(\/?)([a-zA-Z][a-zA-Z0-9]*)/;
667 |
668 | /** split markup into chunks of html tags (style null) and
669 | * plain text (style {@link #PR_PLAIN}), converting tags which are
670 | * significant for tokenization (<br>) into their textual equivalent.
671 | *
672 | * @param {string} s html where whitespace is considered significant.
673 | * @return {Object} source code and extracted tags.
674 | * @private
675 | */
676 | function extractTags(s) {
677 | // since the pattern has the 'g' modifier and defines no capturing groups,
678 | // this will return a list of all chunks which we then classify and wrap as
679 | // PR_Tokens
680 | var matches = s.match(pr_chunkPattern);
681 | var sourceBuf = [];
682 | var sourceBufLen = 0;
683 | var extractedTags = [];
684 | if (matches) {
685 | for (var i = 0, n = matches.length; i < n; ++i) {
686 | var match = matches[i];
687 | if (match.length > 1 && match.charAt(0) === '<') {
688 | if (pr_commentPrefix.test(match)) { continue; }
689 | if (pr_cdataPrefix.test(match)) {
690 | // strip CDATA prefix and suffix. Don't unescape since it's CDATA
691 | sourceBuf.push(match.substring(9, match.length - 3));
692 | sourceBufLen += match.length - 12;
693 | } else if (pr_brPrefix.test(match)) {
694 | // <br> tags are lexically significant so convert them to text.
695 | // This is undone later.
696 | sourceBuf.push('\n');
697 | ++sourceBufLen;
698 | } else {
699 | if (match.indexOf(PR_NOCODE) >= 0 && isNoCodeTag(match)) {
700 | // A <span class="nocode"> will start a section that should be
701 | // ignored. Continue walking the list until we see a matching end
702 | // tag.
703 | var name = match.match(pr_tagNameRe)[2];
704 | var depth = 1;
705 | var j;
706 | end_tag_loop:
707 | for (j = i + 1; j < n; ++j) {
708 | var name2 = matches[j].match(pr_tagNameRe);
709 | if (name2 && name2[2] === name) {
710 | if (name2[1] === '/') {
711 | if (--depth === 0) { break end_tag_loop; }
712 | } else {
713 | ++depth;
714 | }
715 | }
716 | }
717 | if (j < n) {
718 | extractedTags.push(
719 | sourceBufLen, matches.slice(i, j + 1).join(''));
720 | i = j;
721 | } else { // Ignore unclosed sections.
722 | extractedTags.push(sourceBufLen, match);
723 | }
724 | } else {
725 | extractedTags.push(sourceBufLen, match);
726 | }
727 | }
728 | } else {
729 | var literalText = htmlToText(match);
730 | sourceBuf.push(literalText);
731 | sourceBufLen += literalText.length;
732 | }
733 | }
734 | }
735 | return { source: sourceBuf.join(''), tags: extractedTags };
736 | }
737 |
738 | /** True if the given tag contains a class attribute with the nocode class. */
739 | function isNoCodeTag(tag) {
740 | return !!tag
741 | // First canonicalize the representation of attributes
742 | .replace(/\s(\w+)\s*=\s*(?:\"([^\"]*)\"|'([^\']*)'|(\S+))/g,
743 | ' $1="$2$3$4"')
744 | // Then look for the attribute we want.
745 | .match(/[cC][lL][aA][sS][sS]=\"[^\"]*\bnocode\b/);
746 | }
747 |
748 | /**
749 | * Apply the given language handler to sourceCode and add the resulting
750 | * decorations to out.
751 | * @param {number} basePos the index of sourceCode within the chunk of source
752 | * whose decorations are already present on out.
753 | */
754 | function appendDecorations(basePos, sourceCode, langHandler, out) {
755 | if (!sourceCode) { return; }
756 | var job = {
757 | source: sourceCode,
758 | basePos: basePos
759 | };
760 | langHandler(job);
761 | out.push.apply(out, job.decorations);
762 | }
763 |
764 | /** Given triples of [style, pattern, context] returns a lexing function,
765 | * The lexing function interprets the patterns to find token boundaries and
766 | * returns a decoration list of the form
767 | * [index_0, style_0, index_1, style_1, ..., index_n, style_n]
768 | * where index_n is an index into the sourceCode, and style_n is a style
769 | * constant like PR_PLAIN. index_n-1 <= index_n, and style_n-1 applies to
770 | * all characters in sourceCode[index_n-1:index_n].
771 | *
772 | * The stylePatterns is a list whose elements have the form
773 | * [style : string, pattern : RegExp, DEPRECATED, shortcut : string].
774 | *
775 | * Style is a style constant like PR_PLAIN, or can be a string of the
776 | * form 'lang-FOO', where FOO is a language extension describing the
777 | * language of the portion of the token in $1 after pattern executes.
778 | * E.g., if style is 'lang-lisp', and group 1 contains the text
779 | * '(hello (world))', then that portion of the token will be passed to the
780 | * registered lisp handler for formatting.
781 | * The text before and after group 1 will be restyled using this decorator
782 | * so decorators should take care that this doesn't result in infinite
783 | * recursion. For example, the HTML lexer rule for SCRIPT elements looks
784 | * something like ['lang-js', /<[s]cript>(.+?)<\/script>/]. This may match
785 | * '<script>foo()<\/script>', which would cause the current decorator to
786 | * be called with '<script>' which would not match the same rule since
787 | * group 1 must not be empty, so it would be instead styled as PR_TAG by
788 | * the generic tag rule. The handler registered for the 'js' extension would
789 | * then be called with 'foo()', and finally, the current decorator would
790 | * be called with '<\/script>' which would not match the original rule and
791 | * so the generic tag rule would identify it as a tag.
792 | *
793 | * Pattern must only match prefixes, and if it matches a prefix, then that
794 | * match is considered a token with the same style.
795 | *
796 | * Context is applied to the last non-whitespace, non-comment token
797 | * recognized.
798 | *
799 | * Shortcut is an optional string of characters, any of which, if the first
800 | * character, gurantee that this pattern and only this pattern matches.
801 | *
802 | * @param {Array} shortcutStylePatterns patterns that always start with
803 | * a known character. Must have a shortcut string.
804 | * @param {Array} fallthroughStylePatterns patterns that will be tried in
805 | * order if the shortcut ones fail. May have shortcuts.
806 | *
807 | * @return {function (Object)} a
808 | * function that takes source code and returns a list of decorations.
809 | */
810 | function createSimpleLexer(shortcutStylePatterns, fallthroughStylePatterns) {
811 | var shortcuts = {};
812 | var tokenizer;
813 | (function () {
814 | var allPatterns = shortcutStylePatterns.concat(fallthroughStylePatterns);
815 | var allRegexs = [];
816 | var regexKeys = {};
817 | for (var i = 0, n = allPatterns.length; i < n; ++i) {
818 | var patternParts = allPatterns[i];
819 | var shortcutChars = patternParts[3];
820 | if (shortcutChars) {
821 | for (var c = shortcutChars.length; --c >= 0;) {
822 | shortcuts[shortcutChars.charAt(c)] = patternParts;
823 | }
824 | }
825 | var regex = patternParts[1];
826 | var k = '' + regex;
827 | if (!regexKeys.hasOwnProperty(k)) {
828 | allRegexs.push(regex);
829 | regexKeys[k] = null;
830 | }
831 | }
832 | allRegexs.push(/[\0-\uffff]/);
833 | tokenizer = combinePrefixPatterns(allRegexs);
834 | })();
835 |
836 | var nPatterns = fallthroughStylePatterns.length;
837 | var notWs = /\S/;
838 |
839 | /**
840 | * Lexes job.source and produces an output array job.decorations of style
841 | * classes preceded by the position at which they start in job.source in
842 | * order.
843 | *
844 | * @param {Object} job an object like {@code
845 | * source: {string} sourceText plain text,
846 | * basePos: {int} position of job.source in the larger chunk of
847 | * sourceCode.
848 | * }
849 | */
850 | var decorate = function (job) {
851 | var sourceCode = job.source, basePos = job.basePos;
852 | /** Even entries are positions in source in ascending order. Odd enties
853 | * are style markers (e.g., PR_COMMENT) that run from that position until
854 | * the end.
855 | * @type {Array.<number|string>}
856 | */
857 | var decorations = [basePos, PR_PLAIN];
858 | var pos = 0; // index into sourceCode
859 | var tokens = sourceCode.match(tokenizer) || [];
860 | var styleCache = {};
861 |
862 | for (var ti = 0, nTokens = tokens.length; ti < nTokens; ++ti) {
863 | var token = tokens[ti];
864 | var style = styleCache[token];
865 | var match = void 0;
866 |
867 | var isEmbedded;
868 | if (typeof style === 'string') {
869 | isEmbedded = false;
870 | } else {
871 | var patternParts = shortcuts[token.charAt(0)];
872 | if (patternParts) {
873 | match = token.match(patternParts[1]);
874 | style = patternParts[0];
875 | } else {
876 | for (var i = 0; i < nPatterns; ++i) {
877 | patternParts = fallthroughStylePatterns[i];
878 | match = token.match(patternParts[1]);
879 | if (match) {
880 | style = patternParts[0];
881 | break;
882 | }
883 | }
884 |
885 | if (!match) { // make sure that we make progress
886 | style = PR_PLAIN;
887 | }
888 | }
889 |
890 | isEmbedded = style.length >= 5 && 'lang-' === style.substring(0, 5);
891 | if (isEmbedded && !(match && typeof match[1] === 'string')) {
892 | isEmbedded = false;
893 | style = PR_SOURCE;
894 | }
895 |
896 | if (!isEmbedded) { styleCache[token] = style; }
897 | }
898 |
899 | var tokenStart = pos;
900 | pos += token.length;
901 |
902 | if (!isEmbedded) {
903 | decorations.push(basePos + tokenStart, style);
904 | } else { // Treat group 1 as an embedded block of source code.
905 | var embeddedSource = match[1];
906 | var embeddedSourceStart = token.indexOf(embeddedSource);
907 | var embeddedSourceEnd = embeddedSourceStart + embeddedSource.length;
908 | if (match[2]) {
909 | // If embeddedSource can be blank, then it would match at the
910 | // beginning which would cause us to infinitely recurse on the
911 | // entire token, so we catch the right context in match[2].
912 | embeddedSourceEnd = token.length - match[2].length;
913 | embeddedSourceStart = embeddedSourceEnd - embeddedSource.length;
914 | }
915 | var lang = style.substring(5);
916 | // Decorate the left of the embedded source
917 | appendDecorations(
918 | basePos + tokenStart,
919 | token.substring(0, embeddedSourceStart),
920 | decorate, decorations);
921 | // Decorate the embedded source
922 | appendDecorations(
923 | basePos + tokenStart + embeddedSourceStart,
924 | embeddedSource,
925 | langHandlerForExtension(lang, embeddedSource),
926 | decorations);
927 | // Decorate the right of the embedded section
928 | appendDecorations(
929 | basePos + tokenStart + embeddedSourceEnd,
930 | token.substring(embeddedSourceEnd),
931 | decorate, decorations);
932 | }
933 | }
934 | job.decorations = decorations;
935 | };
936 | return decorate;
937 | }
938 |
939 | /** returns a function that produces a list of decorations from source text.
940 | *
941 | * This code treats ", ', and ` as string delimiters, and \ as a string
942 | * escape. It does not recognize perl's qq() style strings.
943 | * It has no special handling for double delimiter escapes as in basic, or
944 | * the tripled delimiters used in python, but should work on those regardless
945 | * although in those cases a single string literal may be broken up into
946 | * multiple adjacent string literals.
947 | *
948 | * It recognizes C, C++, and shell style comments.
949 | *
950 | * @param {Object} options a set of optional parameters.
951 | * @return {function (Object)} a function that examines the source code
952 | * in the input job and builds the decoration list.
953 | */
954 | function sourceDecorator(options) {
955 | var shortcutStylePatterns = [], fallthroughStylePatterns = [];
956 | if (options['tripleQuotedStrings']) {
957 | // '''multi-line-string''', 'single-line-string', and double-quoted
958 | shortcutStylePatterns.push(
959 | [PR_STRING, /^(?:\'\'\'(?:[^\'\\]|\\[\s\S]|\'{1,2}(?=[^\']))*(?:\'\'\'|$)|\"\"\"(?:[^\"\\]|\\[\s\S]|\"{1,2}(?=[^\"]))*(?:\"\"\"|$)|\'(?:[^\\\']|\\[\s\S])*(?:\'|$)|\"(?:[^\\\"]|\\[\s\S])*(?:\"|$))/,
960 | null, '\'"']);
961 | } else if (options['multiLineStrings']) {
962 | // 'multi-line-string', "multi-line-string"
963 | shortcutStylePatterns.push(
964 | [PR_STRING, /^(?:\'(?:[^\\\']|\\[\s\S])*(?:\'|$)|\"(?:[^\\\"]|\\[\s\S])*(?:\"|$)|\`(?:[^\\\`]|\\[\s\S])*(?:\`|$))/,
965 | null, '\'"`']);
966 | } else {
967 | // 'single-line-string', "single-line-string"
968 | shortcutStylePatterns.push(
969 | [PR_STRING,
970 | /^(?:\'(?:[^\\\'\r\n]|\\.)*(?:\'|$)|\"(?:[^\\\"\r\n]|\\.)*(?:\"|$))/,
971 | null, '"\'']);
972 | }
973 | if (options['verbatimStrings']) {
974 | // verbatim-string-literal production from the C# grammar. See issue 93.
975 | fallthroughStylePatterns.push(
976 | [PR_STRING, /^@\"(?:[^\"]|\"\")*(?:\"|$)/, null]);
977 | }
978 | if (options['hashComments']) {
979 | if (options['cStyleComments']) {
980 | // Stop C preprocessor declarations at an unclosed open comment
981 | shortcutStylePatterns.push(
982 | [PR_COMMENT, /^#(?:(?:define|elif|else|endif|error|ifdef|include|ifndef|line|pragma|undef|warning)\b|[^\r\n]*)/,
983 | null, '#']);
984 | fallthroughStylePatterns.push(
985 | [PR_STRING,
986 | /^<(?:(?:(?:\.\.\/)*|\/?)(?:[\w-]+(?:\/[\w-]+)+)?[\w-]+\.h|[a-z]\w*)>/,
987 | null]);
988 | } else {
989 | shortcutStylePatterns.push([PR_COMMENT, /^#[^\r\n]*/, null, '#']);
990 | }
991 | }
992 | if (options['cStyleComments']) {
993 | fallthroughStylePatterns.push([PR_COMMENT, /^\/\/[^\r\n]*/, null]);
994 | fallthroughStylePatterns.push(
995 | [PR_COMMENT, /^\/\*[\s\S]*?(?:\*\/|$)/, null]);
996 | }
997 | if (options['regexLiterals']) {
998 | var REGEX_LITERAL = (
999 | // A regular expression literal starts with a slash that is
1000 | // not followed by * or / so that it is not confused with
1001 | // comments.
1002 | '/(?=[^/*])'
1003 | // and then contains any number of raw characters,
1004 | + '(?:[^/\\x5B\\x5C]'
1005 | // escape sequences (\x5C),
1006 | + '|\\x5C[\\s\\S]'
1007 | // or non-nesting character sets (\x5B\x5D);
1008 | + '|\\x5B(?:[^\\x5C\\x5D]|\\x5C[\\s\\S])*(?:\\x5D|$))+'
1009 | // finally closed by a /.
1010 | + '/');
1011 | fallthroughStylePatterns.push(
1012 | ['lang-regex',
1013 | new RegExp('^' + REGEXP_PRECEDER_PATTERN + '(' + REGEX_LITERAL + ')')
1014 | ]);
1015 | }
1016 |
1017 | var keywords = options['keywords'].replace(/^\s+|\s+$/g, '');
1018 | if (keywords.length) {
1019 | fallthroughStylePatterns.push(
1020 | [PR_KEYWORD,
1021 | new RegExp('^(?:' + keywords.replace(/\s+/g, '|') + ')\\b'), null]);
1022 | }
1023 |
1024 | shortcutStylePatterns.push([PR_PLAIN, /^\s+/, null, ' \r\n\t\xA0']);
1025 | fallthroughStylePatterns.push(
1026 | // TODO(mikesamuel): recognize non-latin letters and numerals in idents
1027 | [PR_LITERAL, /^@[a-z_$][a-z_$@0-9]*/i, null],
1028 | [PR_TYPE, /^@?[A-Z]+[a-z][A-Za-z_$@0-9]*/, null],
1029 | [PR_PLAIN, /^[a-z_$][a-z_$@0-9]*/i, null],
1030 | [PR_LITERAL,
1031 | new RegExp(
1032 | '^(?:'
1033 | // A hex number
1034 | + '0x[a-f0-9]+'
1035 | // or an octal or decimal number,
1036 | + '|(?:\\d(?:_\\d+)*\\d*(?:\\.\\d*)?|\\.\\d\\+)'
1037 | // possibly in scientific notation
1038 | + '(?:e[+\\-]?\\d+)?'
1039 | + ')'
1040 | // with an optional modifier like UL for unsigned long
1041 | + '[a-z]*', 'i'),
1042 | null, '0123456789'],
1043 | [PR_PUNCTUATION, /^.[^\s\w\.$@\'\"\`\/\#]*/, null]);
1044 |
1045 | return createSimpleLexer(shortcutStylePatterns, fallthroughStylePatterns);
1046 | }
1047 |
1048 | var decorateSource = sourceDecorator({
1049 | 'keywords': ALL_KEYWORDS,
1050 | 'hashComments': true,
1051 | 'cStyleComments': true,
1052 | 'multiLineStrings': true,
1053 | 'regexLiterals': true
1054 | });
1055 |
1056 | /** Breaks {@code job.source} around style boundaries in
1057 | * {@code job.decorations} while re-interleaving {@code job.extractedTags},
1058 | * and leaves the result in {@code job.prettyPrintedHtml}.
1059 | * @param {Object} job like {
1060 | * source: {string} source as plain text,
1061 | * extractedTags: {Array.<number|string>} extractedTags chunks of raw
1062 | * html preceded by their position in {@code job.source}
1063 | * in order
1064 | * decorations: {Array.<number|string} an array of style classes preceded
1065 | * by the position at which they start in job.source in order
1066 | * }
1067 | * @private
1068 | */
1069 | function recombineTagsAndDecorations(job) {
1070 | var sourceText = job.source;
1071 | var extractedTags = job.extractedTags;
1072 | var decorations = job.decorations;
1073 |
1074 | var html = [];
1075 | // index past the last char in sourceText written to html
1076 | var outputIdx = 0;
1077 |
1078 | var openDecoration = null;
1079 | var currentDecoration = null;
1080 | var tagPos = 0; // index into extractedTags
1081 | var decPos = 0; // index into decorations
1082 | var tabExpander = makeTabExpander(window['PR_TAB_WIDTH']);
1083 |
1084 | var adjacentSpaceRe = /([\r\n ]) /g;
1085 | var startOrSpaceRe = /(^| ) /gm;
1086 | var newlineRe = /\r\n?|\n/g;
1087 | var trailingSpaceRe = /[ \r\n]$/;
1088 | var lastWasSpace = true; // the last text chunk emitted ended with a space.
1089 |
1090 | // See bug 71 and http://stackoverflow.com/questions/136443/why-doesnt-ie7-
1091 | var isIE678 = window['_pr_isIE6']();
1092 | var lineBreakHtml = (
1093 | isIE678
1094 | ? (job.sourceNode.tagName === 'PRE'
1095 | // Use line feeds instead of <br>s so that copying and pasting works
1096 | // on IE.
1097 | // Doing this on other browsers breaks lots of stuff since \r\n is
1098 | // treated as two newlines on Firefox.
1099 | ? (isIE678 === 6 ? ' \r\n' :
1100 | isIE678 === 7 ? ' <br>\r' : ' \r')
1101 | // IE collapses multiple adjacent <br>s into 1 line break.
1102 | // Prefix every newline with ' ' to prevent such behavior.
1103 | // is the same as   but works in XML as well as HTML.
1104 | : ' <br />')
1105 | : '<br />');
1106 |
1107 | // Look for a class like linenums or linenums:<n> where <n> is the 1-indexed
1108 | // number of the first line.
1109 | var numberLines = job.sourceNode.className.match(/\blinenums\b(?::(\d+))?/);
1110 | var lineBreaker;
1111 | if (numberLines) {
1112 | var lineBreaks = [];
1113 | for (var i = 0; i < 10; ++i) {
1114 | lineBreaks[i] = lineBreakHtml + '</li><li class="L' + i + '">';
1115 | }
1116 | var lineNum = numberLines[1] && numberLines[1].length
1117 | ? numberLines[1] - 1 : 0; // Lines are 1-indexed
1118 | html.push('<ol class="linenums"><li class="L', (lineNum) % 10, '"');
1119 | if (lineNum) {
1120 | html.push(' value="', lineNum + 1, '"');
1121 | }
1122 | html.push('>');
1123 | lineBreaker = function () {
1124 | var lb = lineBreaks[++lineNum % 10];
1125 | // If a decoration is open, we need to close it before closing a list-item
1126 | // and reopen it on the other side of the list item.
1127 | return openDecoration
1128 | ? ('</span>' + lb + '<span class="' + openDecoration + '">') : lb;
1129 | };
1130 | } else {
1131 | lineBreaker = lineBreakHtml;
1132 | }
1133 |
1134 | // A helper function that is responsible for opening sections of decoration
1135 | // and outputing properly escaped chunks of source
1136 | function emitTextUpTo(sourceIdx) {
1137 | if (sourceIdx > outputIdx) {
1138 | if (openDecoration && openDecoration !== currentDecoration) {
1139 | // Close the current decoration
1140 | html.push('</span>');
1141 | openDecoration = null;
1142 | }
1143 | if (!openDecoration && currentDecoration) {
1144 | openDecoration = currentDecoration;
1145 | html.push('<span class="', openDecoration, '">');
1146 | }
1147 | // This interacts badly with some wikis which introduces paragraph tags
1148 | // into pre blocks for some strange reason.
1149 | // It's necessary for IE though which seems to lose the preformattedness
1150 | // of <pre> tags when their innerHTML is assigned.
1151 | // http://stud3.tuwien.ac.at/~e0226430/innerHtmlQuirk.html
1152 | // and it serves to undo the conversion of <br>s to newlines done in
1153 | // chunkify.
1154 | var htmlChunk = textToHtml(
1155 | tabExpander(sourceText.substring(outputIdx, sourceIdx)))
1156 | .replace(lastWasSpace
1157 | ? startOrSpaceRe
1158 | : adjacentSpaceRe, '$1 ');
1159 | // Keep track of whether we need to escape space at the beginning of the
1160 | // next chunk.
1161 | lastWasSpace = trailingSpaceRe.test(htmlChunk);
1162 | html.push(htmlChunk.replace(newlineRe, lineBreaker));
1163 | outputIdx = sourceIdx;
1164 | }
1165 | }
1166 |
1167 | while (true) {
1168 | // Determine if we're going to consume a tag this time around. Otherwise
1169 | // we consume a decoration or exit.
1170 | var outputTag;
1171 | if (tagPos < extractedTags.length) {
1172 | if (decPos < decorations.length) {
1173 | // Pick one giving preference to extractedTags since we shouldn't open
1174 | // a new style that we're going to have to immediately close in order
1175 | // to output a tag.
1176 | outputTag = extractedTags[tagPos] <= decorations[decPos];
1177 | } else {
1178 | outputTag = true;
1179 | }
1180 | } else {
1181 | outputTag = false;
1182 | }
1183 | // Consume either a decoration or a tag or exit.
1184 | if (outputTag) {
1185 | emitTextUpTo(extractedTags[tagPos]);
1186 | if (openDecoration) {
1187 | // Close the current decoration
1188 | html.push('</span>');
1189 | openDecoration = null;
1190 | }
1191 | html.push(extractedTags[tagPos + 1]);
1192 | tagPos += 2;
1193 | } else if (decPos < decorations.length) {
1194 | emitTextUpTo(decorations[decPos]);
1195 | currentDecoration = decorations[decPos + 1];
1196 | decPos += 2;
1197 | } else {
1198 | break;
1199 | }
1200 | }
1201 | emitTextUpTo(sourceText.length);
1202 | if (openDecoration) {
1203 | html.push('</span>');
1204 | }
1205 | if (numberLines) { html.push('</li></ol>'); }
1206 | job.prettyPrintedHtml = html.join('');
1207 | }
1208 |
1209 | /** Maps language-specific file extensions to handlers. */
1210 | var langHandlerRegistry = {};
1211 | /** Register a language handler for the given file extensions.
1212 | * @param {function (Object)} handler a function from source code to a list
1213 | * of decorations. Takes a single argument job which describes the
1214 | * state of the computation. The single parameter has the form
1215 | * {@code {
1216 | * source: {string} as plain text.
1217 | * decorations: {Array.<number|string>} an array of style classes
1218 | * preceded by the position at which they start in
1219 | * job.source in order.
1220 | * The language handler should assigned this field.
1221 | * basePos: {int} the position of source in the larger source chunk.
1222 | * All positions in the output decorations array are relative
1223 | * to the larger source chunk.
1224 | * } }
1225 | * @param {Array.<string>} fileExtensions
1226 | */
1227 | function registerLangHandler(handler, fileExtensions) {
1228 | for (var i = fileExtensions.length; --i >= 0;) {
1229 | var ext = fileExtensions[i];
1230 | if (!langHandlerRegistry.hasOwnProperty(ext)) {
1231 | langHandlerRegistry[ext] = handler;
1232 | } else if ('console' in window) {
1233 | console['warn']('cannot override language handler %s', ext);
1234 | }
1235 | }
1236 | }
1237 | function langHandlerForExtension(extension, source) {
1238 | if (!(extension && langHandlerRegistry.hasOwnProperty(extension))) {
1239 | // Treat it as markup if the first non whitespace character is a < and
1240 | // the last non-whitespace character is a >.
1241 | extension = /^\s*</.test(source)
1242 | ? 'default-markup'
1243 | : 'default-code';
1244 | }
1245 | return langHandlerRegistry[extension];
1246 | }
1247 | registerLangHandler(decorateSource, ['default-code']);
1248 | registerLangHandler(
1249 | createSimpleLexer(
1250 | [],
1251 | [
1252 | [PR_PLAIN, /^[^<?]+/],
1253 | [PR_DECLARATION, /^<!\w[^>]*(?:>|$)/],
1254 | [PR_COMMENT, /^<\!--[\s\S]*?(?:-\->|$)/],
1255 | // Unescaped content in an unknown language
1256 | ['lang-', /^<\?([\s\S]+?)(?:\?>|$)/],
1257 | ['lang-', /^<%([\s\S]+?)(?:%>|$)/],
1258 | [PR_PUNCTUATION, /^(?:<[%?]|[%?]>)/],
1259 | ['lang-', /^<xmp\b[^>]*>([\s\S]+?)<\/xmp\b[^>]*>/i],
1260 | // Unescaped content in javascript. (Or possibly vbscript).
1261 | ['lang-js', /^<script\b[^>]*>([\s\S]*?)(<\/script\b[^>]*>)/i],
1262 | // Contains unescaped stylesheet content
1263 | ['lang-css', /^<style\b[^>]*>([\s\S]*?)(<\/style\b[^>]*>)/i],
1264 | ['lang-in.tag', /^(<\/?[a-z][^<>]*>)/i]
1265 | ]),
1266 | ['default-markup', 'htm', 'html', 'mxml', 'xhtml', 'xml', 'xsl']);
1267 | registerLangHandler(
1268 | createSimpleLexer(
1269 | [
1270 | [PR_PLAIN, /^[\s]+/, null, ' \t\r\n'],
1271 | [PR_ATTRIB_VALUE, /^(?:\"[^\"]*\"?|\'[^\']*\'?)/, null, '\"\'']
1272 | ],
1273 | [
1274 | [PR_TAG, /^^<\/?[a-z](?:[\w.:-]*\w)?|\/?>$/i],
1275 | [PR_ATTRIB_NAME, /^(?!style[\s=]|on)[a-z](?:[\w:-]*\w)?/i],
1276 | ['lang-uq.val', /^=\s*([^>\'\"\s]*(?:[^>\'\"\s\/]|\/(?=\s)))/],
1277 | [PR_PUNCTUATION, /^[=<>\/]+/],
1278 | ['lang-js', /^on\w+\s*=\s*\"([^\"]+)\"/i],
1279 | ['lang-js', /^on\w+\s*=\s*\'([^\']+)\'/i],
1280 | ['lang-js', /^on\w+\s*=\s*([^\"\'>\s]+)/i],
1281 | ['lang-css', /^style\s*=\s*\"([^\"]+)\"/i],
1282 | ['lang-css', /^style\s*=\s*\'([^\']+)\'/i],
1283 | ['lang-css', /^style\s*=\s*([^\"\'>\s]+)/i]
1284 | ]),
1285 | ['in.tag']);
1286 | registerLangHandler(
1287 | createSimpleLexer([], [[PR_ATTRIB_VALUE, /^[\s\S]+/]]), ['uq.val']);
1288 | registerLangHandler(sourceDecorator({
1289 | 'keywords': CPP_KEYWORDS,
1290 | 'hashComments': true,
1291 | 'cStyleComments': true
1292 | }), ['c', 'cc', 'cpp', 'cxx', 'cyc', 'm']);
1293 | registerLangHandler(sourceDecorator({
1294 | 'keywords': 'null true false'
1295 | }), ['json']);
1296 | registerLangHandler(sourceDecorator({
1297 | 'keywords': CSHARP_KEYWORDS,
1298 | 'hashComments': true,
1299 | 'cStyleComments': true,
1300 | 'verbatimStrings': true
1301 | }), ['cs']);
1302 | registerLangHandler(sourceDecorator({
1303 | 'keywords': JAVA_KEYWORDS,
1304 | 'cStyleComments': true
1305 | }), ['java']);
1306 | registerLangHandler(sourceDecorator({
1307 | 'keywords': SH_KEYWORDS,
1308 | 'hashComments': true,
1309 | 'multiLineStrings': true
1310 | }), ['bsh', 'csh', 'sh']);
1311 | registerLangHandler(sourceDecorator({
1312 | 'keywords': PYTHON_KEYWORDS,
1313 | 'hashComments': true,
1314 | 'multiLineStrings': true,
1315 | 'tripleQuotedStrings': true
1316 | }), ['cv', 'py']);
1317 | registerLangHandler(sourceDecorator({
1318 | 'keywords': PERL_KEYWORDS,
1319 | 'hashComments': true,
1320 | 'multiLineStrings': true,
1321 | 'regexLiterals': true
1322 | }), ['perl', 'pl', 'pm']);
1323 | registerLangHandler(sourceDecorator({
1324 | 'keywords': RUBY_KEYWORDS,
1325 | 'hashComments': true,
1326 | 'multiLineStrings': true,
1327 | 'regexLiterals': true
1328 | }), ['rb']);
1329 | registerLangHandler(sourceDecorator({
1330 | 'keywords': JSCRIPT_KEYWORDS,
1331 | 'cStyleComments': true,
1332 | 'regexLiterals': true
1333 | }), ['js']);
1334 | registerLangHandler(
1335 | createSimpleLexer([], [[PR_STRING, /^[\s\S]+/]]), ['regex']);
1336 |
1337 | function applyDecorator(job) {
1338 | var sourceCodeHtml = job.sourceCodeHtml;
1339 | var opt_langExtension = job.langExtension;
1340 |
1341 | // Prepopulate output in case processing fails with an exception.
1342 | job.prettyPrintedHtml = sourceCodeHtml;
1343 |
1344 | try {
1345 | // Extract tags, and convert the source code to plain text.
1346 | var sourceAndExtractedTags = extractTags(sourceCodeHtml);
1347 | /** Plain text. @type {string} */
1348 | var source = sourceAndExtractedTags.source;
1349 | job.source = source;
1350 | job.basePos = 0;
1351 |
1352 | /** Even entries are positions in source in ascending order. Odd entries
1353 | * are tags that were extracted at that position.
1354 | * @type {Array.<number|string>}
1355 | */
1356 | job.extractedTags = sourceAndExtractedTags.tags;
1357 |
1358 | // Apply the appropriate language handler
1359 | langHandlerForExtension(opt_langExtension, source)(job);
1360 | // Integrate the decorations and tags back into the source code to produce
1361 | // a decorated html string which is left in job.prettyPrintedHtml.
1362 | recombineTagsAndDecorations(job);
1363 | } catch (e) {
1364 | if ('console' in window) {
1365 | console['log'](e && e['stack'] ? e['stack'] : e);
1366 | }
1367 | }
1368 | }
1369 |
1370 | function prettyPrintOne(sourceCodeHtml, opt_langExtension) {
1371 | var job = {
1372 | sourceCodeHtml: sourceCodeHtml,
1373 | langExtension: opt_langExtension
1374 | };
1375 | applyDecorator(job);
1376 | return job.prettyPrintedHtml;
1377 | }
1378 |
1379 | function prettyPrint(opt_whenDone) {
1380 | // fetch a list of nodes to rewrite
1381 | var codeSegments = [
1382 | document.getElementsByTagName('pre'),
1383 | document.getElementsByTagName('code'),
1384 | document.getElementsByTagName('xmp') ];
1385 | var elements = [];
1386 | for (var i = 0; i < codeSegments.length; ++i) {
1387 | for (var j = 0, n = codeSegments[i].length; j < n; ++j) {
1388 | elements.push(codeSegments[i][j]);
1389 | }
1390 | }
1391 | codeSegments = null;
1392 |
1393 | var clock = Date;
1394 | if (!clock['now']) {
1395 | clock = { 'now': function () { return (new Date).getTime(); } };
1396 | }
1397 |
1398 | // The loop is broken into a series of continuations to make sure that we
1399 | // don't make the browser unresponsive when rewriting a large page.
1400 | var k = 0;
1401 | var prettyPrintingJob;
1402 |
1403 | function doWork() {
1404 | var endTime = (window['PR_SHOULD_USE_CONTINUATION'] ?
1405 | clock.now() + 250 /* ms */ :
1406 | Infinity);
1407 | for (; k < elements.length && clock.now() < endTime; k++) {
1408 | var cs = elements[k];
1409 | if (cs.className && cs.className.indexOf('prettyprint') >= 0) {
1410 | // If the classes includes a language extensions, use it.
1411 | // Language extensions can be specified like
1412 | // <pre class="prettyprint lang-cpp">
1413 | // the language extension "cpp" is used to find a language handler as
1414 | // passed to PR_registerLangHandler.
1415 | var langExtension = cs.className.match(/\blang-(\w+)\b/);
1416 | if (langExtension) { langExtension = langExtension[1]; }
1417 |
1418 | // make sure this is not nested in an already prettified element
1419 | var nested = false;
1420 | for (var p = cs.parentNode; p; p = p.parentNode) {
1421 | if ((p.tagName === 'pre' || p.tagName === 'code' ||
1422 | p.tagName === 'xmp') &&
1423 | p.className && p.className.indexOf('prettyprint') >= 0) {
1424 | nested = true;
1425 | break;
1426 | }
1427 | }
1428 | if (!nested) {
1429 | // fetch the content as a snippet of properly escaped HTML.
1430 | // Firefox adds newlines at the end.
1431 | var content = getInnerHtml(cs);
1432 | content = content.replace(/(?:\r\n?|\n)$/, '');
1433 |
1434 | // do the pretty printing
1435 | prettyPrintingJob = {
1436 | sourceCodeHtml: content,
1437 | langExtension: langExtension,
1438 | sourceNode: cs
1439 | };
1440 | applyDecorator(prettyPrintingJob);
1441 | replaceWithPrettyPrintedHtml();
1442 | }
1443 | }
1444 | }
1445 | if (k < elements.length) {
1446 | // finish up in a continuation
1447 | setTimeout(doWork, 250);
1448 | } else if (opt_whenDone) {
1449 | opt_whenDone();
1450 | }
1451 | }
1452 |
1453 | function replaceWithPrettyPrintedHtml() {
1454 | var newContent = prettyPrintingJob.prettyPrintedHtml;
1455 | if (!newContent) { return; }
1456 | var cs = prettyPrintingJob.sourceNode;
1457 |
1458 | // push the prettified html back into the tag.
1459 | if (!isRawContent(cs)) {
1460 | // just replace the old html with the new
1461 | cs.innerHTML = newContent;
1462 | } else {
1463 | // we need to change the tag to a <pre> since <xmp>s do not allow
1464 | // embedded tags such as the span tags used to attach styles to
1465 | // sections of source code.
1466 | var pre = document.createElement('PRE');
1467 | for (var i = 0; i < cs.attributes.length; ++i) {
1468 | var a = cs.attributes[i];
1469 | if (a.specified) {
1470 | var aname = a.name.toLowerCase();
1471 | if (aname === 'class') {
1472 | pre.className = a.value; // For IE 6
1473 | } else {
1474 | pre.setAttribute(a.name, a.value);
1475 | }
1476 | }
1477 | }
1478 | pre.innerHTML = newContent;
1479 |
1480 | // remove the old
1481 | cs.parentNode.replaceChild(pre, cs);
1482 | cs = pre;
1483 | }
1484 | }
1485 |
1486 | doWork();
1487 | }
1488 |
1489 | window['PR_normalizedHtml'] = normalizedHtml;
1490 | window['prettyPrintOne'] = prettyPrintOne;
1491 | window['prettyPrint'] = prettyPrint;
1492 | window['PR'] = {
1493 | 'combinePrefixPatterns': combinePrefixPatterns,
1494 | 'createSimpleLexer': createSimpleLexer,
1495 | 'registerLangHandler': registerLangHandler,
1496 | 'sourceDecorator': sourceDecorator,
1497 | 'PR_ATTRIB_NAME': PR_ATTRIB_NAME,
1498 | 'PR_ATTRIB_VALUE': PR_ATTRIB_VALUE,
1499 | 'PR_COMMENT': PR_COMMENT,
1500 | 'PR_DECLARATION': PR_DECLARATION,
1501 | 'PR_KEYWORD': PR_KEYWORD,
1502 | 'PR_LITERAL': PR_LITERAL,
1503 | 'PR_NOCODE': PR_NOCODE,
1504 | 'PR_PLAIN': PR_PLAIN,
1505 | 'PR_PUNCTUATION': PR_PUNCTUATION,
1506 | 'PR_SOURCE': PR_SOURCE,
1507 | 'PR_STRING': PR_STRING,
1508 | 'PR_TAG': PR_TAG,
1509 | 'PR_TYPE': PR_TYPE
1510 | };
1511 | })();
1512 |
--------------------------------------------------------------------------------