void DefaultFoundSpanEnd (Span span, int offset, int length)
			{
				PopSpan ();
			}

			public static Span CreatePreprocessorSpan ()
			{
				var result = new Span ();
				result.TagColor = "text.preprocessor";
				result.Color = "text.preprocessor";
				result.Rule = "String";
				result.StopAtEol = true;
				return result;
			}

			void DefaultFoundSpanBegin (Span span, int offset, int length)
			{
				PushSpan (span, GetRule (span));
			}

			public void FoundSpanEnd (Span span, int offset, int length)
			{
				curChunk.Length = offset - curChunk.Offset;
				curChunk.Style  = GetStyle (curChunk) ?? GetChunkStyle (span);
				AddChunk (ref curChunk, 0, defaultStyle);

				curChunk.Offset = offset;
				curChunk.Length = length;
				curChunk.Style  = span.TagColor ?? GetChunkStyle (span);
				AddChunk (ref curChunk, 0, defaultStyle);
				spanParser.PopSpan ();
			}

 protected override bool ScanSpanEnd(Span cur, ref int i)
 {
     return base.ScanSpanEnd(cur, ref i);
 }

			protected virtual bool ScanSpanEnd (Span cur, ref int i)
			{
				int textOffset = i - StartOffset;
				
				if (cur.End != null) {
					RegexMatch match = cur.End.TryMatch (CurText, textOffset);
					if (match.Success) {
						FoundSpanEnd (cur, i, match.Length);
						i += match.Length - 1;
						return true;
					}
				}

				if (cur.Exit != null) {
					RegexMatch match = cur.Exit.TryMatch (CurText, textOffset);
					if (match.Success) {
						FoundSpanExit (cur, i, match.Length);
						i += match.Length - 1;
						return true;
					}
				}
				return false;
			}

			public void FoundSpanBegin (Span span, int offset, int length)
			{
				curChunk.Length = offset - curChunk.Offset;
				curChunk.Style = GetStyle (curChunk);
				if (string.IsNullOrEmpty (curChunk.Style)) {
//					Span tmpSpan = spanParser.SpanStack.Count > 0 ? spanParser.SpanStack.Pop () : null;
					curChunk.Style = GetSpanStyle ();
//					if (tmpSpan != null)
//						spanParser.SpanStack.Push (tmpSpan);
				}
				AddChunk (ref curChunk, 0, curChunk.Style);

				Rule spanRule = spanParser.GetRule (span);
				
				if (spanRule == null)
					throw new Exception ("Rule " + span.Rule + " not found in " + span);
				spanParser.PushSpan (span, spanRule);

				curChunk.Offset = offset;
				curChunk.Length = length;
				curChunk.Style  = span.TagColor ?? GetChunkStyle (span);
				curChunk.SpanStack.Push (span);
				AddChunk (ref curChunk, 0, curChunk.Style);
				foreach (SemanticRule semanticRule in spanRule.SemanticRules) {
					semanticRule.Analyze (this.doc, line, curChunk, offset, line.EndOffset);
				}
			}

			public void PushSpan (Span span, Rule rule)
			{
				spanStack.Push (span);
				ruleStack.Push (rule);
				CurRule = rule;
				CurSpan = span;
				if (rule.Name == "InterpolatedString" || rule.Name == "InterpolatedVerbatimString")
					interpolatedBraces.Push(0);
			}

			protected virtual bool ScanSpanEnd (Span cur, ref int i)
			{
				int textOffset = i - StartOffset;
				
				if (cur.End != null) {
					if (interpolatedBraces.Count > 0) {
						char ch = CurText [textOffset];
						if (ch == '{')
							interpolatedBraces.Push (interpolatedBraces.Pop () + 1);
						else if (ch == '}')
							interpolatedBraces.Push (interpolatedBraces.Pop () - 1);
						if (interpolatedBraces.Peek () >= 1)
							return false;
					}
					RegexMatch match = cur.End.TryMatch (CurText, textOffset);
					if (match.Success) {
						FoundSpanEnd (cur, i, match.Length);
						i += System.Math.Max (0, match.Length - 1);
						return true;
					}
				}

				if (cur.Exit != null) {
					RegexMatch match = cur.Exit.TryMatch (CurText, textOffset);
					if (match.Success) {
						FoundSpanExit (cur, i, match.Length);
						i += System.Math.Max (0, match.Length - 1);
						return true;
					}
				}
				return false;
			}

			public void FoundSpanBegin (Span span, int offset, int length)
			{
				curChunk.Length = offset - curChunk.Offset;
				curChunk.Style  = GetStyle (curChunk) ?? GetSpanStyle ();
				AddChunk (ref curChunk, 0, curChunk.Style);
				
				curChunk.Offset = offset;
				curChunk.Length = length;
				curChunk.Style  = GetChunkStyle (span);
				AddChunk (ref curChunk, 0, curChunk.Style);
				Rule spanRule = spanParser.GetRule (span);
				if (spanRule == null)
					throw new Exception ("Rule " + span.Rule + " not found in " + span);
				foreach (SemanticRule semanticRule in spanRule.SemanticRules) {
					semanticRule.Analyze (this.doc, line, curChunk, offset, line.EndOffset);
				}
			}

			bool EndsWithContinuation (Span span, LineSegment line)
			{
				return !span.StopAtEol || span.StopAtEol && !string.IsNullOrEmpty (span.Continuation) &&
					line != null && doc.GetTextAt (line).Trim ().EndsWith (span.Continuation);
			}

			protected virtual bool ScanSpanEnd (Span cur, int i)
			{
				if (cur.End != null) {
					RegexMatch match = cur.End.TryMatch (doc, i);
					if (match.Success) {
						OnFoundSpanEnd (cur, i, match.Length);
						spanStack.Pop ();
						if (ruleStack.Count > 1) // rulStack[1] is always syntax mode
							ruleStack.Pop ();
						return true;
					}
				}
				
				if (cur.Exit != null) {
					RegexMatch match = cur.Exit.TryMatch (doc, i);
					if (match.Success) {
						spanStack.Pop ();
						if (ruleStack.Count > 1) // rulStack[1] is always syntax mode
							ruleStack.Pop ();
						OnFoundSpanExit (cur, i, match.Length);
						return true;
					}
				}
				return false;
			}

			public virtual void OnFoundSpanEnd (Span span, int offset, int length)
			{
				if (FoundSpanEnd != null)
					FoundSpanEnd (span, offset, length);
			}

			public virtual void OnFoundSpanBegin (Span span, int offset, int length)
			{
				if (FoundSpanBegin != null)
					FoundSpanBegin (span, offset, length);
			}

			public void PushSpan (Span span, Rule rule)
			{
				spanStack.Push (span);
				ruleStack.Push (rule);
				this.CurRule = rule;
				this.CurSpan = span;
			}

            protected override bool ScanSpanEnd(Span cur, ref int i)
            {
                int textOffset = i - StartOffset;

                if (cur.End != null && (cur.Rule == "Table" || cur.Rule == "TableHeader")) {
                    if (cur.Rule == "Table") {
                        if (CurText [textOffset] != cur.End.Pattern [0] || CurText.Skip (textOffset + 1).Any (e => e == cur.End.Pattern [0])) {
                            return false;
                        }
                    }

                    if (cur.Rule == "TableHeader") {
                        if (textOffset != 0 || (!string.IsNullOrWhiteSpace(CurText) && CurText.First (ch => !char.IsWhiteSpace (ch)) == cur.End.Pattern [0])) {
                            return false;
                        }
                    }

                    FoundSpanEnd (cur, i, 1);
                    return true;
                }

                if (cur.End != null) {
                    RegexMatch match = cur.End.TryMatch (CurText, textOffset);
                    if (match.Success) {
                        FoundSpanEnd (cur, i, match.Length);
                        i += Math.Max (0, match.Length - 1);
                        return true;
                    }
                }

                if (cur.Exit != null) {
                    RegexMatch match = cur.Exit.TryMatch (CurText, textOffset);
                    if (match.Success) {
                        FoundSpanExit (cur, i, match.Length);
                        i += -1;
                        return true;
                    }
                }

                return false;
            }

			public Rule GetRule (Span span)
			{
				if (string.IsNullOrEmpty (span.Rule))
					return new Rule (mode);
				return CurRule.GetRule (span.Rule);
			}

		public Span Clone ()
		{
			var newSpan = new Span ();
			if (Begin != null)
				newSpan.Begin = Begin.Clone ();
			newSpan.BeginFlags = BeginFlags;
			newSpan.Color = Color;
			newSpan.Continuation = Continuation;
			if (End != null)
				newSpan.End = End.Clone ();
			newSpan.EndFlags = EndFlags;
			newSpan.Escape = Escape;
			if (Exit != null)
				newSpan.Exit = Exit.Clone ();
			newSpan.ExitFlags = ExitFlags;
			newSpan.NextColor = NextColor;
			newSpan.Rule = Rule;
			newSpan.StopAtEol = StopAtEol;
			newSpan.TagColor = TagColor;
			newSpan.BeginTagColor = beginTagColor;
			newSpan.EndTagColor = endTagColor;
			return newSpan;
		}

			string GetChunkStyle (Span span)
			{
				if (span == null)
					return GetSpanStyle ();
				return span.Color ?? GetSpanStyle ();
			}

		public static Span Read (XmlReader reader)
		{
			Span result = new Span ();
			
			result.Rule       = reader.GetAttribute ("rule");
			result.Color      = reader.GetAttribute ("color");
			result.TagColor   = reader.GetAttribute ("tagColor");
			result.NextColor  = reader.GetAttribute ("nextColor");
			
			result.Escape = reader.GetAttribute ("escape");
			
			string stopateol = reader.GetAttribute ("stopateol");
			if (!String.IsNullOrEmpty (stopateol)) {
				result.StopAtEol = Boolean.Parse (stopateol);
			}
			
			if (reader.LocalName == AltNode) {
				AddFlags (result.BeginFlags, reader.GetAttribute ("flags"));
				result.Continuation = reader.GetAttribute ("continuation");
				result.Begin        = new Regex (reader.ReadElementString ());
				result.StopAtEol = true;
			} else {
				XmlReadHelper.ReadList (reader, Node, delegate () {
					switch (reader.LocalName) {
					case "Begin":
						AddFlags (result.BeginFlags, reader.GetAttribute ("flags"));
						result.Begin = new Regex (reader.ReadElementString ());
						return true;
					case "End":
						AddFlags (result.EndFlags, reader.GetAttribute ("flags"));
						result.End = new Regex (reader.ReadElementString ());
						return true;
					case "Exit":
						AddFlags (result.ExitFlags, reader.GetAttribute ("flags"));
						result.Exit = new Regex (reader.ReadElementString ());
						return true;
					}
					return false;
				});
			}
			return result;
		}