Attachment #240990 for bug #430632

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 430632
Collapse All | Expand All





	// Styles
	var caretLineStyle = {styleClass: "meta annotation currentLine"}; //$NON-NLS-0$
var NEW = 1;
	var PUNCTUATION_SECTION_BEGIN = ".begin"; //$NON-NLS-0$
	var PUNCTUATION_SECTION_END = ".end"; //$NON-NLS-0$


	var spacePattern = {regex: /[ ]/g, style: {styleClass: "punctuation separator space", unmergeable: true}}; //$NON-NLS-0$
	var tabPattern = {regex: /\t/g, style: {styleClass: "punctuation separator tab", unmergeable: true}}; //$NON-NLS-0$

	var _findMatch_latest = function(regex, model, startIndex, endIndex, testBeforeMatch) {
		/*
		 * testBeforeMatch provides a potential optimization for callers that do not strongly expect to find
		 * a match.  If this argument is defined then test() is initially called on the regex, which executes
		 * significantly faster than exec().  If a match is found then the regex's lastIndex is reverted to
		 * its pre-test() value, and exec() is then invoked on it in order to get the match details.
		 */

		var initialLastIndex = regex.lastIndex;

		var lineIndex = model.getLineAtOffset(startIndex);
		var endLineIndex = model.getLineAtOffset(endIndex);

		var lineStart = model.getLineStart(lineIndex);

		var lineString = model.getLine(lineIndex);
		regex.lastIndex = startIndex - lineStart; // TODO is the -1 still appropriate?
		while (lineIndex <= endLineIndex) {
			var result;
			if (testBeforeMatch) {
				var revertIndex = regex.lastIndex;
				if (regex.test(lineString)) {
					regex.lastIndex = revertIndex;
					result = regex.exec(lineString);
				}
			} else {
				result = regex.exec(lineString);
			}
			if (result) {
				result.index += model.getLineStart(lineIndex);
				regex.lastIndex = initialLastIndex;
				return result;
			}
			if (endLineIndex < ++lineIndex) break;
//			lineString = model.getLine(lineIndex, true);
			lineStart = model.getLineStart(lineIndex);
//			if (lineStart + lineString.length > endIndex) {
//				lineString = lineString.substring(0, endIndex - lineStart)
//			}
			/*
			 * TODO the following passes includeLineDelimiter then subtracts 1 to make it run faster,
			 * which is potentially wrong.
			 */
			var lineEnd = model.getLineEnd(lineIndex, true) - 1;
			if (endIndex < lineEnd) {
				lineString = model.getText(/*model.getLineStart(lineIndex)*/lineStart, endIndex);
			} else {
				lineString = model.getText(/*model.getLineStart(lineIndex)*/lineStart, lineEnd);
			//	lineString = model.getLine(lineIndex); // slower
			}
			regex.lastIndex = 0;
		}
		regex.lastIndex = initialLastIndex;
		return null;
	};
	
	var _findMatch_orig = function(regex, model, startIndex, endIndex, testBeforeMatch) {
		var text = model.getText(/*startIndex*/0, endIndex);

		/*
		 * testBeforeMatch provides a potential optimization for callers that do not strongly expect to find
		 * a match.  If this argument is defined then test() is initially called on the regex, which executes

		regex.lastIndex = initialLastIndex;
		return null;
	};

	var _findMatch_new = function(regex, model, startIndex, endIndex, testBeforeMatch) {
		var text = model.getText(/*startIndex*/0, endIndex);

		/*
		 * testBeforeMatch provides a potential optimization for callers that do not strongly expect to find
		 * a match.  If this argument is defined then test() is initially called on the regex, which executes
		 * significantly faster than exec().  If a match is found then the regex's lastIndex is reverted to
		 * its pre-test() value, and exec() is then invoked on it in order to get the match details.
		 */

		var result;
		var initialLastIndex = regex.lastIndex;
		regex.lastIndex = startIndex;
		if (testBeforeMatch) {
			var revertIndex = regex.lastIndex;
			if (regex.test(text)) {
				regex.lastIndex = revertIndex;
				result = regex.exec(text);
			}
		} else {
			result = regex.exec(text);
		}
		regex.lastIndex = initialLastIndex;
		return result;
	};
	var _findMatch = NEW ? _findMatch_latest : _findMatch_orig;

	var substituteCaptureValues = function(regex, resolvedResult) {
		var regexString = regex.toString();
		captureReferenceRegex.lastIndex = 0;

		/* return an updated regex, remove the leading '/' and trailing /FLAGS */
		return new RegExp(regexString.substring(1, regexString.length - 1 - FLAGS.length), FLAGS);
	};
	var updateMatch = function(match, matches, model, startIndex, endIndex) {
		var regEx = match.pattern.regex ? match.pattern.regex : match.pattern.regexBegin;
		var result = _findMatch(regEx, model, startIndex, endIndex, true);
		if (result) {
			match.result = result;
			for (var i = 0; i < matches.length; i++) {

			resultStyles.push({start: i, end: fullStyle.end, style: fullStyle.style});
		}
	};
	var parse = function(model, /*offset*/startIndex, endIndex, block, styles, ignoreCaptures) {
		if (startIndex === endIndex) {
			return;
		}
		var patterns = block.getLinePatterns();

		patterns.forEach(function(current) {
			var regex = current.regex || current.regexBegin;
			regex.oldLastIndex = regex.lastIndex;
			var result = _findMatch(regex, model, startIndex, endIndex);
			if (result) {
				matches.push({result: result, pattern: current});
			}


			if (current.result.index < index) {
				/* processing of another match has moved index beyond this match */
				updateMatch(current, matches, model, index, endIndex);
				continue;
			}


			if (current.pattern.regex) {	/* line pattern defined by a "match" */
				result = current.result;
				end = start + result[0].length;
				var tokenStyle = {start: /*offset +*/ start, end: /*offset +*/ end, style: current.pattern.pattern.name};
				if (!ignoreCaptures) {
					if (current.pattern.pattern.captures) {
						getCaptureStyles(result, current.pattern.pattern.captures, /*offset +*/ start, substyles);
					}
					substyles.sort(function(a,b) {
						if (a.start < b.start) {

				var endRegex = current.pattern.regexEnd;
				endRegex = substituteCaptureValues(endRegex, current.result);

				result = _findMatch(endRegex, model, current.result.index + current.result[0].length, endIndex);
				if (!result) {
					eolRegex.lastIndex = 0;
					result = _findMatch(eolRegex, model, /*startIndex*/endIndex, endIndex); // TODO verify that this works
				}
				end = result.index + result[0].length;
				styles.push({start: /*offset +*/ start, end: /*offset +*/ end, style: current.pattern.pattern.name});
			}
			index = result.index + result[0].length;
			updateMatch(current, matches, model, index, endIndex);
		}
		patterns.forEach(function(current) {
			var regex = current.regex || current.regexBegin;
			regex.lastIndex = regex.oldLastIndex;
		});
	};
	var computeBlocks = function(model, startIndex, endIndex, block/*, offset*/) {
		if (startIndex === endIndex) {
			return [];
		}

		var results = [];
		var matches = [];
		block.getBlockPatterns().forEach(function(current) {
			var result = _findMatch(current.regexBegin || current.regex, model, startIndex, endIndex);
			if (result) {
				matches.push({result: result, pattern: current});
			}


			if (current.result.index < index) {
				/* processing of another match has moved index beyond this match */
				updateMatch(current, matches, model, index, endIndex);
				continue;
			}

			var start = /*offset +*/ current.result.index;
			var contentStart = current.result.index;
			var resultEnd = null;



				var lastIndex = contentStart;
				while (!resultEnd) {
					var result = _findMatch(resolvedEndRegex, model, lastIndex, endIndex);
					if (!result) {
						eolRegex.lastIndex = 0;
						result = _findMatch(eolRegex, model, /*startIndex*/endIndex, endIndex); // TODO verify that this works
					}
					var testBlock = new Block(
						{
							start: start,
							end: /*offset +*/ result.index + result[0].length,
							contentStart: /*offset +*/ contentStart,
							contentEnd: /*offset +*/ result.index
						},
						testPattern,
						block.getStyler(),
						model,
						block);
					var subBlocks = testBlock.getBlocks();
					if (!subBlocks.length || subBlocks[subBlocks.length - 1].end <= (result.index /*+ offset*/)) {
						resultEnd = testBlock;
					}
					lastIndex = result.index + result[0].length;
				}
			}
			results.push(resultEnd);
			index = resultEnd.end/*- offset*/;
			updateMatch(current, matches, model, index, endIndex);
		}
		return results;
	};

		var subPatterns = block.getLinePatterns();
		if (subPatterns.length && block.pattern && block.pattern.pattern.name && block.pattern.pattern.name.indexOf("comment") === 0) {
			var substyles = [];
			parse(baseModel, block.contentStart, block.end, block, substyles, true);
			for (var i = 0; i < substyles.length; i++) {
				if (substyles[i].style === "meta.annotation.task.todo") {
					annotations.push(mAnnotations.AnnotationType.createAnnotation(annotationType, substyles[i].start, substyles[i].end, baseModel.getText(substyles[i].start, substyles[i].end)));

		this._enclosurePatterns = {};
		if (model) {
			this._initPatterns();
			this._subBlocks = computeBlocks(model, this.start, this.end, this, 0/*, this.start*/); // TODO should the bounds be contentStart/contentEnd?
		}
	}
	Block.prototype = {

			}
			var block = this._findBlock(this._rootBlock, offset);
			var lineIndex = model.getLineAtOffset(offset);
			var lineText = model.getLine(lineIndex);
			var styles = [];
			parse(model, model.getLineStart(lineIndex), model.getLineEnd(lineIndex), block, styles);
			for (var i = 0; i < styles.length; i++) {
				if (offset < styles[i].start) {
					break;

			return result;
		},
		_findMatchingBracket: function(model, block, offset) {
			if (1) return -1;
			
			var lineIndex = model.getLineAtOffset(offset);
			var lineEnd = model.getLineEnd(lineIndex);
			var text = model.getText(offset, lineEnd);

		_getPatternManager: function() {
			return this.patternManager;
		},
		_getStyles: function(block, model, startIndex, endIndex) {
//			if (model.getBaseModel) {	// TODO verify that this works with blocks folded
//				start = model.mapOffset(start);
//			}
//			var end = start + text.length;

			var styles = [];
			var offset = startIndex, blocks = block.getBlocks();
			var blockStartIndex = this._binarySearch(blocks, startIndex, true);
			for (var i = blockStartIndex; i < blocks.length; i++) {
				if (blocks[i].start >= endIndex) { break; }
				var blockStart = blocks[i].start;
				var blockEnd = blocks[i].end;
				if (offset < blockStart) {
					/* content on that line that preceeds the start of the block */
					parse(model, offset/* - start*/, blockStart/* - start*/, block, styles);
				}
				var s = Math.max(offset, blockStart);
				if (s === blockStart) {
					/* currently at the block's "start" match, which specifies its style by either a capture or name */
					if (blocks[i].pattern.regexBegin) {
						var result = _findMatch(blocks[i].pattern.regexBegin, model, s - startIndex, model.getCharCount());
						if (result) {
							/* the begin match is still valid */
							var captures = blocks[i].pattern.pattern.beginCaptures || blocks[i].pattern.pattern.captures;

				 * Compute the end match now in order to determine the end-bound of the contained content, but do not add the
				 * end match's styles to the styles array until content styles have been computed so that ordering is preserved.
				 */
				var e = Math.min(endIndex, blockEnd);
				var endStyles = [];
				if (e === blockEnd) {
					/* currently at the block's "end" match, which specifies its style by either a capture or name */
					if (blocks[i].pattern.regexEnd) {
						var result = _findMatch(blocks[i].pattern.regexEnd, model, e - offset - (blocks[i].end - blocks[i].contentEnd), model.getCharCount());
						var result = _findMatch(blocks[i].pattern.regexEnd, testString, 0);
						if (result) {
							/* the end match is still valid */
							var captures = blocks[i].pattern.pattern.endCaptures || blocks[i].pattern.pattern.captures;

					}
				}

				var blockSubstyles = this._getStyles(blocks[i], model, s, e);
				var blockStyle = blocks[i].pattern.pattern.contentName || blocks[i].pattern.pattern.name;
				if (blockStyle) {
					/*

				styles = styles.concat(endStyles);
				offset = blockEnd;
			}
			if (offset < endIndex) {
				/* content on that line that follows the end of the block */
				parse(model, offset, endIndex, block, styles);
			}
			if (model.getBaseModel) {
				for (var j = 0; j < styles.length; j++) {

			if (e.textView === this.view) {
				e.style = this._getLineStyle(e.lineIndex);
			}
			var model = e.textView.getModel();
			e.ranges = this._getStyles(this._rootBlock, model, e.lineStart, model.getLineEnd(e.lineIndex));
			e.ranges.forEach(function(current) {
				if (current.style) {
					current.style = {styleClass: current.style.replace(/\./g, " ")}; //$NON-NLS-1$
				}
			});
			if (this._isRenderingWhitespace()) {

					te = charCount;	//TODO could it be smaller?
				}
				var text = baseModel.getText(ts, te), block;
var startTime = new Date().getTime();
				newBlocks = computeBlocks(baseModel, ts, te, this._rootBlock, 0/*ts*/);
var endTime = new Date().getTime();
window.console.log(endTime - startTime);
			} while (newBlocks.length && blocks.length && blockEnd < blockCount && newBlocks[newBlocks.length - 1].pattern.pattern.id !== blocks[blockEnd - 1].pattern.pattern.id);

			for (var i = blockStart; i < blocks.length; i++) {

Return to bug 430632