/// <summary> /// Merges this namespace definition with <paramref name="otherScope"/>. This happens when <c>otherScope.CanBeMergedInto(this)</c> evaluates to true. /// </summary> /// <param name="otherScope">the scope to merge with</param> /// <returns>a new namespace definition from this and otherScope, or null if they couldn't be merged.</returns> public override NamedScope Merge(NamedScope otherScope) { NamespaceDefinition mergedScope = null; if(otherScope != null) { if(otherScope.CanBeMergedInto(this)) { mergedScope = new NamespaceDefinition(this); mergedScope.AddFrom(otherScope); } } return mergedScope; }
/// <summary> /// Creates a NamespaceDefinition object for the given namespace typeUseElement. This must be one of the typeUseElement types defined in NamespaceElementNames. /// </summary> /// <param name="namespaceElement">the namespace element</param> /// <param name="context">The parser context</param> /// <returns>a new NamespaceDefinition object</returns> public override void ParseNamespaceElement(XElement namespaceElement, ParserContext context) { if(namespaceElement == null) throw new ArgumentNullException("namespaceElement"); if(!NamespaceElementNames.Contains(namespaceElement.Name)) throw new ArgumentException(string.Format("Not a valid namespace typeUseElement: {0}", namespaceElement.Name), "namespaceElement"); var nameElement = namespaceElement.Element(SRC.Name); var namespaceName = nameElement != null ? nameElement.Value : string.Empty; var namespaceDefinition = new NamespaceDefinition { Name = namespaceName }; context.Push(namespaceDefinition); }
/// <summary> /// Creates a <see cref="NamespaceDefinition"/> object from this use (along with all of its descendants based on <see cref="NamedScopeUse.ChildScopeUse"/>). /// </summary> /// <returns>A new namespace definition based on this use</returns> public override NamedScope CreateScope() { var ns = new NamespaceDefinition { Name = this.Name, ProgrammingLanguage = this.ProgrammingLanguage }; ns.AddSourceLocation(this.Location); if(ChildScopeUse != null) { ns.AddChildScope(ChildScopeUse.CreateScope()); } return ns; }
/// <summary> /// Parses a Java package directive /// </summary> /// <param name="namespaceElement">A file unit</param> /// <param name="context">The parser context</param> public override void ParseNamespaceElement(XElement namespaceElement, ParserContext context) { var javaPackage = context.FileUnit.Elements(SRC.Package).FirstOrDefault(); // Add a global namespace definition var globalNamespace = new NamespaceDefinition(); context.Push(globalNamespace); if(null != javaPackage) { var namespaceElements = from name in javaPackage.Elements(SRC.Name) select name; foreach(var name in namespaceElements) { var namespaceForName = new NamespaceDefinition() { Name = name.Value, ProgrammingLanguage = ParserLanguage, }; namespaceForName.AddSourceLocation(context.CreateLocation(name)); context.Push(namespaceForName, globalNamespace); } } }
/// <summary> /// Parses a C# namespace block /// </summary> /// <param name="namespaceElement">the namespace element to parse</param> /// <param name="context">the parser context</param> public override void ParseNamespaceElement(XElement namespaceElement, ParserContext context) { if(namespaceElement == null) throw new ArgumentNullException("namespaceElement"); if(!NamespaceElementNames.Contains(namespaceElement.Name)) throw new ArgumentException(string.Format("Not a valid namespace element: {0}", namespaceElement.Name), "namespaceElement"); var nameElement = namespaceElement.Element(SRC.Name); string namespaceName; if(nameElement == null) { namespaceName = string.Empty; } else { NamespaceDefinition root = null; foreach(var name in NameHelper.GetNameElementsFromName(nameElement)) { var namespaceForName = new NamespaceDefinition() { Name = name.Value, ProgrammingLanguage = ParserLanguage, }; if(root == null) { root = namespaceForName; } else { namespaceForName.AddSourceLocation(context.CreateLocation(name)); } context.Push(namespaceForName, root); } } }
/// <summary> /// Creates a NamespaceDefinition object for the given namespace typeUseElement. This must /// be one of the typeUseElement types defined in NamespaceElementNames. /// </summary> /// <param name="namespaceElement">the namespace element</param> /// <param name="context">The parser context</param> /// <returns>a new NamespaceDefinition object</returns> protected override NamespaceDefinition ParseNamespaceElement(XElement namespaceElement, ParserContext context) { if(namespaceElement == null) throw new ArgumentNullException("namespaceElement"); if(!NamespaceElementNames.Contains(namespaceElement.Name)) throw new ArgumentException(string.Format("Not a valid namespace element: {0}", namespaceElement.Name), "namespaceElement"); if(context == null) throw new ArgumentNullException("context"); var nameElement = namespaceElement.Element(SRC.Name); var namespaceName = nameElement != null ? nameElement.Value : string.Empty; var nd = new NamespaceDefinition { Name = namespaceName, ProgrammingLanguage = ParserLanguage, }; nd.AddLocation(context.CreateLocation(namespaceElement)); //add children var blockElement = namespaceElement.Element(SRC.Block); if(blockElement != null) { foreach(var child in blockElement.Elements()) { nd.AddChildStatement(ParseStatement(child, context)); } } return nd; }
private MethodDeclarationNode FromMethodCallToSWUM(MethodCall mcall, NamespaceDefinition globalNamespace, DataProject<CompleteWorkingSet> dataProject) { var mdef = globalNamespace.GetDescendants<MethodDefinition>().Where(decl => mcall.SignatureMatches(decl)); if (mdef.Count() > 0) { var mdefXml = DataHelpers.GetElement(dataProject.SourceArchive, mdef.First().PrimaryLocation); MethodContext mc = ContextBuilder.BuildMethodContext(mdefXml); MethodDeclarationNode mdn = new MethodDeclarationNode(mcall.Name, mc); BaseVerbRule rule = new BaseVerbRule(posData, tagger, splitter); if (rule.InClass(mdn)) { rule.ConstructSwum(mdn); return mdn; } else { return null; } } else { Console.WriteLine(mcall.Name + " could not be found"); return null; } }
/// <summary> /// Parses a C# namespace block /// </summary> /// <param name="namespaceElement">the namespace element to parse</param> /// <param name="context">the parser context</param> protected override NamespaceDefinition ParseNamespaceElement(XElement namespaceElement, ParserContext context) { if(namespaceElement == null) throw new ArgumentNullException("namespaceElement"); if(!NamespaceElementNames.Contains(namespaceElement.Name)) throw new ArgumentException(string.Format("Not a valid namespace element: {0}", namespaceElement.Name), "namespaceElement"); if(context == null) throw new ArgumentNullException("context"); var nameElement = namespaceElement.Element(SRC.Name); if(nameElement == null) { throw new ParseException(context.FileName, namespaceElement.GetSrcLineNumber(), namespaceElement.GetSrcLinePosition(), this, "No SRC.Name element found in namespace.", null); } //parse the name and create a NamespaceDefinition for each component NamespaceDefinition topNS = null; NamespaceDefinition lastNS = null; foreach(var name in NameHelper.GetNameElementsFromName(nameElement)) { var newNS = new NamespaceDefinition { Name = name.Value, ProgrammingLanguage = ParserLanguage }; newNS.AddLocation(context.CreateLocation(name)); if(topNS == null) { topNS = newNS; } if(lastNS != null) { lastNS.AddChildStatement(newNS); } lastNS = newNS; } //add body of namespace to lastNS var blockElement = namespaceElement.Element(SRC.Block); if(blockElement != null) { foreach(var child in blockElement.Elements()) { lastNS.AddChildStatement(ParseStatement(child, context)); } } return topNS; }
/// <summary> /// Returns true if both this and <paramref name="otherScope"/> have the same name. /// </summary> /// <param name="otherScope">The scope to test</param> /// <returns>true if they are the same namespace; false otherwise.</returns> public virtual bool CanBeMergedInto(NamespaceDefinition otherScope) { return base.CanBeMergedInto(otherScope); }
/// <summary> /// Copy constructor /// </summary> /// <param name="otherDefinition">The scope to copy from</param> public NamespaceDefinition(NamespaceDefinition otherDefinition) : base(otherDefinition) {}
private static void PrintScopeReport(NamespaceDefinition globalScope, string sourcePath, string csvDirectory) { //var csvPath = Path.Combine(csvDirectory, "scopes.csv"); //Console.WriteLine("\nScope Report"); //Console.WriteLine("==============="); //var allScopes = VariableScopeIterator.Visit(globalScope); //int numScopes = allScopes.Count(); //int numNamedScopes = allScopes.OfType<INamedScope>().Count(); //int numNamespaces = allScopes.OfType<NamespaceDefinition>().Count(); //int numTypes = allScopes.OfType<ITypeDefinition>().Count(); //int numMethods = allScopes.OfType<IMethodDefinition>().Count(); //Console.WriteLine("{0,10:N0} scopes", numScopes); //Console.WriteLine("{0,10:N0} named scopes", numNamedScopes); //Console.WriteLine("{0,10:N0} namespaces", numNamespaces); //Console.WriteLine("{0,10:N0} types", numTypes); //Console.WriteLine("{0,10:N0} methods", numMethods); //if(!File.Exists(csvPath)) { // File.WriteAllText(csvPath, String.Format("{0}{1}", String.Join(",", "Project", "Scopes", "Named Scopes", "Namespaces", "Types", "Methods"), Environment.NewLine)); //} //File.AppendAllText(csvPath, String.Format("{0}{1}", String.Join(",", sourcePath, numScopes, numNamedScopes, numNamespaces, numTypes, numMethods), Environment.NewLine)); throw new NotImplementedException(); }
private static void PrintMethodCallReport(NamespaceDefinition globalScope, string sourcePath, string csvDirectory, string callLogPath) { //TODO reimpleement once visitors have been modified //var csvPath = Path.Combine(csvDirectory, "methodcalls.csv"); //Console.WriteLine("\nMethod Call Report"); //Console.WriteLine("==============="); //var methodCalls = from scope in VariableScopeIterator.Visit(globalScope) // from call in scope.MethodCalls // select call; //int numMethodCalls = 0; //int numMatchedMethodCalls = 0; //Stopwatch sw = new Stopwatch(); //using(var callLog = new StreamWriter(callLogPath)) { // foreach(var call in methodCalls) { // sw.Start(); // var match = call.FindMatches().FirstOrDefault(); // sw.Stop(); // numMethodCalls++; // if(null != match) { // numMatchedMethodCalls++; // callLog.WriteLine("{0} ({1}:{2}) -> {3} ({4}:{5})", call.Name, call.Location.SourceFileName, call.Location.StartingLineNumber, match.Name, match.PrimaryLocation.SourceFileName, match.PrimaryLocation.StartingLineNumber); // } // } //} //Console.WriteLine("{0,10:N0} method calls", numMethodCalls); //Console.WriteLine("{0,10:N0} matched method calls ({1,8:P2})", numMatchedMethodCalls, ((float) numMatchedMethodCalls) / numMethodCalls); //Console.WriteLine("{0,10:N0} matches / millisecond ({1,7:N0} ms elapsed)", ((float) numMethodCalls) / sw.ElapsedMilliseconds, sw.ElapsedMilliseconds); //Console.WriteLine("See matched method calls in {0}", callLogPath); //if(!File.Exists(csvPath)) { // File.WriteAllText(csvPath, String.Format("{0}{1}", String.Join(",", "Project", "Method Calls", "Matched Method Calls", "Time (ms)"), Environment.NewLine)); //} //File.AppendAllText(csvPath, String.Format("{0}{1}", String.Join(",", sourcePath, numMethodCalls, numMatchedMethodCalls, sw.ElapsedMilliseconds), Environment.NewLine)); throw new NotImplementedException(); }
private static void OutputCallGraphByType(NamespaceDefinition globalScope, string jsonPath) { //TODO reimplement once MethodCalls has been reimplemented //using(var writer = new JsonTextWriter(new StreamWriter(jsonPath))) { // writer.WriteStartArray(); // foreach(var typeDefinition in globalScope.GetDescendantsAndSelf<TypeDefinition>()) { // writer.WriteStartObject(); // writer.WritePropertyName("name"); // writer.WriteValue(typeDefinition.GetFullName()); // var calls = from scope in typeDefinition.GetDescendantsAndSelf() // from call in scope.MethodCalls // select call; // writer.WritePropertyName("size"); // writer.WriteValue(calls.Count()); // // find the parent type of all the calls // var callMatches = from call in calls // let match = call.FindMatches().FirstOrDefault() // where match != null // let parentOfMatch = match.GetFirstParent<ITypeDefinition>() // where parentOfMatch != null // select parentOfMatch.GetFullName(); // // output the calls property and array // writer.WritePropertyName("calls"); // writer.WriteStartArray(); // foreach(var call in callMatches) { // writer.WriteValue(call); // } // writer.WriteEndArray(); // writer.WriteEndObject(); // } // writer.WriteEndArray(); //} throw new NotImplementedException(); }
/// <summary> /// Parses a java file unit. This handles the "package" directive by calling /// <see cref="ParseNamespaceElement"/> /// </summary> /// <param name="unitElement">The file unit to parse.</param> /// <param name="context">The parser context to use.</param> protected override NamespaceDefinition ParseUnitElement(XElement unitElement, ParserContext context) { if(null == unitElement) throw new ArgumentNullException("unitElement"); if(SRC.Unit != unitElement.Name) throw new ArgumentException("should be a SRC.Unit", "unitElement"); if(context == null) throw new ArgumentNullException("context"); context.FileUnit = unitElement; //var aliases = from aliasStatement in GetAliasElementsForFile(unitElement) // select ParseAliasElement(aliasStatement, context); //context.Aliases = new Collection<Alias>(aliases.ToList()); //create a global namespace for the file unit var namespaceForUnit = new NamespaceDefinition() {ProgrammingLanguage = ParserLanguage}; namespaceForUnit.AddLocation(context.CreateLocation(unitElement)); NamespaceDefinition bottomNamespace = namespaceForUnit; //create a namespace for the package, and attach to global namespace var packageElement = unitElement.Element(SRC.Package); if(packageElement != null) { var namespaceForPackage = ParseNamespaceElement(packageElement, context); namespaceForUnit.AddChildStatement(namespaceForPackage); bottomNamespace = namespaceForPackage.GetDescendantsAndSelf<NamespaceDefinition>().Last(); } //add children to bottom namespace foreach(var child in unitElement.Elements()) { var childStmt = ParseStatement(child, context); if(childStmt != null) { bottomNamespace.AddChildStatement(childStmt); } } return namespaceForUnit; }
/// <summary> /// Creates a NamespaceDefinition object from the given Java package element. /// This will create a NamespaceDefinition for each component of the name, e.g. com.java.foo.bar, and link them as children of each other. /// This will not add any child statements to the bottom namespace. /// </summary> /// <param name="packageElement">The SRC.Package element to parse.</param> /// <param name="context">The parser context to use.</param> /// <returns>A NamespaceDefinition corresponding to <paramref name="packageElement"/>.</returns> protected override NamespaceDefinition ParseNamespaceElement(XElement packageElement, ParserContext context) { if(packageElement == null) throw new ArgumentNullException("packageElement"); if(packageElement.Name != SRC.Package) throw new ArgumentException("must be a SRC.Package", "packageElement"); if(context == null) throw new ArgumentNullException("context"); var nameElement = packageElement.Element(SRC.Name); if(nameElement == null) { throw new ParseException(context.FileName, packageElement.GetSrcLineNumber(), packageElement.GetSrcLinePosition(), this, "No SRC.Name element found in namespace.", null); } //parse the name and create a NamespaceDefinition for each component NamespaceDefinition topNS = null; NamespaceDefinition lastNS = null; foreach(var name in NameHelper.GetNameElementsFromName(nameElement)) { var newNS = new NamespaceDefinition { Name = name.Value, ProgrammingLanguage = ParserLanguage }; newNS.AddLocation(context.CreateLocation(name)); if(topNS == null) { topNS = newNS; } if(lastNS != null) { lastNS.AddChildStatement(newNS); } lastNS = newNS; } return topNS; }
/// <summary> /// Creates a global <see cref="NamespaceDefinition"/> object for <paramref name="unitElement"/> and pushes it onto <paramref name="context"/> /// </summary> /// <param name="unitElement">The element to parse</param> /// <param name="context">The context to place the resulting namespace definition in</param> public virtual void ParseUnitElement(XElement unitElement, ParserContext context) { if(null == unitElement) throw new ArgumentNullException("unitElement"); if(SRC.Unit != unitElement.Name) throw new ArgumentException("should be a SRC.Unit", "unitElement"); context.FileUnit = unitElement; var aliases = from aliasStatement in GetAliasElementsForFile(unitElement) select ParseAliasElement(aliasStatement, context); context.Aliases = new Collection<Alias>(aliases.ToList()); var namespaceForUnit = new NamespaceDefinition(); context.Push(namespaceForUnit); }