Visualization and dependency
analysis of source code

Source Code
Analysis

 Imagix 4D helps software developers comprehend complex or legacy C, C++ and Java source code. By using Imagix 4D to reverse engineer and analyze your code, you're able to speed your development, enhancement, reuse, and testing. Eliminate bugs due to faulty understanding. Get new hires on board faster. Spend time engineering, not reading through code.

A comprehensive source code analysis tool, Imagix 4D enables you to rapidly check or systematically study your software on any level -- from its high level architecture to the details of its build, class and function dependencies. You can visually explore a wide range of aspects about your software - control structures, data usage, and inheritance. All based on Imagix 4D's precise static analysis of your source code.

You're able to find and focus on the relevant portions of your source code through Imagix 4D's querying capabilities. Automated analysis, database lookups, and graphical querying all sift through the mountains of data inherent in your source code so you examine the structural and dependency info you're interested in. Quickly and accurately.
Watch Demo »

Process of software reverse engineering
Underneath Imagix 4D's powerful software visualization and analysis functionality is a precise, comprehensive database, generated through a full semantic analysis of your source code.

This precision is achieved in part through the use of compiler configuration files. These enable Imagix 4D's source analyzer to parse your code the same way your specific compiler does, supporting the same language extensions and keywords, and using the same system header files.
Full language support includes:
  • Conditional compilation directives
  • Class templates and namespaces
  • Calls via Java reflection API
  • Function pointers
  • Macro substitutions
Configuration files support:
  • Microsoft Visual Studio
  • GNU gcc compiler variants
  • Other native compilers
  • Embedded cross-compilers
  • Multitasking systems
Subsystem architecture reverse engineered from C++ source code
An extensive range of graphical view types, 15 in all, include a number of high level views. These provide a 'big picture' perspective and analysis of your software's inherent architecture - its components, dependencies and packaging.

Some of these high level views use abstraction to represent information at a less granular level than it actually occurs in the source code. For example, function calls can be summarized at the class level, so that ClassA::FunctionA calling ClassB::FunctionB can be represented as ClassA calling ClassB.
High level displays include: Abstraction mechanisms include:
  • Abstractions to file and class
  • Showing function calls, variable use and type dependencies
  • Analysis of subsystem layering
  • User defined abstraction levels through Grouping
Analysis of software control flow
You can begin your source code analysis with less complex, high level views and then show more and more detail with a few clicks. Drilling down through increasingly granular views provides more detailed understanding of particular portions of the software.

You're able to find and analyze the control flow, data usage and type dependencies that underlie your software. And through Imagix 4D's interactive graphs, you're able to follow specific implementations and trace their impacts on other parts of your code.
Mid level displays include:
  • Function calls
  • Variable sets and reads
  • Macro usage by functions
  • Class use
  • Datatype hierarchy
Low level displays include:
  • Flow Chart showing intra-function program logic
  • Control Flow Graph showing call sequence and conditionality of function calls
  • Control flow with variable usage
Source code analysis of variable data flow
Complementing Imagix 4D's extensive set of displays for control flow analysis, the Calculation Trees present information about the assignments leading to the current value of a variable. You're able to examine all of the initializations, sets and reads, of any variable, that contribute to a specific variable's value.

Automatically generated from Imagix 4D's comprehensive database by the data flow engine, the calculation trees track assignment dependencies across function boundaries and through parameter passing.
Calculation Tree displays:
  • Assignment Flow graphically displaying hierarchy of all assignments
  • Assignment List listing all assignments, including full line of source
  • Variable Dependencies graphically showing hierarchy of variables and parameters involved
  • Variable Table organizing individual assignments by assigned variable
Program comprehension aided by complementary displays
Individual displays are leveraged by distributing information between different view types, and displaying multiple views side by side. For example, one graph might show the control flow by which one function indirectly calls another. Next to that, for added perspective, might be a Subsystem Architecture diagram showing the specific subsystems that are involved in that calling hierarchy.

The information and navigation available in the Graph windows, Flow Charts and Calculation Trees is further supplemented by an extensive and integrated set of complementary displays.
Addition displays include:
  • Project summary
  • Directory, file, class, function and variable level metrics tools
  • File, namespace and class indices
  • Symbol index with filter
  • Graph window symbol context
  • Symbol cross-reference display
  • Symbol usage table
  • Database symbol searching
  • Project-wide grep string searching
  • Tightly integrated file editors
  • File source check quality report
Visualization through automated source code analysis
What makes Imagix 4D's software visualization especially powerful is the ability to focus the displays on the information of interest. With database lookups, graphical querying and drill down capabilities, you're able to identify and explore the relevant portions of your source code.

And with the Analyze feature, you're able to direct Imagix 4D to do much of the analysis for you. You can quickly examine important interfaces and automatically track down critical dependencies.
Automated analyses include:
  • Paths between two functions
  • Paths for function setting or reading variable
  • Common descendants or ancestors of two functions
  • Functions similar to function
  • Include paths between two files
  • File or class function interfaces
  • File or class variable interfaces
  • Internal calling hierarchy of subsystem, file or class
  • Violations of layering rules