• Part 1: Writing Your First Script
• Part 2: Entities and References
• Part 3: Lexers and Lexemes

The plugin also generates an html file to quickly navigate the generated graphs:

The options dialog lets you pick which graph you want to generate, what format you want the files saved in, and where to save them. You can also specify advanced options that correspond to the options available on the graphs right click menu in the GUI

You can grab the Batch Graph Generator in the Interactive Reports section of our GUI Plugins Page. You’ll also find installation instructions there. Enjoy!

Latest Changes:

(Build b669) – 8 Jun 2013

CODECHECK

• Add complexity check for python

COMMANDLINE

• Added relative and named root portability for synced visual studio files.

GENERAL

• Fixed crash in project configuration when selecting a file imported from msvc with an unknown file type.

METRICS

• For C#, added CountLinePreprocessor metric.
• For C#, added CountLineInactive metric.

PARSER

• Create entities of kind ‘unparsed file’ for project files that are not of a parseable type.

PROJECT

• Force .h files in fortran visual studio projects to be treated as fortran files, not c header files

STRICT_PARSER

• Fixed issue on Windows with looking up missing includes from project files when the include contains a directory separator.

UPERL

• Add new $ref->lexeme() command.

VISUALSTUDIO

• Fix bug importing MSVC 2010/2012 projects with source file specifications that include the metadata AdditionalIncludeDirectories or PreprocessorDefinitions.

Build Notes

Grab it at www.getunderstand.com

Other features added since the release of Understand 3.0:

Added build system monitoring with buildspy
Added support for Windows 8
Improved project building capability
Improved Visio Export
Added ability to annotate code

Why do I care?

The more information Understand has about include paths and macro configuration, the more closely your Understand project will match your compiled code. In most cases, Understand does a great job of parsing the code and figuring out what goes where, but sometimes there are things you don’t expect in your project.

Some symptoms the project configuration may need to be improved:

1. Chunks of inactive (pink) code that should be getting parsed but are not:

2. The same entity shows up multiple times, with some of those definitions unresolved(gray)

3. Missing entities in graphs

Strict or Fuzzy Parsing

Understand now let’s you chose between two different types of parsing when creating C/C++ projects. The fuzzy parse is not as accurate but is great if the code doesn’t compile or for making an initial pass of the project with Understand. The strict parser requires that the include paths and macros be setup correctly, as outlined below, but in return will provide a very accurate parse. Objective-C and Objective-C++ both require the strict parser. Also if your project makes heavy use of C++ or Overloaded functions you will want to use the Strict Parser.

Choose Compiler Options

It’s important to double check the Compiler Options and make sure they are set correctly. By configuring the right Compiler details, many Macros, Pragmas and Include Paths are automatically added to the project and increase the accuracy. These settings are accessed under Project->Configure Project->C++ or C++(Strict)

Automatically Set Includes and Macros

Depending on your build system, Understand may be able to extrapolate the Include and Macro information automatically.

Visual Studio

If you use Visual Studio, you can specify the Visual Studio solution or project files directly and Understand will gather all the information from them.  Those files can be specified during the Project Creation wizard or in Project->Configure Project->Visual Studio.

GCC/G++

If your project builds with GCC or G++, you can use the new Buildspy feature to hook into the build system and gather the correct data for the Understand project.  More details on configuring Buildspy here, or there is a video here to get you started.

CMake

If your team uses the cross-platform build system, CMake, follow the directions here to create an Understand project as it compiles.

Manually Setting Includes and Macros

If your project doesn’t support any of the above options, you can manually configure the Includes and Macros for the project. We’ve added a couple of new tools to identify the missing bits and make this process more intuitive.

Missing Includes

Missing include directories can be added in Project->Configure Project->C++->Includes. The new "Search" button opens a dialog that let’s you quickly identify where the missing search files are and add those directories to the include paths for your project.

Missing Macros

Similarly, Missing Macros can be added via Project->Configure Project->C++->Macros.  The new "Undefined Macros" button opens a dialog that will let you quickly identify macros that may be missing from the project and you can specify their definitions.

Overrides

In some cases, individual files or directories have their own macros and include paths that are different from other parts of the project. These can be specified by going to the file or folder in question in Project->Configure Project->Files. Right click on it, and select Configure override settings. From that dialog you can add the specifics.

Conclusion

Understand does a great job of parsing projects "out of the box" but if the project is more complex, there are a lot of options for adding more detail to the project configuration and ending up with a perfect analysis.

To use Buildspy, you first need to change your compiler from gcc/g++ to gccwrapper/g++wrapper in your makefile or build system. Alternatively, it is possible to override these settings from the command line without having to touch the Makefile using the following command:

buildspy –db example.udb –cmd “make <additional_Make_Options>”

You may also need to add the /SciTools/bin/linux32/buildspy directory to your path.Then, starting with a clean build, run:

buildspy –db path/name.udb –cmd <command to compile project>

For example:

Or, to override the makefile settings:

This allows Buildspy to receive information from gccwrapper/g++wrapper to build a complete project. The wrappers will then call the corresponding compiler. To change the compiler edit the Buildspy.ini file located at $HOME/.config/SciTools on Linux systems and $HOME/Library/Preferences on Mac.

The wrappers will work with any compiler that has gcc-like syntax. To finish, simply open the project in Understand and Analyze All. Those tedious includes and macros are now set.

Cygwin/Windows Users

We have added support for Buildspy on Windows using Cygwin as of build 633. However, when the buildspy command results in this error:

 gcc – Process failed to start: Access is denied.

extra setup is required.  Cygwin uses a symlink to access the gcc executable and the actual name of the executable is required in the configuration file.  Trace the symlink until the executable is found in order to get the actual name.  In my case, the executable was named gcc-3.

On Windows, the configuration file is located in C:\Users\<USERNAME>\AppData\Roaming\SciTools and is called Buildspy.ini.  Open the Buildspy.ini file and change the compiler name appropriately. 

Once this is done, Buildspy should work as expected.

Any feedback on this new feature is welcome and appreciated.

In the past we have used the Visio API to export Understand’s graphs to Microsoft Visio. Understand would attempt to launch Visio and use the API to interactively draw the graph in Visio. There were several problems with this approach, the nodes and arrows of the graphs were not adequately connected, and in some cases the API would refuse to launch Visio. Of course this approach also required that Visio itself be installed on the same system as Understand. 

Some graphs also have an option to export to the graphviz .dot format. This option is only available to newer graphs that are generated using the graphviz engine in Understand. Some older graphs use a different layout engine so that option is not available for them.

These comments can be displayed inline, or can be turned off to only be seen in hover text so they don’t disrupt the normal flow of the code when you don’t want to see them.  Each annotation can be “tagged” with key value pairs which can be useful for organizing data using certain keywords, differentiating between authors, and any other identifiers you may want to use.  You can search using our Annotations Search GUI for quick access to exactly what you are looking for.

Annotations are saved in a SQLite database file which can also be modified and searched directly if desired.

Annotations are “linked” to entities in Understand and can be added quickly by right clicking on the entity, selecting ‘Add/Edit Annotations’, or they can be added from the top level menu. 

So, what happens to the annotation if the entity that it was linked to is deleted?  It is still there, it just doesn’t “belong” anywhere so it won’t show up in the in-line annotations.  These orphan annotations can be seen, and linked again to another entity in the ‘Manage Annotations’ top level menu.

This new feature is available to use in Understand build 618. We didn’t want to wait for the documentation to be completed before we made Annotations available so if you have any questions, please email us at support@scitools.com.  We expect the documentation to be available in the next month or so.  Any feedback on this new feature is appreciated.

We don’t like to make you wait for new features, so many of these features were already added in beta form and you may be familiar with some of them. There is an updated manual covering all of these new features, and several new floating licensing options are also available.  The upgrade to 3.0 is free as long as your maintenance is up to date and Understand 2.5 and 2.6 Licenses will also work with Understand 3.0.  Grab Understand 3.0 here

Features Added Since Understand 2.6 Release

• Objective C/C++ Language Support
• C++ Support for Templates and Overloads
• COBOL Language Support
• Python Language  Support
• Python API
• Re-written Command Line Tool ‘Und’
• Improved Parsing Tools
• Unused Entity Highlighting
• Keybinding Enhancements
• Clustered Call Graphs

New Floating Licensing Options

Node-Locked Floating License

A node-locked floating license is designed for a single machine that many users will be accessing, such as in a lab or a secure environment.  It is similar in concept to a Standard Floating License but no license server is needed, and it will only work on the one machine.

USB-Dongle Floating License

This license is ideal when the license needs to be shared between different people on different networks, or if there is a lot of traveling involved. The license is mailed to you on a USB drive. As long as that drive is attached to the computer, Understand will work. The license dongle can be shared between users as needed.

Dongle licenses expire after two years and will need to be replaced. There is an additional fee for new and replacement dongle licenses to offset the setup and shipping costs.

To enable this option go into Tools->Options->Editor->Advanced->Unused Entities

Right now this only works for functions and variables. Let us know if you find it useful, and if there are other entities you want it added for.

Update April,26 2012 – I’ve made some extensive changes to this script to improve performance and remove repeated results

In order to use this,

1. Navigate to your build directory
2. Edit CMakeCache.txt and set CMAKE_EXPORT_COMPILE_COMMANDS to ON.
3. Run make again, you’ll see a file called compile_commands.json in your build directory.
4. To import into an understand project run the following from the command line (skip the red part for existing projects):
        und -db path/to/db.udb create -languages C++ add path/to/build/dir/compile_commands.json settings -c++AddFoundFilesToProject on analyze

Update – On Windows you must use the NMake Makefiles generator. For example:
cmake -G "NMake Makefiles" -DCMAKE_EXPORT_COMPILE_COMMANDS=ON

As an extra incentive, they are offering a free license to the first 3 Understand users who demo one of their tools and send an exported image such as the one below of any part of their code or an Open Source project. Just send it to hwsupport@headwaysoftware.com and tell them Kevin sent you

To be fair to another great partner, Lattix can also import your Understand projects and is a great tool for organizing and refactoring your code, so give them a look.

As always, let us know if you run into any questions or problems – support@scitools.com

To run CodeCheck from the command line, first you will need to export the CodeCheck configuration file from the Understand GUI that has the checks you wish to run selected.

Once that is saved to a file, the command line option is

und codecheck C:\path\to\configuration.ini C:\path\to\OutputDir

–db C:\path\to\UnderstandProject.udb  

Where configuration.ini is my saved configuration file, the results are saved to the OutputDir, and it is running the checks on UnderstandProject.udb. 

We are still in scenic St George, near Zion National Park and less than two hours from Vegas. If you are in the area feel free to stop by and visit us!

Our new address is:

Scientific Toolworks, Inc.
249 East Tabernacle, Suite 200
St George, UT 84770

Many users have asked us in the past if Understand could have better support for Templates and Overloaded functions. We are excited to announce that this is now a reality. Our engineers have worked hard to add a completely new C++ parser to Understand, which is available for Beta testing in build 586.

Our current C++ parser was written with the goal of being able to use fuzzy logic to handle incomplete, non-compiling code gracefully and as accurately as possible. It does a great job at that and will continue to be an important part of our toolset. Unfortunately that same feature caused severe difficulties in parsing templates and recognizing overloaded functions.  The new parser is more strict than the old parser and requires a more accurate project definition. If you plan on using it, please follow the instructions from this post to ensure your project is as correct as possible:  Improving Project Accuracy (C/C++)

To access the new parser, just check the new checkbox on the Languages screen when creating a new project or in the Project Configuration dialog.

We welcome and appreciate your feedback and comments on this new parser – please send it to us at support@scitools.com

Key Bindings can still be accessed via Tools->Options->Key Bindings  but this page now lets you search for key binding, either by name or by the actual keystrokes. This page also has all of the key bindings in one place for easy browsing. The other change was to add a separate page for each Component(Category) of key bindings in the navigation pane.

While these are relatively small changes, we hope they will make life easier for those who rely heavily on keyboard navigation.