defaulthighlightingstrategy.cs

c#源代码

									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.Count > 0) ? currentSpanStack : null;
			
			return processNextLine;
		}
		
		public void MarkTokens(IDocument document, ArrayList inputLines)
		{
			try
			{
				if (Rules.Count == 0) {
					return;
				}
				
				Hashtable processedLines = new Hashtable();
				
				bool spanChanged = false;
				
				foreach (LineSegment lineToProcess in inputLines) {
					if (processedLines[lineToProcess] == null) {
						int lineNumber = document.GetLineNumberForOffset(lineToProcess.Offset);
						bool processNextLine = true;
						
						if (lineNumber != -1) {
							while (processNextLine && lineNumber < document.TotalNumberOfLines) {
								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 :)
								}
								
								processNextLine = MarkTokensInLine(document, lineNumber, ref spanChanged);
								processedLines[currentLine] = String.Empty;
								++lineNumber;
							}
						}
					} 
				}
				
				if (spanChanged) {
					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, document.GetLineNumberForOffset(lineToProcess.Offset)));
					}
					
				}
				document.CommitUpdate();
			}
			finally
			{
				currentLine = null;
			}
		}
		
		// Span state variables
		bool inSpan;
		Span activeSpan;
		HighlightRuleSet activeRuleSet;
		
		// Line scanning state variables
		int currentOffset;
		int currentLength;
		
		void UpdateSpanStateVariables() 
		{
			inSpan = (currentSpanStack != null && currentSpanStack.Count > 0);
			activeSpan = inSpan ? (Span)currentSpanStack.Peek() : null;
			activeRuleSet = GetRuleSet(activeSpan);
		}

		ArrayList ParseLine(IDocument document)
		{
			ArrayList words = new ArrayList();
			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.ToUpper(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.ToUpper(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.ToUpper(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.ToUpper(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.ToUpper(document.GetCharAt(currentLine.Offset + i + 1)) == 'U') {
									++i;
									++currentLength;
									isunsigned = true;
								}
								if (i + 1 < currentLine.Length && Char.ToUpper(document.GetCharAt(currentLine.Offset + i + 1)) == 'L') {
									++i;
									++currentLength;
									if (!isunsigned && i + 1 < currentLine.Length && Char.ToUpper(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)) {
									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 (currentLine.MatchExpr(span.Begin, i, document)) {
									PushCurWord(document, ref markNext, words);
									string regex = currentLine.GetRegString(span.Begin, i, document);
									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 Stack();
									currentSpanStack.Push(span);
									
									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);			
			
			return words;
		}		
		
		/// <summary>
		/// pushes the curWord string on the word list, with the
		/// correct color.
		/// </summary>
		void PushCurWord(IDocument document, ref HighlightColor markNext, ArrayList 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 = GetColorFor("Default");
						}
						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, GetColorFor("Default"), 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;					
			}
		}		
	}
}