private SourceEditorPanel CreateOrSwitchEditFunctionPanel(FilePositionItem filePositionItem)
        {
            SourceEditorPanel panel = null;

            panel = EditFunctionPaels.Where(x => x.FilePositionItem == filePositionItem).FirstOrDefault();

            if (panel == null)
            {
                try
                {
                    panel = new SourceEditorPanel();
                    panel.IsEditFunctionType      = true;
                    panel.SourceContainerDocument = this;
                    panel.Text             = filePositionItem.Name;
                    panel.FilePositionItem = filePositionItem;
                    panel.SetSourceFileClass(FileClass);
                    string text = SourceEditorPanel.fastColoredTextBox1.GetRange(new Place(0, filePositionItem.LineNumberStart), new Place(0, filePositionItem.LineNumberEnd)).Text;
                    panel.fastColoredTextBox1.Text = text;
                }
                catch (Exception ex) {
                    MessageBox.Show(ex.Message);
                }
                if (panel != null)
                {
                    EditFunctionPaels.Add(panel);
                }
            }

            if (panel != null)
            {
                panel.Show(dockPanel1);
            }
            return(panel);
        }
 private void ExpandChildeDataWindowsNode(TreeNode node)
 {
     foreach (TreeNode cnode in node.Nodes)
     {
         FilePositionItem filePositionItem = cnode.Tag as FilePositionItem;
         if (filePositionItem != null && filePositionItem.ItemType == "DataObjectList")
         {
             cnode.Expand();
         }
     }
 }
Example #3
0
        private void AddNodeByRegex(FileClass fileClass, string nodeName, string regex, string format, int imageIndex)
        {
            MatchCollection matchCollection = Regex.Matches(fileClass.Text, regex, RegexOptions.ExplicitCapture);
            var             typeNode        = new TreeNode();

            typeNode.Expand();
            typeNode.Text               = string.Format(nodeName, matchCollection.Count);
            typeNode.ImageIndex         = imageIndex;
            typeNode.SelectedImageIndex = typeNode.ImageIndex;
            typeNode.NodeFont           = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Bold);
            foreach (Match match in matchCollection)
            {
                var node = new TreeNode();
                node.Text               = string.Format(format, match.Groups[1], match.Groups[2]);
                node.ImageIndex         = imageIndex;
                node.SelectedImageIndex = node.ImageIndex;
                var filePositionItem = new FilePositionItem();
                filePositionItem.IndexItemStart = match.Groups[1].Index;
                filePositionItem.IndexItemEnd   = filePositionItem.IndexItemStart + 10;
//                filePositionItem.IndexItemEnd = eventMatch.Groups[5].Index + powerBuilderFileType.IndexInstanceVarEnd;
//                filePositionItem.IsHasCode = eventMatch.Groups[4].Length > 5;
                filePositionItem.LineNumberStart = MainEngine.Instance.GetTextLineByCharIndex(filePositionItem.IndexItemStart);
                filePositionItem.LineNumberEnd   = MainEngine.Instance.GetTextLineByCharIndex(filePositionItem.IndexItemEnd);
                node.Tag = filePositionItem;
                MatchCollection matchExpresionCollection = Regex.Matches(match.Groups[0].Value, @"(?<prop>\w+)\=\""(?<val>[^\""]*)\~t(?<expr>.*?)\""", RegexOptions.ExplicitCapture);
                foreach (Match m in matchExpresionCollection)
                {
                    var nodeExpr = new TreeNode();
                    nodeExpr.Text               = string.Format("{0}=  {2}", m.Groups[1], m.Groups[2], m.Groups[3]);
                    nodeExpr.ImageIndex         = 14;
                    nodeExpr.SelectedImageIndex = node.ImageIndex;
                    nodeExpr.Tag = filePositionItem;
//                    nodeExpr.NodeFont = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Italic);
                    nodeExpr.ForeColor = Color.Gray;
                    node.Nodes.Add(nodeExpr);
                }
                typeNode.Nodes.Add(node);
            }
            treeView1.Nodes.Add(typeNode);
        }
        public void SetObjectsList(FileClass fileClass)
        {
            try
            {
                treeView1.BeginUpdate();

                //DataWindow's objects
                if (fileClass.Text.Contains(".srd"))
                {
                    treeView1.Nodes.Clear();

                    MainEngine.Instance.FillRnCounts(fileClass.Text);
                    AddNodeByRegex(fileClass, "Arguments ({0})", @"\,?\(\""(?<name>(\w+))\""\,\s*(?<type>\w+)\)", ":{0}=? : {1}", 11, "sqlArgument");
                    AddNodeByRegex(fileClass, "SQL Columns ({0})", @"(column\=\().*?name\=(?<name>\w+).*?dbname\=\""(?<dbname>(\w|\.)+)\"".*\)", "{0} : {1}", 9, "sqlColumns");
                    AddNodeByRegex(fileClass, "Columns ({0})", @"(?<=column\().*?name\=(?<name>\w+).*\)", "{0}", 12, "pbColumns");
                    AddNodeByRegex(fileClass, "Reports ({0})", @"(?<=report\().*?dataobject\=\""(?<dataobject>(\w)+)\"".*?name\=(?<name>\w+).*?\)", "{1} : {0}", 12, "reports");
                    AddNodeByRegex(fileClass, "Calculated ({0})", @"(?<=compute\().*?expression\=\""(?<expr>.*?)\"".*?name\=(?<name>\w+).*\)", "{1} : {0}", 12, "calculated");
                    AddNodeByRegex(fileClass, "Texts ({0})", @"(?<=text\().*?text\=\""(?<expr>.*?)\"".*?name\=(?<name>\w+).*\)", "\"{0}\" : {1}", 15, "text");
                    //treeView1.ExpandAll();
                }
                else if (fileClass.IsSql == false)
                {
                    treeView1.Nodes.Clear();
                    foreach (PowerBuilderFileType powerBuilderFileType in fileClass.PowerBuilderFileTypes)
                    {
                        MainEngine.Instance.FillRnCounts(fileClass.Text);

                        var typeNode = new TreeNode();
                        if (powerBuilderFileType.IsMainType)
                        {
                            typeNode.Expand();
                        }
                        FilePositionItem textVar = GetVarValueFromType(powerBuilderFileType, "Text", fileClass, @"string\s*(text|title)\s*\=\s*\""(?<dataobj>[^""]+)""");
                        var name = string.IsNullOrEmpty(textVar?.Name) ? "" : "  '" + textVar?.Name + "'  ";
                        typeNode.Text = $"{powerBuilderFileType.Name}{name}: {powerBuilderFileType.InheritFrom}";
                        typeNode.Tag  = powerBuilderFileType;
                        //typeNode.NodeFont = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Bold);
                        if (typeNode.Text.ToLower().StartsWith("w"))
                        {
                            typeNode.ImageIndex = 0;
                        }
                        if (typeNode.Text.ToLower().StartsWith("d"))
                        {
                            typeNode.ImageIndex = 7;
                        }
                        if (typeNode.Text.ToLower().StartsWith("u"))
                        {
                            typeNode.ImageIndex = 2;
                        }
                        if (typeNode.Text.ToLower().StartsWith("s"))
                        {
                            typeNode.ImageIndex = 1;
                        }
                        if (typeNode.Text.ToLower().StartsWith("cb"))
                        {
                            typeNode.ImageIndex = 13;
                        }
                        typeNode.SelectedImageIndex = typeNode.ImageIndex;

                        //DataObjects
                        if (powerBuilderFileType.Name.ToLower().StartsWith("d"))
                        {
                            string initialDataObject = "";
                            var    dataObjNode       = new TreeNode();
                            dataObjNode.Text               = "Dataobject";
                            dataObjNode.ImageIndex         = 7;
                            dataObjNode.SelectedImageIndex = dataObjNode.ImageIndex;
                            typeNode.Nodes.Add(dataObjNode);

                            string textInstanceRange = fileClass.Text.Substring(powerBuilderFileType.IndexStart, powerBuilderFileType.IndexInstanceVarEnd - powerBuilderFileType.IndexStart);
                            Match  match             = Regex.Match(textInstanceRange, @"string\s*dataobject\s*\=\s*\""(?<dataobj>\w+)""", RegexOptions.ExplicitCapture);
                            if (match.Success)
                            {
                                string dataObjectSource = match.Groups["dataobj"].Value;
                                initialDataObject = dataObjectSource;
                                //typeNode.Text = string.Format(@"{0} ""{2}"" : {1}", powerBuilderFileType.Name, powerBuilderFileType.InheritFrom, initialDataObject);
                                TreeNode dnode = new TreeNode();
                                dnode.Text = initialDataObject;
                                dnode.Tag  = new FilePositionItem()
                                {
                                    LineNumberStart = MainEngine.Instance.GetTextLineByCharIndex(powerBuilderFileType.IndexStart + match.Groups["dataobj"].Index),
                                    ItemType        = "DataObjectSource",
                                    Name            = dataObjectSource
                                };
                                dataObjNode.Tag = new FilePositionItem()
                                {
                                    LineNumberStart = MainEngine.Instance.GetTextLineByCharIndex(powerBuilderFileType.IndexStart + match.Groups["dataobj"].Index),
                                    ItemType        = "DataObjectList"
                                };
                                dataObjNode.Nodes.Add(dnode);
                            }

                            int length = powerBuilderFileType.IndexEnd - powerBuilderFileType.IndexStart;
                            length            = length > 0 ? length : fileClass.Text.Length - powerBuilderFileType.IndexStart;
                            textInstanceRange = fileClass.Text.Substring(powerBuilderFileType.IndexStart, length);

                            MatchCollection matchesCollection    = Regex.Matches(textInstanceRange, @"[\r\n](\s*)(this\.)?dataobject\s*\=\s*(\""|\')(?<dataobj>\w+)(\""|\')", RegexOptions.ExplicitCapture);
                            MatchCollection matchesCollection2   = Regex.Matches(fileClass.Text, @"[\r\n](\s*)" + powerBuilderFileType.Name + @"\.dataobject\s*\=\s*(\""|\')(?<dataobj>\w+)(\""|\')", RegexOptions.ExplicitCapture);
                            Action <MatchCollection, int> action = (MatchCollection matches, int indexOffset) =>
                            {
                                foreach (Match m in matches)
                                {
                                    TreeNode dnode            = new TreeNode();
                                    string   dataObjectSource = m.Groups["dataobj"].Value;
                                    dnode.Text = dataObjectSource;
                                    dnode.Tag  = new FilePositionItem()
                                    {
                                        LineNumberStart = MainEngine.Instance.GetTextLineByCharIndex(indexOffset + m.Groups["dataobj"].Index),
                                        ItemType        = "DataObjectSource",
                                        Name            = dataObjectSource
                                    };
                                    dataObjNode.Nodes.Add(dnode);
                                }
                            };
                            action.Invoke(matchesCollection, powerBuilderFileType.IndexStart);
                            action.Invoke(matchesCollection2, 0);
                            int count = dataObjNode.Nodes.Count;
                            if (count > 1)
                            {
                                dataObjNode.Text = $"Dataobjects ({count})";
                            }
                            typeNode.Text = string.Format(@"{0} ""{2}""{3}: {1}", powerBuilderFileType.Name, powerBuilderFileType.InheritFrom, initialDataObject, count > 1 ? " (" + count + ") ":" ");
                        }

                        // Events
                        foreach (var filePositionItem in powerBuilderFileType.Events.OrderBy(o => o.Name))
                        {
                            var eventNode = new TreeNode();
                            eventNode.Text        = $"{filePositionItem.Name}{(filePositionItem.ItemParameters.Length > 0 ? " (...) " : " () ")}[{filePositionItem.LineNumberEnd - filePositionItem.LineNumberStart}]";
                            eventNode.Tag         = filePositionItem;
                            eventNode.ImageIndex  = 6;
                            eventNode.ToolTipText = $"{filePositionItem.Name}{" (" + filePositionItem.ItemParameters + ") "}[{filePositionItem.LineNumberEnd - filePositionItem.LineNumberStart}]";
                            ;
                            eventNode.SelectedImageIndex = eventNode.ImageIndex;
                            if (filePositionItem.IsHasCode == false)
                            {
                                eventNode.ForeColor = Color.DimGray;
                            }
                            typeNode.Nodes.Add(eventNode);
                        }

                        //Functions
                        foreach (var filePositionItem in powerBuilderFileType.Functions.OrderBy(o => o.Name))
                        {
                            var eventNode = new TreeNode();
                            eventNode.Text        = $"{filePositionItem.Name}{(filePositionItem.ItemParameters.Length > 0 ? " (...) " : " () ")}: {(filePositionItem.ReturnType == "subroutine" ? "" : filePositionItem.ReturnType)} [{filePositionItem.LineNumberEnd - filePositionItem.LineNumberStart}]";
                            eventNode.Tag         = filePositionItem;
                            eventNode.ImageIndex  = 10;
                            eventNode.ToolTipText = $"{filePositionItem.Name}{" (" + filePositionItem.ItemParameters + ") "}: {(filePositionItem.ReturnType == "subroutine" ? "" : filePositionItem.ReturnType)} [{filePositionItem.LineNumberEnd - filePositionItem.LineNumberStart}]";
                            ;
                            eventNode.SelectedImageIndex = eventNode.ImageIndex;
                            if (filePositionItem.IsHasCode == false)
                            {
                                eventNode.ForeColor = Color.DimGray;
                            }
                            typeNode.Nodes.Add(eventNode);
                        }
                        treeView1.Nodes.Add(typeNode);
                    }
                }
                treeView1.EndUpdate();
            }
            catch (Exception ex)
            {
            }
        }
Example #5
0
        public void AnalayzeFileForTypes(FileClass fileClass)
        {
            string text = fileClass.Text;

            try
            {
                //return;
//                var regex = new Regex(@"^event\s*(?<eventname>\w+)\s*(\((?<params>.*?)\))?;.*", RegexOptions.Multiline);
//                MatchCollection matchCollection = regex.Matches(text);
                //var test = Regex.Matches(text, @"(?<=event)\s*(?<eventname>\w+)\s*\((?<params>.+?)\);(.+?)(?=end event)", RegexOptions.Multiline);

                FillRnCounts(text);

                Match matchEndFarword = Regex.Match(text, "end forward", RegexOptions.ExplicitCapture, TimeSpan.FromSeconds(5));
                int   indexEndFarword = matchEndFarword.Groups[0].Index;

                string typeListRegex = @"(?si)[\n](global\s+type|type)+\s+(?<typename>\w+)\s+from\s+(?<inferitfrom>\w+)(\s+within\s+\w+)?(?<instatncevars>.*?)(?<endtype>end type)";

                MatchCollection matchCollection = Regex.Matches(text, typeListRegex, RegexOptions.ExplicitCapture, TimeSpan.FromSeconds(5));
                // Find Types
                PowerBuilderFileType fileType = null;
                fileClass.PowerBuilderFileTypes = new List <PowerBuilderFileType>();
                foreach (Match matchType in matchCollection)
                {
                    if (indexEndFarword > matchType.Groups[1].Index)
                    {
                        continue;
                    }

                    if (fileType != null)
                    {
                        fileType.IndexEnd      = matchType.Groups[1].Index;
                        fileType.LineNumberEnd = GetTextLineByCharIndex(fileType.IndexEnd);
                    }
                    //New type
                    fileType                       = new PowerBuilderFileType();
                    fileType.Name                  = matchType.Groups["typename"].Value;
                    fileType.InheritFrom           = matchType.Groups["inferitfrom"].Value;
                    fileType.IndexInstanceVarStart = matchType.Groups[3].Index;
                    fileType.IndexStart            = matchType.Groups[1].Index;
                    fileType.IndexInstanceVarEnd   = matchType.Groups["endtype"].Index;

                    fileType.LineNumberStart           = GetTextLineByCharIndex(fileType.IndexStart);
                    fileType.LineNumberInstanceVarsEnd = GetTextLineByCharIndex(fileType.IndexInstanceVarEnd);

                    fileClass.PowerBuilderFileTypes.Add(fileType);

                    //Find Instance Vars
                    if (matchType.Groups[3].Length > 5)
                    {
                        //
                    }
                }

                string eventListRegex = @"(?si)([\n]event|^event)(.*?)(?<eventname>\w+)\s*(\((?<params>.*?)\))?;(?<body>.*?)(?<endevent>([\n]e|^e)nd event)";
                foreach (var powerBuilderFileType in fileClass.PowerBuilderFileTypes)
                {
                    int length = powerBuilderFileType.IndexEnd - powerBuilderFileType.IndexInstanceVarEnd;
                    if (length < 0)
                    {
                        length = text.Length - powerBuilderFileType.IndexInstanceVarEnd;
                    }
                    var subText = text.Substring(powerBuilderFileType.IndexInstanceVarEnd, length);
                    matchCollection = Regex.Matches(subText, eventListRegex, RegexOptions.ExplicitCapture, TimeSpan.FromSeconds(5));
                    foreach (Match eventMatch in matchCollection)
                    {
                        var filePositionItem = new FilePositionItem();
                        filePositionItem.Name            = eventMatch.Groups[1].Value;
                        filePositionItem.ItemType        = "event";
                        filePositionItem.ItemParameters  = eventMatch.Groups[2].Value;
                        filePositionItem.IndexItemStart  = eventMatch.Groups[1].Index + powerBuilderFileType.IndexInstanceVarEnd;
                        filePositionItem.IndexItemEnd    = eventMatch.Groups[4].Index + powerBuilderFileType.IndexInstanceVarEnd;
                        filePositionItem.IsHasCode       = eventMatch.Groups[3].Length > 5;
                        filePositionItem.LineNumberStart = GetTextLineByCharIndex(filePositionItem.IndexItemStart);
                        filePositionItem.LineNumberEnd   = GetTextLineByCharIndex(filePositionItem.IndexItemEnd);
                        powerBuilderFileType.Events.Add(filePositionItem);
                    }
                }


                if (fileClass.PowerBuilderFileTypes.Count > 0)
                {
                    string functionListRegex = @"(?si)([\n](public|private|protected)(\sfunction)?|^(public|private|protected)(\sfunction)?)\s*(?<functype>\w+)\s*(?<functname>\w+)\s*(\((?<params>[^\)]*?)\));+(?<body>.*?)(?<endfunct>end(\sfunction|\ssubroutine))";
//                    string functionListRegex = @"(?si)([\n](public|private)(\sfunction)?|^(public|private)(\sfunction)?)\s*(?<functype>\w+)\s*(?<functname>\w+)\s*(\((?<params>[^)]*?)\));+(?<body>.*?)(?<endfunct>end(\sfunction|\ssubroutine))";
                    //var powerBuilderFileType = fileClass.PowerBuilderFileTypes.FirstOrDefault();
                    foreach (var powerBuilderFileType in fileClass.PowerBuilderFileTypes)
                    {
                        int length = powerBuilderFileType.IndexEnd - powerBuilderFileType.IndexInstanceVarEnd;
                        if (length < 0)
                        {
                            length = text.Length - powerBuilderFileType.IndexInstanceVarEnd;
                        }
                        var subText = text.Substring(powerBuilderFileType.IndexInstanceVarEnd, length);
                        matchCollection = Regex.Matches(subText, functionListRegex, RegexOptions.ExplicitCapture, TimeSpan.FromSeconds(5));
                        foreach (Match eventMatch in matchCollection)
                        {
                            var filePositionItem = new FilePositionItem();
                            filePositionItem.Name            = eventMatch.Groups[2].Value;
                            filePositionItem.ReturnType      = eventMatch.Groups[1].Value;
                            filePositionItem.ItemType        = "function";
                            filePositionItem.ItemParameters  = eventMatch.Groups[3].Value;
                            filePositionItem.IndexItemStart  = eventMatch.Groups[2].Index + powerBuilderFileType.IndexInstanceVarEnd;
                            filePositionItem.IndexItemEnd    = eventMatch.Groups[5].Index + powerBuilderFileType.IndexInstanceVarEnd;
                            filePositionItem.IsHasCode       = eventMatch.Groups[4].Length > 5;
                            filePositionItem.LineNumberStart = GetTextLineByCharIndex(filePositionItem.IndexItemStart);
                            filePositionItem.LineNumberEnd   = GetTextLineByCharIndex(filePositionItem.IndexItemEnd);
                            powerBuilderFileType.Functions.Add(filePositionItem);
                        }
                    }
                }

                _rnCounts = null;
            }
            catch (Exception e) {
                MessageBox.Show(e.Message);
            }
        }