public string Lookup(VB6SubTree subTree) { if (subTree == null) { throw new ArgumentNullException(nameof(subTree)); } //var t = GetNodeHash(subTree.GetRoot()); var t = subTree.GetRoot(); if (generatedPatterns.ContainsKey(t)) { return(generatedPatterns[t]); } return(null); }
public static List <ASTSequenceItem> Create(ASTPatternGenerator apg, ParseTree rootNode) { if (apg == null) { throw new ArgumentNullException(nameof(apg)); } VB6NodeTree nodeTree = new VB6NodeTree(rootNode); List <ASTSequenceItem> returnedList = new List <ASTSequenceItem> { }; foreach (var node in nodeTree.GetAllNodes()) { var subtree = new VB6SubTree(nodeTree, node); int depth = 0; string childIndices = ""; string typePath = ""; var paths = nodeTree.GetPath(node).ToList(); if (paths.Count == 0) { continue; } foreach (IndexedPath path in paths) { childIndices += path.ChildIndex + "/"; typePath += path.NodeTypeName + "/"; depth++; } var asi = new ASTSequenceItem { setpos = returnedList.Count, depth = depth, childPath = childIndices, token = paths.Last().Token, typeName = paths.First().NodeTypeName, pattern = apg.Lookup(subtree), node = node }; returnedList.Add(asi); } return(returnedList); }
public static string GetNodeTreeHashString(VB6SubTree nodeTree) { if (nodeTree == null) { throw new ArgumentNullException(nameof(nodeTree)); } var typeNames = new List <string>(); var count = 0; foreach (var node in nodeTree.GetAllNodes()) { typeNames.Add(VbToCsharpPattern.LookupNodeType(node)); count++; if (count > 20) { break; } } return(String.Join("/", typeNames)); }
public void GetPatterns(VB6NodeTree nodeTree) { if (nodeTree == null) { throw new ArgumentNullException(nameof(nodeTree)); } // Iterate over all nodes and add them to node hash based on their concatenated type strings foreach (var node in nodeTree.GetAllNodes()) { var subtree = new VB6SubTree(nodeTree, node); //var nodeTreeHashString = GetNodeTreeHashString(subtree); var nodeHash = GetNodeHash(node); if (!nodeHashDict.ContainsKey(nodeHash)) { nodeHashDict[nodeHash] = new Dictionary <string, List <VB6SubTree> >(); } var tokens = String.Join(" ", GetTokens(node)); if (!nodeHashDict[nodeHash].ContainsKey(tokens)) { nodeHashDict[nodeHash][tokens] = new List <VB6SubTree>(); } nodeHashDict[nodeHash][tokens].Add(subtree); } foreach (var key in nodeHashDict.Keys) { foreach (var key2 in nodeHashDict[key].Keys) { var s = new List <string>(); foreach (var subtree in nodeHashDict[key][key2]) { var node = subtree.GetRoot(); var tokens = String.Join(" ", GetTokens(node)); s.Add(tokens); } var s2 = String.Join(", ", s); DebugClass.LogError("NodeTreeHashString: " + key + " " + key2 + ": " + nodeHashDict[key][key2].Count + ": " + s2); } } // TODO: Is it possible to auto-generate this dictionary? // No stress, it's small, but would be nice for other languages. var replaceable = new Dictionary <string, bool>(); replaceable["AmbiguousIdentifierContext"] = true; replaceable["CertainIdentifierContext"] = true; replaceable["LiteralContext"] = true; replaceable["FieldLengthContext"] = true; // Iterate over all nodes and replace each token/text in pattern with pattern letter, // if there are two or more variations of this token under this node type name const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ"; foreach (var node in nodeTree.GetAllNodes()) { var subtree = new VB6SubTree(nodeTree, node); int letterIndex = 0; var text = node.getText(); var pattern = text; foreach (var child in subtree.GetAllNodes()) { if (replaceable.ContainsKey(VbToCsharpPattern.LookupNodeType(child))) { //DebugClass.LogError("REPLACING: " + VbToCsharpPattern.LookupNodeType(child)); var tokens = GetTokens(child); foreach (var token in tokens) { if (letterIndex < letters.Length) { var oldPattern = pattern; pattern = pattern.Replace(token, letters[letterIndex].ToString(System.Globalization.CultureInfo.InvariantCulture)); if (pattern != oldPattern) { letterIndex++; } //DebugClass.LogError("REPLACING: " + token); } if (letterIndex >= letters.Length) { break; } } if (letterIndex >= letters.Length) { break; } } } if (pattern.Length >= 100) { pattern = "PATTERN TOO LONG"; } generatedPatterns[node] = pattern; } }
public static void GetCode(VB6NodeTree nodeTree) { const string genFolder = @"F:\emh-dev\VB6ToCSharpCompiler\VB6ToCSharpCompiler\VB6NodeTranslatorLogging"; Dictionary <string, Dictionary <ImmutableList <string>, List <VB6SubTree> > > nodeTypeDict = new Dictionary <string, Dictionary <ImmutableList <string>, List <VB6SubTree> > >(); if (nodeTree == null) { throw new ArgumentNullException(nameof(nodeTree)); } // Iterate over all nodes and add them to node hash based on their concatenated type strings var assignments = new List <string>(); foreach (var node in nodeTree.GetAllNodes()) { var subtree = new VB6SubTree(nodeTree, node); //var nodeTreeHashString = GetNodeTreeHashString(subtree); var nodeHash = GetNodeHash(node); if (!nodeTypeDict.ContainsKey(nodeHash)) { nodeTypeDict[nodeHash] = new Dictionary <ImmutableList <string>, List <VB6SubTree> >(); } var children = ImmutableList.Create <string>(); foreach (var child in nodeTree.GetChildren(node)) { var tokens = String.Join(" ", GetTokens(child)); //if (!string.IsNullOrEmpty(tokens)) //{ // children = children.Add("\"" + tokens + "\""); //} else //{ //} children = children.Add(GetNodeHash(child)); } if (!nodeTypeDict[nodeHash].ContainsKey(children)) { nodeTypeDict[nodeHash][children] = new List <VB6SubTree>(); } nodeTypeDict[nodeHash][children].Add(subtree); } var hasContexts = new Dictionary <string, bool>(); foreach (ContextNodeType contextNodeType in (ContextNodeType[])Enum.GetValues(typeof(ContextNodeType))) { var typeName = contextNodeType.ToString("F"); var fileName = typeName + ".cs"; var outString = GetCls(typeName); hasContexts[typeName] = true; System.IO.File.WriteAllText(Path.Combine(genFolder, fileName), outString); typeName = typeName[0] .ToString(System.Globalization.CultureInfo.InvariantCulture) .ToUpper(System.Globalization.CultureInfo.InvariantCulture) + typeName.Substring(1); var assignment = "dict[ContextNodeType.$TYPE] = new VB6NodeTranslatorLogging.$TYPE(nodeTree, dict);\r\n" .Replace("$TYPE", typeName).Replace("$TYPE", typeName); assignments.Add(assignment); } var mainClass = @" using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace VB6ToCSharpCompiler { public static class VB6NodeTranslatorLoader { public static IEnumerable<string> Translate(VB6NodeTree nodeTree) { if (nodeTree == null) { throw new ArgumentNullException(nameof(nodeTree)); } var dict = new Dictionary<ContextNodeType, VB6NodeTranslator>(); // dict[ContextNodeType.AmbiguousIdentifierContext] = new VB6NodeTranslatorLogging.AmbiguousIdentifierContext(nodeTree, dict); $ASSIGNMENTS if (!Enum.TryParse(nodeTree.GetRoot().GetType().Name, out ContextNodeType contextNodeType)) { throw new ArgumentException(""contextNodeType""); } return dict[contextNodeType].Translate(nodeTree.GetChildren(nodeTree.GetRoot())); } } } "; mainClass = mainClass.Replace("$ASSIGNMENTS", String.Join("", assignments)); System.IO.File.WriteAllText(Path.Combine(genFolder, "../VB6NodeTranslatorLoader.cs"), mainClass); //foreach (var key in nodeTypeDict.Keys) //{ // var typeName = key; // if (!hasContexts.ContainsKey(typeName)) // { // DebugClass.LogError(typeName + ","); // hasContexts[typeName] = true; // } // var fileName = typeName + ".cs"; // var outString = GetCls(typeName); // System.IO.File.WriteAllText(Path.Combine(genFolder, fileName), outString); //} }