Exemple #1
0
		/// <summary>
/// 
/// </summary>
/// <param name="Pattern"></param>
/// <returns></returns>
		public Pattern Add(Pattern Pattern)
		{
			if (this.Parent != null && this.Parent.Parent != null && this.Parent.Parent.Parent != null)
			{
				Pattern.Separators = this.Parent.Parent.Parent.Separators;
				this.Parent.Parent.Parent.ChangeVersion();

			}

			if (!Pattern.IsComplex && !Pattern.ContainsSeparator)
			{
				//store pattern in lookuptable if it is a simple pattern
				string s = "";

				if (Pattern.StringPattern.Length >= 2)
					s = Pattern.StringPattern.Substring(0, 2);
				else
					s = Pattern.StringPattern.Substring(0, 1) + " ";

				s = s.ToLower();

				if (Pattern.StringPattern.Length == 1)
				{
					SimplePatterns1Char[Pattern.StringPattern] = Pattern;
				}
				else
				{
					if (SimplePatterns2Char[s] == null)
						SimplePatterns2Char[s] = new PatternCollection();
					PatternCollection ar = (PatternCollection) SimplePatterns2Char[s];
					ar.Add(Pattern);
				}

				if (this.CaseSensitive)
					SimplePatterns[Pattern.LowerStringPattern] = Pattern;
				else
					SimplePatterns[Pattern.StringPattern] = Pattern;

//				if (SimplePatterns[s]==null)
//					SimplePatterns.Add (s,new ArrayList ());
//				
//				ArrayList bb=(ArrayList) SimplePatterns[s];
//
//				bb.Add (Pattern);

			}
			else
			{
				ComplexPatterns.Add(Pattern);
			}

			mPatterns.Add(Pattern);
			if (Pattern.Parent == null)
				Pattern.Parent = this;
			else
			{
				throw(new Exception("Pattern already assigned to another PatternList"));
			}
			return Pattern;
		}
Exemple #2
0
		public Word GetEndBracketWord(Word Start, Pattern End, Segment FindIn)
		{
			if (Start == null || Start.Pattern == null || Start.Segment == null)
				return null;

			int CurrentRow = Start.Row.Index;

			int LastRow = this.Count - 1;
			if (FindIn.EndRow != null)
				LastRow = FindIn.EndRow.Index;


			int x = Start.Index;
			int count = 0;
			while (CurrentRow <= LastRow)
			{
				for (int i = x; i < this[CurrentRow].Count; i++)
				{
					Word w = this[CurrentRow][i];
					if (w.Segment == FindIn && w.Type == WordType.xtWord)
					{
						if (w.Pattern == Start.Pattern)
							count++;
						if (w.Pattern == End)
							count--;

						if (count == 0)
							return w;
					}
				}

				if (!Start.Pattern.IsMultiLineBracket)
					break;

				CurrentRow++;
				x = 0;
			}
			return null;
		}
Exemple #3
0
        private void ParseBlock(XmlNode node)
        {
            string Name = "", Style = "", PatternStyle = "";
            bool IsMultiline = false;
            bool TerminateChildren = false;
            Color BackColor = Color.Transparent;
            foreach (XmlAttribute att in node.Attributes)
            {
                if (att.Name.ToLower() == "name")
                    Name = att.Value;
                if (att.Name.ToLower() == "style")
                    Style = att.Value;
                if (att.Name.ToLower() == "patternstyle")
                    PatternStyle = att.Value;
                if (att.Name.ToLower() == "ismultiline")
                    IsMultiline = bool.Parse(att.Value);
                if (att.Name.ToLower() == "terminatechildren")
                    TerminateChildren = bool.Parse(att.Value);
                if (att.Name.ToLower() == "backcolor")
                {
                    BackColor = Color.FromName(att.Value);
                    //Transparent =false;
                }
            }

            //create block object here
            BlockType bl = GetBlock(Name);
            bl.BackColor = BackColor;
            bl.Name = Name;
            bl.MultiLine = IsMultiline;
            bl.Style = GetStyle(Style);
            bl.TerminateChildren = TerminateChildren;
            //		if (PatternStyle!="")
            //			bl.PatternStyle = GetStyle(PatternStyle);
            //		else
            //			bl.PatternStyle = bl.Style;			

            foreach (XmlNode n in node.ChildNodes)
            {
                if (n.NodeType == XmlNodeType.Element)
                {
                    if (n.Name.ToLower() == "scope")
                    {
                        //bool IsComplex=false;
                        //bool IsSeparator=false;
                        string Start = "";
                        string End = "";
                        string style = "";
                        string text = "";
                        string EndIsSeparator = "";
                        string StartIsSeparator = "";
                        string StartIsComplex = "false";
                        string EndIsComplex = "false";
                        string StartIsKeyword = "false";
                        string EndIsKeyword = "false";
                        string spawnstart = "";
                        string spawnend = "";
                        string EscapeChar = "";
                        string CauseIndent = "false";

                        bool expanded = true;

                        foreach (XmlAttribute att in n.Attributes)
                        {
                            if (att.Name.ToLower() == "start")
                                Start = att.Value;
                            if (att.Name.ToLower() == "escapechar")
                                EscapeChar = att.Value;
                            if (att.Name.ToLower() == "end")
                                End = att.Value;
                            if (att.Name.ToLower() == "style")
                                style = att.Value;
                            if (att.Name.ToLower() == "text")
                                text = att.Value;
                            if (att.Name.ToLower() == "defaultexpanded")
                                expanded = bool.Parse(att.Value);
                            if (att.Name.ToLower() == "endisseparator")
                                EndIsSeparator = att.Value;
                            if (att.Name.ToLower() == "startisseparator")
                                StartIsSeparator = att.Value;
                            if (att.Name.ToLower() == "startiskeyword")
                                StartIsKeyword = att.Value;
                            if (att.Name.ToLower() == "startiscomplex")
                                StartIsComplex = att.Value;
                            if (att.Name.ToLower() == "endiscomplex")
                                EndIsComplex = att.Value;
                            if (att.Name.ToLower() == "endiskeyword")
                                EndIsKeyword = att.Value;
                            if (att.Name.ToLower() == "spawnblockonstart")
                                spawnstart = att.Value;
                            if (att.Name.ToLower() == "spawnblockonend")
                                spawnend = att.Value;
                            if (att.Name.ToLower() == "causeindent")
                                CauseIndent = att.Value;
                        }
                        if (Start != "")
                        {
                            //bl.StartPattern =new Pattern (Pattern,IsComplex,false,IsSeparator);
                            //bl.StartPatterns.Add (new Pattern (Pattern,IsComplex,IsSeparator,true));
                            Scope scop = new Scope();
                            scop.Style = GetStyle(style);
                            scop.ExpansionText = text;
                            scop.DefaultExpanded = expanded;
                            bool blnStartIsComplex = bool.Parse(StartIsComplex);
                            bool blnEndIsComplex = bool.Parse(EndIsComplex);
                            bool blnCauseIndent = bool.Parse(CauseIndent);
                            scop.CauseIndent = blnCauseIndent;

                            Pattern StartP = new Pattern(Start, blnStartIsComplex, false, bool.Parse(StartIsKeyword));
                            Pattern EndP = null;
                            if (EscapeChar != "")
                            {
                                EndP = new Pattern(End, blnEndIsComplex, false, bool.Parse(EndIsKeyword), EscapeChar);
                            }
                            else
                            {
                                EndP = new Pattern(End, blnEndIsComplex, false, bool.Parse(EndIsKeyword));
                            }

                            if (EndIsSeparator != "")
                                EndP.IsSeparator = bool.Parse(EndIsSeparator);
                            scop.Start = StartP;
                            scop.EndPatterns.Add(EndP);
                            bl.ScopePatterns.Add(scop);
                            if (spawnstart != "")
                            {
                                scop.SpawnBlockOnStart = GetBlock(spawnstart);
                            }
                            if (spawnend != "")
                            {
                                scop.SpawnBlockOnEnd = GetBlock(spawnend);
                            }
                        }
                    }
                    if (n.Name.ToLower() == "bracket")
                    {
                        //bool IsComplex=false;
                        //bool IsSeparator=false;
                        string Start = "";
                        string End = "";
                        string style = "";

                        string EndIsSeparator = "";
                        string StartIsSeparator = "";

                        string StartIsComplex = "false";
                        string EndIsComplex = "false";

                        string StartIsKeyword = "false";
                        string EndIsKeyword = "false";
                        string IsMultiLineB = "true";

                        foreach (XmlAttribute att in n.Attributes)
                        {
                            if (att.Name.ToLower() == "start")
                                Start = att.Value;
                            if (att.Name.ToLower() == "end")
                                End = att.Value;
                            if (att.Name.ToLower() == "style")
                                style = att.Value;
                            if (att.Name.ToLower() == "endisseparator")
                                EndIsSeparator = att.Value;
                            if (att.Name.ToLower() == "startisseparator")
                                StartIsSeparator = att.Value;
                            if (att.Name.ToLower() == "startiskeyword")
                                StartIsKeyword = att.Value;
                            if (att.Name.ToLower() == "startiscomplex")
                                StartIsComplex = att.Value;
                            if (att.Name.ToLower() == "endiscomplex")
                                EndIsComplex = att.Value;
                            if (att.Name.ToLower() == "endiskeyword")
                                EndIsKeyword = att.Value;
                            if (att.Name.ToLower() == "ismultiline")
                                IsMultiLineB = att.Value;
                        }
                        if (Start != "")
                        {
                            PatternList pl = new PatternList();
                            pl.Style = GetStyle(style);

                            bool blnStartIsComplex = bool.Parse(StartIsComplex);
                            bool blnEndIsComplex = bool.Parse(EndIsComplex);
                            bool blnIsMultiLineB = bool.Parse(IsMultiLineB);

                            Pattern StartP = new Pattern(Start, blnStartIsComplex, false, bool.Parse(StartIsKeyword));
                            Pattern EndP = new Pattern(End, blnEndIsComplex, false, bool.Parse(EndIsKeyword));

                            StartP.MatchingBracket = EndP;
                            EndP.MatchingBracket = StartP;
                            StartP.BracketType = BracketType.StartBracket;
                            EndP.BracketType = BracketType.EndBracket;
                            StartP.IsMultiLineBracket = EndP.IsMultiLineBracket = blnIsMultiLineB;

                            pl.Add(StartP);
                            pl.Add(EndP);
                            bl.OperatorsList.Add(pl);
                        }
                    }

                }

                if (n.Name.ToLower() == "keywords")
                    foreach (XmlNode cn in n.ChildNodes)
                    {
                        if (cn.Name.ToLower() == "patterngroup")
                        {
                            PatternList pl = new PatternList();
                            bl.KeywordsList.Add(pl);
                            foreach (XmlAttribute att in cn.Attributes)
                            {
                                if (att.Name.ToLower() == "style")
                                    pl.Style = GetStyle(att.Value);

                                if (att.Name.ToLower() == "name")
                                    pl.Name = att.Value;

                                if (att.Name.ToLower() == "normalizecase")
                                    pl.NormalizeCase = bool.Parse(att.Value);

                                if (att.Name.ToLower() == "casesensitive")
                                    pl.CaseSensitive = bool.Parse(att.Value);

                            }
                            foreach (XmlNode pt in cn.ChildNodes)
                            {
                                if (pt.Name.ToLower() == "pattern")
                                {
                                    bool IsComplex = false;
                                    bool IsSeparator = false;
                                    string Category = null;
                                    string Pattern = "";
                                    if (pt.Attributes != null)
                                    {
                                        foreach (XmlAttribute att in pt.Attributes)
                                        {
                                            if (att.Name.ToLower() == "text")
                                                Pattern = att.Value;
                                            if (att.Name.ToLower() == "iscomplex")
                                                IsComplex = bool.Parse(att.Value);
                                            if (att.Name.ToLower() == "isseparator")
                                                IsSeparator = bool.Parse(att.Value);
                                            if (att.Name.ToLower() == "category")
                                                Category = (att.Value);

                                        }
                                    }
                                    if (Pattern != "")
                                    {
                                        Pattern pat = new Pattern(Pattern, IsComplex, IsSeparator, true);
                                        pat.Category = Category;
                                        pl.Add(pat);
                                    }

                                }
                                else if (pt.Name.ToLower() == "patterns")
                                {
                                    string Patterns = pt.ChildNodes[0].Value;
                                    Patterns = Patterns.Replace("\t", " ");
                                    while (Patterns.IndexOf("  ") >= 0)
                                        Patterns = Patterns.Replace("  ", " ");


                                    foreach (string Pattern in Patterns.Split())
                                    {
                                        if (Pattern != "")
                                            pl.Add(new Pattern(Pattern, false, false, true));
                                    }
                                }
                            }
                        }
                    }
                //if (n.Name == "Operators")
                //	ParseStyle(n);
                if (n.Name.ToLower() == "operators")
                    foreach (XmlNode cn in n.ChildNodes)
                    {
                        if (cn.Name.ToLower() == "patterngroup")
                        {
                            PatternList pl = new PatternList();
                            bl.OperatorsList.Add(pl);
                            foreach (XmlAttribute att in cn.Attributes)
                            {
                                if (att.Name.ToLower() == "style")
                                    pl.Style = GetStyle(att.Value);

                                if (att.Name.ToLower() == "name")
                                    pl.Name = att.Value;

                                if (att.Name.ToLower() == "normalizecase")
                                    pl.NormalizeCase = bool.Parse(att.Value);

                                if (att.Name.ToLower() == "casesensitive")
                                    pl.CaseSensitive = bool.Parse(att.Value);
                            }

                            foreach (XmlNode pt in cn.ChildNodes)
                            {
                                if (pt.Name.ToLower() == "pattern")
                                {
                                    bool IsComplex = false;
                                    bool IsSeparator = false;
                                    string Pattern = "";
                                    string Category = null;
                                    if (pt.Attributes != null)
                                    {
                                        foreach (XmlAttribute att in pt.Attributes)
                                        {
                                            if (att.Name.ToLower() == "text")
                                                Pattern = att.Value;
                                            if (att.Name.ToLower() == "iscomplex")
                                                IsComplex = bool.Parse(att.Value);
                                            if (att.Name.ToLower() == "isseparator")
                                                IsSeparator = bool.Parse(att.Value);
                                            if (att.Name.ToLower() == "category")
                                                Category = (att.Value);

                                        }
                                    }
                                    if (Pattern != "")
                                    {
                                        Pattern pat = new Pattern(Pattern, IsComplex, IsSeparator, false);
                                        pat.Category = Category;
                                        pl.Add(pat);
                                    }
                                }
                                else if (pt.Name.ToLower() == "patterns")
                                {
                                    string Patterns = pt.ChildNodes[0].Value;
                                    Patterns = Patterns.Replace("\t", " ");
                                    while (Patterns.IndexOf("  ") >= 0)
                                        Patterns = Patterns.Replace("  ", " ");

                                    string[] pattSplit = Patterns.Split();

                                    foreach (string Pattern in pattSplit)
                                    {
                                        if (Pattern != "")
                                            pl.Add(new Pattern(Pattern, false, false, false));
                                    }
                                }
                            }
                        }
                    }

                if (n.Name.ToLower() == "childblocks")
                {
                    foreach (XmlNode cn in n.ChildNodes)
                    {
                        if (cn.Name.ToLower() == "child")
                        {
                            foreach (XmlAttribute att in cn.Attributes)
                                if (att.Name.ToLower() == "name")
                                    bl.ChildBlocks.Add(GetBlock(att.Value));
                        }
                    }
                }
            }
        }
Exemple #4
0
		public Word GetStartBracketWord(Word Start, Pattern End, Segment FindIn)
		{
			if (Start == null || Start.Pattern == null || Start.Segment == null)
				return null;

			int CurrentRow = Start.Row.Index;
			int FirstRow = FindIn.StartRow.Index;
			int x = Start.Index;
			int count = 0;
			while (CurrentRow >= FirstRow)
			{
				for (int i = x; i >= 0; i--)
				{
					Word w = this[CurrentRow][i];
					if (w.Segment == FindIn && w.Type == WordType.xtWord)
					{
						if (w.Pattern == Start.Pattern)
							count++;
						if (w.Pattern == End)
							count--;

						if (count == 0)
							return w;
					}
				}

				if (!Start.Pattern.IsMultiLineBracket)
					break;

				CurrentRow--;
				if (CurrentRow >= 0)
					x = this[CurrentRow].Count - 1;
			}
			return null;
		}
Exemple #5
0
		public void AddToLookupTable(Pattern pattern)
		{
			if (pattern.IsComplex)
			{
				ComplexPatterns.Add(pattern);
				return;
			}
			else
			{
				this.tmpSimplePatterns.Add(pattern);
			}

		}