Exemple #1
0
        private void ExtractLineInformation(List <string> lines)
        {
            int lineCounter = 0;

            foreach (string line in lines)
            {
                #region Intialize LineStruct with default values
                LineStruct lineStruct = new LineStruct
                {
                    fullLineText                = string.Empty,
                    structText                  = string.Empty,
                    dataTypeText                = string.Empty,
                    nodeStatus                  = NodeStatus.None,
                    nodeType                    = NodeType.None,
                    currentNodes                = new List <string>(),
                    previousNodes               = new List <string>(),
                    currentNodesFormatted       = new List <string>(),
                    previousNodesFormatted      = new List <string>(),
                    currentNodesWithoutIndexes  = new List <string>(),
                    previousNodesWithoutIndexes = new List <string>(),
                    lastNode                    = string.Empty,
                    lastNodeFormatted           = string.Empty,
                    nodeLevel                   = 0,
                    nodeDatatype                = string.Empty,
                    isStructReplicated          = false,
                    lineNumber                  = 0,
                    previousChildNumbers        = 0,
                    matchedItemsCount           = 0,
                    isArray = false
                };

                //Debugging: To Print Line Number in Output
                lineStruct.lineNumber = lineCounter++;

                lineStruct.fullLineText = line;

                //Make sure there is two parts ... 0:nodes 1:dataType
                if (lineStruct.fullLineText.Split(',').Length < 2)
                {
                    return;
                }

                lineStruct.structText   = lineStruct.fullLineText.Split(',')[0];
                lineStruct.dataTypeText = lineStruct.fullLineText.Split(',')[1];

                lineStruct.currentNodes  = (lineStruct.structText.Split('.')).ToList();
                lineStruct.previousNodes = (previousPartOfStruct.Split('.')).ToList();

                lineStruct.currentNodesFormatted  = (lineStruct.structText.Split('.')).ToList();
                lineStruct.previousNodesFormatted = (previousPartOfStruct.Split('.')).ToList();

                lineStruct.currentNodesWithoutIndexes  = (lineStruct.structText.Split('.')).ToList();
                lineStruct.previousNodesWithoutIndexes = (previousPartOfStruct.Split('.')).ToList();

                bool isArray  = false;
                bool isArray2 = false;

                #endregion

                #region Node's Formatting & CleanUp

                //Node's Formatting: Making [i] to [{i}]
                lineStruct.lastNode          = lineStruct.currentNodes.Last();
                lineStruct.lastNodeFormatted = RemoveBetween(lineStruct.currentNodes.Last(), '[', ']', out isArray);

                for (int i = 0; i < lineStruct.currentNodes.Count; i++)
                {
                    //Node's Formatting: Making [i] to [{i}] only to last element
                    if (i == lineStruct.currentNodes.Count - 1)
                    {
                        lineStruct.currentNodesFormatted[i] = RemoveBetween(lineStruct.currentNodes[i], '[', ']', isArray: out isArray2);
                    }
                    //Node's Clean Up: Replace index with [{0}] for string.format( )
                    else
                    {
                        //2018.12.18: Bug Fixed: command0 issue.
                        //lineStruct.currentNodesFormatted[i] = lineStruct.currentNodes[i].Replace("[", "[{").Replace("]", "}]").Replace("1", "0");

                        if (lineStruct.currentNodes[i].Contains("[") && lineStruct.currentNodes[i].Contains("]"))
                        {
                            lineStruct.currentNodesFormatted[i] = lineStruct.currentNodes[i].Replace("[", "[{").Replace("]", "}]").Replace("1", "0");
                        }

                        lineStruct.currentNodesFormatted[i] = lineStruct.currentNodes[i].Replace("[", "[{").Replace("]", "}]");
                    }
                }

                for (int i = 0; i < lineStruct.previousNodes.Count; i++)
                {
                    lineStruct.previousNodesWithoutIndexes[i] = RemoveBetween(lineStruct.previousNodes[i], '[', ']', isArray: out isArray2).Replace("[", "").Replace("]", "");
                }

                for (int i = 0; i < lineStruct.currentNodes.Count; i++)
                {
                    lineStruct.currentNodesWithoutIndexes[i] = RemoveBetween(lineStruct.currentNodes[i], '[', ']', isArray: out isArray2).Replace("[", "").Replace("]", "");
                }

                #endregion

                #region Compare Current Nodes with Previous Nodes

                int currentNodeMatchCount = 0, previousNodeMatchCount = 0;
                int currentNodeWithoutIndexMatchCount = 0, previousNodeWithoutIndexMatchCount = 0;

                for (int i = 0; i < lineStruct.currentNodes.Count; i++)
                {
                    currentNodeMatchCount++;

                    if (i < lineStruct.previousNodes.Count())
                    {
                        if (lineStruct.currentNodes[i] == lineStruct.previousNodes[i])
                        {
                            previousNodeMatchCount++;
                        }
                    }
                }

                for (int i = 0; i < lineStruct.currentNodesWithoutIndexes.Count; i++)
                {
                    currentNodeWithoutIndexMatchCount++;

                    if (i < lineStruct.previousNodes.Count())
                    {
                        if (lineStruct.currentNodesWithoutIndexes[i] == lineStruct.previousNodesWithoutIndexes[i])
                        {
                            previousNodeWithoutIndexMatchCount++;
                        }
                    }
                }

                lineStruct.currentNodeMatchCount  = currentNodeMatchCount;
                lineStruct.previousNodeMatchCount = previousNodeMatchCount;

                lineStruct.currentNodeWithoutIndexMatchCount  = currentNodeWithoutIndexMatchCount;
                lineStruct.previousNodeWithoutIndexMatchCount = previousNodeWithoutIndexMatchCount;

                #endregion

                if (lineStruct.fullLineText == "GVL_Automation.fbLoadConv.fbLifterIn.pis_SideHolder.b_CloseLoop,ARRAY [0..2] OF BOOL,")
                {
                }
                if (lineStruct.fullLineText == "GVL_Automation.stCarr,ARRAY [0..6] OF E_CarrierStationState,")
                {
                }

                if (lineStruct.lineNumber == 1175)
                {
                }

                //2018.12.25: Verify the CurrentNodes against AllStructs
                var    currentNodesWithIndexes       = lineStruct.currentNodesWithoutIndexes;
                string currentNodesStrWithoutIndexes = string.Join(".", currentNodesWithIndexes);
                if (listOfAllStructs.Exists(x => x.Contains(currentNodesStrWithoutIndexes)))
                {
                    lineStruct.isAllStructReplicated = true;
                }
                else
                {
                    listOfAllStructs.Add(currentNodesStrWithoutIndexes);
                }

                #region NodeStatus

                //If parents matches:   1:Node appended   2. Peer node
                if (lineStruct.currentNodes[0] == lineStruct.previousNodes[0])
                {
                    //2018.12.24 Not every contains(previousNode) is appended node
                    var nodes    = lineStruct.currentNodesWithoutIndexes;
                    var lastNode = lineStruct.currentNodesWithoutIndexes[nodes.Count - 1];
                    nodes.Remove(lastNode);
                    string nodesStrWithoutIndexes = string.Join(".", nodes);

                    if (listOfStructs.Exists(x => x.Contains(nodesStrWithoutIndexes)))
                    {
                        lineStruct.nodeStatus            = NodeStatus.PeerNodeWithSameParents;
                        lineStruct.isAllStructReplicated = true;
                    }

                    //If new node contains the previous node ... then it will be appended
                    else if (lineStruct.structText.Contains(previousPartOfStruct))
                    {
                        lineStruct.nodeStatus = NodeStatus.AppendedNodeWithSameParents;
                    }

                    //2018.12.20: Node match count updated [May be Fix required]
                    //If new node didn't contain the previous node && second last item are same for both ... then it will be peer node
                    else if (lineStruct.currentNodes.AsEnumerable().Reverse().Skip(1).FirstOrDefault() == lineStruct.previousNodes.AsEnumerable().Reverse().Skip(1).FirstOrDefault() &&
                             currentNodeMatchCount - 1 == previousNodeMatchCount)
                    {
                        lineStruct.nodeStatus = NodeStatus.PeerNodeWithSameParents;
                    }

                    //2018.12.15  PreviousNodeWithDifferentParents Condtion added.
                    //If new node didn't contain the previous node && second last item are not same for both ... then it will be previous node
                    else if (lineStruct.previousNodeMatchCount > 1 && lineStruct.lineNumber != 1)
                    {
                        //2018.12.18 Further condition added
                        //If all parents elements are same except the last one, then they have same parents
                        if (lineStruct.previousNodes.Intersect(lineStruct.currentNodes).Count() == lineStruct.currentNodes.Count() - 1)
                        {
                            lineStruct.nodeStatus = NodeStatus.PreviousNodeWithSameParents;
                        }
                        else
                        {
                            lineStruct.nodeStatus = NodeStatus.PreviousNodeWithDifferentParents;
                            lineStruct.nodeLevel  = previousNodeMatchCount;
                        }
                    }

                    //2018.12.28: Only Top Parent Matched case
                    else if (lineStruct.previousNodeMatchCount == 1)
                    {
                        lineStruct.nodeStatus = NodeStatus.PreviousNodeWithDifferentParents;
                        lineStruct.nodeLevel  = previousNodeMatchCount;
                    }

                    //[May be Fix required]
                    else
                    {
                        lineStruct.nodeStatus = NodeStatus.NotFound;
                    }
                }

                //If both didn't have same parent, then it be new node
                else
                {
                    lineStruct.nodeStatus = NodeStatus.NewParent;
                }

                #endregion

                //Testing the NodeType
                string[] arrays = new string[] { "ARRAY" };

                string[] dataTypes = new string[] { "BOOL", "INT", "TIME", "E_ErrorPiton", "STRING", "UINT", "SINT", "LREAL", "WORD", "DWORD", "UDINT", "DINT", "BYTE", "LINT" };

                //Skip the headings (with Text "ARRAY")
                if (lineStruct.dataTypeText.ContainsAny(arrays, StringComparison.Ordinal))
                {
                    string textBwBrackets = lineStruct.dataTypeText.Split('[', ']')[1];

                    int arrayCount = 0;

                    int.TryParse(textBwBrackets.Replace("..", ".").Split('.')[1], out arrayCount);              //TODO: Take arrayCount globally

                    //HR: 2018.12.13 Fixed the Index Exception
                    if (lineStruct.dataTypeText.Split(new string[] { "OF" }, StringSplitOptions.RemoveEmptyEntries).Count() >= 2)
                    {
                        string structName = lineStruct.dataTypeText.Split(new string[] { "OF" }, StringSplitOptions.RemoveEmptyEntries)[1];
                        if ((!structName.ContainsAny(dataTypes, StringComparison.Ordinal) && !listOfStructsTypes.Contains(structName)))
                        {
                            listOfStructsTypes.Add(structName.Trim());
                        }

                        if (lineStruct.nodeStatus == NodeStatus.PreviousNodeWithDifferentParents)
                        {
                            for (int i = previousNodeMatchCount; i < lineStruct.currentNodes.Count; i++)
                            {
                                listOfStructsTypes.Add(lineStruct.currentNodes[i].Trim());
                            }
                        }
                    }
                    continue;
                }

                //Strcutures
                else if (lineStruct.dataTypeText.ContainsAny(listOfStructsTypes, StringComparison.Ordinal))
                {
                    //HR: 2018.12.24: Should take the clean struct without indexes.
                    //string structNameCleaned = RemoveBetween(lineStruct.structText, '[', ']', isArray: out isArray2);
                    string structNameCleaned = RemoveBetween(lineStruct.structText, '[', ']', isArray: out isArray2).Replace("[", "").Replace("]", "");

                    if (listOfStructs.Exists(x => x == structNameCleaned))
                    {
                        isStructReplicated = true;
                        structIndex++;
                    }
                    else
                    {
                        isStructReplicated = false;
                        structIndex        = 0;

                        listOfStructs.Add(structNameCleaned);

                        //2018.12.25: Also add it to the listOfAllStructs
                        var    nodes = lineStruct.currentNodesWithoutIndexes;
                        string nodesStrWithoutIndexes = string.Join(".", nodes);
                        listOfAllStructs.Add(nodesStrWithoutIndexes);

                        previousStruct = lineStruct.lastNodeFormatted;
                    }

                    //2018.12.16 & 2018.12.21
                    var    joinedAllStruct        = string.Join(",", lineStruct.currentNodes);
                    string joinedAllStructCleaned = RemoveBetween(joinedAllStruct, '[', ']', isArray: out isArray2);
                    if (listOfAllStructs.Exists(x => x == joinedAllStructCleaned))
                    {
                        lineStruct.isAllStructReplicated = true;
                    }
                    else
                    {
                        lineStruct.isAllStructReplicated = false;
                        listOfAllStructs.Add(joinedAllStructCleaned);

                        //2018.12.20 Commented
                        if (lineStruct.lineNumber != 1)
                        {
                            lineStruct.nodeStatus = NodeStatus.PreviousNodeWithDifferentParents;
                        }
                    }

                    lineStruct.nodeType     = NodeType.Structure;
                    lineStruct.nodeDatatype = "struct";

                    lineStruct.previousChildNumbers = childNumber;
                    childNumber = 0;
                }

                //Properties
                else if (lineStruct.dataTypeText.ContainsAny(dataTypes, StringComparison.Ordinal))
                {
                    //string structNameCleaned = lineStruct.currentNodes.AsEnumerable().Reverse().Skip(1).FirstOrDefault();
                    //2018.12.25 Properites should also be cleaned
                    //string structNameCleaned = lineStruct.currentNodes.AsEnumerable().Reverse().FirstOrDefault();
                    string node = lineStruct.currentNodes.AsEnumerable().Reverse().FirstOrDefault();
                    string structNameCleaned = RemoveBetween(node, '[', ']', isArray: out isArray2).Replace("[", "").Replace("]", "");

                    if (listOfStructs.Exists(x => x == structNameCleaned))
                    {
                    }
                    else
                    {
                        //2018.12.25:
                        isStructReplicated = false;
                        listOfStructs.Add(structNameCleaned);
                    }

                    if (isArray)
                    {
                        lineStruct.isArray = true;
                    }
                    else
                    {
                        lineStruct.isArray = false;
                    }

                    if (lineStruct.lastNodeFormatted == previousArray)
                    {
                        isArrayReplicated = true;
                        arrayIndex++;
                    }
                    else
                    {
                        isArrayReplicated = false;
                        arrayIndex        = 0;

                        previousArray = lineStruct.lastNodeFormatted;
                    }

                    #region NodeType
                    lineStruct.nodeType = NodeType.DataType;

                    if (lineStruct.dataTypeText == "BOOL")
                    {
                        lineStruct.nodeDatatype = "bool";
                    }
                    else if (lineStruct.dataTypeText == "INT")
                    {
                        lineStruct.nodeDatatype = "int";
                    }
                    else if (lineStruct.dataTypeText == "TIME")
                    {
                        lineStruct.nodeDatatype = "int";
                    }
                    else if (lineStruct.dataTypeText == "E_ErrorPiton")
                    {
                        lineStruct.nodeDatatype = "int";
                    }
                    else if (lineStruct.dataTypeText.Contains("STRING"))
                    {
                        lineStruct.nodeDatatype = "string";
                    }

                    else if (lineStruct.dataTypeText == "UINT")
                    {
                        lineStruct.nodeDatatype = "uint";
                    }
                    else if (lineStruct.dataTypeText == "SINT")
                    {
                        lineStruct.nodeDatatype = "int";
                    }
                    else if (lineStruct.dataTypeText == "LREAL")
                    {
                        lineStruct.nodeDatatype = "double";
                    }
                    else if (lineStruct.dataTypeText == "WORD")
                    {
                        lineStruct.nodeDatatype = "ushort";
                    }
                    else if (lineStruct.dataTypeText == "DWORD")
                    {
                        lineStruct.nodeDatatype = "uint";
                    }
                    else if (lineStruct.dataTypeText == "UDINT")
                    {
                        lineStruct.nodeDatatype = "double";
                    }
                    else if (lineStruct.dataTypeText == "DINT")
                    {
                        lineStruct.nodeDatatype = "double";
                    }
                    else if (lineStruct.dataTypeText == "BYTE")
                    {
                        lineStruct.nodeDatatype = "byte";
                    }
                    else if (lineStruct.dataTypeText == "LINT")
                    {
                        lineStruct.nodeDatatype = "int";
                    }
                    else
                    {
                        lineStruct.nodeDatatype = "int";
                    }
                    #endregion

                    childNumber = childNumber + 1;
                    lineStruct.previousChildNumbers = childNumber;
                }

                else if ((lineStruct.nodeStatus == NodeStatus.PreviousNodeWithSameParents && !lineStruct.currentNodes.AsEnumerable().Reverse().Skip(1).FirstOrDefault().Contains("[")))
                {
                    //2018.12.25 Properites should also be cleaned
                    //string structNameCleaned = lineStruct.currentNodes.AsEnumerable().Reverse().Skip(1).FirstOrDefault();
                    string node = lineStruct.currentNodes.AsEnumerable().Reverse().Skip(1).FirstOrDefault();
                    string structNameCleaned = RemoveBetween(node, '[', ']', isArray: out isArray2).Replace("[", "").Replace("]", "");

                    if (listOfStructs.Exists(x => x == structNameCleaned))
                    {
                        isStructReplicated = true;
                        structIndex++;

                        //2018.12.25
                        var dump = lineStruct.currentNodesWithoutIndexes;
                        var last = lineStruct.currentNodesWithoutIndexes[dump.Count - 1];
                        dump.Remove(last);
                        //COMMENTED
                        //var joinedAllStruct = string.Join(",", lineStruct.currentNodes);
                        var joinedAllStruct = string.Join(".", dump);
                        if (listOfAllStructs.Exists(x => x == joinedAllStruct))
                        {
                            lineStruct.isAllStructReplicated = true;
                        }
                        else
                        {
                            lineStruct.isAllStructReplicated = false;
                            listOfAllStructs.Add(joinedAllStruct);

                            //2018.12.20 Commented
                            if (lineStruct.lineNumber != 1)
                            {
                                lineStruct.nodeStatus = NodeStatus.PreviousNodeWithDifferentParents;
                            }
                        }
                    }
                    else
                    {
                        isStructReplicated = false;
                        structIndex        = 0;

                        listOfStructs.Add(structNameCleaned);

                        //2018.12.25: Also add it to the listOfAllStructs
                        var    nodes = lineStruct.currentNodesWithoutIndexes;
                        string nodesStrWithoutIndexes = string.Join(".", nodes);
                        listOfAllStructs.Add(nodesStrWithoutIndexes);

                        previousStruct = lineStruct.lastNodeFormatted;
                    }

                    lineStruct.nodeType     = NodeType.Structure;
                    lineStruct.nodeDatatype = "struct";

                    //2018.12.20: Commented
                    //lineStruct.nodeStatus = NodeStatus.PreviousNodeWithDifferentParents;

                    childNumber = 0;
                    lineStruct.previousChildNumbers = childNumber;
                }

                else
                {
                    lineStruct.nodeType     = NodeType.NotConfirmed;
                    lineStruct.nodeDatatype = "int";

                    childNumber = childNumber + 1;
                    lineStruct.previousChildNumbers = childNumber;
                }

                lineStruct.nodeLevel = currentNodeMatchCount;

                lineStruct.isStructReplicated = isStructReplicated;
                lineStruct.structIndex        = structIndex;

                lineStruct.isArrayReplicated = isArrayReplicated;
                lineStruct.arrayIndex        = arrayIndex;

                #region Debugging Information on Output
                //2018.12.13 & 2018.12.24 Padding Increased
                Debug.WriteLine(
                    lineStruct.lineNumber.ToString().PadRight(8) +
                    "cm:" + currentNodeMatchCount.ToString().PadRight(3) + " pm:" + previousNodeMatchCount.ToString().PadRight(3) + " nL:" + lineStruct.nodeLevel.ToString().PadRight(3) +
                    "s:" + lineStruct.nodeStatus.ToString().PadRight(35) + " t:" + lineStruct.nodeType.ToString().PadRight(14) +
                    "structR:" + lineStruct.isStructReplicated.ToString().PadRight(7) + " structR:" + lineStruct.isAllStructReplicated.ToString().PadRight(7) + "isArray:" + lineStruct.isArray.ToString().PadRight(10) +
                    "n:" + lineStruct.lastNode.ToString().PadRight(35) + "cm:" + lineStruct.structText.PadRight(50) /*+ "cNum:" + lineStruct.previousChildNumbers*/);
                #endregion

                previousPartOfStruct = lineStruct.structText;

                listOfLineStructs.Add(lineStruct);
            }
        }
Exemple #2
0
        private void WriteIntoCodeFile(LineStruct lineStruct, string nodeInformation = "", int nodeLevel = -1)
        {
            #region Debugging
            if (lineStruct.fullLineText == "GVL_Automation.fbLoadConv.fbLifterIn.pis_SideHolder.b_CloseLoop,ARRAY [0..2] OF BOOL,")
            {
            }
            if (lineStruct.lastNodeFormatted == "stCarr")
            {
            }
            if (lineStruct.lineNumber == 164)
            {
            }
            #endregion


            //No need to write the next index of same struct in the file again
            if (lineStruct.isStructReplicated && lineStruct.isAllStructReplicated)
            {
                return;
            }

            //No need to write the next index of same array in the file again
            if (lineStruct.isArray && lineStruct.isArrayReplicated)
            {
                return;
            }

            // Use defaults if not explicilty defined
            string nodeDatatypePlusNodeName = string.Empty;

            if (lineStruct.isArray)
            {
                nodeDatatypePlusNodeName = (nodeInformation == "") ? lineStruct.nodeDatatype + "[] " + lineStruct.lastNodeFormatted : nodeInformation;
            }
            else
            {
                nodeDatatypePlusNodeName = (nodeInformation == "") ? lineStruct.nodeDatatype + " " + lineStruct.lastNodeFormatted : nodeInformation;
            }

            // Use defaults if not explicilty defined
            lineStruct.nodeLevel = (nodeLevel == -1) ? lineStruct.nodeLevel : nodeLevel;

            //Empty Space / Node Level Calculation
            string emptySpacing = string.Empty;
            for (int i = 0; i < lineStruct.nodeLevel * 4 + 4; i++) //VS uses 4 spaces for indentation
            {
                Console.Write(" ");                                //For Console Debugging
                emptySpacing += " ";                               //For File Writing
            }

            Console.WriteLine(nodeDatatypePlusNodeName);

            //Closing Brackets Calculation (If previous node has no child: Just insert a single closing bracket)
            //HR: 2018.12.14 First Line will not have any previous nodes ...
            if (lineStruct.nodeLevel == 1 && lineStruct.previousChildNumbers == 0 && lineStruct.lineNumber != 1)
            {
                fullText += emptySpacing + "    " + "}" + Environment.NewLine;
            }

            //Closing Brackets Calculation
            int bracketsToMoveBack = prevousNodeLevel - lineStruct.nodeLevel;
            for (int i = bracketsToMoveBack; i > 0; i--)
            {
                var extraEmptySpacing = string.Empty;
                for (int j = 1; j < i; j++)
                {
                    extraEmptySpacing += "    ";
                }
                fullText += emptySpacing + extraEmptySpacing + "}" + Environment.NewLine;
            }

            //Populate Structures
            if (lineStruct.nodeType == NodeType.Structure)
            {
                fullText += emptySpacing + "public " + nodeDatatypePlusNodeName + Environment.NewLine;
                fullText += emptySpacing + "{" + Environment.NewLine;
                fullText += emptySpacing + "    public int index;" + Environment.NewLine;
                fullText += emptySpacing + "    public int arrayIndex;" + Environment.NewLine;
            }

            //Populate Arrays
            else if (lineStruct.isArray)
            {
                string structtext1 = lineStruct.currentNodesFormatted.Last();
                string structtext2 = String.Join(".", lineStruct.currentNodesFormatted.ToArray());
                fullText += emptySpacing + "public void " + structtext1 + " (int i, bool value)" + Environment.NewLine;
                fullText += emptySpacing + "{" + Environment.NewLine;
                fullText += emptySpacing + "    string str = string.Format(\"" + structtext2 + "" + "[{1}]\", index, i);" + Environment.NewLine;
                fullText += emptySpacing + "    symbol = m_plcSymbols[str];" + Environment.NewLine;
                fullText += emptySpacing + "    Client.WriteSymbol(symbol, value.ToString());" + Environment.NewLine;
                fullText += emptySpacing + "}" + Environment.NewLine;
            }

            //Populate Properties
            else
            {
                fullText += emptySpacing + "public " + nodeDatatypePlusNodeName + Environment.NewLine;
                fullText += emptySpacing + "{" + Environment.NewLine;

                //Populating Getter

                fullText += emptySpacing + "    get" + Environment.NewLine;
                fullText += emptySpacing + "    {" + Environment.NewLine;

                //2018.12.28: Fix the index issue.
                //string getterText = String.Join(".", lineStruct.currentNodesFormatted.ToArray()).Replace("1", "0");
                string getterText = String.Join(".", lineStruct.currentNodesFormatted.ToArray()).Replace("1", "0");
                switch (lineStruct.nodeDatatype)
                {
                case "string":
                    fullText += emptySpacing + "        string str = string.Format(\"" + getterText + "\", index);" + Environment.NewLine;
                    fullText += emptySpacing + "        symbol = m_plcSymbols[str];" + Environment.NewLine;
                    fullText += emptySpacing + "        return Client.ReadSymbol(symbol).ToString();" + Environment.NewLine;
                    break;

                case "bool":
                    fullText += emptySpacing + "        string str = string.Format(\"" + getterText + "\", index);" + Environment.NewLine;
                    fullText += emptySpacing + "        symbol = m_plcSymbols[str];" + Environment.NewLine;
                    fullText += emptySpacing + "        return Convert.ToBoolean(Client.ReadSymbol(symbol));" + Environment.NewLine;
                    break;

                case "int":
                    fullText += emptySpacing + "        string str = string.Format(\"" + getterText + "\", index);" + Environment.NewLine;
                    fullText += emptySpacing + "        symbol = m_plcSymbols[str];" + Environment.NewLine;
                    fullText += emptySpacing + "        return Convert.ToInt32(Client.ReadSymbol(symbol));" + Environment.NewLine;
                    break;

                case "uint":
                    fullText += emptySpacing + "        string str = string.Format(\"" + getterText + "\", index);" + Environment.NewLine;
                    fullText += emptySpacing + "        symbol = m_plcSymbols[str];" + Environment.NewLine;
                    fullText += emptySpacing + "        return Convert.ToUInt32(Client.ReadSymbol(symbol));" + Environment.NewLine;
                    break;

                case "double":
                    fullText += emptySpacing + "        string str = string.Format(\"" + getterText + "\", index);" + Environment.NewLine;
                    fullText += emptySpacing + "        symbol = m_plcSymbols[str];" + Environment.NewLine;
                    fullText += emptySpacing + "        return Convert.ToDouble(Client.ReadSymbol(symbol));" + Environment.NewLine;
                    break;

                case "ushort":
                    fullText += emptySpacing + "        string str = string.Format(\"" + getterText + "\", index);" + Environment.NewLine;
                    fullText += emptySpacing + "        symbol = m_plcSymbols[str];" + Environment.NewLine;
                    fullText += emptySpacing + "        return Convert.ToUInt16(Client.ReadSymbol(symbol));" + Environment.NewLine;
                    break;

                case "byte":
                    fullText += emptySpacing + "        string str = string.Format(\"" + getterText + "}\", index);" + Environment.NewLine;
                    fullText += emptySpacing + "        symbol = m_plcSymbols[str];" + Environment.NewLine;
                    fullText += emptySpacing + "        return Convert.ToByte(Client.ReadSymbol(symbol));" + Environment.NewLine;
                    break;

                default:
                    break;
                }
                fullText += emptySpacing + "    }" + Environment.NewLine;

                //Populating Setter

                fullText += emptySpacing + "    set" + Environment.NewLine;
                fullText += emptySpacing + "    {" + Environment.NewLine;

                //2018.12.28: Fix the index issue.
                //string setterText = String.Join(".", lineStruct.currentNodesFormatted.ToArray());
                string setterText = String.Join(".", lineStruct.currentNodesFormatted.ToArray()).Replace("1", "0");
                switch (lineStruct.nodeDatatype)
                {
                case "string":
                    fullText += emptySpacing + "        string str = string.Format(\"" + setterText + "\", index);" + Environment.NewLine;
                    fullText += emptySpacing + "        symbol = m_plcSymbols[str];" + Environment.NewLine;
                    fullText += emptySpacing + "        Client.WriteSymbol(symbol, value.ToString());" + Environment.NewLine;
                    break;

                case "bool":
                    fullText += emptySpacing + "        string str = string.Format(\"" + setterText + "\", index);" + Environment.NewLine;
                    fullText += emptySpacing + "        symbol = m_plcSymbols[str];" + Environment.NewLine;
                    fullText += emptySpacing + "        Client.WriteSymbol(symbol, value.ToString());" + Environment.NewLine;
                    break;

                case "int":
                    fullText += emptySpacing + "        string str = string.Format(\"" + setterText + "\", index);" + Environment.NewLine;
                    fullText += emptySpacing + "        symbol = m_plcSymbols[str];" + Environment.NewLine;
                    fullText += emptySpacing + "        Client.WriteSymbol(symbol, value.ToString());" + Environment.NewLine;
                    break;

                default:
                    fullText += emptySpacing + "        string str = string.Format(\"" + setterText + "\", index);" + Environment.NewLine;
                    fullText += emptySpacing + "        symbol = m_plcSymbols[str];" + Environment.NewLine;
                    fullText += emptySpacing + "        Client.WriteSymbol(symbol, value.ToString());" + Environment.NewLine;
                    break;
                }
                fullText += emptySpacing + "    }" + Environment.NewLine;

                fullText += emptySpacing + "}" + Environment.NewLine;
            }

            prevousNodeLevel = lineStruct.nodeLevel;
        }
        private static void ExtractLineInformation(List <string> lines)
        {
            foreach (string line in lines)
            {
                //Intialize LineStruct with default values...
                LineStruct lineStruct = new LineStruct
                {
                    fullLineText  = string.Empty,
                    structText    = string.Empty,
                    dataTypeText  = string.Empty,
                    nodeStatus    = NodeStatus.None,
                    nodeType      = NodeType.None,
                    currentNodes  = new List <string>(),
                    previousNodes = new List <string>(),
                    lastNode      = string.Empty,
                    nodeLevel     = 0,
                    nodeDatatype  = string.Empty
                };

                lineStruct.fullLineText = line;

                if (line == "GVL_HMI.stCycle_Command.stCycle_ReplaceLoadingTray,ST_Cycle_Control,")
                {
                }

                //Make sure there is two parts ... 0:nodes 1:dataType
                if (lineStruct.fullLineText.Split(',').Length < 2)
                {
                    return;
                }

                lineStruct.structText   = lineStruct.fullLineText.Split(',')[0];
                lineStruct.dataTypeText = lineStruct.fullLineText.Split(',')[1];

                lineStruct.currentNodes = (lineStruct.structText.Split('.')).ToList();

                lineStruct.previousNodes = (previousPartOfStruct.Split('.')).ToList();

                lineStruct.currentNodes.Insert(0, "STPLC");         //Insert STPLC into each nodes' list
                lineStruct.previousNodes.Insert(0, "STPLC");        //Insert STPLC into each nodes' list

                lineStruct.lastNode = lineStruct.currentNodes.Last();

                int currentNodeMatchCount = 0, previousNodeMatchCount = 0;

                //If parents matches:   1:Node appended   2. Peer node
                if (lineStruct.currentNodes[1] == lineStruct.previousNodes[1])      //Ignore STPLC ... take index 1 as parent
                {
                    //If new node contains the previous node ... then it will be appended
                    if (lineStruct.structText.Contains(previousPartOfStruct))
                    {
                        for (int i = 0; i < lineStruct.currentNodes.Count; i++)
                        {
                            currentNodeMatchCount++;

                            if (i < lineStruct.previousNodes.Count())
                            {
                                if (lineStruct.currentNodes[i] == lineStruct.previousNodes[i])
                                {
                                    previousNodeMatchCount++;
                                }
                            }
                        }

                        //Algorithm Update: 2018.10.12: Append Node can contain more than 1 element.
                        lineStruct.nodeStatus = NodeStatus.AppendedNode;

                        if (lineStruct.currentNodes.Count > lineStruct.previousNodes.Count + 1)
                        {
                            lineStruct.nodeStatus = NodeStatus.AppendedNode2;
                        }
                    }

                    //If new node didn't contain the previous node && second last item are same for both ... then it will be peer node
                    else if (lineStruct.currentNodes.AsEnumerable().Reverse().Skip(1).FirstOrDefault() ==
                             lineStruct.previousNodes.AsEnumerable().Reverse().Skip(1).FirstOrDefault())
                    {
                        lineStruct.nodeStatus = NodeStatus.PeerNode;

                        for (int i = 0; i < lineStruct.currentNodes.Count; i++)
                        {
                            currentNodeMatchCount++;

                            if (i < lineStruct.previousNodes.Count())
                            {
                                if (lineStruct.currentNodes[i] == lineStruct.previousNodes[i])
                                {
                                    previousNodeMatchCount++;
                                }
                            }
                        }
                    }

                    //If new node didn't contain the previous node && second last item are not same for both ... then it will be previous node
                    else
                    {
                        lineStruct.nodeStatus = NodeStatus.PreviousNode;

                        for (int i = 0; i < lineStruct.currentNodes.Count; i++)
                        {
                            currentNodeMatchCount++;

                            if (i < lineStruct.previousNodes.Count())
                            {
                                if (lineStruct.currentNodes[i] == lineStruct.previousNodes[i])
                                {
                                    previousNodeMatchCount++;
                                }
                            }
                        }

                        //Algorithm Update: 2018.10.12: Previous Node can contain more than 1 element.
                        if (currentNodeMatchCount > previousNodeMatchCount + 1)
                        {
                            lineStruct.nodeStatus = NodeStatus.PreviousNode2;
                        }
                    }
                }

                //If both didn't have same parent, then it be new node
                else
                {
                    lineStruct.nodeStatus = NodeStatus.NewNode;

                    for (int i = 0; i < lineStruct.currentNodes.Count; i++)
                    {
                        currentNodeMatchCount++;

                        if (i < lineStruct.previousNodes.Count())
                        {
                            if (lineStruct.currentNodes[i] == lineStruct.previousNodes[i])
                            {
                                previousNodeMatchCount++;
                            }
                        }
                    }
                }

                lineStruct.nodeLevel = currentNodeMatchCount;
                //lineStruct.nodeLevel++;                             //To cater STPLC node;

                //Testing the NodeType
                string[] structures = new string[] { "ST_", "DUT_", "FB_" };
                string[] dataTypes  = new string[] { "BOOL", "LREAL", "WORD", "DWORD", "STRING", "INT", "UINT", "BYTE" };

                string[] structuresSkips = new string[] { "^" };
                string[] dataTypeSkips   = new string[] { "POINTER TO" };

                if (lineStruct.structText.ContainsAny(structuresSkips, StringComparison.Ordinal))
                {
                    //Skip this item
                    continue;
                }
                if (lineStruct.dataTypeText.ContainsAny(dataTypeSkips, StringComparison.Ordinal))
                {
                    //Skip this item
                    continue;
                }
                else if (lineStruct.dataTypeText.ContainsAny(dataTypes, StringComparison.Ordinal))
                {
                    lineStruct.nodeType = NodeType.DataType;

                    if (lineStruct.dataTypeText.Contains("STRING"))
                    {
                        lineStruct.nodeDatatype = "string";
                    }
                    else if (lineStruct.dataTypeText == "BOOL")
                    {
                        lineStruct.nodeDatatype = "bool";
                    }
                    else if (lineStruct.dataTypeText == "INT")
                    {
                        lineStruct.nodeDatatype = "int";
                    }
                    else if (lineStruct.dataTypeText == "UINT")
                    {
                        lineStruct.nodeDatatype = "uint";
                    }
                    else if (lineStruct.dataTypeText == "LREAL")
                    {
                        lineStruct.nodeDatatype = "double";
                    }
                    else if (lineStruct.dataTypeText == "WORD")
                    {
                        lineStruct.nodeDatatype = "ushort";
                    }
                    else if (lineStruct.dataTypeText == "DWORD")
                    {
                        lineStruct.nodeDatatype = "uint";
                    }
                    else if (lineStruct.dataTypeText == "UDINT")
                    {
                        lineStruct.nodeDatatype = "double";
                    }
                    else if (lineStruct.dataTypeText == "DINT")
                    {
                        lineStruct.nodeDatatype = "double";
                    }
                    else if (lineStruct.dataTypeText == "TIME")
                    {
                        lineStruct.nodeDatatype = "int";
                    }
                    else if (lineStruct.dataTypeText == "BYTE")
                    {
                        lineStruct.nodeDatatype = "byte";
                    }
                }
                else if (lineStruct.dataTypeText.ContainsAny(structures, StringComparison.Ordinal))
                {
                    lineStruct.nodeType     = NodeType.Structure;
                    lineStruct.nodeDatatype = "struct";

                    //Algorithm Update: 2018.10.13: Remove the struct that contains the array
                    if (listOfLineStructs.Count > 0)                    //Ignore the First Element
                    {
                        //Detection: Both (Last and Current) have same struct type. Both have same node level
                        if (listOfLineStructs.Last().nodeType == NodeType.Structure && listOfLineStructs.Last().nodeLevel == lineStruct.nodeLevel)
                        {
                            listOfLineStructs.RemoveAt(listOfLineStructs.Count - 1);
                            lineStruct.nodeStatus = NodeStatus.NewNode;
                        }
                    }
                }
                else
                {
                    lineStruct.nodeType     = NodeType.NotConfirmed;
                    lineStruct.nodeDatatype = "int";
                }



                Debug.WriteLine(
                    $"cm:{currentNodeMatchCount.ToString().PadRight(5)} pm:{previousNodeMatchCount.ToString().PadRight(5)} " +
                    $"s:{lineStruct.nodeStatus.ToString().PadRight(15)} t:{lineStruct.nodeType.ToString().PadRight(15)} " +
                    $"n:{lineStruct.lastNode.ToString().PadRight(20)} nl:{lineStruct.nodeLevel.ToString().PadRight(5)} cm:{lineStruct.structText} ");

                previousPartOfStruct = lineStruct.structText;

                listOfLineStructs.Add(lineStruct);
            }
        }
Exemple #4
0
        private void FilteringInformation()
        {
            #region Adding Namespace and Class code ...
            fullText =
                "using System;" + Environment.NewLine + Environment.NewLine +

                "namespace PLCApi" + Environment.NewLine +
                "{" + Environment.NewLine +
                "    public partial class PLCTypes : PLCSymbols" + Environment.NewLine +
                "    {" + Environment.NewLine;
            #endregion

            for (int i = 0; i < listOfLineStructs.Count; i++)
            {
                #region Handle the NotConfirmed case
                if (listOfLineStructs[i].nodeType == NodeType.NotConfirmed)
                {
                    if (i < listOfLineStructs.Count - 1)
                    {
                        if (listOfLineStructs[i + 1].nodeStatus == NodeStatus.AppendedNodeWithSameParents)
                        {
                            //It's not INT (It should be struct)
                            listOfLineStructs[i].nodeType     = NodeType.Structure;
                            listOfLineStructs[i].nodeDatatype = "struct";
                        }
                    }
                }
                #endregion

                switch (listOfLineStructs[i].nodeStatus)
                {
                case NodeStatus.NewParent:

                    LineStruct lineStruct = (LineStruct)listOfLineStructs[i].Clone();

                    for (int j = 0; j < listOfLineStructs[i].currentNodes.Count; j++)
                    {
                        if (j < listOfLineStructs[i].currentNodes.Count - 1)
                        {
                            listOfLineStructs[i].nodeType     = NodeType.Structure;
                            listOfLineStructs[i].nodeDatatype = "struct";
                        }
                        else
                        {
                            listOfLineStructs[i].nodeType     = lineStruct.nodeType;
                            listOfLineStructs[i].nodeDatatype = lineStruct.nodeDatatype;
                        }
                        WriteIntoCodeFile(listOfLineStructs[i], listOfLineStructs[i].nodeDatatype + " " + listOfLineStructs[i].currentNodesFormatted[j], j + 1);
                    }

                    break;

                case NodeStatus.AppendedNodeWithSameParents:
                    WriteIntoCodeFile(listOfLineStructs[i]);
                    break;

                case NodeStatus.PeerNodeWithSameParents:
                    WriteIntoCodeFile(listOfLineStructs[i]);
                    break;

                case NodeStatus.PreviousNodeWithSameParents:
                    WriteIntoCodeFile(listOfLineStructs[i]);
                    //WriteIntoCodeFile(listOfLineStructs[i], listOfLineStructs[i].nodeDatatype + " " + listOfLineStructs[i].currentNodesFormatted.AsEnumerable().Reverse().Skip(1).FirstOrDefault(), listOfLineStructs[i].nodeLevel/* - 1*/);
                    break;

                case NodeStatus.PreviousNodeWithDifferentParents:
                    //WriteIntoCodeFile(listOfLineStructs[i], listOfLineStructs[i].nodeDatatype + " " + listOfLineStructs[i].currentNodesFormatted.AsEnumerable().Reverse().Skip(1).FirstOrDefault(), listOfLineStructs[i].nodeLevel - 1);
                    LineStruct lineStruct2 = (LineStruct)listOfLineStructs[i].Clone();

                    for (int j = listOfLineStructs[i].previousNodeMatchCount; j < listOfLineStructs[i].currentNodes.Count; j++)
                    {
                        if (j < listOfLineStructs[i].currentNodes.Count - 1)
                        {
                            listOfLineStructs[i].nodeType     = NodeType.Structure;
                            listOfLineStructs[i].nodeDatatype = "struct";
                        }
                        else
                        {
                            listOfLineStructs[i].nodeType     = lineStruct2.nodeType;
                            listOfLineStructs[i].nodeDatatype = lineStruct2.nodeDatatype;
                        }
                        WriteIntoCodeFile(listOfLineStructs[i], listOfLineStructs[i].nodeDatatype + " " + listOfLineStructs[i].currentNodesFormatted[j], j + 1);
                    }

                    break;

                case NodeStatus.None:
                    break;

                default:
                    break;
                }
            }

            #region Closing Brackets
            int bracketsToMoveBack = prevousNodeLevel + 1 - 0;          //Cater the last struct ...

            for (int i = bracketsToMoveBack; i > 0; i--)
            {
                var extraEmptySpacing = "";
                for (int j = 1; j < i; j++)
                {
                    extraEmptySpacing += "    ";
                }

                fullText += extraEmptySpacing + "}" + Environment.NewLine;
            }
            #endregion
        }
        private static void WriteIntoCodeFile(LineStruct lineStruct, string nodeInformation = "", int nodeLevel = -1)
        {
            // Use defaults if not explicilty defined
            string nodeDatatypePlusNodeName = (nodeInformation == "") ? $"{lineStruct.nodeDatatype} {lineStruct.lastNode}" : nodeInformation;

            // Use defaults if not explicilty defined
            lineStruct.nodeLevel = (nodeLevel == -1) ? lineStruct.nodeLevel : nodeLevel;

            //Empty Space / Node Level Calculation
            string emptySpacing = string.Empty;

            for (int i = 0; i < lineStruct.nodeLevel * 4 + 4; i++) //VS uses 4 spaces for indentation
            {
                Console.Write(" ");                                //For Console Debugging
                emptySpacing += " ";                               //For File Writing
            }

            Console.WriteLine(nodeDatatypePlusNodeName);

            //Closing Brackets Calculation
            int bracketsToMoveBack = prevousNodeLevel - lineStruct.nodeLevel;

            for (int i = bracketsToMoveBack; i > 0; i--)
            {
                var extraEmptySpacing = string.Empty;
                for (int j = 1; j < i; j++)
                {
                    extraEmptySpacing += "    ";
                }
                fullText += emptySpacing + extraEmptySpacing + "}" + Environment.NewLine;
            }

            //Populate Structs and Properties
            if (lineStruct.nodeType == NodeType.Structure)
            {
                fullText += emptySpacing + "public " + nodeDatatypePlusNodeName + Environment.NewLine;
                fullText += emptySpacing + "{" + Environment.NewLine;
            }
            else
            {
                //Populating Getter

                if (lineStruct.nodeType == NodeType.NotConfirmed)
                {
                    fullText += emptySpacing + @"//Datatype yet to be confirmed" + Environment.NewLine;
                }

                fullText += emptySpacing + "public static " + nodeDatatypePlusNodeName + Environment.NewLine;
                fullText += emptySpacing + "{" + Environment.NewLine;
                fullText += emptySpacing + "    get" + Environment.NewLine;
                fullText += emptySpacing + "    {" + Environment.NewLine;
                switch (lineStruct.nodeDatatype)
                {
                case "string":
                    fullText += emptySpacing + $"        symbol = m_plcSymbols[\"{String.Join(".", lineStruct.currentNodes.Skip(1).ToArray())}\"];" + Environment.NewLine;
                    fullText += emptySpacing + $"        return Client.ReadSymbol(symbol).ToString();" + Environment.NewLine;
                    break;

                case "bool":
                    fullText += emptySpacing + $"        symbol = m_plcSymbols[\"{String.Join(".", lineStruct.currentNodes.Skip(1).ToArray())}\"];" + Environment.NewLine;
                    fullText += emptySpacing + $"        return Convert.ToBoolean(Client.ReadSymbol(symbol));" + Environment.NewLine;
                    break;

                case "int":
                    fullText += emptySpacing + $"        symbol = m_plcSymbols[\"{String.Join(".", lineStruct.currentNodes.Skip(1).ToArray())}\"];" + Environment.NewLine;
                    fullText += emptySpacing + $"        return Convert.ToInt32(Client.ReadSymbol(symbol));" + Environment.NewLine;
                    break;

                case "uint":
                    fullText += emptySpacing + $"        symbol = m_plcSymbols[\"{String.Join(".", lineStruct.currentNodes.Skip(1).ToArray())}\"];" + Environment.NewLine;
                    fullText += emptySpacing + $"        return Convert.ToUInt32(Client.ReadSymbol(symbol));" + Environment.NewLine;
                    break;

                case "double":
                    fullText += emptySpacing + $"        symbol = m_plcSymbols[\"{String.Join(".", lineStruct.currentNodes.Skip(1).ToArray())}\"];" + Environment.NewLine;
                    fullText += emptySpacing + $"        return Convert.ToDouble(Client.ReadSymbol(symbol));" + Environment.NewLine;
                    break;

                case "ushort":
                    fullText += emptySpacing + $"        symbol = m_plcSymbols[\"{String.Join(".", lineStruct.currentNodes.Skip(1).ToArray())}\"];" + Environment.NewLine;
                    fullText += emptySpacing + $"        return Convert.ToUInt16(Client.ReadSymbol(symbol));" + Environment.NewLine;
                    break;

                case "byte":
                    fullText += emptySpacing + $"        symbol = m_plcSymbols[\"{String.Join(".", lineStruct.currentNodes.Skip(1).ToArray())}\"];" + Environment.NewLine;
                    fullText += emptySpacing + $"        return Convert.ToByte(Client.ReadSymbol(symbol));" + Environment.NewLine;
                    break;

                default:
                    break;
                }
                fullText += emptySpacing + "    }" + Environment.NewLine;

                //Populating Setter
                fullText += emptySpacing + "    set" + Environment.NewLine;
                fullText += emptySpacing + "    {" + Environment.NewLine;
                switch (lineStruct.nodeDatatype)
                {
                case "string":
                    fullText += emptySpacing + $"        symbol = m_plcSymbols[\"{String.Join(".", lineStruct.currentNodes.Skip(1).ToArray())}\"];" + Environment.NewLine;
                    fullText += emptySpacing + $"        Client.WriteSymbol(symbol, value.ToString());" + Environment.NewLine;
                    break;

                case "bool":
                    fullText += emptySpacing + $"        symbol = m_plcSymbols[\"{String.Join(".", lineStruct.currentNodes.Skip(1).ToArray())}\"];" + Environment.NewLine;
                    fullText += emptySpacing + $"        Client.WriteSymbol(symbol, value.ToString());" + Environment.NewLine;
                    break;

                case "int":
                    fullText += emptySpacing + $"        symbol = m_plcSymbols[\"{String.Join(".", lineStruct.currentNodes.Skip(1).ToArray())}\"];" + Environment.NewLine;
                    fullText += emptySpacing + $"        Client.WriteSymbol(symbol, value.ToString());" + Environment.NewLine;
                    break;

                default:
                    fullText += emptySpacing + $"        symbol = m_plcSymbols[\"{String.Join(".", lineStruct.currentNodes.Skip(1).ToArray())}\"];" + Environment.NewLine;
                    fullText += emptySpacing + $"        Client.WriteSymbol(symbol, value.ToString());" + Environment.NewLine;
                    break;
                }
                fullText += emptySpacing + "    }" + Environment.NewLine;
                fullText += emptySpacing + "}" + Environment.NewLine;
            }

            prevousNodeLevel = lineStruct.nodeLevel;
        }