Code Coverage Statistics for Source File

c:\Tools\SD3\src\Libraries\ICSharpCode.TextEditor\Project\Src\Document\HighlightingStrategy\DefaultHighlightingStrategy.cs

Sequence Point Coverage N/A 0 of 0	Branch Coverage N/A 0 of 0	Lines 906

Sequence Point Coverage

N/A

0 of 0

Branch Coverage

N/A

0 of 0

Lines

906

Highlight: Uncovered Code Covered Code


// <file>
//     <copyright see="prj:///doc/copyright.txt"/>
//     <license see="prj:///doc/license.txt"/>
//     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
//     <version>$Revision: 2683 $</version>
// </file>

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Windows.Forms;

namespace ICSharpCode.TextEditor.Document
{
	public class DefaultHighlightingStrategy : IHighlightingStrategy
	{
		string    name;
		List<HighlightRuleSet> rules = new List<HighlightRuleSet>();
		
		Dictionary<string, HighlightColor> environmentColors = new Dictionary<string, HighlightColor>();
		Dictionary<string, string> properties       = new Dictionary<string, string>();
		string[]  extensions;
		
		HighlightColor   digitColor;
		HighlightRuleSet defaultRuleSet = null;
		
		public HighlightColor DigitColor {
			get {
				return digitColor;
			}
			set {
				digitColor = value;
			}
		}
		
		public IEnumerable<KeyValuePair<string, HighlightColor>> EnvironmentColors {
			get {
				return environmentColors;
			}
		}
		
		protected void ImportSettingsFrom(DefaultHighlightingStrategy source)
		{
			if (source == null)
				throw new ArgumentNullException("source");
			properties = source.properties;
			extensions = source.extensions;
			digitColor = source.digitColor;
			defaultRuleSet = source.defaultRuleSet;
			name = source.name;
			rules = source.rules;
			environmentColors = source.environmentColors;
			defaultTextColor = source.defaultTextColor;
		}
		
		public DefaultHighlightingStrategy() : this("Default")
		{
		}
		
		public DefaultHighlightingStrategy(string name)
		{
			this.name = name;
			
			digitColor       = new HighlightColor(SystemColors.WindowText, false, false);
			defaultTextColor = new HighlightColor(SystemColors.WindowText, false, false);
			
			// set small 'default color environment'
			environmentColors["Default"]          = new HighlightBackground("WindowText", "Window", false, false);
			environmentColors["Selection"]        = new HighlightColor("HighlightText", "Highlight", false, false);
			environmentColors["VRuler"]           = new HighlightColor("ControlLight", "Window", false, false);
			environmentColors["InvalidLines"]     = new HighlightColor(Color.Red, false, false);
			environmentColors["CaretMarker"]      = new HighlightColor(Color.Yellow, false, false);
			environmentColors["LineNumbers"]      = new HighlightBackground("ControlDark", "Window", false, false);
			
			environmentColors["FoldLine"]         = new HighlightColor(Color.FromArgb(0x80, 0x80, 0x80), Color.Black, false, false);
			environmentColors["FoldMarker"]       = new HighlightColor(Color.FromArgb(0x80, 0x80, 0x80), Color.White, false, false);
			environmentColors["SelectedFoldLine"] = new HighlightColor(Color.Black, false, false);
			environmentColors["EOLMarkers"]       = new HighlightColor("ControlLight", "Window", false, false);
			environmentColors["SpaceMarkers"]     = new HighlightColor("ControlLight", "Window", false, false);
			environmentColors["TabMarkers"]       = new HighlightColor("ControlLight", "Window", false, false);
			
		}
		
		public Dictionary<string, string> Properties {
			get {
				return properties;
			}
		}
		
		public string Name
		{
			get {
				return name;
			}
		}
		
		public string[] Extensions
		{
			set {
				extensions = value;
			}
			get {
				return extensions;
			}
		}
		
		public List<HighlightRuleSet> Rules {
			get {
				return rules;
			}
		}
		
		public HighlightRuleSet FindHighlightRuleSet(string name)
		{
			foreach(HighlightRuleSet ruleSet in rules) {
				if (ruleSet.Name == name) {
					return ruleSet;
				}
			}
			return null;
		}
		
		public void AddRuleSet(HighlightRuleSet aRuleSet)
		{
			HighlightRuleSet existing = FindHighlightRuleSet(aRuleSet.Name);
			if (existing != null) {
				existing.MergeFrom(aRuleSet);
			} else {
				rules.Add(aRuleSet);
			}
		}
		
		public void ResolveReferences()
		{
			// Resolve references from Span definitions to RuleSets
			ResolveRuleSetReferences();
			// Resolve references from RuleSet defintitions to Highlighters defined in an external mode file
			ResolveExternalReferences();
		}
		
		void ResolveRuleSetReferences()
		{
			foreach (HighlightRuleSet ruleSet in Rules) {
				if (ruleSet.Name == null) {
					defaultRuleSet = ruleSet;
				}
				
				foreach (Span aSpan in ruleSet.Spans) {
					if (aSpan.Rule != null) {
						bool found = false;
						foreach (HighlightRuleSet refSet in Rules) {
							if (refSet.Name == aSpan.Rule) {
								found = true;
								aSpan.RuleSet = refSet;
								break;
							}
						}
						if (!found) {
							aSpan.RuleSet = null;
							throw new HighlightingDefinitionInvalidException("The RuleSet " + aSpan.Rule + " could not be found in mode definition " + this.Name);
						}
					} else {
						aSpan.RuleSet = null;
					}
				}
			}
			
			if (defaultRuleSet == null) {
				throw new HighlightingDefinitionInvalidException("No default RuleSet is defined for mode definition " + this.Name);
			}
		}
		
		void ResolveExternalReferences()
		{
			foreach (HighlightRuleSet ruleSet in Rules) {
				if (ruleSet.Reference != null) {
					IHighlightingStrategy highlighter = HighlightingManager.Manager.FindHighlighter (ruleSet.Reference);
					
					if (highlighter != null) {
						ruleSet.Highlighter = highlighter;
					} else {
						ruleSet.Highlighter = this;
						throw new HighlightingDefinitionInvalidException("The mode defintion " + ruleSet.Reference + " which is refered from the " + this.Name + " mode definition could not be found");
					}
				} else {
					ruleSet.Highlighter = this;
				}
			}
		}
		
//		internal void SetDefaultColor(HighlightBackground color)
//		{
//			return (HighlightColor)environmentColors[name];
//			defaultColor = color;
//		}
		
		HighlightColor defaultTextColor;
		
		public HighlightColor DefaultTextColor {
			get {
				return defaultTextColor;
			}
		}
		
		public void SetColorFor(string name, HighlightColor color)
		{
			if (name == "Default")
				defaultTextColor = new HighlightColor(color.Color, color.Bold, color.Italic);
			environmentColors[name] = color;
		}

		public HighlightColor GetColorFor(string name)
		{
			HighlightColor color;
			if (environmentColors.TryGetValue(name, out color))
				return color;
			else
				return defaultTextColor;
		}
		
		public HighlightColor GetColor(IDocument document, LineSegment currentSegment, int currentOffset, int currentLength)
		{
			return GetColor(defaultRuleSet, document, currentSegment, currentOffset, currentLength);
		}

		protected virtual HighlightColor GetColor(HighlightRuleSet ruleSet, IDocument document, LineSegment currentSegment, int currentOffset, int currentLength)
		{
			if (ruleSet != null) {
				if (ruleSet.Reference != null) {
					return ruleSet.Highlighter.GetColor(document, currentSegment, currentOffset, currentLength);
				} else {
					return (HighlightColor)ruleSet.KeyWords[document,  currentSegment, currentOffset, currentLength];
				}
			}
			return null;
		}
		
		public HighlightRuleSet GetRuleSet(Span aSpan)
		{
			if (aSpan == null) {
				return this.defaultRuleSet;
			} else {
				if (aSpan.RuleSet != null)
				{
					if (aSpan.RuleSet.Reference != null) {
						return aSpan.RuleSet.Highlighter.GetRuleSet(null);
					} else {
						return aSpan.RuleSet;
					}
				} else {
					return null;
				}
			}
		}

		// Line state variable
		protected LineSegment currentLine;
		protected int currentLineNumber;
		
		// Span stack state variable
		protected SpanStack currentSpanStack;

		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 = (LineSegment)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;
		}
		
		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;
		}
		
		public virtual void MarkTokens(IDocument document, List<LineSegment> inputLines)
		{
			if (Rules.Count == 0) {
				return;
			}
			
			Dictionary<LineSegment, bool> processedLines = new Dictionary<LineSegment, bool>();
			
			bool spanChanged = false;
			int documentLineSegmentCount = document.LineSegmentCollection.Count;
			
			foreach (LineSegment lineToProcess in inputLines) {
				if (!processedLines.ContainsKey(lineToProcess)) {
					int lineNumber = lineToProcess.LineNumber;
					bool processNextLine = true;
					
					if (lineNumber != -1) {
						while (processNextLine && lineNumber < documentLineSegmentCount) {
							processNextLine = MarkTokensInLine(document, lineNumber, ref spanChanged);
							processedLines[currentLine] = true;
							++lineNumber;
						}
					}
				}
			}
			
			if (spanChanged || inputLines.Count > 20) {
				// if the span was changed (more than inputLines lines had to be reevaluated)
				// or if there are many lines in inputLines, it's faster to update the whole
				// text area instead of many small segments
				document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.WholeTextArea));
			} else {
//				document.Caret.ValidateCaretPos();
//				document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.SingleLine, document.GetLineNumberForOffset(document.Caret.Offset)));
//
				foreach (LineSegment lineToProcess in inputLines) {
					document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.SingleLine, lineToProcess.LineNumber));
				}
				
			}
			document.CommitUpdate();
			currentLine = null;
		}
		
		// Span state variables
		protected bool inSpan;
		protected Span activeSpan;
		protected HighlightRuleSet activeRuleSet;
		
		// Line scanning state variables
		protected int currentOffset;
		protected int currentLength;
		
		void UpdateSpanStateVariables()
		{
			inSpan = (currentSpanStack != null && !currentSpanStack.IsEmpty);
			activeSpan = inSpan ? currentSpanStack.Peek() : null;
			activeRuleSet = GetRuleSet(activeSpan);
		}

		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;
		}
		
		protected virtual void OnParsedLine(IDocument document, LineSegment currentLine, List<TextWord> words)
		{
		}
		
		protected virtual bool OverrideSpan(string spanBegin, IDocument document, List<TextWord> words, Span span, ref int lineOffset)
		{
			return false;
		}
		
		/// <summary>
		/// pushes the curWord string on the word list, with the
		/// correct color.
		/// </summary>
		void PushCurWord(IDocument document, ref HighlightColor markNext, List<TextWord> words)
		{
			// Svante Lidman : Need to look through the next prev logic.
			if (currentLength > 0) {
				if (words.Count > 0 && activeRuleSet != null) {
					TextWord prevWord = null;
					int pInd = words.Count - 1;
					while (pInd >= 0) {
						if (!((TextWord)words[pInd]).IsWhiteSpace) {
							prevWord = (TextWord)words[pInd];
							if (prevWord.HasDefaultColor) {
								PrevMarker marker = (PrevMarker)activeRuleSet.PrevMarkers[document, currentLine, currentOffset, currentLength];
								if (marker != null) {
									prevWord.SyntaxColor = marker.Color;
//									document.Caret.ValidateCaretPos();
//									document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.SingleLine, document.GetLineNumberForOffset(document.Caret.Offset)));
								}
							}
							break;
						}
						pInd--;
					}
				}
				
				if (inSpan) {
					HighlightColor c = null;
					bool hasDefaultColor = true;
					if (activeSpan.Rule == null) {
						c = activeSpan.Color;
					} else {
						c = GetColor(activeRuleSet, document, currentLine, currentOffset, currentLength);
						hasDefaultColor = false;
					}
					
					if (c == null) {
						c = activeSpan.Color;
						if (c.Color == Color.Transparent) {
							c = this.DefaultTextColor;
						}
						hasDefaultColor = true;
					}
					words.Add(new TextWord(document, currentLine, currentOffset, currentLength, markNext != null ? markNext : c, hasDefaultColor));
				} else {
					HighlightColor c = markNext != null ? markNext : GetColor(activeRuleSet, document, currentLine, currentOffset, currentLength);
					if (c == null) {
						words.Add(new TextWord(document, currentLine, currentOffset, currentLength, this.DefaultTextColor, true));
					} else {
						words.Add(new TextWord(document, currentLine, currentOffset, currentLength, c, false));
					}
				}
				
				if (activeRuleSet != null) {
					NextMarker nextMarker = (NextMarker)activeRuleSet.NextMarkers[document, currentLine, currentOffset, currentLength];
					if (nextMarker != null) {
						if (nextMarker.MarkMarker && words.Count > 0) {
							TextWord prevword = ((TextWord)words[words.Count - 1]);
							prevword.SyntaxColor = nextMarker.Color;
						}
						markNext = nextMarker.Color;
					} else {
						markNext = null;
					}
				}
				currentOffset += currentLength;
				currentLength = 0;
			}
		}
		
		#region Matching
		/// <summary>
		/// get the string, which matches the regular expression expr,
		/// in string s2 at index
		/// </summary>
		static string GetRegString(LineSegment lineSegment, char[] expr, int index, IDocument document)
		{
			int j = 0;
			StringBuilder regexpr = new StringBuilder();
			
			for (int i = 0; i < expr.Length; ++i, ++j) {
				if (index + j >= lineSegment.Length)
					break;
				
				switch (expr[i]) {
					case '@': // "special" meaning
						++i;
						switch (expr[i]) {
							case '!': // don't match the following expression
								StringBuilder whatmatch = new StringBuilder();
								++i;
								while (i < expr.Length && expr[i] != '@') {
									whatmatch.Append(expr[i++]);
								}
								break;
							case '@': // matches @
								regexpr.Append(document.GetCharAt(lineSegment.Offset + index + j));
								break;
						}
						break;
					default:
						if (expr[i] != document.GetCharAt(lineSegment.Offset + index + j)) {
							return regexpr.ToString();
						}
						regexpr.Append(document.GetCharAt(lineSegment.Offset + index + j));
						break;
				}
			}
			return regexpr.ToString();
		}
		
		/// <summary>
		/// returns true, if the get the string s2 at index matches the expression expr
		/// </summary>
		static bool MatchExpr(LineSegment lineSegment, char[] expr, int index, IDocument document, bool ignoreCase)
		{
			for (int i = 0, j = 0; i < expr.Length; ++i, ++j) {
				switch (expr[i]) {
					case '@': // "special" meaning
						++i;
						if (i < expr.Length) {
							switch (expr[i]) {
								case 'C': // match whitespace or punctuation
									if (index + j == lineSegment.Offset || index + j >= lineSegment.Offset + lineSegment.Length) {
										// nothing (EOL or SOL)
									} else {
										char ch = document.GetCharAt(lineSegment.Offset + index + j);
										if (!Char.IsWhiteSpace(ch) && !Char.IsPunctuation(ch)) {
											return false;
										}
									}
									break;
								case '!': // don't match the following expression
									{
										StringBuilder whatmatch = new StringBuilder();
										++i;
										while (i < expr.Length && expr[i] != '@') {
											whatmatch.Append(expr[i++]);
										}
										if (lineSegment.Offset + index + j + whatmatch.Length < document.TextLength) {
											int k = 0;
											for (; k < whatmatch.Length; ++k) {
												char docChar = ignoreCase ? Char.ToUpperInvariant(document.GetCharAt(lineSegment.Offset + index + j + k)) : document.GetCharAt(lineSegment.Offset + index + j + k);
												char spanChar = ignoreCase ? Char.ToUpperInvariant(whatmatch[k]) : whatmatch[k];
												if (docChar != spanChar) {
													break;
												}
											}
											if (k >= whatmatch.Length) {
												return false;
											}
										}
//									--j;
										break;
									}
								case '-': // don't match the  expression before
									{
										StringBuilder whatmatch = new StringBuilder();
										++i;
										while (i < expr.Length && expr[i] != '@') {
											whatmatch.Append(expr[i++]);
										}
										if (index - whatmatch.Length >= 0) {
											int k = 0;
											for (; k < whatmatch.Length; ++k) {
												char docChar = ignoreCase ? Char.ToUpperInvariant(document.GetCharAt(lineSegment.Offset + index - whatmatch.Length + k)) : document.GetCharAt(lineSegment.Offset + index - whatmatch.Length + k);
												char spanChar = ignoreCase ? Char.ToUpperInvariant(whatmatch[k]) : whatmatch[k];
												if (docChar != spanChar)
													break;
											}
											if (k >= whatmatch.Length) {
												return false;
											}
										}
//									--j;
										break;
									}
								case '@': // matches @
									if (index + j >= lineSegment.Length || '@' != document.GetCharAt(lineSegment.Offset + index + j)) {
										return false;
									}
									break;
							}
						}
						break;
					default:
						{
							if (index + j >= lineSegment.Length) {
								return false;
							}
							char docChar = ignoreCase ? Char.ToUpperInvariant(document.GetCharAt(lineSegment.Offset + index + j)) : document.GetCharAt(lineSegment.Offset + index + j);
							char spanChar = ignoreCase ? Char.ToUpperInvariant(expr[i]) : expr[i];
							if (docChar != spanChar) {
								return false;
							}
							break;
						}
				}
			}
			return true;
		}
		#endregion
	}
}

L	V	Source
1		// <file>
2		// <copyright see="prj:///doc/copyright.txt"/>
3		// <license see="prj:///doc/license.txt"/>
4		// <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
5		// <version>$Revision: 2683 $</version>
6		// </file>
7
8		using System;
9		using System.Collections.Generic;
10		using System.Text;
11		using System.Drawing;
12		using System.Windows.Forms;
13
14		namespace ICSharpCode.TextEditor.Document
15		{
16		public class DefaultHighlightingStrategy : IHighlightingStrategy
17		{
18		string name;
19		List<HighlightRuleSet> rules = new List<HighlightRuleSet>();
20
21		Dictionary<string, HighlightColor> environmentColors = new Dictionary<string, HighlightColor>();
22		Dictionary<string, string> properties = new Dictionary<string, string>();
23		string[] extensions;
24
25		HighlightColor digitColor;
26		HighlightRuleSet defaultRuleSet = null;
27
28		public HighlightColor DigitColor {
29		get {
30		return digitColor;
31		}
32		set {
33		digitColor = value;
34		}
35		}
36
37		public IEnumerable<KeyValuePair<string, HighlightColor>> EnvironmentColors {
38		get {
39		return environmentColors;
40		}
41		}
42
43		protected void ImportSettingsFrom(DefaultHighlightingStrategy source)
44		{
45		if (source == null)
46		throw new ArgumentNullException("source");
47		properties = source.properties;
48		extensions = source.extensions;
49		digitColor = source.digitColor;
50		defaultRuleSet = source.defaultRuleSet;
51		name = source.name;
52		rules = source.rules;
53		environmentColors = source.environmentColors;
54		defaultTextColor = source.defaultTextColor;
55		}
56
57		public DefaultHighlightingStrategy() : this("Default")
58		{
59		}
60
61		public DefaultHighlightingStrategy(string name)
62		{
63		this.name = name;
64
65		digitColor = new HighlightColor(SystemColors.WindowText, false, false);
66		defaultTextColor = new HighlightColor(SystemColors.WindowText, false, false);
67
68		// set small 'default color environment'
69		environmentColors["Default"] = new HighlightBackground("WindowText", "Window", false, false);
70		environmentColors["Selection"] = new HighlightColor("HighlightText", "Highlight", false, false);
71		environmentColors["VRuler"] = new HighlightColor("ControlLight", "Window", false, false);
72		environmentColors["InvalidLines"] = new HighlightColor(Color.Red, false, false);
73		environmentColors["CaretMarker"] = new HighlightColor(Color.Yellow, false, false);
74		environmentColors["LineNumbers"] = new HighlightBackground("ControlDark", "Window", false, false);
75
76		environmentColors["FoldLine"] = new HighlightColor(Color.FromArgb(0x80, 0x80, 0x80), Color.Black, false, false);
77		environmentColors["FoldMarker"] = new HighlightColor(Color.FromArgb(0x80, 0x80, 0x80), Color.White, false, false);
78		environmentColors["SelectedFoldLine"] = new HighlightColor(Color.Black, false, false);
79		environmentColors["EOLMarkers"] = new HighlightColor("ControlLight", "Window", false, false);
80		environmentColors["SpaceMarkers"] = new HighlightColor("ControlLight", "Window", false, false);
81		environmentColors["TabMarkers"] = new HighlightColor("ControlLight", "Window", false, false);
82
83		}
84
85		public Dictionary<string, string> Properties {
86		get {
87		return properties;
88		}
89		}
90
91		public string Name
92		{
93		get {
94		return name;
95		}
96		}
97
98		public string[] Extensions
99		{
100		set {
101		extensions = value;
102		}
103		get {
104		return extensions;
105		}
106		}
107
108		public List<HighlightRuleSet> Rules {
109		get {
110		return rules;
111		}
112		}
113
114		public HighlightRuleSet FindHighlightRuleSet(string name)
115		{
116		foreach(HighlightRuleSet ruleSet in rules) {
117		if (ruleSet.Name == name) {
118		return ruleSet;
119		}
120		}
121		return null;
122		}
123
124		public void AddRuleSet(HighlightRuleSet aRuleSet)
125		{
126		HighlightRuleSet existing = FindHighlightRuleSet(aRuleSet.Name);
127		if (existing != null) {
128		existing.MergeFrom(aRuleSet);
129		} else {
130		rules.Add(aRuleSet);
131		}
132		}
133
134		public void ResolveReferences()
135		{
136		// Resolve references from Span definitions to RuleSets
137		ResolveRuleSetReferences();
138		// Resolve references from RuleSet defintitions to Highlighters defined in an external mode file
139		ResolveExternalReferences();
140		}
141
142		void ResolveRuleSetReferences()
143		{
144		foreach (HighlightRuleSet ruleSet in Rules) {
145		if (ruleSet.Name == null) {
146		defaultRuleSet = ruleSet;
147		}
148
149		foreach (Span aSpan in ruleSet.Spans) {
150		if (aSpan.Rule != null) {
151		bool found = false;
152		foreach (HighlightRuleSet refSet in Rules) {
153		if (refSet.Name == aSpan.Rule) {
154		found = true;
155		aSpan.RuleSet = refSet;
156		break;
157		}
158		}
159		if (!found) {
160		aSpan.RuleSet = null;
161		throw new HighlightingDefinitionInvalidException("The RuleSet " + aSpan.Rule + " could not be found in mode definition " + this.Name);
162		}
163		} else {
164		aSpan.RuleSet = null;
165		}
166		}
167		}
168
169		if (defaultRuleSet == null) {
170		throw new HighlightingDefinitionInvalidException("No default RuleSet is defined for mode definition " + this.Name);
171		}
172		}
173
174		void ResolveExternalReferences()
175		{
176		foreach (HighlightRuleSet ruleSet in Rules) {
177		if (ruleSet.Reference != null) {
178		IHighlightingStrategy highlighter = HighlightingManager.Manager.FindHighlighter (ruleSet.Reference);
179
180		if (highlighter != null) {
181		ruleSet.Highlighter = highlighter;
182		} else {
183		ruleSet.Highlighter = this;
184		throw new HighlightingDefinitionInvalidException("The mode defintion " + ruleSet.Reference + " which is refered from the " + this.Name + " mode definition could not be found");
185		}
186		} else {
187		ruleSet.Highlighter = this;
188		}
189		}
190		}
191
192		// internal void SetDefaultColor(HighlightBackground color)
193		// {
194		// return (HighlightColor)environmentColors[name];
195		// defaultColor = color;
196		// }
197
198		HighlightColor defaultTextColor;
199
200		public HighlightColor DefaultTextColor {
201		get {
202		return defaultTextColor;
203		}
204		}
205
206		public void SetColorFor(string name, HighlightColor color)
207		{
208		if (name == "Default")
209		defaultTextColor = new HighlightColor(color.Color, color.Bold, color.Italic);
210		environmentColors[name] = color;
211		}
212
213		public HighlightColor GetColorFor(string name)
214		{
215		HighlightColor color;
216		if (environmentColors.TryGetValue(name, out color))
217		return color;
218		else
219		return defaultTextColor;
220		}
221
222		public HighlightColor GetColor(IDocument document, LineSegment currentSegment, int currentOffset, int currentLength)
223		{
224		return GetColor(defaultRuleSet, document, currentSegment, currentOffset, currentLength);
225		}
226
227		protected virtual HighlightColor GetColor(HighlightRuleSet ruleSet, IDocument document, LineSegment currentSegment, int currentOffset, int currentLength)
228		{
229		if (ruleSet != null) {
230		if (ruleSet.Reference != null) {
231		return ruleSet.Highlighter.GetColor(document, currentSegment, currentOffset, currentLength);
232		} else {
233		return (HighlightColor)ruleSet.KeyWords[document, currentSegment, currentOffset, currentLength];
234		}
235		}
236		return null;
237		}
238
239		public HighlightRuleSet GetRuleSet(Span aSpan)
240		{
241		if (aSpan == null) {
242		return this.defaultRuleSet;
243		} else {
244		if (aSpan.RuleSet != null)
245		{
246		if (aSpan.RuleSet.Reference != null) {
247		return aSpan.RuleSet.Highlighter.GetRuleSet(null);
248		} else {
249		return aSpan.RuleSet;
250		}
251		} else {
252		return null;
253		}
254		}
255		}
256
257		// Line state variable
258		protected LineSegment currentLine;
259		protected int currentLineNumber;
260
261		// Span stack state variable
262		protected SpanStack currentSpanStack;
263
264		public virtual void MarkTokens(IDocument document)
265		{
266		if (Rules.Count == 0) {
267		return;
268		}
269
270		int lineNumber = 0;
271
272		while (lineNumber < document.TotalNumberOfLines) {
273		LineSegment previousLine = (lineNumber > 0 ? document.GetLineSegment(lineNumber - 1) : null);
274		if (lineNumber >= document.LineSegmentCollection.Count) { // may be, if the last line ends with a delimiter
275		break; // then the last line is not in the collection :)
276		}
277
278		currentSpanStack = ((previousLine != null && previousLine.HighlightSpanStack != null) ? previousLine.HighlightSpanStack.Clone() : null);
279
280		if (currentSpanStack != null) {
281		while (!currentSpanStack.IsEmpty && currentSpanStack.Peek().StopEOL)
282		{
283		currentSpanStack.Pop();
284		}
285		if (currentSpanStack.IsEmpty) currentSpanStack = null;
286		}
287
288		currentLine = (LineSegment)document.LineSegmentCollection[lineNumber];
289
290		if (currentLine.Length == -1) { // happens when buffer is empty !
291		return;
292		}
293
294		currentLineNumber = lineNumber;
295		List<TextWord> words = ParseLine(document);
296		// Alex: clear old words
297		if (currentLine.Words != null) {
298		currentLine.Words.Clear();
299		}
300		currentLine.Words = words;
301		currentLine.HighlightSpanStack = (currentSpanStack==null \|\| currentSpanStack.IsEmpty) ? null : currentSpanStack;
302
303		++lineNumber;
304		}
305		document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.WholeTextArea));
306		document.CommitUpdate();
307		currentLine = null;
308		}
309
310		bool MarkTokensInLine(IDocument document, int lineNumber, ref bool spanChanged)
311		{
312		currentLineNumber = lineNumber;
313		bool processNextLine = false;
314		LineSegment previousLine = (lineNumber > 0 ? document.GetLineSegment(lineNumber - 1) : null);
315
316		currentSpanStack = ((previousLine != null && previousLine.HighlightSpanStack != null) ? previousLine.HighlightSpanStack.Clone() : null);
317		if (currentSpanStack != null) {
318		while (!currentSpanStack.IsEmpty && currentSpanStack.Peek().StopEOL) {
319		currentSpanStack.Pop();
320		}
321		if (currentSpanStack.IsEmpty) {
322		currentSpanStack = null;
323		}
324		}
325
326		currentLine = (LineSegment)document.LineSegmentCollection[lineNumber];
327
328		if (currentLine.Length == -1) { // happens when buffer is empty !
329		return false;
330		}
331
332		List<TextWord> words = ParseLine(document);
333
334		if (currentSpanStack != null && currentSpanStack.IsEmpty) {
335		currentSpanStack = null;
336		}
337
338		// Check if the span state has changed, if so we must re-render the next line
339		// This check may seem utterly complicated but I didn't want to introduce any function calls
340		// or allocations here for perf reasons.
341		if(currentLine.HighlightSpanStack != currentSpanStack) {
342		if (currentLine.HighlightSpanStack == null) {
343		processNextLine = false;
344		foreach (Span sp in currentSpanStack) {
345		if (!sp.StopEOL) {
346		spanChanged = true;
347		processNextLine = true;
348		break;
349		}
350		}
351		} else if (currentSpanStack == null) {
352		processNextLine = false;
353		foreach (Span sp in currentLine.HighlightSpanStack) {
354		if (!sp.StopEOL) {
355		spanChanged = true;
356		processNextLine = true;
357		break;
358		}
359		}
360		} else {
361		SpanStack.Enumerator e1 = currentSpanStack.GetEnumerator();
362		SpanStack.Enumerator e2 = currentLine.HighlightSpanStack.GetEnumerator();
363		bool done = false;
364		while (!done) {
365		bool blockSpanIn1 = false;
366		while (e1.MoveNext()) {
367		if (!((Span)e1.Current).StopEOL) {
368		blockSpanIn1 = true;
369		break;
370		}
371		}
372		bool blockSpanIn2 = false;
373		while (e2.MoveNext()) {
374		if (!((Span)e2.Current).StopEOL) {
375		blockSpanIn2 = true;
376		break;
377		}
378		}
379		if (blockSpanIn1 \|\| blockSpanIn2) {
380		if (blockSpanIn1 && blockSpanIn2) {
381		if (e1.Current != e2.Current) {
382		done = true;
383		processNextLine = true;
384		spanChanged = true;
385		}
386		} else {
387		spanChanged = true;
388		done = true;
389		processNextLine = true;
390		}
391		} else {
392		done = true;
393		processNextLine = false;
394		}
395		}
396		}
397		} else {
398		processNextLine = false;
399		}
400
401		//// Alex: remove old words
402		if (currentLine.Words!=null) currentLine.Words.Clear();
403		currentLine.Words = words;
404		currentLine.HighlightSpanStack = (currentSpanStack != null && !currentSpanStack.IsEmpty) ? currentSpanStack : null;
405
406		return processNextLine;
407		}
408
409		public virtual void MarkTokens(IDocument document, List<LineSegment> inputLines)
410		{
411		if (Rules.Count == 0) {
412		return;
413		}
414
415		Dictionary<LineSegment, bool> processedLines = new Dictionary<LineSegment, bool>();
416
417		bool spanChanged = false;
418		int documentLineSegmentCount = document.LineSegmentCollection.Count;
419
420		foreach (LineSegment lineToProcess in inputLines) {
421		if (!processedLines.ContainsKey(lineToProcess)) {
422		int lineNumber = lineToProcess.LineNumber;
423		bool processNextLine = true;
424
425		if (lineNumber != -1) {
426		while (processNextLine && lineNumber < documentLineSegmentCount) {
427		processNextLine = MarkTokensInLine(document, lineNumber, ref spanChanged);
428		processedLines[currentLine] = true;
429		++lineNumber;
430		}
431		}
432		}
433		}
434
435		if (spanChanged \|\| inputLines.Count > 20) {
436		// if the span was changed (more than inputLines lines had to be reevaluated)
437		// or if there are many lines in inputLines, it's faster to update the whole
438		// text area instead of many small segments
439		document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.WholeTextArea));
440		} else {
441		// document.Caret.ValidateCaretPos();
442		// document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.SingleLine, document.GetLineNumberForOffset(document.Caret.Offset)));
443		//
444		foreach (LineSegment lineToProcess in inputLines) {
445		document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.SingleLine, lineToProcess.LineNumber));
446		}
447
448		}
449		document.CommitUpdate();
450		currentLine = null;
451		}
452
453		// Span state variables
454		protected bool inSpan;
455		protected Span activeSpan;
456		protected HighlightRuleSet activeRuleSet;
457
458		// Line scanning state variables
459		protected int currentOffset;
460		protected int currentLength;
461
462		void UpdateSpanStateVariables()
463		{
464		inSpan = (currentSpanStack != null && !currentSpanStack.IsEmpty);
465		activeSpan = inSpan ? currentSpanStack.Peek() : null;
466		activeRuleSet = GetRuleSet(activeSpan);
467		}
468
469		List<TextWord> ParseLine(IDocument document)
470		{
471		List<TextWord> words = new List<TextWord>();
472		HighlightColor markNext = null;
473
474		currentOffset = 0;
475		currentLength = 0;
476		UpdateSpanStateVariables();
477
478		int currentLineLength = currentLine.Length;
479		int currentLineOffset = currentLine.Offset;
480
481		for (int i = 0; i < currentLineLength; ++i) {
482		char ch = document.GetCharAt(currentLineOffset + i);
483		switch (ch) {
484		case '\n':
485		case '\r':
486		PushCurWord(document, ref markNext, words);
487		++currentOffset;
488		break;
489		case ' ':
490		PushCurWord(document, ref markNext, words);
491		if (activeSpan != null && activeSpan.Color.HasBackground) {
492		words.Add(new TextWord.SpaceTextWord(activeSpan.Color));
493		} else {
494		words.Add(TextWord.Space);
495		}
496		++currentOffset;
497		break;
498		case '\t':
499		PushCurWord(document, ref markNext, words);
500		if (activeSpan != null && activeSpan.Color.HasBackground) {