Skip to content

Per-language accuracy notes

Each language has its own set of project-configuration options. Get them right and Understand's cross-references, metrics, and graphs match what your toolchain actually sees.

Open the options for a language at Project → Configure Project → <language>, or set them from the CLI with und settings (see the CLI and the settings reference). Every language also has a Save comments associated with entities toggle and, where relevant, Multiple Language Linkage options that control how externally linkable names are matched across languages — the latter matters for mixed-language projects.

C/C++ has its own guide

C, C++, and Objective-C accuracy (Strict vs Fuzzy, includes, macros, compile_commands.json) is covered separately in Create an accurate C/C++ project, Build from CMake, and Fix parse errors.

Ada

  • Version — Ada83, Ada95, Ada05, or Ada12.
  • Preprocessor — none, C, Gnatprep, GreenHills, or Verdix.
  • Standard — point Understand at your Ada standard/runtime directory.
  • Library Directories and Main Subprograms — help resolve withed units and entry points.
  • Macros — for the selected preprocessor.
  • Metrics toggles let you include and/or operators, exception handlers, and for-loops in the strict complexity count.

The most common accuracy fix is supplying the correct Standard directory and library directories so package references resolve.

Assembly

Minimal options: choose the Assembler and add a System Include Path. Understand supports Coldfire 68k and IBM System/370 assembly. For where assembly fits into a firmware project, see Set up an embedded / firmware project.

Visual Basic (.NET)

  • Imported Namespaces — namespaces imported automatically, project-wide.
  • References — additional assemblies to include beyond the framework (the equivalent of the classpath); without them, framework and library types are undefined.
  • Root Namespace — the default namespace for the project.
  • Framework / Implicit Framework References — select the .NET framework version; the implicit framework references are then populated automatically.
  • Preprocessor Symbols — compiler constants defined at the project level, equivalent to #Const declarations or constants passed at build time.
  • Analyze Found Reference Files — writes the contents of referenced assemblies into the database.

C#

  • References — additional assemblies to include beyond the framework assemblies. Use the Alias column to assign an extern alias that disambiguates assemblies containing conflicting type names (the C# extern alias feature).
  • Analyze Found Reference Files — writes the contents of referenced assemblies into the database.
  • Preprocessor Symbols — symbols defined at the project level, equivalent to #define constants or symbols passed via /define at build time.
  • Framework and Implicit Framework References — for the targeted .NET framework.
  • C# up to and including C# 12 is supported.

Fortran

  • Version — FORTRAN 77/90/95/2003/2008/2018.
  • Format — Fixed, Free, or Auto; set the Truncate column for fixed-format code.
  • Use preprocessor and an Intrinsics File.
  • Includes and Macros for the preprocessor.
  • Several lexical-tolerance switches (C-style comments, colons in names, quote in octal constants, case-sensitive identifiers, etc.) let you match compiler extensions.

Getting Format and Version right is the usual difference between a clean parse and spurious errors.

Java

Java analysis usually needs the classpath to resolve library and JDK types — missing entries are the top cause of undefined entities.

  • Class Paths (Project → Configure Project → Java → Class Paths): use New Jar to add .jar, .jmod, or .zip files, and New Path for class directories. Adding the JDK's java.base.jmod and src.zip resolves many built-in base types.
  • Version — target JDK level.
  • Use Spring — enable before analyzing to recognize Spring annotations for Dependency Injection, AOP, and JPA/Hibernate; the parser then surfaces a Spring Framework entity (Entity Filter → Frameworks) with Beans, Tables, and injected variables. Support currently covers annotations, not XML configuration.

Gradle / Maven projects

Understand does not read build.gradle or pom.xml directly. Instead, export the classpath from your build and add the resulting jars as Class Paths. SciTools ships a gradlepaths.py helper (attached to the Using Gradle and Maven Projects KB article) that runs gradle dependencies and resolves the full jar paths from the Gradle cache. For Maven, export the dependency classpath the same way and add those jars.

JOVIAL

  • Version — JOVIAL73 or JOVIAL3.
  • Automatic compool file — path to a compool file that is implicitly included in every source file.
  • Truncate column — set if source lines should be truncated.
  • !COPY — directories to search for files named in !COPY statements; Expand copy file references pulls their contents in.
  • Implementation sizes (bits in byte/word/pointer, fixed/float/int precision) describe the target machine model, and are used to analyze data overlay.

Delphi / Pascal

  • Version — Delphi, Turbo, HP, Compaq, Pascal86, or VSI.
  • Allow embedded SQL — for Ingres embedded SQL.
  • Predeclared entities file — a list of built-in / predefined entities.
  • dfm converter exe — a converter executable that translates binary Delphi .dfm files to text.
  • Namespaces — namespace prefixes for resolving unqualified names (the Unit Scope Names option in Delphi).
  • Parse library implementation code — parse the implementation sections of library units.
  • Macros — compiler defines for conditional compilation.
  • Standard Library Paths — paths to the Delphi standard library source files.
  • Search Paths — additional paths searched when resolving unit references and include files.

Python

  • Python executable — point at the interpreter so Understand can determine the Python version and locate the standard library and installed packages; leave it at the default to use the Python interpreter found on your PATH.
  • Version — select Python 2 or Python 3 only if the version can't be determined from the Python executable.
  • Use built-in standard library files — analyze the shipped stdlib stubs.
  • Assume nearest matches (Dynamic Resolve) — resolve ambiguous dynamic references to the closest candidate.
  • Ignore import errors in try blocks — avoid errors from optional imports guarded by try.

Rust

The Rust parser runs a full HIR-level analysis, so most configuration mirrors Cargo:

  • Release Profile and Target Directory.
  • Features — enable All features or No default features to match how you build.
  • Add found module files to source list — pull in modules discovered during analysis.

VHDL

Few options: set the Library and, if needed, Ignore Parent Overrides. VHDL-87, VHDL-93, VHDL-2002, and VHDL-2008 are supported.

Web (HTML / CSS / JavaScript / TypeScript / PHP / XML)

  • JavaScript / TypeScript:
    • Analyze jQuery — create database entities for jQuery selectors.
    • Analyze Node.js — recognize Node.js built-ins and require functions.
    • Search Path — directories to search when processing Node.js requires.
    • Module Search Path — directories to search when locating imported modules.
    • Search Strings for Entity Names and Add found imported files to source list — pull in resolved imports.
  • PHP — choose the Version and enable Allow Short Tags / Allow ASP Style Tags to match your PHP configuration.

When accuracy still looks wrong

If entities are undefined or duplicated, or references are missing, the cause is almost always an incomplete configuration for that language (a missing classpath, library directory, reference assembly, or preprocessor symbol). Add the missing inputs above and re-analyze — for C/C++ symptoms (inactive code, unresolved entities), see fix parse errors. For projects that span several languages, also read Analyze a mixed / multi-language project.