Meaning: The set of all authors that contributed to the source code of the Working Set.
Designation: The name of an author (taken from @author tags). If the tag appears in particular file, SourceGlider assumes, that the corresponding author contributed to the whole file, even if the tag appears before the single method. If several authors are mentioned, SourceGlider assumes that all of them contributed to the same file.
Special cases: Files that don't have @author tags are considered to be contributed by an unknown author.
Meaning: The set of all folders in the part of Eclipse file system, representing the current Working Set. Each package corresponds to the folder, but not each folder corresponds to the package (e.g. project folders and package fragment roots). Folders are needed only for displaying the Structure Metrics.
Designation: The full path to the folder, separated by dots (like the full-qualified name of the package).
Special cases: There is a special folder Default package, corresponding to the default package (see Package).
Meaning: The set of all call sites in the Working Set, including the constructor calls.
Designation: The piece of code for the call site.
Special cases: For the dummy init method of each class (see Method) there is an implicit invocation of the dummy init method for its superclass. It is designated as Super init method call for type + <the short-name of the class>.
Meaning: The set of all methods and constructors in the Working Set.
Designation: <The full-qualified name of the method> + "()" if it has no parameters, or <the full-qualified name of the method> + "(...)" if it has one or more parameters.
Special cases:
For each class there is a special dummy init method that correspond to the code in the implicit constructor. It is assumed that all the code in the fields and class initializers of this class is being executed in this dummy init method. Method is designated as Init method for type + <the short-name of the class>.
If the method can't be resolved by Eclipse due to severe compilation errors, it is designated as Unresolved method.
Meaning: The set of all class instances, arrays instances and primitive values (literals) in the Working Set. All arithmetical expressions are also considered as objects, because SourceGlider is unable to analyze the structure of arithmetical expressions.
Designation: The piece of code for the object.
Special cases:
Arrays initializers are considered as objects.
Enum constants are considered as objects.
Each non-void external call site is considered as an external object, because SourceGlider can't discover, which objects the calling method may return.
For each external call site all its declared exceptions are considered as external objects, because SourceGlider can't prove, whether these exceptions will be actually thrown by an external method or not.
Each external field access (e.g. System.out) is considered as an external object, because SourceGlider can't understand, which values it may refer to.
If some particular method is never called in the Working Set, SourceGlider assumes that it is an "entry"-method, and all its formal parameters are considered as external objects.
If some external object is an array or container, it is considered to have special dummy elements, designated by "[designation for external array object]";
Meaning: The set of all references to the packages.
Designation: The piece of code for the package reference. Note that if there are several references to the same package, each of them will represent an individual Package usage.
Meaning: The set of all threads in the Working Set. Threads are being detected by the set of heuristics, some of which can be configured in the Threads Filters. In some of theses heuristics threads are represented by the class instances (e.g. new Thread() {...). SourceGlider also assumes that each method public static void main(String[] args) represents the separate thread.
Designation: The special name of the thread, if one of filters criteria holds, the piece of code for the class instance, or the concrete main method.
Meaning: The set of all references to the classes, interfaces, enums and primitive types.
Designation: The piece of code for the type reference. Note that if there are several references to the same type, each of them will represent an individual Type usage.
Meaning: The set of all fields, local variables and formal parameters in the Working Set.
Designation: The name of the variable.
Special cases:
Each class has the corresponding this variable, which points to the instances of this class. It is designated as This variable for type + <the short-name of the class>.
If the variable can't be resolved by Eclipse due to severe compilation errors, it is designated as Unresolved variable.
For convenience, all the array access expressions are considered as the special kinds of variables. They are called Array (container) Elements and are designated as the piece of code (e.g. array[i]). Since SourceGlider treats the container classes as plain arrays, container access expressions will also be variables (e.g. vector.get( 1 )). You can configure, which containers will be treated as arrays, in Arrays (Containers) Filters.
Since SourceGlider represents thread monitors as variables that hold the monitor objects, the two special variables are introduced for convenience: Monitor for instance of + <the short-name of the type> and Static monitor for type + <the short-name of the type>. They correspond to the types, which hold the monitor objects, when the synchronized methods are called.
For convenience, all Objects have the corresponding variables, which are used in the Holders queries. They are designated the same way as the objects.
Meaning: The set of all references to the fields, local variables and formal parameters in the Working Set.
Designation: The piece of code for the variable reference. Note that if there are several references to the same variable, each of them will represent an individual Variable usage.
This part provides the list of all available Analysis Profiles. For each Analysis Profile there is a list of its Analysis Types with corresponding options.
Structure Metrics profile evaluates only one Analysis Type: Structure Metrics Analysis. The analysis is extremely fast and low on memory. Choose this profile, when you need to evaluate only the structure metrics.
Dependencies+ profile evaluates the dependencies and all the basic profiles (Types, Objects, Callees, etc). It does not include nor Points To (Equals) Analysis, nor its outcome, nor Impact Analysis. It is quite fast and low on memory. Choose this profile, when you need to evaluate the dependencies, but you are not going to dig into the variables and objects behavior.
Points To+ profile evaluates the full set of analyses except for Impact Analysis. Choose this profile, when you need to discover your code thoroughly, but you are not going to use the impact info.
Points To (light)+ profile is slightly less comprehensive than Points To+ profile, but is still very powerful. It does not consider arrays and exceptions during evaluation of points-to info. This profile is much faster and lower on memory, than Points To+. Choose this profile, when you need to discover your code thoroughly, but your code is very large to perform the Points To+ on it.
Impact+ profile evaluates the full impact info and all the basic profiles (Types, Objects, Callees, Dependencies, etc). Choose this profile, when you want to discover thoroughly the impact of you code, but you are not going to dig into the variables and objects behavior.
Impact (light)+ profile is slightly less comprehensive than Impact+ profile: it doesn't evaluate the forward impact. It is faster than Impact+ and lower on memory. Choose this profile, when you want to discover the backward impact of you code.
Backward Traces+ profile is the shortest variation of Impact+ profile. It evaluates only the backward traces and all the basic profiles (Types, Objects, Callees, Dependencies, etc). Choose this profile, when you want to discover the backward impact of you code, but your code is very large to perform the full Impact+ on it.
This part provides the list of all available Analysis Types. For each Analysis Type there is a list of prerequisite Analysis Types and the list of Queries generated by this Analysis Type.
Structure Metrics Analysis calculates the structure metrics for all the parts of the program. It helps to measure the properties of the source code and monitor its quality.
For each program folder and type:
it counts the total size and the number of LOC (lines of code).
it counts the total number of fields, statements, methods and types.
it evaluates the latest last modified time of all the files in it.
it lists all the authors that contributed to this part of source code (they are taken from @author tags).
For each author it counts his investment to the development of the whole program: the number of created files, methods and statements, total LOC, size of code and the time of the last modified file.
Below are the Queries generated by Structure Metrics:
Dependencies Analysis evaluates the external dependencies for all the methods, types and packages in the program and reveals its side effects.
For each method and class it searches the external variables, accessed or written by it. It helps to understand what does this method or class need and to reveal its side effects.
For each class and package it evaluates its class and package dependencies. It helps to understand the high-level design of the program, find common design patterns and improve the code by refactoring.
Below are the Queries generated by Dependencies Analysis:
Depends on:
Objects Analysis,
Callees Analysis Available options:
Handle arrays (in Points To),
Handle exceptions (in Points To)
Points To (Equals) Analysis is one of the major analyses in SourceGlider. It propagates the points-to dataflow information through all the Java constructions: assignments, types, method calls/returns, fields, arrays, exceptions, etc.
For each variable and field it understands which class instances it may refer to or which primitive values (literals) it may be equal to.
For each non-void method it shows which class instances or primitive values it may return.
For each array it reveals which class instances or primitive values it may hold.
For each method it understands which explicit and implicit exceptions it may throw and where they are thrown. The information about exceptions is taken from the source code of this method and all the methods that are called from this method.
For each class instance and primitive value it shows where it is used and what variables, arrays and methods may hold it.
Below are the Queries generated by Points To (Equals) Analysis:
Actual Type Analysis uses the Points To (Equals) Analysis and refines the types information using the points-to dataflow information.
For each variable and field it understands its actual type: the type of the values that it may refer to or be equal to. This type is in fact more precise than the declaring type, it may reveal the actual meaning of the variable.
For each non-void method it shows the actual types of its results: the type of the values that this method may return.
For each array it reveals the actual type of its elements.
Below are the Queries generated by Actual Type Analysis:
Actual Callees Analysis uses the Points To (Equals) Analysis and refines the Call Graph using the points-to dataflow information.
For each call site it understands what actual methods are invoked here. It is extremely useful in the places, where the abstract interface methods are invoked.
For each method it shows where it is actually invoked. For example it can display all the actual call sites for the overloaded java.lang.Runnable.run() method of particular java.lang.Runnable instance, while all other browsers will show senseless results - all the call sites for all java.lang.Runnable usages in the whole program.
It computes the complete Call Graphs using the Actual Callees information
For each non-void call site it understands which class instances or primitive values (literals) it may obtain.
For each call site it reveals which explicit and implicit exceptions it may throw and where they are thrown.
Below are the Queries generated by Actual Callees Analysis:
Impact Analysis is one of the major analyses in SourceGlider. It understands which statements depend on the other ones and propagates this information through the whole program.
It reveals all the statements in the program affected by the value of particular variable or field.
It displays all the statements in the program that may influence the value of particular variable or field.
It shows all the conditional statements that may influence whether control reaches the particular statement or not.
Impact analysis introduces the notions of Slices and Traces.
Slice is the set of statements that are somehow dependent on some variable or affect its value. In this case all possible dependencies are taken into account, therefore the total size of the slice can be very large.
Trace is almost the same as the slice, but only the direct explicit dependencies are considered. The size of the trace is much less than the size of the slice, what makes it easier to understand.
Below are the Queries generated by Impact Analysis:
This part provides the full set of Queries available in SourceGlider. The list is divided by Java Elements Types, to which these Queries are applicable. For each Query its Type of Result and required Analysis Type are mentioned.
Online Manual
Files: