Code Coverage Statistics for Source File

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

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

Sequence Point Coverage

N/A

0 of 0

Branch Coverage

N/A

0 of 0

Lines

190

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: 2115 $</version>
// </file>

using System;
using System.Collections;
using System.Xml;

using ICSharpCode.TextEditor.Util;

namespace ICSharpCode.TextEditor.Document
{
	public class HighlightRuleSet
	{
		LookupTable keyWords;
		ArrayList   spans = new ArrayList();
		LookupTable prevMarkers;
		LookupTable nextMarkers;
		IHighlightingStrategy highlighter = null;
		char escapeCharacter;
		
		bool ignoreCase = false;
		string name     = null;
		
		bool[] delimiters = new bool[256];
		
		string      reference  = null;
		
		public ArrayList Spans {
			get {
				return spans;
			}
		}
		
		internal IHighlightingStrategy Highlighter {
			get {
				return highlighter;
			}
			set {
				highlighter = value;
			}
		}
		
		public LookupTable KeyWords {
			get {
				return keyWords;
			}
		}
		
		public LookupTable PrevMarkers {
			get {
				return prevMarkers;
			}
		}
		
		public LookupTable NextMarkers {
			get {
				return nextMarkers;
			}
		}
		
		public bool[] Delimiters {
			get {
				return delimiters;
			}
		}
		
		public char EscapeCharacter {
			get {
				return escapeCharacter;
			}
		}
		
		public bool IgnoreCase {
			get {
				return ignoreCase;
			}
		}
		
		public string Name {
			get {
				return name;
			}
			set {
				name = value;
			}
		}
		
		public string Reference {
			get {
				return reference;
			}
		}
		
		public HighlightRuleSet()
		{
			keyWords    = new LookupTable(false);
			prevMarkers = new LookupTable(false);
			nextMarkers = new LookupTable(false);
		}
		
		public HighlightRuleSet(XmlElement el)
		{
			XmlNodeList nodes;
			
			if (el.Attributes["name"] != null) {
				Name = el.Attributes["name"].InnerText;
			}
			
			if (el.HasAttribute("escapecharacter")) {
				escapeCharacter = el.GetAttribute("escapecharacter")[0];
			}
			
			if (el.Attributes["reference"] != null) {
				reference = el.Attributes["reference"].InnerText;
			}
			
			if (el.Attributes["ignorecase"] != null) {
				ignoreCase  = Boolean.Parse(el.Attributes["ignorecase"].InnerText);
			}
			
			for (int i  = 0; i < Delimiters.Length; ++i) {
				delimiters[i] = false;
			}
			
			if (el["Delimiters"] != null) {
				string delimiterString = el["Delimiters"].InnerText;
				foreach (char ch in delimiterString) {
					delimiters[(int)ch] = true;
				}
			}
			
//			Spans       = new LookupTable(!IgnoreCase);

			keyWords    = new LookupTable(!IgnoreCase);
			prevMarkers = new LookupTable(!IgnoreCase);
			nextMarkers = new LookupTable(!IgnoreCase);
			
			nodes = el.GetElementsByTagName("KeyWords");
			foreach (XmlElement el2 in nodes) {
				HighlightColor color = new HighlightColor(el2);
				
				XmlNodeList keys = el2.GetElementsByTagName("Key");
				foreach (XmlElement node in keys) {
					keyWords[node.Attributes["word"].InnerText] = color;
				}
			}
			
			nodes = el.GetElementsByTagName("Span");
			foreach (XmlElement el2 in nodes) {
				Spans.Add(new Span(el2));
				/*
				Span span = new Span(el2);
				Spans[span.Begin] = span;*/
			}
			
			nodes = el.GetElementsByTagName("MarkPrevious");
			foreach (XmlElement el2 in nodes) {
				PrevMarker prev = new PrevMarker(el2);
				prevMarkers[prev.What] = prev;
			}
			
			nodes = el.GetElementsByTagName("MarkFollowing");
			foreach (XmlElement el2 in nodes) {
				NextMarker next = new NextMarker(el2);
				nextMarkers[next.What] = next;
			}
		}
		
		/// <summary>
		/// Merges spans etc. from the other rule set into this rule set.
		/// </summary>
		public void MergeFrom(HighlightRuleSet ruleSet)
		{
			for (int i = 0; i < delimiters.Length; i++) {
				delimiters[i] |= ruleSet.delimiters[i];
			}
			// insert merged spans in front of old spans
			ArrayList oldSpans = spans;
			spans = (ArrayList)ruleSet.spans.Clone();
			spans.AddRange(oldSpans);
			//keyWords.MergeFrom(ruleSet.keyWords);
			//prevMarkers.MergeFrom(ruleSet.prevMarkers);
			//nextMarkers.MergeFrom(ruleSet.nextMarkers);
		}
	}
}

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: 2115 $</version>
6		// </file>
7
8		using System;
9		using System.Collections;
10		using System.Xml;
11
12		using ICSharpCode.TextEditor.Util;
13
14		namespace ICSharpCode.TextEditor.Document
15		{
16		public class HighlightRuleSet
17		{
18		LookupTable keyWords;
19		ArrayList spans = new ArrayList();
20		LookupTable prevMarkers;
21		LookupTable nextMarkers;
22		IHighlightingStrategy highlighter = null;
23		char escapeCharacter;
24
25		bool ignoreCase = false;
26		string name = null;
27
28		bool[] delimiters = new bool[256];
29
30		string reference = null;
31
32		public ArrayList Spans {
33		get {
34		return spans;
35		}
36		}
37
38		internal IHighlightingStrategy Highlighter {
39		get {
40		return highlighter;
41		}
42		set {
43		highlighter = value;
44		}
45		}
46
47		public LookupTable KeyWords {
48		get {
49		return keyWords;
50		}
51		}
52
53		public LookupTable PrevMarkers {
54		get {
55		return prevMarkers;
56		}
57		}
58
59		public LookupTable NextMarkers {
60		get {
61		return nextMarkers;
62		}
63		}
64
65		public bool[] Delimiters {
66		get {
67		return delimiters;
68		}
69		}
70
71		public char EscapeCharacter {
72		get {
73		return escapeCharacter;
74		}
75		}
76
77		public bool IgnoreCase {
78		get {
79		return ignoreCase;
80		}
81		}
82
83		public string Name {
84		get {
85		return name;
86		}
87		set {
88		name = value;
89		}
90		}
91
92		public string Reference {
93		get {
94		return reference;
95		}
96		}
97
98		public HighlightRuleSet()
99		{
100		keyWords = new LookupTable(false);
101		prevMarkers = new LookupTable(false);
102		nextMarkers = new LookupTable(false);
103		}
104
105		public HighlightRuleSet(XmlElement el)
106		{
107		XmlNodeList nodes;
108
109		if (el.Attributes["name"] != null) {
110		Name = el.Attributes["name"].InnerText;
111		}
112
113		if (el.HasAttribute("escapecharacter")) {
114		escapeCharacter = el.GetAttribute("escapecharacter")[0];
115		}
116
117		if (el.Attributes["reference"] != null) {
118		reference = el.Attributes["reference"].InnerText;
119		}
120
121		if (el.Attributes["ignorecase"] != null) {
122		ignoreCase = Boolean.Parse(el.Attributes["ignorecase"].InnerText);
123		}
124
125		for (int i = 0; i < Delimiters.Length; ++i) {
126		delimiters[i] = false;
127		}
128
129		if (el["Delimiters"] != null) {
130		string delimiterString = el["Delimiters"].InnerText;
131		foreach (char ch in delimiterString) {
132		delimiters[(int)ch] = true;
133		}
134		}
135
136		// Spans = new LookupTable(!IgnoreCase);
137
138		keyWords = new LookupTable(!IgnoreCase);
139		prevMarkers = new LookupTable(!IgnoreCase);
140		nextMarkers = new LookupTable(!IgnoreCase);
141
142		nodes = el.GetElementsByTagName("KeyWords");
143		foreach (XmlElement el2 in nodes) {
144		HighlightColor color = new HighlightColor(el2);
145
146		XmlNodeList keys = el2.GetElementsByTagName("Key");
147		foreach (XmlElement node in keys) {
148		keyWords[node.Attributes["word"].InnerText] = color;
149		}
150		}
151
152		nodes = el.GetElementsByTagName("Span");
153		foreach (XmlElement el2 in nodes) {
154		Spans.Add(new Span(el2));
155		/*
156		Span span = new Span(el2);
157		Spans[span.Begin] = span;*/
158		}
159
160		nodes = el.GetElementsByTagName("MarkPrevious");
161		foreach (XmlElement el2 in nodes) {
162		PrevMarker prev = new PrevMarker(el2);
163		prevMarkers[prev.What] = prev;
164		}
165
166		nodes = el.GetElementsByTagName("MarkFollowing");
167		foreach (XmlElement el2 in nodes) {
168		NextMarker next = new NextMarker(el2);
169		nextMarkers[next.What] = next;
170		}
171		}
172
173		/// <summary>
174		/// Merges spans etc. from the other rule set into this rule set.
175		/// </summary>
176		public void MergeFrom(HighlightRuleSet ruleSet)
177		{
178		for (int i = 0; i < delimiters.Length; i++) {
179		delimiters[i] \|= ruleSet.delimiters[i];
180		}
181		// insert merged spans in front of old spans
182		ArrayList oldSpans = spans;
183		spans = (ArrayList)ruleSet.spans.Clone();
184		spans.AddRange(oldSpans);
185		//keyWords.MergeFrom(ruleSet.keyWords);
186		//prevMarkers.MergeFrom(ruleSet.prevMarkers);
187		//nextMarkers.MergeFrom(ruleSet.nextMarkers);
188		}
189		}
190		}