public virtual void MarkTokens(IDocument document) { if (Rules.Count == 0) { return; } int lineNumber = 0; while (lineNumber < document.TotalNumberOfLines) { LineSegment previousLine = (lineNumber > 0 ? document.GetLineSegment(lineNumber - 1) : null); if (lineNumber >= document.LineSegmentCollection.Count) { // may be, if the last line ends with a delimiter break; // then the last line is not in the collection :) } currentSpanStack = previousLine != null && previousLine.HighlightSpanStack != null?previousLine.HighlightSpanStack.Clone() : null; if (currentSpanStack != null) { while (!currentSpanStack.IsEmpty && currentSpanStack.Peek().StopEOL) { currentSpanStack.Pop(); } if (currentSpanStack.IsEmpty) { currentSpanStack = null; } } currentLine = document.LineSegmentCollection[lineNumber]; if (currentLine.Length == -1) { // happens when buffer is empty ! return; } currentLineNumber = lineNumber; List <TextWord> words = ParseLine(document); // Alex: clear old words if (currentLine.Words != null) { currentLine.Words.Clear(); } currentLine.Words = words; currentLine.HighlightSpanStack = currentSpanStack == null || currentSpanStack.IsEmpty ? null : currentSpanStack; ++lineNumber; } document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.WholeTextArea)); document.CommitUpdate(); currentLine = null; }
public SpanStack Clone() { SpanStack n = new SpanStack { top = this.top }; return(n); }
public virtual void MarkTokens(IDocument document) { if (Rules.Count == 0) { return; } var lineNumber = 0; while (lineNumber < document.TotalNumberOfLines) { var previousLine = lineNumber > 0 ? document.GetLineSegment(lineNumber - 1) : null; if (lineNumber >= document.LineSegmentCollection.Count) { break; // then the last line is not in the collection :) } currentSpanStack = previousLine?.HighlightSpanStack?.Clone(); if (currentSpanStack != null) { while (!currentSpanStack.IsEmpty && currentSpanStack.Peek().StopEOL) { currentSpanStack.Pop(); } if (currentSpanStack.IsEmpty) { currentSpanStack = null; } } currentLine = document.LineSegmentCollection[lineNumber]; if (currentLine.Length == -1) { return; } currentLineNumber = lineNumber; var words = ParseLine(document); // Alex: clear old words currentLine.Words?.Clear(); currentLine.Words = words; currentLine.HighlightSpanStack = currentSpanStack == null || currentSpanStack.IsEmpty ? null : currentSpanStack; ++lineNumber; } document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.WholeTextArea)); document.CommitUpdate(); currentLine = null; }
List <TextWord> ParseLine(IDocument document) { List <TextWord> words = new List <TextWord>(); HighlightColor markNext = null; currentOffset = 0; currentLength = 0; UpdateSpanStateVariables(); int currentLineLength = currentLine.Length; int currentLineOffset = currentLine.Offset; for (int i = 0; i < currentLineLength; ++i) { char ch = document.GetCharAt(currentLineOffset + i); switch (ch) { case '\n': case '\r': PushCurWord(document, ref markNext, words); ++currentOffset; break; case ' ': PushCurWord(document, ref markNext, words); if (activeSpan != null && activeSpan.Color.HasBackground) { words.Add(new TextWord.SpaceTextWord(activeSpan.Color)); } else { words.Add(TextWord.Space); } ++currentOffset; break; case '\t': PushCurWord(document, ref markNext, words); if (activeSpan != null && activeSpan.Color.HasBackground) { words.Add(new TextWord.TabTextWord(activeSpan.Color)); } else { words.Add(TextWord.Tab); } ++currentOffset; break; default: { // handle escape characters char escapeCharacter = '\0'; if (activeSpan != null && activeSpan.EscapeCharacter != '\0') { escapeCharacter = activeSpan.EscapeCharacter; } else if (activeRuleSet != null) { escapeCharacter = activeRuleSet.EscapeCharacter; } if (escapeCharacter != '\0' && escapeCharacter == ch) { // we found the escape character if (activeSpan != null && activeSpan.End != null && activeSpan.End.Length == 1 && escapeCharacter == activeSpan.End[0]) { // the escape character is a end-doubling escape character // it may count as escape only when the next character is the escape, too if (i + 1 < currentLineLength) { if (document.GetCharAt(currentLineOffset + i + 1) == escapeCharacter) { currentLength += 2; PushCurWord(document, ref markNext, words); ++i; continue; } } } else { // this is a normal \-style escape ++currentLength; if (i + 1 < currentLineLength) { ++currentLength; } PushCurWord(document, ref markNext, words); ++i; continue; } } // highlight digits if (!inSpan && (Char.IsDigit(ch) || (ch == '.' && i + 1 < currentLineLength && Char.IsDigit(document.GetCharAt(currentLineOffset + i + 1)))) && currentLength == 0) { bool ishex = false; bool isfloatingpoint = false; if (ch == '0' && i + 1 < currentLineLength && Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1)) == 'X') // hex digits { const string hex = "0123456789ABCDEF"; ++currentLength; ++i; // skip 'x' ++currentLength; ishex = true; while (i + 1 < currentLineLength && hex.IndexOf(Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1))) != -1) { ++i; ++currentLength; } } else { ++currentLength; while (i + 1 < currentLineLength && Char.IsDigit(document.GetCharAt(currentLineOffset + i + 1))) { ++i; ++currentLength; } } if (!ishex && i + 1 < currentLineLength && document.GetCharAt(currentLineOffset + i + 1) == '.') { isfloatingpoint = true; ++i; ++currentLength; while (i + 1 < currentLineLength && Char.IsDigit(document.GetCharAt(currentLineOffset + i + 1))) { ++i; ++currentLength; } } if (i + 1 < currentLineLength && Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1)) == 'E') { isfloatingpoint = true; ++i; ++currentLength; if (i + 1 < currentLineLength && (document.GetCharAt(currentLineOffset + i + 1) == '+' || document.GetCharAt(currentLine.Offset + i + 1) == '-')) { ++i; ++currentLength; } while (i + 1 < currentLine.Length && Char.IsDigit(document.GetCharAt(currentLineOffset + i + 1))) { ++i; ++currentLength; } } if (i + 1 < currentLine.Length) { char nextch = Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1)); if (nextch == 'F' || nextch == 'M' || nextch == 'D') { isfloatingpoint = true; ++i; ++currentLength; } } if (!isfloatingpoint) { bool isunsigned = false; if (i + 1 < currentLineLength && Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1)) == 'U') { ++i; ++currentLength; isunsigned = true; } if (i + 1 < currentLineLength && Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1)) == 'L') { ++i; ++currentLength; if (!isunsigned && i + 1 < currentLineLength && Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1)) == 'U') { ++i; ++currentLength; } } } words.Add(new TextWord(document, currentLine, currentOffset, currentLength, DigitColor, false)); currentOffset += currentLength; currentLength = 0; continue; } // Check for SPAN ENDs if (inSpan) { if (activeSpan.End != null && activeSpan.End.Length > 0) { if (MatchExpr(currentLine, activeSpan.End, i, document, activeSpan.IgnoreCase)) { PushCurWord(document, ref markNext, words); string regex = GetRegString(currentLine, activeSpan.End, i, document); currentLength += regex.Length; words.Add(new TextWord(document, currentLine, currentOffset, currentLength, activeSpan.EndColor, false)); currentOffset += currentLength; currentLength = 0; i += regex.Length - 1; currentSpanStack.Pop(); UpdateSpanStateVariables(); continue; } } } // check for SPAN BEGIN if (activeRuleSet != null) { foreach (Span span in activeRuleSet.Spans) { if ((!span.IsBeginSingleWord || currentLength == 0) && (!span.IsBeginStartOfLine.HasValue || span.IsBeginStartOfLine.Value == (currentLength == 0 && words.TrueForAll(delegate(TextWord textWord) { return(textWord.Type != TextWordType.Word); }))) && MatchExpr(currentLine, span.Begin, i, document, activeRuleSet.IgnoreCase)) { PushCurWord(document, ref markNext, words); string regex = GetRegString(currentLine, span.Begin, i, document); if (!OverrideSpan(regex, document, words, span, ref i)) { currentLength += regex.Length; words.Add(new TextWord(document, currentLine, currentOffset, currentLength, span.BeginColor, false)); currentOffset += currentLength; currentLength = 0; i += regex.Length - 1; if (currentSpanStack == null) { currentSpanStack = new SpanStack(); } currentSpanStack.Push(span); span.IgnoreCase = activeRuleSet.IgnoreCase; UpdateSpanStateVariables(); } goto skip; } } } // check if the char is a delimiter if (activeRuleSet != null && (int)ch < 256 && activeRuleSet.Delimiters[(int)ch]) { PushCurWord(document, ref markNext, words); if (currentOffset + currentLength + 1 < currentLine.Length) { ++currentLength; PushCurWord(document, ref markNext, words); goto skip; } } ++currentLength; skip : continue; } } } PushCurWord(document, ref markNext, words); OnParsedLine(document, currentLine, words); return(words); }
bool MarkTokensInLine(IDocument document, int lineNumber, ref bool spanChanged) { currentLineNumber = lineNumber; bool processNextLine = false; LineSegment previousLine = (lineNumber > 0 ? document.GetLineSegment(lineNumber - 1) : null); currentSpanStack = ((previousLine != null && previousLine.HighlightSpanStack != null) ? previousLine.HighlightSpanStack.Clone() : null); if (currentSpanStack != null) { while (!currentSpanStack.IsEmpty && currentSpanStack.Peek().StopEOL) { currentSpanStack.Pop(); } if (currentSpanStack.IsEmpty) { currentSpanStack = null; } } currentLine = (LineSegment)document.LineSegmentCollection[lineNumber]; if (currentLine.Length == -1) // happens when buffer is empty ! { return(false); } List <TextWord> words = ParseLine(document); if (currentSpanStack != null && currentSpanStack.IsEmpty) { currentSpanStack = null; } // Check if the span state has changed, if so we must re-render the next line // This check may seem utterly complicated but I didn't want to introduce any function calls // or allocations here for perf reasons. if (currentLine.HighlightSpanStack != currentSpanStack) { if (currentLine.HighlightSpanStack == null) { processNextLine = false; foreach (Span sp in currentSpanStack) { if (!sp.StopEOL) { spanChanged = true; processNextLine = true; break; } } } else if (currentSpanStack == null) { processNextLine = false; foreach (Span sp in currentLine.HighlightSpanStack) { if (!sp.StopEOL) { spanChanged = true; processNextLine = true; break; } } } else { SpanStack.Enumerator e1 = currentSpanStack.GetEnumerator(); SpanStack.Enumerator e2 = currentLine.HighlightSpanStack.GetEnumerator(); bool done = false; while (!done) { bool blockSpanIn1 = false; while (e1.MoveNext()) { if (!((Span)e1.Current).StopEOL) { blockSpanIn1 = true; break; } } bool blockSpanIn2 = false; while (e2.MoveNext()) { if (!((Span)e2.Current).StopEOL) { blockSpanIn2 = true; break; } } if (blockSpanIn1 || blockSpanIn2) { if (blockSpanIn1 && blockSpanIn2) { if (e1.Current != e2.Current) { done = true; processNextLine = true; spanChanged = true; } } else { spanChanged = true; done = true; processNextLine = true; } } else { done = true; processNextLine = false; } } } } else { processNextLine = false; } //// Alex: remove old words if (currentLine.Words != null) { currentLine.Words.Clear(); } currentLine.Words = words; currentLine.HighlightSpanStack = (currentSpanStack != null && !currentSpanStack.IsEmpty) ? currentSpanStack : null; return(processNextLine); }
private bool MarkTokensInLine(IDocument document, int lineNumber, ref bool spanChanged) { currentLineNumber = lineNumber; var processNextLine = false; var previousLine = lineNumber > 0 ? document.GetLineSegment(lineNumber - 1) : null; currentSpanStack = previousLine != null && previousLine.HighlightSpanStack != null?previousLine.HighlightSpanStack.Clone() : null; if (currentSpanStack != null) { while (!currentSpanStack.IsEmpty && currentSpanStack.Peek().StopEOL) { currentSpanStack.Pop(); } if (currentSpanStack.IsEmpty) { currentSpanStack = null; } } currentLine = document.LineSegmentCollection[lineNumber]; if (currentLine.Length == -1) { return(false); } var words = ParseLine(document); if (currentSpanStack != null && currentSpanStack.IsEmpty) { currentSpanStack = null; } // Check if the span state has changed, if so we must re-render the next line // This check may seem utterly complicated but I didn't want to introduce any function calls // or allocations here for perf reasons. if (currentLine.HighlightSpanStack != currentSpanStack) { if (currentLine.HighlightSpanStack == null) { foreach (var sp in currentSpanStack) { if (!sp.StopEOL) { spanChanged = true; processNextLine = true; break; } } } else if (currentSpanStack == null) { foreach (var sp in currentLine.HighlightSpanStack) { if (!sp.StopEOL) { spanChanged = true; processNextLine = true; break; } } } else { var e1 = currentSpanStack.GetEnumerator(); var e2 = currentLine.HighlightSpanStack.GetEnumerator(); var done = false; while (!done) { var blockSpanIn1 = false; while (e1.MoveNext()) { if (!e1.Current.StopEOL) { blockSpanIn1 = true; break; } } var blockSpanIn2 = false; while (e2.MoveNext()) { if (!e2.Current.StopEOL) { blockSpanIn2 = true; break; } } if (blockSpanIn1 || blockSpanIn2) { if (blockSpanIn1 && blockSpanIn2) { if (e1.Current != e2.Current) { done = true; processNextLine = true; spanChanged = true; } } else { spanChanged = true; done = true; processNextLine = true; } } else { done = true; } } } } //// Alex: remove old words currentLine.Words?.Clear(); currentLine.Words = words; currentLine.HighlightSpanStack = currentSpanStack != null && !currentSpanStack.IsEmpty ? currentSpanStack : null; return(processNextLine); }
List <TextWord> ParseLine(IDocument document) { List <TextWord> words = new List <TextWord>(); HighlightColor markNext = null; currentOffset = 0; currentLength = 0; UpdateSpanStateVariables(); for (int i = 0; i < currentLine.Length; ++i) { char ch = document.GetCharAt(currentLine.Offset + i); switch (ch) { case '\n': case '\r': PushCurWord(document, ref markNext, words); ++currentOffset; break; case ' ': PushCurWord(document, ref markNext, words); if (activeSpan != null && activeSpan.Color.HasBackground) { words.Add(new TextWord.SpaceTextWord(activeSpan.Color)); } else { words.Add(TextWord.Space); } ++currentOffset; break; case '\t': PushCurWord(document, ref markNext, words); if (activeSpan != null && activeSpan.Color.HasBackground) { words.Add(new TextWord.TabTextWord(activeSpan.Color)); } else { words.Add(TextWord.Tab); } ++currentOffset; break; case '\\': // handle escape chars if ((activeRuleSet != null && activeRuleSet.NoEscapeSequences) || (activeSpan != null && activeSpan.NoEscapeSequences)) { goto default; } ++currentLength; if (i + 1 < currentLine.Length) { ++currentLength; } PushCurWord(document, ref markNext, words); ++i; continue; default: { // highlight digits if (!inSpan && (Char.IsDigit(ch) || (ch == '.' && i + 1 < currentLine.Length && Char.IsDigit(document.GetCharAt(currentLine.Offset + i + 1)))) && currentLength == 0) { bool ishex = false; bool isfloatingpoint = false; if (ch == '0' && i + 1 < currentLine.Length && Char.ToUpperInvariant(document.GetCharAt(currentLine.Offset + i + 1)) == 'X') // hex digits { const string hex = "0123456789ABCDEF"; ++currentLength; ++i; // skip 'x' ++currentLength; ishex = true; while (i + 1 < currentLine.Length && hex.IndexOf(Char.ToUpperInvariant(document.GetCharAt(currentLine.Offset + i + 1))) != -1) { ++i; ++currentLength; } } else { ++currentLength; while (i + 1 < currentLine.Length && Char.IsDigit(document.GetCharAt(currentLine.Offset + i + 1))) { ++i; ++currentLength; } } if (!ishex && i + 1 < currentLine.Length && document.GetCharAt(currentLine.Offset + i + 1) == '.') { isfloatingpoint = true; ++i; ++currentLength; while (i + 1 < currentLine.Length && Char.IsDigit(document.GetCharAt(currentLine.Offset + i + 1))) { ++i; ++currentLength; } } if (i + 1 < currentLine.Length && Char.ToUpperInvariant(document.GetCharAt(currentLine.Offset + i + 1)) == 'E') { isfloatingpoint = true; ++i; ++currentLength; if (i + 1 < currentLine.Length && (document.GetCharAt(currentLine.Offset + i + 1) == '+' || document.GetCharAt(currentLine.Offset + i + 1) == '-')) { ++i; ++currentLength; } while (i + 1 < currentLine.Length && Char.IsDigit(document.GetCharAt(currentLine.Offset + i + 1))) { ++i; ++currentLength; } } if (i + 1 < currentLine.Length) { char nextch = Char.ToUpperInvariant(document.GetCharAt(currentLine.Offset + i + 1)); if (nextch == 'F' || nextch == 'M' || nextch == 'D') { isfloatingpoint = true; ++i; ++currentLength; } } if (!isfloatingpoint) { bool isunsigned = false; if (i + 1 < currentLine.Length && Char.ToUpperInvariant(document.GetCharAt(currentLine.Offset + i + 1)) == 'U') { ++i; ++currentLength; isunsigned = true; } if (i + 1 < currentLine.Length && Char.ToUpperInvariant(document.GetCharAt(currentLine.Offset + i + 1)) == 'L') { ++i; ++currentLength; if (!isunsigned && i + 1 < currentLine.Length && Char.ToUpperInvariant(document.GetCharAt(currentLine.Offset + i + 1)) == 'U') { ++i; ++currentLength; } } } words.Add(new TextWord(document, currentLine, currentOffset, currentLength, DigitColor, false)); currentOffset += currentLength; currentLength = 0; continue; } // Check for SPAN ENDs if (inSpan) { if (activeSpan.End != null && !activeSpan.End.Equals("")) { if (currentLine.MatchExpr(activeSpan.End, i, document, activeSpan.IgnoreCase)) { PushCurWord(document, ref markNext, words); string regex = currentLine.GetRegString(activeSpan.End, i, document); currentLength += regex.Length; words.Add(new TextWord(document, currentLine, currentOffset, currentLength, activeSpan.EndColor, false)); currentOffset += currentLength; currentLength = 0; i += regex.Length - 1; currentSpanStack.Pop(); UpdateSpanStateVariables(); continue; } } } // check for SPAN BEGIN if (activeRuleSet != null) { foreach (Span span in activeRuleSet.Spans) { if ((!span.IsBeginSingleWord || currentLength == 0) && currentLine.MatchExpr(span.Begin, i, document, activeRuleSet.IgnoreCase)) { PushCurWord(document, ref markNext, words); string regex = currentLine.GetRegString(span.Begin, i, document); if (!OverrideSpan(regex, document, words, span, ref i)) { currentLength += regex.Length; words.Add(new TextWord(document, currentLine, currentOffset, currentLength, span.BeginColor, false)); currentOffset += currentLength; currentLength = 0; i += regex.Length - 1; if (currentSpanStack == null) { currentSpanStack = new SpanStack(); } currentSpanStack.Push(span); span.IgnoreCase = activeRuleSet.IgnoreCase; UpdateSpanStateVariables(); } goto skip; } } } // check if the char is a delimiter if (activeRuleSet != null && (int)ch < 256 && activeRuleSet.Delimiters[(int)ch]) { PushCurWord(document, ref markNext, words); if (currentOffset + currentLength + 1 < currentLine.Length) { ++currentLength; PushCurWord(document, ref markNext, words); goto skip; } } ++currentLength; skip : continue; } } } PushCurWord(document, ref markNext, words); OnParsedLine(document, currentLine, words); return(words); }
private List <TextWord> ParseLine(IDocument document) { List <TextWord> textWords = new List <TextWord>(); HighlightColor highlightColor = null; this.currentOffset = 0; this.currentLength = 0; this.UpdateSpanStateVariables(); int length = this.currentLine.Length; int offset = this.currentLine.Offset; for (int i = 0; i < length; i++) { char charAt = document.GetCharAt(offset + i); char chr = charAt; switch (chr) { case '\t': { this.PushCurWord(document, ref highlightColor, textWords); if (this.activeSpan == null || !this.activeSpan.Color.HasBackground) { textWords.Add(TextWord.Tab); } else { textWords.Add(new TextWord.TabTextWord(this.activeSpan.Color)); } this.currentOffset++; break; } case '\n': case '\r': { this.PushCurWord(document, ref highlightColor, textWords); this.currentOffset++; break; } case '\v': case '\f': { char escapeCharacter = '\0'; if (this.activeSpan != null && this.activeSpan.EscapeCharacter != 0) { escapeCharacter = this.activeSpan.EscapeCharacter; } else if (this.activeRuleSet != null) { escapeCharacter = this.activeRuleSet.EscapeCharacter; } if (escapeCharacter != 0 && escapeCharacter == charAt) { if (this.activeSpan == null || this.activeSpan.End == null || (int)this.activeSpan.End.Length != 1 || escapeCharacter != this.activeSpan.End[0]) { this.currentLength++; if (i + 1 < length) { this.currentLength++; } this.PushCurWord(document, ref highlightColor, textWords); i++; break; } else if (i + 1 < length && document.GetCharAt(offset + i + 1) == escapeCharacter) { this.currentLength += 2; this.PushCurWord(document, ref highlightColor, textWords); i++; break; } } if (!this.inSpan && (char.IsDigit(charAt) || charAt == '.' && i + 1 < length && char.IsDigit(document.GetCharAt(offset + i + 1))) && this.currentLength == 0) { bool flag = false; bool flag1 = false; if (charAt != '0' || i + 1 >= length || char.ToUpper(document.GetCharAt(offset + i + 1)) != 'X') { this.currentLength++; while (i + 1 < length && char.IsDigit(document.GetCharAt(offset + i + 1))) { i++; this.currentLength++; } } else { this.currentLength++; i++; this.currentLength++; flag = true; while (i + 1 < length) { if ("0123456789ABCDEF".IndexOf(char.ToUpper(document.GetCharAt(offset + i + 1))) != -1) { i++; this.currentLength++; } else { break; } } } if (!flag && i + 1 < length && document.GetCharAt(offset + i + 1) == '.') { flag1 = true; i++; this.currentLength++; while (i + 1 < length && char.IsDigit(document.GetCharAt(offset + i + 1))) { i++; this.currentLength++; } } if (i + 1 < length && char.ToUpper(document.GetCharAt(offset + i + 1)) == 'E') { flag1 = true; i++; this.currentLength++; if (i + 1 < length && (document.GetCharAt(offset + i + 1) == '+' || document.GetCharAt(this.currentLine.Offset + i + 1) == '-')) { i++; this.currentLength++; } while (i + 1 < this.currentLine.Length && char.IsDigit(document.GetCharAt(offset + i + 1))) { i++; this.currentLength++; } } if (i + 1 < this.currentLine.Length) { char upper = char.ToUpper(document.GetCharAt(offset + i + 1)); if (upper == 'F' || upper == 'M' || upper == 'D') { flag1 = true; i++; this.currentLength++; } } if (!flag1) { bool flag2 = false; if (i + 1 < length && char.ToUpper(document.GetCharAt(offset + i + 1)) == 'U') { i++; this.currentLength++; flag2 = true; } if (i + 1 < length && char.ToUpper(document.GetCharAt(offset + i + 1)) == 'L') { i++; this.currentLength++; if (!flag2 && i + 1 < length && char.ToUpper(document.GetCharAt(offset + i + 1)) == 'U') { i++; this.currentLength++; } } } textWords.Add(new TextWord(document, this.currentLine, this.currentOffset, this.currentLength, this.DigitColor, false)); this.currentOffset += this.currentLength; this.currentLength = 0; break; } else if (!this.inSpan || this.activeSpan.End == null || (int)this.activeSpan.End.Length <= 0 || !DefaultHighlightingStrategy.MatchExpr(this.currentLine, this.activeSpan.End, i, document, this.activeSpan.IgnoreCase)) { if (this.activeRuleSet != null) { foreach (Span span in this.activeRuleSet.Spans) { if (span.IsBeginSingleWord && this.currentLength != 0) { continue; } if (span.IsBeginStartOfLine.HasValue) { if (span.IsBeginStartOfLine.Value != (this.currentLength != 0 ? false : textWords.TrueForAll((TextWord textWord) => textWord.Type != TextWordType.Word))) { continue; } } if (!DefaultHighlightingStrategy.MatchExpr(this.currentLine, span.Begin, i, document, this.activeRuleSet.IgnoreCase)) { continue; } this.PushCurWord(document, ref highlightColor, textWords); string regString = DefaultHighlightingStrategy.GetRegString(this.currentLine, span.Begin, i, document); if (!this.OverrideSpan(regString, document, textWords, span, ref i)) { this.currentLength += regString.Length; textWords.Add(new TextWord(document, this.currentLine, this.currentOffset, this.currentLength, span.BeginColor, false)); this.currentOffset += this.currentLength; this.currentLength = 0; i = i + (regString.Length - 1); if (this.currentSpanStack == null) { this.currentSpanStack = new SpanStack(); } this.currentSpanStack.Push(span); span.IgnoreCase = this.activeRuleSet.IgnoreCase; this.UpdateSpanStateVariables(); } goto label0; } } if (this.activeRuleSet != null && charAt < 'Ā' && this.activeRuleSet.Delimiters[charAt]) { this.PushCurWord(document, ref highlightColor, textWords); if (this.currentOffset + this.currentLength + 1 < this.currentLine.Length) { this.currentLength++; this.PushCurWord(document, ref highlightColor, textWords); break; } } this.currentLength++; break; } else { this.PushCurWord(document, ref highlightColor, textWords); string str = DefaultHighlightingStrategy.GetRegString(this.currentLine, this.activeSpan.End, i, document); this.currentLength += str.Length; textWords.Add(new TextWord(document, this.currentLine, this.currentOffset, this.currentLength, this.activeSpan.EndColor, false)); this.currentOffset += this.currentLength; this.currentLength = 0; i = i + (str.Length - 1); this.currentSpanStack.Pop(); this.UpdateSpanStateVariables(); break; } } default: { if (chr == ' ') { this.PushCurWord(document, ref highlightColor, textWords); if (this.activeSpan == null || !this.activeSpan.Color.HasBackground) { textWords.Add(TextWord.Space); } else { textWords.Add(new TextWord.SpaceTextWord(this.activeSpan.Color)); } this.currentOffset++; break; } else { goto case '\f'; } } } label0 :; } this.PushCurWord(document, ref highlightColor, textWords); this.OnParsedLine(document, this.currentLine, textWords); return(textWords); }
private bool MarkTokensInLine(IDocument document, int lineNumber, ref bool spanChanged) { LineSegment lineSegment; SpanStack spanStacks; SpanStack spanStacks1; this.currentLineNumber = lineNumber; bool flag = false; if (lineNumber > 0) { lineSegment = document.GetLineSegment(lineNumber - 1); } else { lineSegment = null; } LineSegment lineSegment1 = lineSegment; if (lineSegment1 == null || lineSegment1.HighlightSpanStack == null) { spanStacks = null; } else { spanStacks = lineSegment1.HighlightSpanStack.Clone(); } this.currentSpanStack = spanStacks; if (this.currentSpanStack != null) { while (!this.currentSpanStack.IsEmpty && this.currentSpanStack.Peek().StopEOL) { this.currentSpanStack.Pop(); } if (this.currentSpanStack.IsEmpty) { this.currentSpanStack = null; } } this.currentLine = document.LineSegmentCollection[lineNumber]; if (this.currentLine.Length == -1) { return(false); } List <TextWord> textWords = this.ParseLine(document); if (this.currentSpanStack != null && this.currentSpanStack.IsEmpty) { this.currentSpanStack = null; } if (this.currentLine.HighlightSpanStack == this.currentSpanStack) { flag = false; } else if (this.currentLine.HighlightSpanStack == null) { flag = false; foreach (Span span in this.currentSpanStack) { if (span.StopEOL) { continue; } spanChanged = true; flag = true; break; } } else if (this.currentSpanStack != null) { SpanStack.Enumerator enumerator = this.currentSpanStack.GetEnumerator(); SpanStack.Enumerator enumerator1 = this.currentLine.HighlightSpanStack.GetEnumerator(); bool flag1 = false; while (!flag1) { bool flag2 = false; while (enumerator.MoveNext()) { if (enumerator.Current.StopEOL) { continue; } flag2 = true; break; } bool flag3 = false; while (enumerator1.MoveNext()) { if (enumerator1.Current.StopEOL) { continue; } flag3 = true; break; } if (!flag2 && !flag3) { flag1 = true; flag = false; } else if (!flag2 || !flag3) { spanChanged = true; flag1 = true; flag = true; } else { if (enumerator.Current == enumerator1.Current) { continue; } flag1 = true; flag = true; spanChanged = true; } } } else { flag = false; foreach (Span highlightSpanStack in this.currentLine.HighlightSpanStack) { if (highlightSpanStack.StopEOL) { continue; } spanChanged = true; flag = true; break; } } if (this.currentLine.Words != null) { this.currentLine.Words.Clear(); } this.currentLine.Words = textWords; LineSegment lineSegment2 = this.currentLine; if (this.currentSpanStack == null || this.currentSpanStack.IsEmpty) { spanStacks1 = null; } else { spanStacks1 = this.currentSpanStack; } lineSegment2.HighlightSpanStack = spanStacks1; return(flag); }
public virtual void MarkTokens(IDocument document) { LineSegment lineSegment; SpanStack spanStacks; SpanStack spanStacks1; if (this.Rules.Count == 0) { return; } for (int i = 0; i < document.TotalNumberOfLines; i++) { if (i > 0) { lineSegment = document.GetLineSegment(i - 1); } else { lineSegment = null; } LineSegment lineSegment1 = lineSegment; if (i >= document.LineSegmentCollection.Count) { break; } if (lineSegment1 == null || lineSegment1.HighlightSpanStack == null) { spanStacks = null; } else { spanStacks = lineSegment1.HighlightSpanStack.Clone(); } this.currentSpanStack = spanStacks; if (this.currentSpanStack != null) { while (!this.currentSpanStack.IsEmpty && this.currentSpanStack.Peek().StopEOL) { this.currentSpanStack.Pop(); } if (this.currentSpanStack.IsEmpty) { this.currentSpanStack = null; } } this.currentLine = document.LineSegmentCollection[i]; if (this.currentLine.Length == -1) { return; } this.currentLineNumber = i; List <TextWord> textWords = this.ParseLine(document); if (this.currentLine.Words != null) { this.currentLine.Words.Clear(); } this.currentLine.Words = textWords; LineSegment lineSegment2 = this.currentLine; if (this.currentSpanStack == null || this.currentSpanStack.IsEmpty) { spanStacks1 = null; } else { spanStacks1 = this.currentSpanStack; } lineSegment2.HighlightSpanStack = spanStacks1; } document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.WholeTextArea)); document.CommitUpdate(); this.currentLine = null; }