fz

  1/**//*
  2Syntax highlighting with language autodetection.
  3http://softwaremaniacs.org/soft/highlight/
  4*/
  5
  6var hljs = new function() {
  7var LANGUAGES = {}
  8var selected_languages = {};
  9
 10function escape(value) {
 11return value.replace(/&/gm, '&amp;').replace(/</gm, '&lt;').replace(/>/gm, '&gt;');
 12}
 13
 14function contains(array, item) {
 15if (!array)
 16return false;
 17for (var i = 0; i < array.length; i++)
 18if (array[i] == item)
 19return true;
 20return false;
 21}
 22
 23function highlight(language_name, value) {
 24function compileSubModes(mode, language) {
 25mode.sub_modes = [];
 26for (var i = 0; i < mode.contains.length; i++) {
 27for (var j = 0; j < language.modes.length; j++) {
 28if (language.modes[j].className == mode.contains[i]) {
 29mode.sub_modes[mode.sub_modes.length] = language.modes[j];
 30}
 31}
 32}
 33}
 34
 35function subMode(lexem, mode) {
 36if (!mode.contains) {
 37return null;
 38}
 39if (!mode.sub_modes) {
 40compileSubModes(mode, language);
 41}
 42for (var i = 0; i < mode.sub_modes.length; i++) {
 43if (mode.sub_modes[i].beginRe.test(lexem)) {
 44return mode.sub_modes[i];
 45}
 46}
 47return null;
 48}
 49
 50function endOfMode(mode_index, lexem) {
 51if (modes[mode_index].end && modes[mode_index].endRe.test(lexem))
 52return 1;
 53if (modes[mode_index].endsWithParent) {
 54var level = endOfMode(mode_index - 1, lexem);
 55return level ? level + 1 : 0;
 56}
 57return 0;
 58}
 59
 60function isIllegal(lexem, mode) {
 61return mode.illegalRe && mode.illegalRe.test(lexem);
 62}
 63
 64function compileTerminators(mode, language) {
 65var terminators = [];
 66
 67function addTerminator(re) {
 68if (!contains(terminators, re)) {
 69terminators[terminators.length] = re;
 70}
 71}
 72
 73if (mode.contains)
 74for (var i = 0; i < language.modes.length; i++) {
 75if (contains(mode.contains, language.modes[i].className)) {
 76addTerminator(language.modes[i].begin);
 77}
 78}
 79
 80var index = modes.length - 1;
 81do {
 82if (modes[index].end) {
 83addTerminator(modes[index].end);
 84}
 85index--;
 86} while (modes[index + 1].endsWithParent);
 87
 88if (mode.illegal) {
 89addTerminator(mode.illegal);
 90}
 91
 92var terminator_re = '(' + terminators[0];
 93for (var i = 0; i < terminators.length; i++)
 94terminator_re += '|' + terminators[i];
 95terminator_re += ')';
 96return langRe(language, terminator_re);
 97}
 98
 99function eatModeChunk(value, index) {
100var mode = modes[modes.length - 1];
101if (!mode.terminators) {
102mode.terminators = compileTerminators(mode, language);
103}
104value = value.substr(index);
105var match = mode.terminators.exec(value);
106if (!match)
107return [value, '', true];
108if (match.index == 0)
109return ['', match[0], false];
110else
111return [value.substr(0, match.index), match[0], false];
112}
113
114function keywordMatch(mode, match) {
115var match_str = language.case_insensitive ? match[0].toLowerCase() : match[0]
116for (var className in mode.keywordGroups) {
117if (!mode.keywordGroups.hasOwnProperty(className))
118continue;
119var value = mode.keywordGroups[className].hasOwnProperty(match_str);
120if (value)
121return [className, value];
122}
123return false;
124}
125
126function processKeywords(buffer, mode) {
127if (!mode.keywords || !mode.lexems)
128return escape(buffer);
129if (!mode.lexemsRe) {
130var lexems_re = '(' + mode.lexems[0];
131for (var i = 1; i < mode.lexems.length; i++)
132lexems_re += '|' + mode.lexems[i];
133lexems_re += ')';
134mode.lexemsRe = langRe(language, lexems_re, true);
135}
136var result = '';
137var last_index = 0;
138mode.lexemsRe.lastIndex = 0;
139var match = mode.lexemsRe.exec(buffer);
140while (match) {
141result += escape(buffer.substr(last_index, match.index - last_index));
142var keyword_match = keywordMatch(mode, match);
143if (keyword_match) {
144keyword_count += keyword_match[1];
145result += '<span class="'+ keyword_match[0] +'">' + escape(match[0]) + '</span>';
146} else {
147result += escape(match[0]);
148}
149last_index = mode.lexemsRe.lastIndex;
150match = mode.lexemsRe.exec(buffer);
151}
152result += escape(buffer.substr(last_index, buffer.length - last_index));
153return result;
154}
155
156function processBuffer(buffer, mode) {
157if (mode.subLanguage && selected_languages[mode.subLanguage]) {
158var result = highlight(mode.subLanguage, buffer);
159keyword_count += result.keyword_count;
160relevance += result.relevance;
161return result.value;
162} else {
163return processKeywords(buffer, mode);
164}
165}
166
167function startNewMode(mode, lexem) {
168var markup = mode.noMarkup?'':'<span class="' + mode.className + '">';
169if (mode.returnBegin) {
170result += markup;
171mode.buffer = '';
172} else if (mode.excludeBegin) {
173result += escape(lexem) + markup;
174mode.buffer = '';
175} else {
176result += markup;
177mode.buffer = lexem;
178}
179modes[modes.length] = mode;
180}
181
182function processModeInfo(buffer, lexem, end) {
183var current_mode = modes[modes.length - 1];
184if (end) {
185result += processBuffer(current_mode.buffer + buffer, current_mode);
186return false;
187}
188
189var new_mode = subMode(lexem, current_mode);
190if (new_mode) {
191result += processBuffer(current_mode.buffer + buffer, current_mode);
192startNewMode(new_mode, lexem);
193relevance += new_mode.relevance;
194return new_mode.returnBegin;
195}
196
197var end_level = endOfMode(modes.length - 1, lexem);
198if (end_level) {
199var markup = current_mode.noMarkup?'':'</span>';
200if (current_mode.returnEnd) {
201result += processBuffer(current_mode.buffer + buffer, current_mode) + markup;
202} else if (current_mode.excludeEnd) {
203result += processBuffer(current_mode.buffer + buffer, current_mode) + markup + escape(lexem);
204} else {
205result += processBuffer(current_mode.buffer + buffer + lexem, current_mode) + markup;
206}
207while (end_level > 1) {
208markup = modes[modes.length - 2].noMarkup?'':'</span>';
209result += markup;
210end_level--;
211modes.length--;
212}
213modes.length--;
214modes[modes.length - 1].buffer = '';
215if (current_mode.starts) {
216for (var i = 0; i < language.modes.length; i++) {
217if (language.modes[i].className == current_mode.starts) {
218startNewMode(language.modes[i], '');
219break;
220}
221}
222}
223return current_mode.returnEnd;
224}
225
226if (isIllegal(lexem, current_mode))
227throw 'Illegal';
228}
229
230var language = LANGUAGES[language_name];
231var modes = [language.defaultMode];
232var relevance = 0;
233var keyword_count = 0;
234var result = '';
235try {
236var index = 0;
237language.defaultMode.buffer = '';
238do {
239var mode_info = eatModeChunk(value, index);
240var return_lexem = processModeInfo(mode_info[0], mode_info[1], mode_info[2]);
241index += mode_info[0].length;
242if (!return_lexem) {
243index += mode_info[1].length;
244}
245} while (!mode_info[2]);
246if(modes.length > 1)
247throw 'Illegal';
248return {
249relevance: relevance,
250keyword_count: keyword_count,
251value: result
252}
253} catch (e) {
254if (e == 'Illegal') {
255return {
256relevance: 0,
257keyword_count: 0,
258value: escape(value)
259}
260} else {
261throw e;
262}
263}
264}
265
266function blockText(block) {
267var result = '';
268for (var i = 0; i < block.childNodes.length; i++)
269if (block.childNodes[i].nodeType == 3)
270result += block.childNodes[i].nodeValue;
271else if (block.childNodes[i].nodeName == 'BR')
272result += 'n';
273else
274result += blockText(block.childNodes[i]);
275return result;
276}
277
278function blockLanguage(block) {
279var classes = block.className.split(/s+/)
280classes = classes.concat(block.parentNode.className.split(/s+/));
281for (var i = 0; i < classes.length; i++) {
282var class_ = classes[i].replace(/^language-/, '');
283if (class_ == 'no-highlight') {
284throw 'No highlight'
285}
286if (LANGUAGES[class_]) {
287return class_;
288}
289}
290}
291
292function nodeStream(node) {
293var result = [];
294(function (node, offset) {
295for (var i = 0; i < node.childNodes.length; i++) {
296if (node.childNodes[i].nodeType == 3)
297offset += node.childNodes[i].nodeValue.length;
298else if (node.childNodes[i].nodeName == 'BR')
299offset += 1
300else {
301result.push({
302event: 'start',
303offset: offset,
304node: node.childNodes[i]
305});
306offset = arguments.callee(node.childNodes[i], offset)
307result.push({
308event: 'stop',
309offset: offset,
310node: node.childNodes[i]
311});
312}
313}
314return offset;
315})(node, 0);
316return result;
317}
318
319function mergeStreams(stream1, stream2, value) {
320var processed = 0;
321var result = '';
322var nodeStack = [];
323
324function selectStream() {
325if (stream1.length && stream2.length) {
326if (stream1[0].offset != stream2[0].offset)
327return (stream1[0].offset < stream2[0].offset) ? stream1 : stream2;
328else
329return (stream1[0].event == 'start' && stream2[0].event == 'stop') ? stream2 : stream1;
330} else {
331return stream1.length ? stream1 : stream2;
332}
333}
334
335function open(node) {
336var result = '<' + node.nodeName.toLowerCase();
337for (var i = 0; i < node.attributes.length; i++) {
338result += ' ' + node.attributes[i].nodeName.toLowerCase()  + '="' + escape(node.attributes[i].nodeValue) + '"';
339}
340return result + '>';
341}
342
343function close(node) {
344return '</' + node.nodeName.toLowerCase() + '>';
345}
346
347while (stream1.length || stream2.length) {
348var current = selectStream().splice(0, 1)[0];
349result += escape(value.substr(processed, current.offset - processed));
350processed = current.offset;
351if ( current.event == 'start') {
352result += open(current.node);
353nodeStack.push(current.node);
354} else if (current.event == 'stop') {
355var i = nodeStack.length;
356do {
357i--;
358var node = nodeStack[i];
359result += close(node);
360} while (node != current.node);
361nodeStack.splice(i, 1);
362while (i < nodeStack.length) {
363result += open(nodeStack[i]);
364i++;
365}
366}
367}
368result += value.substr(processed);
369return result;
370}
371
372function highlightBlock(block, tabReplace) {
373try {
374var text = blockText(block);
375var language = blockLanguage(block);
376} catch (e) {
377if (e == 'No highlight')
378return;
379}
380
381if (language) {
382var result = highlight(language, text).value;
383} else {
384var max_relevance = 0;
385for (var key in selected_languages) {
386if (!selected_languages.hasOwnProperty(key))
387continue;
388var lang_result = highlight(key, text);
389var relevance = lang_result.keyword_count + lang_result.relevance;
390if (relevance > max_relevance) {
391max_relevance = relevance;
392var result = lang_result.value;
393language = key;
394}
395}
396}
397
398if (result) {
399if (tabReplace) {
400result = result.replace(/^(t+)/gm, function(match, p1, offset, s) {
401return p1.replace(/t/g, tabReplace);
402})
403}
404var class_name = block.className;
405if (!class_name.match(language)) {
406class_name += ' ' + language;
407}
408var original = nodeStream(block);
409if (original.length) {
410var pre = document.createElement('pre');
411pre.innerHTML = result;
412result = mergeStreams(original, nodeStream(pre), text);
413}
414// See these 4 lines? This is IE's notion of "block.innerHTML = result". Love this browser :-/
415var container = document.createElement('div');
416container.innerHTML = '<pre><code class="' + class_name + '">' + result + '</code></pre>';
417var environment = block.parentNode.parentNode;
418environment.replaceChild(container.firstChild, block.parentNode);
419}
420}
421
422function langRe(language, value, global) {
423var mode =  'm' + (language.case_insensitive ? 'i' : '') + (global ? 'g' : '');
424return new RegExp(value, mode);
425}
426
427function compileModes() {
428for (var i in LANGUAGES) {
429if (!LANGUAGES.hasOwnProperty(i))
430continue;
431var language = LANGUAGES[i];
432for (var j = 0; j < language.modes.length; j++) {
433if (language.modes[j].begin)
434language.modes[j].beginRe = langRe(language, '^' + language.modes[j].begin);
435if (language.modes[j].end)
436language.modes[j].endRe = langRe(language, '^' + language.modes[j].end);
437if (language.modes[j].illegal)
438language.modes[j].illegalRe = langRe(language, '^(?:' + language.modes[j].illegal + ')');
439language.defaultMode.illegalRe = langRe(language, '^(?:' + language.defaultMode.illegal + ')');
440if (language.modes[j].relevance == undefined) {
441language.modes[j].relevance = 1;
442}
443}
444}
445}
446
447function compileKeywords() {
448
449function compileModeKeywords(mode) {
450if (!mode.keywordGroups) {
451for (var key in mode.keywords) {
452if (!mode.keywords.hasOwnProperty(key))
453continue;
454if (mode.keywords[key] instanceof Object)
455mode.keywordGroups = mode.keywords;
456else
457mode.keywordGroups = {'keyword': mode.keywords};
458break;
459}
460}
461}
462
463for (var i in LANGUAGES) {
464if (!LANGUAGES.hasOwnProperty(i))
465continue;
466var language = LANGUAGES[i];
467compileModeKeywords(language.defaultMode);
468for (var j = 0; j < language.modes.length; j++) {
469compileModeKeywords(language.modes[j]);
470}
471}
472}
473
474function findCode(pre) {
475for (var i = 0; i < pre.childNodes.length; i++) {
476node = pre.childNodes[i];
477if (node.nodeName == 'CODE')
478return node;
479if (!(node.nodeType == 3 && node.nodeValue.match(/s+/)))
480return null;
481}
482}
483
484function initHighlighting() {
485if (initHighlighting.called)
486return;
487initHighlighting.called = true;
488compileModes();
489compileKeywords();
490if (arguments.length) {
491for (var i = 0; i < arguments.length; i++) {
492if (LANGUAGES[arguments[i]]) {
493selected_languages[arguments[i]] = LANGUAGES[arguments[i]];
494}
495}
496} else
497selected_languages = LANGUAGES;
498var pres = document.getElementsByTagName('pre');
499for (var i = 0; i < pres.length; i++) {
500var code = findCode(pres[i]);
501if (code)
502highlightBlock(code, hljs.tabReplace);
503}
504}
505
506function initHighlightingOnLoad() {
507var original_arguments = arguments;
508var handler = function(){initHighlighting.apply(null, original_arguments)};
509if (window.addEventListener) {
510window.addEventListener('DOMContentLoaded', handler, false);
511window.addEventListener('load', handler, false);
512} else if (window.attachEvent)
513window.attachEvent('onload', handler);
514else
515window.onload = handler;
516}
517
518this.LANGUAGES = LANGUAGES;
519this.initHighlightingOnLoad = initHighlightingOnLoad;
520this.highlightBlock = highlightBlock;
521this.initHighlighting = initHighlighting;
522
523// Common regexps
524this.IDENT_RE = '[a-zA-Z][a-zA-Z0-9_]*';
525this.UNDERSCORE_IDENT_RE = '[a-zA-Z_][a-zA-Z0-9_]*';
526this.NUMBER_RE = '\b\d+(\.\d+)?';
527this.C_NUMBER_RE = '\b(0x[A-Za-z0-9]+|\d+(\.\d+)?)';
528this.RE_STARTERS_RE = '!|!=|!==|%|%=|&|&&|&=|\*|\*=|\+|\+=|,|\.|-|-=|/|/=|:|;|<|<<|<<=|<=|=|==|===|>|>=|>>|>>=|>>>|>>>=|\?|\[|\{|\(|\^|\^=|\||\|=|\|\||~';
529
530// Common modes
531this.APOS_STRING_MODE = {
532className: 'string',
533begin: ''', end: ''',
534illegal: '\n',
535contains: ['escape'],
536relevance: 0
537};
538this.QUOTE_STRING_MODE = {
539className: 'string',
540begin: '"', end: '"',
541illegal: '\n',
542contains: ['escape'],
543relevance: 0
544};
545this.BACKSLASH_ESCAPE = {
546className: 'escape',
547begin: '\\.', end: '^', noMarkup: true,
548relevance: 0
549};
550this.C_LINE_COMMENT_MODE = {
551className: 'comment',
552begin: '//', end: '$',
553relevance: 0
554};
555this.C_BLOCK_COMMENT_MODE = {
556className: 'comment',
557begin: '/\*', end: '\*/'
558};
559this.HASH_COMMENT_MODE = {
560className: 'comment',
561begin: '#', end: '$'
562};
563this.C_NUMBER_MODE = {
564className: 'number',
565begin: this.C_NUMBER_RE, end: '^',
566relevance: 0
567};
568}();
569
570var initHighlightingOnLoad = hljs.initHighlightingOnLoad;
571