NAME

Package Understand - perl class interface to Understand databases.

SYNOPSIS

use Understand;

The package Understand provides class-oriented access to Understand databases for the languages Ada, C/C++, C#, Fortran, Java, Jovial, Pascal, and Plm.

A list of entities (files, functions, variables, etc) may be obtained from an open database. In addition to the name, kind and type of an entity, a variety of metric values are available (lines of code, complexity, etc). A list of all references made to or from an entity (calls, includes, sets, etc) may be obtained. Reference information includes file, line and column, reference kind and referencing and referenced entity.

There are four classes used to access an Understand database, which are automatically made available with the Understand package.

• Understand::Db

• Understand::Ent

• Understand::Kind

• Understand::Ref

DESCRIPTION

Licensing

Use of the Understand package requires proper licensing. Presently, this means a user- or host-locked license, or an available floating license, for the product Understand for Ada, Understand for C++, Understand for Fortran, Understand for Java, Understand for Jovial or Understand for Pascal as appropriate for the language of the database.

A license regcode, file or directory may be specified with Understand::license(filename).

However, this is usually unnecessary, as the license file will be found automatically with the following checks, in order:

• Understand::license(name)

• The environment variable $STILICENSE

• In the subdirectory conf/license of an installed Understand product.

Open/Close a Database

Currently, only one database at a time may be opened - an error will be returned on an attempt to open a second, simultaneous database.

A database is opened with the command ($db, $status) = Understand::open($name).

If the open fails, $status will be defined with a string indicating the kind of failure. On a successful open, the returned $db will be an object from the class Understand::Db. An open database may be closed with the command $db->close().

List of Entities

A list of all entities, such as files, functions and variables, may be obtained from an Understand::Db object with the command $db->ents(). The returned list may be refined with a filter that specifies the kind of entities desired. For example, $db->ents("File") will return just file entities. All entities returned are objects of the class Understand::Ent.

Entity Attributes

There are a variety of attributes available for an Understand::Ent object. The command $ent->name() returns the name of the entity, while $ent->longname() returns a long name, if available. Examples of entities with long names include files, C++ members and most Ada entities.

If an entity has a type or return type associated with, for example a variables, types or functions, the type may be determined with the command $ent->type().

The kind of an entity, such as File or Function, may be determined with the command $ent->kindname(). If desired, the command: $ent->kind() may be used instead, which returns an object of the class Understand::Kind. This is sometimes useful when more detailed information about the kind is required.

List of References

A list of references for an entity may be obtained from an Understand::Ent object with the command $ent->refs(). The list may be refined with a filter that specifies the kind of references desired. For example, $ent->refs("Define") will return definition references. The list may be even further refined with a second filter that specifies the kind of referenced entities desired. For example, @refs=$ent->refs("Define","Parameter") will return just definition references for parameter entities. A final parameter with value 1 may be used to specify that only unique entities be returned. For example, @refs=$ent->refs("Call","Function",1) will return a list of references to called functions, where only the first reference to each unique function is returned. All references returned are objects of the class Understand::Ref.

Comment Association

If associated comments have been stored in the database, they may be retrieved for an entity. (Note, use the undada/undc command line option -comment or the understand_ada/understand_c setting on the dialog Project->Configure->Options->AssociateComments). Associated comments are comments that occur near the declaration of an entity in source code. Some entity kinds have different kinds of declarations, which can be explicity specified. Also, comment position, before or after the declaration, can be specified. The returned comments can be a formatted string (the default) or may be an array of raw comment strings.

Project Metrics

Metric values associated with the entire database or project are available for Understand::Db objects. The command $db->metrics() returns a list of all available project metric names. The command $db->metric(@mets) returns a list of values for specific metrics.

Entity Metrics

Metric values associated with a specific entity are available for Understand::Ent objects. The command $ent->metrics() returns a list of all available entity metric names. The command $ent->metric(@mets) returns a list of values for specific metrics.

Graphics

Graphical views of entities may be created and saved as jpg or png files, using the command $ent->draw(). On windows that have Visio installed, vsd files may also be created.

Info Browser

The text for Info Browser views of entities may be created using the command $ent->ib().

Lexer

A lexical stream may be generated for a file entity, if the original file exists and is unchanged from the last database reparse. The lexical stream is created with $ent->lexer(). Individual lexemes (tokens) may be accessed for a lexer object, either sequentially with $lexer->first() and $lexeme->next(), or as an array with $lexer->lexemes(). Each lexeme object indicates its token kind ($lexeme->token()), its text ($lexeme->text()), its referenced entity ($lexeme->ent()) and its line and column position.

Gui

When a script is being run from within the Understand application, the class Gui becomes available. This class gives access to the current open database and information about the cursor position and current selection for the file being edited.

Examples

The following examples are meant to be complete, yet simplistic, scripts that demonstrate one or more features each. For the sake of brevity and readability, common elements, such as testing the open $status or sorting, are not repeated in each example. Most examples are for C++; however, Ada, Fortran, Java, Jovial and Pascal examples would be very similar.

Sorted list of All Entities

  # test open status
  use Understand;
  ($db, $status) = Understand::open("test.udc");
  die "Error status: ",$status,"\n" if $status;

  # sort function
  foreach $ent (sort {$a->name() cmp $b->name();} $db->ents()) {

    # print entity and its kind
    print $ent->name(),"  [",$ent->kindname(),"]\n";
  }

List of Files

  use Understand;
  $db = Understand::open("test.udc");
  foreach $file ($db->ents("File")) {

    # print the long name (ie, show directory names)
    print $file->longname(),"\n";
  }

Lookup an entity

  use Understand;
  $db = Understand::open("test.udc");

  # find all 'File' entities that match test*.cpp
  foreach $file ($db->lookup("test*.cpp","File")) {
    print $file->name(),"\n";
  }

Global Variable Usage

  use Understand;
  $db = Understand::open("test.udc");
  foreach $var ($db->ents("Global Object ~Static")) {
    print $var->name(),":\n";
    foreach $ref ($var->refs()) {
      printf "  %-8s %-16s %s (%d,%d)\n",
        $ref->kindname(),
        $ref->ent()->name(),
        $ref->file()->name(),
        $ref->line(),
        $ref->column();
    }
    print "\n";
  }

List of Functions with Parameters

  use Understand;
  $db = Understand::open("test.udc");
  foreach $func ($db->ents("Function")) {
    print $func->longname(),"(";
    $first = 1;

    # get list of refs that define a parameter entity
    foreach $param ($func->ents("Define","Parameter")) {
      print ", " unless $first;
      print $param->type()," ",$param->name;
      $first = 0;
    }
    print ")\n";
  }

List of Functions with Associated Comments

  use Understand;
  $db = Understand::open("test.udc");
  foreach $func ($db->ents("function ~unresolved ~unknown")) {
    @comments = $func->comments("after");
    if (@comments) {
      print $func->longname(),":\n";
      foreach $comment (@comments) {print "  ",$comment,"\n";}
      print "\n";
      }
  }

List of Ada Packages

  use Understand;
  $db = Understand::open("test.uda");

  print "Standard Packages:\n";
  foreach $package ($db->ents("Package")) {
    print "  ",$package->longname(),"\n"
      if ($package->library() eq "Standard");
  }

  print "\nUser Packages:\n";
  foreach $package ($db->ents("Package")) {
    print "  ",$package->longname(),"\n"
      if ($package->library() ne "Standard");
  }

All Project Metrics

  use Understand;
  $db = Understand::open("test.udc");

  # loop through all project metrics
  foreach $met ($db->metrics()) {
    print $met," = ",$db->metric($met),"\n";
  }

Cyclomatic Complexity of Functions

  use Understand;
  $db = Understand::open("test.udc");

  # lookup a specific metric
  foreach $func ($db->ents("Function")) {
    $val = $func->metric("Cyclomatic");

    # only if metric is defined for entity
    print $func->name()," = ",$val,"\n" if defined($val);
  }

Callby Graphs of Functions

  use Understand;
  $db = Understand::open("test.udc");

  # loop through all functions
  foreach $func ($db->ents("Function")) {
    $file = "callby_" . $func->name() . ".png";
    print $func->longname(), " -> ", $file,"\n";
    $func->draw("callby",$file);
  }

Info Browser view of Functions

  use Understand;
  $db = Understand::open("test.udc");

  # loop through all functions
  foreach $func ($db->ents("Function")) {
    print $func->ib(),"\n";
  }

Lexical stream

  use Understand;
  $db = Understand::open("test.udc");

  # lookup file entity, create lexer
  $file = $db->lookup("test.cpp");
  $lexer = $file->lexer();

  # regenerate source file from lexemes
  # add a '@' after each entity name
  foreach $lexeme ($lexer->lexemes()) {
    print $lexeme->text();
    if ($lexeme->ent()) {
      print "@";
    }
  }

Gui access

  # This script is only designed to run from within the understand application
  use Understand;
  die "Must be run from within Understand" if !Understand::Gui::active();
  die "Must be run with a db open" if !Understand::Gui::db();

  my $db = Understand::Gui::db();
  printf("Database: %s\n",$db->name());

  my $filename = Understand::Gui::filename();
  my $col      = Understand::Gui::column();
  my $line     = Understand::Gui::line();
  printf("File '%s' [%d,%d]\n",$filename,$line,$col) if ($filename);

  my $entity = Understand::Gui::entity();
  printf("Entity '%s'\n",$entity->name()) if $entity;

  my $selection = Understand::Gui::selection();
  my $word = Understand::Gui::word();
  printf("Selection '%s'\n",$selection) if $selection;
  printf("Word '%s'\n",$word) if $word;

Reference

Understand package

Understand::license(name)

  Specify a regcode string, or a specific path to an Understand license.

Understand::open(path)

  Open a database. Returns ($db, $status). $db is an object in the
  class Understand::Db. $status, if defined, will be:

    "DBAlreadyOpen"      - only one database may be open at once
    "DBCorrupt"          - sorry, bad database file
    "DBOldVersion"       - database needs to be rebuilt
    "DBUnknownVersion"   - database needs to be rebuilt
    "DBUnableOpen"       - database is unreadable or does not exist
    "NoApiLicenseAda"    - Ada license required
    "NoApiLicenseC"      - C license required
    "NoApiLicenseFtn"    - Fortran license required
    "NoApiLicenseJava"   - Java license required
    "NoApiLicenseJovial" - Jovial license required
    "NoApiLicensePascal" - Pascal license required

Understand::version()

  Return the build number for the current installed uperl module.

Understand::Db class

$db->archs($ent)

  Returns the list of architectures that contain entity $ent.

$db->close()

  Closes a database so that another database may be opened. This is not
  available when run from within the Understand application.

$db->docformat($header, $body, $footer )

  Sets the comment format for the database for use with the 
  Understand::Doc module.  Using this module, it is possible to 
  extract structured information from the comments associated with an 
  entity.  The comments will be searched based on the patterns 
  specified by $header, $body, and $footer.  Each of these is a 
  regular expression using '~<pattern>&<tag>~' construct to designate 
  a pattern which should be associated with a contextual tag.

  Precisely, the pattern will first be searched for the $header 
  expression at the beginning of the comment, followed by a maximimal 
  number of matches of the $body pattern, closing with one instance 
  of the $footer pattern.  If any of the patterns do not match, they 
  will be skipped, and no tags for that section will be generated.

  The comment format is based on perl regular expressions, with a new
  operator for saving sub-patterns. '(' and ')' will perform grouping,
  but they will not save information and behave identically to '(?:'.
  Sub-patterns can be saved using the '~<pattern>&<tag>~' format, where 
  the text matching <pattern> will be stored in the doc object under 
  the tag <tag>.  The tag '@' will produce a tag entry with the name 
  of the first '@' pattern in the match.

  For example, to match javadoc-format strings in the body of the 
  message, the call:
      $db->docformat('', '\@~\w+&@~ - ~[^$]*&@~', '');
  would set the format to recognize the first word after the @ symbol 
  to be a javadoc tagname, and store the name and the rest of the line 
  under the name of the javadoc tag.

$db->ent_from_id($id)

  Returns an entity from the numeric identifier obtained from $ent->id().
  This should only be called for identifiers that have been obtained
  while the database has remained open. When a database is reopened the
  identifier is not guaranteed to remain consistent and refer to the
  same entity.

$db->ents( [$kindstring] )

  Returns a list of entities. If the optional parameter $kindstring is not
  passed, then all entities in the database are returned. Otherwise,
  $kindstring should be a language-specific entity filter string. 
  Each returned entity is an object in the class Understand::Ent.

$db->language()

  If called in an array context, returns a list of languages used in the
  database. Otherwise, returns a string of languages, separated by spaces.
  Possible language names are:"Ada", "C", "C#", "Fortran", "Java", "Jovial",
  "Pascal", "Plm", "Verilog", "VHDL" or "Web".

$db->lookup($name [,$kindstring] [,$case])

  Returns a list of entities that match the specified $name. The special
  character '?' may be used to indicate a match of any single character
  and the special character '*' may be used to indicate a match of 0 or
  more characters. If the optional parameter $kindstring is passed, it
  should be a language-specific entity filter string. If the optional
  parameter $case is passed, it should be 0 to mean case-insensitive
  and 1 to mean case-sensitive lookup. The default is case-insensitive.

$db->lookup_arch($longname)

  Lookup the architecture by longname and return an Arch object or undef
  if it is not found.

$db->lookup_snapshot($name)

  Lookup the snapshot by name and return a Snapshot object or undef if it
  is not found.

$db->lookup_uniquename($uniquename)

  Returns the entity identified by uniquename, or UNDEF if no entity is
  found. Uniquename is the name returned by $ent->uniquename().

$db->metric(@metriclist)

  Returns a project metric value for each specified metric name in
  @metriclist

$db->metrics()

  Returns a list of all project metric names.

$db->name()

  Returns the filename of the database.

$db->root_archs()

  Returns the list of root architectures for the database.

$db->snapshots()

  Returns the list of snapshots the database.

Understand::Arch class

$arch->name()

  Return the short name of the architecture.

$arch->longname()

  Return the long name of the architecture.

$arch->parent()

  Return the parent of the architecture or undef if it is a root.

$arch->children()

  Return the children of the architecture.

$arch->ents([$recursive])

  Return the entities within the architecture. If recursive is specified
  and is true, the list will also include all the entities from all nested
  architectures.

$arch->contains($entity [,$recursive])

  Return true if the entity is contained within the architecture. If
  $recursive is specfified and is true, also consider all nested
  architectures as well.

Understand::Ent class

$ent->comments( [$style [,$format [,$refkindstring]]] )

  Returns a formatted string based on comments that are associated with
  an entity.

  The optional parameter $style is used to specify which comments are
  to be used. By default, comments that come after the entity 
  declaration are processed. Here is a summary of all values that may be
  specified for $style:

    default - same as 'after'
    after   - process comments after the entity declaration
    before  - process comments before the entity declaration

  The optional parameter $format is used to specify what kind of
  formatting, if any, is applied to the comment text.

    default - removes comment characters and certain repeating
              characters, while retaining the original newlines
    raw     - return an array of comment strings in original format,
              including comment characters

  If the optional parameter $refkindstring is specified, it should be a
  language-specific reference filter string. For C++, the default is
  "definein", which is almost always correct. However, to see comments
  associated with member declarations, "declarein" should be used. For
  Ada there are many declaration kinds that may be used, including
  "declarein body", "declarein spec" and "declarein instance".

$ent->doc( [$style [, $format [, $refkindstring]]] )

  Generates an Understand::Doc object based on the entity comments and 
  the format strings specified in Understand::Db::docformat().  In 
  particular, it performs the searching explained in docformat() on the 
  comments selected by the arguments.

$ent->draw( $kind, $filename [,$options] )

  Generates a graphics file for an entity. Only jpg, png and svg file formats
  are supported on all platforms, so the $filename parameter must end with
  either the extension .jpg, .png or .svg.

  On windows systems that have Visio installed, the $filename parameter may
  end with .vsd, which will cause Visio to be invoked, to draw the graphics,
  and to save the drawing to the named file. Visio will remain running, but
  may be quit by calling Understand::Visio::quit().

  One of the following status strings will be returned on error:
    "NoFont"           - no suitable font can be found
    "NoImage"          - no image is defined or is empty
    "NoVisioSupport"   - no Visio .vsd files can be generated on non-windows
    "TooBig"           - jpg does not support a dimension greater than 64k
    "UnableCreateFile" - file cannot be opened/created
    "UnsupportedFile"  - only .jpg, .png or .svg files are supported.

  Additional error messages are also possible when generating a Visio file.

  The $kind parameter should specify the kind of view for the entity.
  The valid view names are the same as what are available in Understand:

    Base Classes              - c
    Callby                    - ada, c, fortran, java, jovial, pascal
    Child Lib Units           - ada
    Contains                  - java
    Data Members              - c
    Declaration               - ada, c, fortran, java, jovial, pascal
    Declaration File          - c, fortran, java, jovial, pascal
    Declaration Tree          - ada
    Declaration Type          - c, java, jovial
    Declared In               - ada
    Derived Classes           - c
    Extends                   - java
    Extended By               - java
    Include                   - c, fortran, pascal
    Includeby                 - c, fortran, pascal
    Instantiated From         - ada
    Instantiations            - ada
    Invocation                - ada, c, fortran, java, jovial, pascal
    Parent Declaration        - ada, c, java, jovial
    Parent Lib Unit           - ada
    Rename Declaration        - ada
    Return Type               - c, java, jovial
    Type Derived From         - ada
    Type Tree                 - ada
    Usedby                    - fortran
    Uses                      - fortran
    With                      - ada
    Withby                    - ada

  The optional string $options may be used to specify some parameters used
  to generate the graphics. The format of the options string is "name=value".
  Multiple options are separated with a semicolon. The valid names and values
  are the same as appear in the Understand Options menus. They may be
  abbreviated to any unique prefix of their full names. An example options
  string: "layout=cross; scale=14".

  Not all options are available for all graphical views. Here is a summary
  of all possible options and values:

    Base classes              - c
       On [default]
       Off
    Called by                 - ada, c, fortran, java
       On [default]
       Off
    Components                - ada
       on
       off [default]
    Constants                 - ada
       On [default]
       Off
    Default Members           - java
       On [default]
       Off
    Derived classes           - c
       On [default]
       Off
    Duplicate Subtrees        - ada, c, fortran, java
       Hide
       Show [default]
    Extends                   - java
       On [default]
       Off
    Extended By               - java
       On [default]
       Off
    External Functions        - c
       On [default]
       Off
    Filename                  - c, java
       None [default]
       Shortname
       Fullname
    Function Pointer          - c, fortran
       On [default]
       Off
    Implements                - java
       On [default]
       Off
    Implemented By            - java
       On [default]
       Off
    Imports                   - java
       On [default]
       Off
    Included by               - c
       On [default]
       Off
    Includes                  - c
       On [default]
       Off
    Intrinsic                 - fortran
       On [default]
       Off
    Invocations               - ada, c, fortran, java
       On [default]
       Off
    Layout                    - ada, c, fortran, java
       Crossing
       Horizontal Non-crossing [default]
       Vertical Non-crossing
    Level                     - ada, c, fortran, java
       All Levels [default]
       1 Level
       2 Levels
       3 Levels
       4 Levels
       5 Levels
    Local                     - ada
       On [default]
       Off
    Members                   - ada
       None [default]
       Components
       Operations
       Components & Operations
    Name                      - ada, c, java
       Shortname [default]
       Fullname
    Objects                   - ada
       On [default]
       Off
    Operators                 - ada
       On [default]
       Off
    Parameters                - ada, c, fortran, java
       On
       Off [default]
    Private                   - c
       On [default]
       Off
    Private Members           - java
       On [default]
       Off
    Protected                 - c
       On [default]
       Off
    Protected Members         - java
       On [default]
       Off
    Public                    - c
       On [default]
       Off
    Public Members            - java
       On [default]
       Off
    Renames                   - ada
       On [default]
       Off
    Scale                     - ada, c, fortran, java
       14pt
       12pt
       10pt [default]
       8pt
       5pt
       2pt
    Static                    - c
       On [default]
       Off
    Text                      - ada, c, fortran, java
       No Truncate
       Truncate Short
       Truncate Medium
       Truncate Long
       Wrap Short
       Wrap Medium
       Wrap Long [default]
    Types                     - ada
       On [default]
       Off
    Typetext                  - c, fortran
       On [default]
       Off
    Unknown                   - java
       On [default]
       Off
    Unresolved                - c, fortran
       On [default]
       Off
    Usedby                    - fortran
       On [default]
       Off
    Uses                      - fortran
       On [default]
       Off
    Withs                     - ada
       On [default]
       Off
    Withed by                 - ada
       On [default]
       Off

  Additionally, the special option 'font' may be specified. Its value
  must be the path to a truetype font (.ttf) for jpg and png files, or
  the name of a system font for Visio .vsd files.

$ent->ents( $refkindstring [,$entkindstring] )

  Returns a list of entities that reference, or are referenced by, the
  entity. $refkindstring should be a language-specific reference filter
  string. If the optional parameter $entkindstring is not passed, then
  all referenced entities are returned. Otherwise, $entkindstring should be
  a language-specific entity filter string that specifies what kind of 
  referenced entities are to be returned. Each returned entity is an object
  in the class Understand::Ent.

$ent->filerefs( [$refkindstring [,$entkindstring [, $unique]]] )

  Returns a list of all references that occur in the specified file entity.
  These references will not necessarily have the file entity for their ->scope
  value. If the optional parameter $refkindstring is not passed, then all
  references are returned. Otherwise, $refkindstring should be a
  language-specific reference filter string. If the optional parameter
  $entkindstring is not passed, then all references to any kind of entity
  are returned. Otherwise, $entkindstring should be a language-specific
  entity filter string that specifies references to what kind of referenced
  entity are to be returned. If the optional parameter $unique is passed with
  value 1, only the first matching reference to each unique entity is returned.

  Each returned reference is an object in the class Understand::Ref.

$ent->ib( [,$options] )

  Returns a list of lines of text, representing the Info Browser
  information for an entity.

  The optional string $options may be used to specify some parameters used
  to create the text. The format of the options string is "name=value" or
  "{field-name}name=value". Multiple options are separated with a semicolon.
  Spaces are allowed and are significant between multi-word field names,
  whereas, case is not significant. An option that specifies a field name
  is specific to that named field of the Info Browser. The available field
  names are exactly as they appear in the Info Browser. When a field is
  nested within another field, the correct name is the two names combined.
  For example, in C++, the field Macros within the field Local would be
  specified as "Local Macros".

  A field and its subfields may be disabled by specifying levels=0, or
  by specifying the field off, without specifying any option. For example,
  either of the will disable and hide the Metrics field:

     {Metrics}levels=0;
     {Metrics}=off;

  The following option is currently available only without a field name.

    Indent  - this specifies the number of indent spaces to output for 
              each level of a line of text. The default is 2.

  The following options are currently available only with a field name.
  Not all options are available for all field names. The options that are
  available are the same as are displayed when right-clicking on the
  field name in the Understand tool. No defaults are given for these
  options, as the defaults are specific for each language and each field
  name.

    Defnfile
      Short    - displays the short filename where entities are defined
      Long     - displays the long filename where entities are defined
      Relative - displays the relative filename where entities are defined
      Off      - never displays the filenames where entities are defined
    Dotrefs
      On       - displays references within longnames
      Off      - never displays references within longnames
    Filenames
      Short    - displays short filenames
      Long     - displays long filenames
      Relative - display relative filenames
    Fullname
      On       - displays fullnames of entities when appropriate
      Off      - always displays short names of entities
    Inactives
      On       - displays inactive references
      Off      - never displays inactive references
    Levels
      -1       - show all nested fields
       0       - hide the field name and all nested fields
       n       - show up to 'n' levels of nested fields; the default is 4
    Parameters
      On       - displays formal parameters of functions when appropriate
      Off      - never displays formal parameters
    References
      On       - displays file/line information and multiple references
      Off      - only displays the simple referenced entity once
    Returntypes
      On       - displays function return types when appropriate
      Off      - never displays function return types
    Sort
      On       - sorts information by name
      Off      - sorts information by reference file/line
      Ref      - sorts information by reference kind, then file/line
    Types
      On       - displays type text of entities when appropriate
      Off      - never displays type text

$ent->id()

  Returns a numeric identifier which is unique for each underlying database
  entity. The identifier is not guaranteed to remain consistent after the
  database has been updated. An id can be converted back into an object of
  the class Understand::Ent with $db->ent_from_id($id).

$ent->kind()

  Returns a kind object from class Understand::Kind for the entity.

$ent->kindname()

  Returns a simple name for the kind of the entity. This is equivalent
  to $ent->kind()->name().

$ent->language()

  Returns a string indicating the language of the entity. Possible
  return values include "Ada", "C", "C#", "Fortran", "Java", "Jovial", "Pascal",
  "Plm", "Verilog", "VHDL" and "Web".

$ent->lexer( [$lookup_ents [,$tabstop [,$show_inactive [,$expand_macros]]]] )

  Returns a lexer object for the specified file entity. The original
  source file must be readable and unchanged since the last database parse.
  If called in an array context, returns ($lexer, $status). $status will be
  undef if no error occurs, or will be:

    "FileModified"        - the file must not be modified since the last parse
    "FileUnreadable"      - the file must be readable from the original location
    "UnsupportedLanguage" - the file language is not supported

  The optional parameter, $lookup_ents, is true by default. If it is
  specified false, the lexemes for the constructed lexer will not have
  entity or reference information, but the lexer construction will be
  much faster.

  The optional parameter, $tabstop, is 8 by default. If it is specified it
  must be greater than 0, and is the value to use for tab stops.

  The optional parameter $show_inactive is true by default. If false,
  inactive lexemes will not be returned.

  The optional parameter $expand_macros is false by default. If true,
  and if macro expansion text is stored, lexemes that are macros will
  be replaced with the lexeme stream of the expansion text.

$ent->library()

  Returns the name of the library that the entity belongs to, or undef
  if it does not belong to a library.

  Currently, the only supported library is 'Standard', to which
  predefined Ada entities such as 'text_io' belong.

$ent->longname()

  Returns the long name of the entity. If there is no long name defined
  the regular name ($ent->name()) is returned. Examples of entities with
  long names include files, c++ members and most ada entities.

$ent->metric(@metriclist)

  Returns a metric value for each specified metric name in @metriclist.

$ent->metrics()

  Returns a list of all metric names that are defined for the entity.

$ent->name()

  Returns the short name for the entity. For Java, this may return a name
  with a single dot in it. Use $ent->simplename() to obtain the simplest,
  shortest name possible.

$ent->parameters($shownames)

  Returns a string (or array if called from an array context) of parameter
  types (and names if $shownames is true) for an entity. There are some
  language-specific cases where there are no entities in the database for
  certain kinds of parameters. For example, in c++, there are no database
  entities for parameters for functions that are only declared, not defined,
  and there are no database entities for parameters for functional macro
  definitions. This method can be used to get some information about these
  cases.

$ent->parsetime()

  Returns the last time the file entity was parsed in the database. Returns
  0 if the entity is not a parsed file.

$ent->refs( [$refkindstring [,$entkindstring [, $unique]]] )

  Returns a list of references. If the optional parameter $refkindstring
  is not passed, then all references for the entity are returned. Otherwise,
  $refkindstring should be a language-specific reference filter string. If
  the optional parameter $entkindstring is not passed, then all references
  to any kind of entity are returned. Otherwise, $entkindstring should be
  a language-specific entity filter string that specifies references to
  what kind of referenced entity are to be returned. If the optional
  parameter $unique is passed with value 1, only the first matching
  reference to each unique entity is returned.

  Each returned reference is an object in the class Understand::Ref.

  In a scalar context, only the first reference is returned.

$ent->ref( [$refkindstring [,$entkindstring]] )

  Return the first reference for the entity. This is really the same as
  calling $ent->refs() from a scalar context.

$ent->relname()

  Return the relative name of the file entity. Return the fullname for
  the file, minus any root directories that are common for all project
  files. Return undef for non-file entities.

$ent->simplename()

  Returns the simple name for the entity. This is the simplest, shortest
  name possible for the entity. It is generally the same as $ent->name()
  except for languages like Java, for which this will not return a name
  with any dots in it.

$ent->type()

  Returns the type string of the entity. This is defined for entity kinds
  like variables and type, as well as entity kinds that have a return type
  like functions.

$ent->uniquename()

  Returns the uniquename of the entity. This name is not suitable for use
  by an end user. Rather, it is a means of identifying an entity uniquely
  in multiple databases, perhaps as the source code changes slightly over
  time. The uniquename is composed of things like parameters and parent
  names. So, some code changes will result in new uniquenames for the same
  instrinsic entity. Use $db->lookup_uniquename() to convert a
  uniquename back to an object of Understand::Ent.

$ent->value()

  Returns the value associated with enumerators, initialized variables and
  macros (not all languages are supported).

Understand::Doc class

$doc->body()

  Returns the unmatched section of comments from the entity.

$doc->tag($name [, $sections] )

  Returns a list of values associated with the tag $name for the given 
  documentation object.  If $sections is specified, it should contain 
  one or more of the following words:

     header
     body
     footer

  If $sections is specified, $doc->tag($name,$sections) will only 
  return tag elements found in the specfied sections.

$doc->tags( [$sections] )

  Returns the names of all tags found for this entity.  If $sections is 
  specified, it should contain one or more of the following words:

     header
     body
     footer

  If $sections is specified, $doc->tags($sections) will only 
  return the names of tags found in the specfied sections.

Understand::Gui class

Understand::Gui::active()

  Returns true if the script has been called from within the Understand
  application. No other functions in this class are available if this
  is not true.

Understand::Gui::analyze($db,[$all])

  Request the database be reanalyzed. If $all is specified and true, all
  files will be analyzed; otherwise, only changed files will be analyzed.
  It is critical that no database objects (entities, references, lexers,
  etc) be retained and used from before the analyze call.

Understand::Gui::column()

  Returns the column of the cursor in the current file being edited, or
  returns 0 if no file is being edited.

Understand::Gui::db()

  Returns the current database. This database must not be closed.

Understand::Gui::entity()

  Returns the current entity at the cursor position, or undef if no file is
  being edited or if the cursor position does not contain an entity.

Understand::Gui::file()

  Returns the entity of the current project file being edited, or undef if no
  project file is being edited.

Understand::Gui::filename()

  Returns the name of the current file being edited, or undef if no file
  is being edited.

Understand::Gui::flush()

  Flush any pending output.

Understand::Gui::line()

  Returns the line of the cursor in the current file being edited, or
  returns 0 if no file is being edited.

Understand::Gui::open_files()

  Returns the list of open files.

Understand::Gui::progress_bar(percent [,allow_cancel [,text]])

  Displays the progress bar, if percent is 0.0 or greater. If it is less
  than 0.0, the progress bar is hidden, if it is currently displayed. If
  it is greater than 1.0, then 1.0 is assumed. If $allow_cancel is specified,
  a value of 1 indicates a cancel button should be displayed on the progress
  bar. If allow_cancel is not specified, the default value is 0, which means
  no cancel button is displayed. If the cancel button is displayed and the
  user presses it, this call will return 1. Otherwise, it will return 0. If
  $text is specified, it will be the text displayed in the progress bar.

Understand::Gui::scope()

  Returns the current entity in scope at the cursor position, or undef if no
  file is being edited or if the cursor position is not within an entity scope.

Understand::Gui::selection()

  Returns the selected text in the current file being edited, or
  returns 0 if no file is being edited or no text is selected.

Understand::Gui::script()

  Returns the name of the current script being run.

Understand::Gui::word()

  Returns the word at the cursor position in the current file being edited,
  or returns 0 if no file is being edited.

Understand::Gui::yield()

  Causes a potential yield event in the understand application, if it is
  needed. Normally, the following functions internally cause a yield:

    Understand::Db::Ents()
    Understand::Db::Metric()
    Understand::Ent::Ents()
    Understand::Ent::Lexer()
    Understand::Ent::Metric()
    Understand::Ent::Refs()

  If these functions are not called for long periods of time, it may be
  desirable to call yield() directly, to allow the understand application
  to respond to external events, such as window repaints.

Understand::Kind class

$kind->check($kindstring)

  Returns true if the kind matches the filter $kindstring.

$kind->inv()

  Returns the logical inverse of the kind. This is not valid for entity
  kinds.

@Understand::Kind::list_entity([entkind])

  Returns the list of entity longname kinds that match the filter $entkind.
  For example, the list of all c function entity kinds:
    my @kinds = Understand::Kind::list_entity("c function");

@Understand::Kind::list_reference([refkind])

  Returns the list of reference longname kinds that match the filter $refkind.
  For example, the list of all ada declare reference kinds:
    my @kinds = Understand::Kind::list_reference("ada declare");

$kind->longname()

  Returns the long form of the kind name. This is usually more detailed
  than desired for human reading.

$kind->name()

  Returns the name of the kind.

Understand::Lexeme class

$lexeme->column_begin()

  Returns the beginning column of the lexeme.

$lexeme->column_end()

  Returns the ending column of the lexeme.

$lexeme->ent()

  Returns the entity associated with the lexeme, or undef if none.

$lexeme->inactive()

  Returns true if the lexeme is part of inactive code.

$lexeme->line_begin()

  Returns the beginning line of the lexeme.

$lexeme->line_end()

  Returns the ending line of the lexeme.

$lexeme->next()

  Returns the next lexeme, or undef if at end of file.

$lexeme->previous()

  Returns the previous lexeme, or undef if at beginning of file.

$lexeme->ref()

  Returns the reference associated with the lexeme, or undef if none.

$lexeme->text()

  Returns the text for the lexeme.

$lexeme->token()

  Returns the token kind of the lexeme. Values include:

    "Comment"
    "Continuation"
    "EndOfStatement"
    "Identifier"
    "Keyword"
    "Label"
    "Literal"
    "Newline"
    "Operator"
    "Preprocessor"
    "Punctuation"
    "String"
    "Whitespace"

Understand::Lexer class

$lexer->first()

  Returns the first lexeme for the lexer.

$lexer->lexeme($line,$column)

  Returns the lexeme that occurs at the specified line and column.

$lexer->lexemes([$start_line,$end_line])

  Returns an array of all lexemes. If the optional parameters $start_line
  and $end_line are specified, only the lexemes within these lines are
  returned.

$lexer->lines()

  Returns the number of lines in the lexer.

Understand::Metric class

Understand::Metric::description($metric)

  Returns the short description of a metric.

Understand::Metric::list([$kindstring])

  Returns a list of metric names. If the optional parameter $kindstring is
  not passed, then the names of all possible metrics are returned. Otherwise,
  only the names of metrics defined for entities that match the entity
  filter $kindstring are returned.

Understand::Ref class

$ref->column()

  Returns the column in source where the reference occurred.

$ref->ent()

  Returns the entity being referenced. The returned entity is an object
  in the class Understand::Ent.

$ref->file()

  Returns the file where the reference occurred. The returned file is an
  object in the class Understand::Ent.

$ref->kind()

  Returns a kind object from the class Understand::Kind for the reference.

$ref->kindname()

  Returns a simple name for the kind of the reference. This is equivalent
  to $ref->kind()->name().

$ref->line()

  Returns the line in source where the reference occurred.

$ref->scope()

  Returns the entity performing the reference. The returned entity is an
  object in the class Understand::Ent.

Understand::Snapshot class

Understand::Snapshot::name()

  Returns the name of the snapshot.

Understand::Snapshot::open()

  Opens the snapshot and returns a database object that may be used as such.
  For example:

        my $snapshot = $db->lookup_snapshot("yesterday");
        my $snapshot_db = $snapshot->open();

Understand::Util class

Understand::Util::checksum($text[,$len])

  Returns a checksum of the text. The optional parameter $len specifies
  the length of the checksum, which may be between 1 and 32 characters,
  with 32 being the default.

Understand::Visio class

Understand::Visio::draw( $ent,$kind,$filename [,$options] )

  On windows only, invokes Visio, if it is not already running,
  generates a graphic for the specified entity, and saves the results
  to a .vsd file. Visio will continue running after this call (for
  efficiency reasons), but may be forced to quit using
  Understand::Visio::quit().

  A description of the $kind and $options parameters may be found by
  referring to the documentation for Understand::Ent::draw().

Understand::Visio::quit()

  In windows only, forces Visio to quit, if it is running from a call to
  Understand::Visio::draw() or Understand::Ent::draw().

Kind Filters

Kind filters are conceptually fairly simple, and in practice are also fairly easy to use. However, there are many details involved that can make documenting them quite daunting.

There are approximately 75 to 150 different defined kinds of entities and references, depending on the language. Some concepts of kind are simple to describe in some languages. For example, there is a single kind which represents file entities in Ada. However, in C++ there are three different kinds which represent different kinds of files. (Actually, there is a fourth kind, but it is used internally only and should not occur in usage of this api).

Each distinct kind is represented by a string of tokens that read together something like a sentence. A Kind string always has a token representing language (C, Ada, Fortran, Java, Jovial or Pascal), and one more more tokens which describe the kind. The tokens have been chosen to be common, when appropriate, among several similar kinds. For example, in C++, the three kinds of files are "C Code File", "C Header File" and "C Unknown Header File". Notice how the token "File" is common to all three kinds and the token "Header" is common to two of the kinds? This is very important when specifying a filter.

A filter string is used to match one or more related or unrelated kinds, for purposes of selecting entities or references from the database. In order for a filter string to match a kind, each token in the filter string must be present as a token in the kind string. This can be thought of as an "and" relationship. For example, the filter "File" will match all three C file kinds, since all three have the token "File" in their strings. The filter "Header File" will match the two C file kinds that have both "Header" and "File" in their strings.

A filter string may use the symbol "~" to indicate the absence of a token. So, again for example, the filter string "File ~Unknown" will match the two C file kinds that both have the token "File" in their string and also do not have the token "Unknown" in their string.

In addition to "and" filters, "or" filters can also be constructed with the ",". Groups of tokens separated by a comma are essentially treated as different filters. When each filter is calculated the results are combined with duplicates discarded. So, the filter string "Code File, Header File" will again match two of the C file kinds.

With proper knowledge of all the kinds available, kind filters can provide a powerful mechanism for selecting entities and references. On the one hand, specifying "File" will match all file kinds; on the other hand, "Undefined" will match undefined files in addition to all other entity kinds that represent the concept "undefined".

Ada Entity Kinds

Below are listed the general categories of ada entity kinds. When these categories are used literally, as filters, the full kind names that match have been listed beneath them.

 Component
    Ada Component
    Ada Component Local
    Ada Component Variant
    Ada Component Variant Local
    Ada Component Discriminant Local

 Constant
    Ada Constant Object
    Ada Constant Object Local
    Ada Constant Object Deferred

 Entry
    Ada Entry
    Ada Entry Body

 Enumeration Literal
    Ada Enumeration Literal

 Exception
    Ada Exception
    Ada Exception Local

 File
    Ada File

 Function
    Ada Abstract Function
    Ada Abstract Function Local
    Ada Abstract Function Operator
    Ada Abstract Function Operator Local
    Ada Function
    Ada Function Local
    Ada Function Operator
    Ada Function Operator Local
    Ada Generic Function
    Ada Generic Function Local

 Implicit
    Ada Implicit

 Object
    Ada Constant Object
    Ada Constant Object Local
    Ada Constant Object Deferred
    Ada Exception Object Local
    Ada Loop Object Local
    Ada Object
    Ada Object Local
    Ada Protected Object
    Ada Protected Object Local
    Ada Task Object
    Ada Task Object Local

 Package
    Ada Generic Package
    Ada Generic Package Local
    Ada Package
    Ada Package Local

 Parameter
    Ada Parameter

 Procedure
    Ada Abstract Procedure
    Ada Abstract Procedure Local
    Ada Generic Procedure
    Ada Generic Procedure Local
    Ada Procedure
    Ada Procedure Local

 Protected
    Ada Protected
    Ada Protected Local
    Ada Protected Object
    Ada Protected Object Local
    Ada Protected Type
    Ada Protected Type Local
    Ada Protected Type Private
    Ada Protected Type Limited Private

 Task
    Ada Task
    Ada Task Local
    Ada Task Object
    Ada Task Object Local
    Ada Task Type
    Ada Task Type Local
    Ada Task Type Private
    Ada Task Type Limited Private

 Type
    Ada Abstract Tagged Type Record
    Ada Abstract Tagged Type Record Local
    Ada Abstract Tagged Type Record Private
    Ada Abstract Tagged Type Record Limited Private
    Ada Protected Type
    Ada Protected Type Local
    Ada Protected Type Private
    Ada Protected Type Limited Private
    Ada Tagged Type Record
    Ada Tagged Type Record Local
    Ada Tagged Type Record Private
    Ada Tagged Type Record Limited Private
    Ada Task Type
    Ada Task Type Local
    Ada Task Type Private
    Ada Task Type Limited Private
    Ada Type
    Ada Type Local
    Ada Type Access
    Ada Type Access Local
    Ada Type Access Private
    Ada Type Access Private Limited
    Ada Type Access Subprogram
    Ada Type Access Subprogram Local
    Ada Type Access Subprogram Private
    Ada Type Access Subprogram Limited Private
    Ada Type Enumeration
    Ada Type Enumeration Local
    Ada Type Enumeration Private
    Ada Type Enumeration Limited Private
    Ada Type Private
    Ada Type Limited Private
    Ada Type Record
    Ada Type Record Local
    Ada Type Record Private
    Ada Type Record LimitedPrivate

 Unknown
    Ada Unknown

 Unresolved
    Ada Unresolved

Ada Reference Kinds

Below are listed the general categories of ada reference kinds, both forward and inverse relations. When these categories are used literally, as filters, the full kind names that match have been listed beneath them.

 AccessAttrTyped (AccessAttrTypedby)
    ada AccessAttrTyped

 Association (Associationby)
    Ada Association

 Call (Callby)
    Ada Call
    Ada Call Indirect
    Ada Call Dispatch
    Ada Call Dispatch Indirect
    Ada Call Access

 CallParamFormal (CallParamFormalfor)
    Ada CallParamFormalfor

 Child (Parent)
    Ada Child Libunit

 Declare (Declarein)
    Ada Declare
    Ada Body Declare
    Ada Body Declare File
    Ada Formal Declare
    Ada Incomplete Declare
    Ada Instance Declare
    Ada Private Declare
    Ada Spec Declare
    Ada Spec Declare File
    Ada Stub Declare

 Derive (Derivefrom)
    Ada Derive

 Dot (Dotby)
    Ada Dot

 End (Endby)
    Ada End
    Ada End Unnamed

 Handle (Handleby)
    Ada Handle

 Instance (Instanceof)
    Ada Instance
    Ada Instance Copy

 InstanceActual (InstanceActualfor)
    Ada InstanceActual

 InstanceParamFormal (InstanceParamFormalfor)
    Ada InstanceParamFormal

 Operation (Operationfor)
    Ada Operation

 Override (Overrideby)
    Ada Override

 Raise (Raiseby)
    Ada Raise

 Ref (Refby)
    Ada Ref
    Ada Ref Convert

 Rename (Renameby)
    Ada Rename

 Root (Rootin)
    Ada Root

 Separate (Separatefrom)
    Ada Separatefrom

 Set (Setby)
    Ada Set
    Ada Set Init

 Subtype (Subtypefrom)
    Ada Subtype

 Typed (Typedby)
    Ada Typed
    Ada Typed Implicit

 Use (Useby)
    Ada Abort Use
    Ada Access Use
    Ada Use

 Usepackage (Usepackageby)
    Ada Usepackage

 Usetype (Usetypeby)
    Ada Usetype

 With (Withby)
    Ada With
    Ada With Needed

 Withaccess (Withaccessby)
    Ada Withaccess

C Entity Kinds

Below are listed the general categories of c entity kinds. When these categories are used literally, as filters, the full kind names that match have been listed beneath them.

 Class
    C Abstract Class Type
    C Class Type
    C Private Member Class Type
    C Protected Member Class Type
    C Public Member Class Type
    C Unknown Class Type
    C Unnamed Class Type
    C Unnamed Private Member Class Type
    C Unnamed Protected Member Class Type
    C Unnamed Public Member Class Type
    C Unresolved Class Type
    C Unresolved Private Member Class Type
    C Unresolved Protected Member Class Type
    C Unresolved Public Member Class Type
    C Unresolved Unnamed Class Type

 Enum
    C Enum Type
    C Private Member Enum Type
    C Protected Member Enum Type
    C Public Member Enum Type
    C Unknown Enum Type
    C Unnamed Enum Type
    C Unnamed Private Member Enum Type
    C Unnamed Protected Member Enum Type
    C Unnamed Public Member Enum Type
    C Unresolved Enum Type
    C Unresolved Private Member Enum Type
    C Unresolved Protected Member Enum Type
    C Unresolved Public Member Enum Type

 Enumerator
    C Enumerator
    C Unresolved Enumerator

 File
    C Code File
    C Header File
    C Unknown Header File
    C Unresolved Header File

 Function
    C Function
    C Function Static
    C Private Member Const Function
    C Private Member Const Function Virtual
    C Private Member Const Function Virtual Pure
    C Private Member Function
    C Private Member Function Static
    C Private Member Function Virtual
    C Private Member Function Virtual Pure
    C Protected Member Const Function
    C Protected Member Const Function Virtual
    C Protected Member Const Function Virtual Pure
    C Protected Member Function
    C Protected Member Function Static
    C Protected Member Function Virtual
    C Protected Member Function Virtual Pure
    C Public Member Const Function
    C Public Member Const Function Virtual
    C Public Member Const Function Virtual Pure
    C Public Member Function
    C Public Member Function Static
    C Public Member Function Virtual
    C Public Member Function Virtual Pure
    C Unknown Function
    C Unknown Member Function
    C Unresolved Function
    C Unresolved Function Static
    C Unresolved Private Member Const Function
    C Unresolved Private Member Const Function Virtual
    C Unresolved Private Member Const Function Virtual Pure
    C Unresolved Private Member Function
    C Unresolved Private Member Function Static
    C Unresolved Private Member Function Virtual
    C Unresolved Private Member Function Virtual Pure
    C Unresolved Protected Member Const Function
    C Unresolved Protected Member Const Function Virtual
    C Unresolved Protected Member Const Function Virtual Pure
    C Unresolved Protected Member Function
    C Unresolved Protected Member Function Static
    C Unresolved Protected Member Function Virtual
    C Unresolved Protected Member Function Virtual Pure
    C Unresolved Public Member Const Function
    C Unresolved Public Member Const Function Virtual
    C Unresolved Public Member Const Function Virtual Pure
    C Unresolved Public Member Function
    C Unresolved Public Member Function Implicit
    C Unresolved Public Member Function Static
    C Unresolved Public Member Function Virtual
    C Unresolved Public Member Function Virtual Pure

 Macro
    C Inactive Macro
    C Macro
    C Macro Project
    C Unknown Macro
    C Unresolved Macro

 Object
    C Object Global
    C Object Global Static
    C Object Local
    C Object Local Static
    C Private Member Object
    C Private Member Object Static
    C Protected Member Object
    C Protected Member Object Static
    C Public Member Object
    C Public Member Object Static
    C Unknown Member Object
    C Unknown Object
    C Unresolved Object Global
    C Unresolved Object Global Static
    C Unresolved Private Member Object
    C Unresolved Private Member Object Static
    C Unresolved Protected Member Object
    C Unresolved Protected Member Object Static
    C Unresolved Public Member Object
    C Unresolved Public Member Object Static

 Parameter
    C Parameter
    C Unnamed Parameter

 Struct
    C Abstract Struct Type
    C Private Member Struct Type
    C Protected Member Struct Type
    C Public Member Struct Type
    C Struct Type
    C Unknown Struct Type
    C Unnamed Private Member Struct Type
    C Unnamed Protected Member Struct Type
    C Unnamed Public Member Struct Type
    C Unnamed Struct Type
    C Unresolved Private Member Struct Type
    C Unresolved Protected Member Struct Type
    C Unresolved Public Member Struct Type
    C Unresolved Struct Type
    C Unresolved Unnamed Struct Type

 Typedef
    C Private Member Typedef Type
    C Protected Member Typedef Type
    C Public Member Typedef Type
    C Typedef Type
    C Unresolved Private Member Typedef Type
    C Unresolved Protected Member Typedef Type
    C Unresolved Public Member Typedef Type
    C Unresolved Typedef Type

 Union
    C Private Member Union Type
    C Protected Member Union Type
    C Public Member Union Type
    C Union Type
    C Unknown Union Type
    C Unnamed Private Member Union Type
    C Unnamed Protected Member Union Type
    C Unnamed Public Member Union Type
    C Unnamed Union Type
    C Unresolved Private Member Union Type
    C Unresolved Protected Member Union Type
    C Unresolved Public Member Union Type
    C Unresolved Union Type
    C Unresolved Unnamed Union Type

C Reference Kinds

Below are listed the general categories of c reference kinds, both forward and inverse relations. When these categories are used literally, as filters, the full kind names that match have been listed beneath them.

 Base (Derive)
    C Private Base
    C Protected Base
    C Public Base
    C Virtual Private Base
    C Virtual Protected Base
    C Virtual Public Base

 Call (Callby)
    C Asm Call
    C Call
    C Implicit Call
    C Inactive Call
    C Virtual Call

 Declare (Declarein)
    C Declare
    C Declare Implicit

 Define (Definein)
    C Define

 Friend (Friendby)
    C Friend

 Include (Includeby)
    C Include
    C Implicit Include

 Modify (Modifyby)
    C Deref Modify
    C Modify

 Set (Setby)
    C Deref Set
    C Set
    C Set Init

 Typed (Typedby)
    C Typed
    C Typed Implicit

 Use (Useby)
    C Asm Use
    C Deref Use
    C Inactive Use
    C Use
    C Use Macrodefine
    C Use Macroexpand
    C Use Ptr
    C Use Return

C# Entity Kinds

Below are listed the general categories of C# entity kinds. When these categories are used literally, as filters, the full kind names that match have been listed beneath them.

 Class
    c# csharp Internal Type Class
    c# csharp Internal Type Class Abstract
    c# csharp Internal Type Class Static
    c# csharp Internal Type Class Sealed
    c# csharp Internal Type Generic Class
    c# csharp Internal Type Generic Class Abstract
    c# csharp Internal Type Generic Class Static
    c# csharp Internal Type Generic Class Sealed
    c# csharp Protected Type Class
    c# csharp Protected Type Class Abstract
    c# csharp Protected Type Class Static
    c# csharp Protected Type Class Sealed
    c# csharp Protected Type Generic Class
    c# csharp Protected Type Generic Class Abstract
    c# csharp Protected Type Generic Class Static
    c# csharp Protected Type Generic Class Sealed
    c# csharp Protected Internal Type Class
    c# csharp Protected Internal Type Class Abstract
    c# csharp Protected Internal Type Class Static
    c# csharp Protected Internal Type Class Sealed
    c# csharp Protected Internal Type Generic Class
    c# csharp Protected Internal Type Generic Class Abstract
    c# csharp Protected Internal Type Generic Class Static
    c# csharp Protected Internal Type Generic Class Sealed
    c# csharp Private Type Class
    c# csharp Private Type Class Abstract
    c# csharp Private Type Class Static
    c# csharp Private Type Class Sealed
    c# csharp Private Type Generic Class
    c# csharp Private Type Generic Class Abstract
    c# csharp Private Type Generic Class Static
    c# csharp Private Type Generic Class Sealed
    c# csharp Public Type Class
    c# csharp Public Type Class Abstract
    c# csharp Public Type Class Static
    c# csharp Public Type Class Sealed
    c# csharp Public Type Generic Class
    c# csharp Public Type Generic Class Abstract
    c# csharp Public Type Generic Class Static
    c# csharp Public Type Generic Class Sealed
    c# csharp Unknown Type Class

 Const 
    c# csharp Const Local

 Enumerator
    c# csharp Enumerator
    c# csharp Unresolved Enumerator

 Event
    c# csharp Internal Event
    c# csharp Internal Event Static
    c# csharp Internal Event Virtual
    c# csharp Internal Event Virtual Abstract
    c# csharp Internal Event Virtual Sealed
    c# csharp Protected Event
    c# csharp Protected Event Static
    c# csharp Protected Event Virtual
    c# csharp Protected Event Virtual Abstract
    c# csharp Protected Event Virtual Sealed
    c# csharp Protected Internal Event
    c# csharp Protected Internal Event Static
    c# csharp Protected Internal Event Virtual
    c# csharp Protected Internal Event Virtual Abstract
    c# csharp Protected Internal Event Virtual Sealed
    c# csharp Private Event
    c# csharp Private Event Static
    c# csharp Public Event
    c# csharp Public Event Static
    c# csharp Public Event Virtual
    c# csharp Public Event Virtual Abstract
    c# csharp Public Event Virtual Sealed
    c# csharp Unresolved Internal Event
    c# csharp Unresolved Internal Event Static
    c# csharp Unresolved Internal Event Virtual
    c# csharp Unresolved Internal Event Virtual Sealed
    c# csharp Unresolved Protected Event
    c# csharp Unresolved Protected Event Static
    c# csharp Unresolved Protected Event Virtual
    c# csharp Unresolved Protected Event Virtual Sealed
    c# csharp Unresolved Protected Internal Event
    c# csharp Unresolved Protected Internal Event Static
    c# csharp Unresolved Protected Internal Event Virtual
    c# csharp Unresolved Protected Internal Event Virtual Sealed
    c# csharp Unresolved Private Event
    c# csharp Unresolved Private Event Static
    c# csharp Unresolved Public Event
    c# csharp Unresolved Public Event Static
    c# csharp Unresolved Public Event Virtual
    c# csharp Unresolved Public Event Virtual Sealed

 Field
    c# csharp Internal Const Field
    c# csharp Internal Field
    c# csharp Internal Field Static
    c# csharp Protected Const Field
    c# csharp Protected Field
    c# csharp Protected Field Static
    c# csharp Protected Internal Const Field
    c# csharp Protected Internal Field
    c# csharp Protected Internal Field Static
    c# csharp Private Const Field
    c# csharp Private Field
    c# csharp Private Field Static
    c# csharp Public Const Field
    c# csharp Public Field
    c# csharp Public Field Static
    c# csharp Unresolved Field

 File
    c# csharp File

 Indexer
    c# csharp Internal Indexer
    c# csharp Internal Indexer Virtual
    c# csharp Internal Indexer Virtual Abstract
    c# csharp Internal Indexer Virtual Sealed
    c# csharp Protected Indexer
    c# csharp Protected Indexer Virtual
    c# csharp Protected Indexer Virtual Abstract
    c# csharp Protected Indexer Virtual Sealed
    c# csharp Protected Internal Indexer
    c# csharp Protected Internal Indexer Virtual
    c# csharp Protected Internal Indexer Virtual Abstract
    c# csharp Protected Internal Indexer Virtual Sealed
    c# csharp Private Indexer
    c# csharp Public Indexer
    c# csharp Public Indexer Virtual
    c# csharp Public Indexer Virtual Abstract
    c# csharp Public Indexer Virtual Sealed
    c# csharp Unresolved Internal Indexer
    c# csharp Unresolved Internal Indexer Virtual
    c# csharp Unresolved Internal Indexer Virtual Sealed
    c# csharp Unresolved Protected Indexer
    c# csharp Unresolved Protected Indexer Virtual
    c# csharp Unresolved Protected Indexer Virtual Sealed
    c# csharp Unresolved Protected Internal Indexer
    c# csharp Unresolved Protected Internal Indexer Virtual
    c# csharp Unresolved Protected Internal Indexer Virtual Sealed
    c# csharp Unresolved Private Indexer
    c# csharp Unresolved Public Indexer
    c# csharp Unresolved Public Indexer Virtual
    c# csharp Unresolved Public Indexer Virtual Sealed

 Method
    c# csharp Constructor Method Static
    c# csharp Finalizer Method
    c# csharp Internal Constructor Method
    c# csharp Internal Method
    c# csharp Internal Method Static
    c# csharp Internal Method Virtual
    c# csharp Internal Method Virtual Abstract
    c# csharp Internal Method Virtual Sealed
    c# csharp Protected Constructor Method
    c# csharp Protected Method
    c# csharp Protected Method Static
    c# csharp Protected Method Virtual
    c# csharp Protected Method Virtual Abstract
    c# csharp Protected Method Virtual Sealed
    c# csharp Protected Internal Constructor Method
    c# csharp Protected Internal Method
    c# csharp Protected Internal Method Static
    c# csharp Protected Internal Method Virtual
    c# csharp Protected Internal Method Virtual Abstract
    c# csharp Protected Internal Method Virtual Sealed
    c# csharp Private Constructor Method
    c# csharp Private Method
    c# csharp Private Method Static
    c# csharp Public Constructor Method
    c# csharp Public Method
    c# csharp Public Method Static
    c# csharp Public Method Virtual
    c# csharp Public Method Virtual Abstract
    c# csharp Public Method Virtual Sealed
    c# csharp Unknown Method
    c# csharp Unresolved Constructor Method Static
    c# csharp Unresolved Finalizer Method
    c# csharp Unresolved Internal Constructor Method
    c# csharp Unresolved Internal Method
    c# csharp Unresolved Internal Extern Method
    c# csharp Unresolved Internal Method Static
    c# csharp Unresolved Internal Extern Method Static
    c# csharp Unresolved Internal Method Virtual
    c# csharp Unresolved Internal Extern Method Virtual
    c# csharp Unresolved Internal Method Virtual Sealed
    c# csharp Unresolved Internal Extern Method Virtual Sealed
    c# csharp Unresolved Protected Constructor Method
    c# csharp Unresolved Protected Method
    c# csharp Unresolved Protected Extern Method
    c# csharp Unresolved Protected Method Static
    c# csharp Unresolved Protected Extern Method Static
    c# csharp Unresolved Protected Method Virtual
    c# csharp Unresolved Protected Extern Method Virtual
    c# csharp Unresolved Protected Method Virtual Sealed
    c# csharp Unresolved Protected Extern Method Virtual Sealed
    c# csharp Unresolved Protected Internal Constructor Method
    c# csharp Unresolved Protected Internal Method
    c# csharp Unresolved Protected Internal Extern Method
    c# csharp Unresolved Protected Internal Method Static
    c# csharp Unresolved Protected Internal Extern Method Static
    c# csharp Unresolved Protected Internal Method Virtual
    c# csharp Unresolved Protected Internal Extern Method Virtual
    c# csharp Unresolved Protected Internal Method Virtual Sealed
    c# csharp Unresolved Protected Internal Extern Method Virtual Sealed
    c# csharp Unresolved Private Constructor Method
    c# csharp Unresolved Private Method
    c# csharp Unresolved Private Extern Method
    c# csharp Unresolved Private Method Static
    c# csharp Unresolved Private Extern Method Static
    c# csharp Unresolved Public Constructor Method
    c# csharp Unresolved Public Method
    c# csharp Unresolved Public Method Static
    c# csharp Unresolved Public Extern Method Static
    c# csharp Unresolved Public Method Virtual
    c# csharp Unresolved Public Extern Method Virtual
    c# csharp Unresolved Public Method Virtual Sealed
    c# csharp Unresolved Public Extern Method Virtual Sealed

 Namespace
    c# csharp Namespace Alias
    c# csharp Extern Alias Namespace
    c# csharp Namespace
    c# csharp Unknown Namespace
    c# csharp Unresolved Namespace

 Proprerty
    c# csharp Internal Property
    c# csharp Internal Property Static
    c# csharp Internal Property Virtual
    c# csharp Internal Property Virtual Abstract
    c# csharp Internal Property Virtual Sealed
    c# csharp Protected Property
    c# csharp Protected Property Static
    c# csharp Protected Property Virtual
    c# csharp Protected Property Virtual Abstract
    c# csharp Protected Property Virtual Sealed
    c# csharp Protected Internal Property
    c# csharp Protected Internal Property Static
    c# csharp Protected Internal Property Virtual
    c# csharp Protected Internal Property Virtual Abstract
    c# csharp Protected Internal Property Virtual Sealed
    c# csharp Private Property
    c# csharp Private Property Static
    c# csharp Public Property
    c# csharp Public Property Static
    c# csharp Public Property Virtual
    c# csharp Public Property Virtual Abstract
    c# csharp Public Property Virtual Sealed
    c# csharp Unresolved Internal Property
    c# csharp Unresolved Internal Property Static
    c# csharp Unresolved Internal Property Virtual
    c# csharp Unresolved Internal Property Virtual Sealed
    c# csharp Unresolved Protected Property
    c# csharp Unresolved Protected Property Static
    c# csharp Unresolved Protected Property Virtual
    c# csharp Unresolved Protected Property Virtual Sealed
    c# csharp Unresolved Protected Internal Property
    c# csharp Unresolved Protected Internal Property Static
    c# csharp Unresolved Protected Internal Property Virtual
    c# csharp Unresolved Protected Internal Property Virtual Sealed
    c# csharp Unresolved Private Property
    c# csharp Unresolved Private Property Static
    c# csharp Unresolved Public Property
    c# csharp Unresolved Public Property Static
    c# csharp Unresolved Public Property Virtual
    c# csharp Unresolved Public Property Virtual Sealed

 Parameter
    c# csharp Parameter Out
    c# csharp Parameter Params
    c# csharp Parameter Ref
    c# csharp Parameter Value
    c# csharp Type Parameter

 Type
    c# csharp Type Alias
    c# csharp Internal Type Delegate
    c# csharp Internal Type Enum
    c# csharp Internal Type Interface
    c# csharp Internal Type Struct
    c# csharp Protected Type Delegate
    c# csharp Protected Type Enum
    c# csharp Protected Type Interface
    c# csharp Protected Type Struct
    c# csharp Protected Internal Type Delegate
    c# csharp Protected Internal Type Enum
    c# csharp Protected Internal Type Interface
    c# csharp Protected Internal Type Struct
    c# csharp Private Type Delegate
    c# csharp Private Type Enum
    c# csharp Private Type Interface
    c# csharp Private Type Struct
    c# csharp Public Type Delegate
    c# csharp Public Type Enum
    c# csharp Public Type Interface
    c# csharp Public Type Struct
    c# csharp Unknown Type Interface
    c# csharp Unknown Type
    c# csharp Unresolved Type

 Variable 
    c# csharp Unknown Variable
    c# csharp Variable Local

C# Reference Kinds

Below are listed the general categories of C# reference kinds, both forward and inverse relations. When these categories are used literally, as filters, the full kind names that match have been listed beneath them.

 Alias  (Aliasfor)
    c# csharp Alias

 Alloc  (Allocby)    
    c# csharp Use Alloc

 Call  (Callby)
    c# csharp Call             
    c# csharp Call Virtual

 Cast  (Castby)
    c# csharp Cast Use

 Declare  (Declarein)
    c# csharp Declare

 Define  (Definein)
    c# csharp Define

 Base  (Derive)    
    c# csharp Base            
    c# csharp Base Implicit

 DotRef  (DotRefby)    
    c# csharp DotRef

 End  (Endby)    
    c# csharp End

 Catch  (Catchby)
    c# csharp Catch Exception

 Throw  (Throwby)
    c# csharp Throw Exception

 Implement (Implementby)
    c# csharp Implement

 Modify  (Modifyby)
    c# csharp Modify

 Overrides  (Overriddenby)
    c# csharp Overrides

 Set  (Setby)
    c# csharp Set              
    c# csharp Set Init

 Typed  (Typedby)
    c# csharp Typed

 Use  (Useby)
    c# csharp Use          
    c# csharp Use Ptr

 Using  (Usingby)
    c# csharp Using

Fortran Entity Kinds

Below are listed the general categories of fortran entity kinds. When these categories are used literally, as filters, the full kind names that match have been listed beneath them.

 Block Data
    Fortran Block Data

 Block Variable
    Fortran Block Variable

 Common
    Fortran Common

 Datapool
    Fortran Datapool

 Dummy Argument
    Fortran Dummy Argument

 Entry
    Fortran Entry

 File
    Fortran File
    Fortran Include File
    Fortran Unknown Include File
    Fortran Unresolved Include File

 Function
    Fortran Function
    Fortran Intrinsic Function
    Fortran Unresolved Function

 Interface
    Fortran Interface

 Pointer Block
    Fortran Pointer

 Main
    Fortran Main Program

 Module
    Fortran Module
    Fortran Unknown Module

 Subroutine
    Fortran Intrinsic Subroutine
    Fortran Subroutine
    Fortran Unresolved Subroutine

 Type
    Fortran Unknown Type
    Fortran Derived Type

 Unresolved
    Fortran Unresolved
    Fortran Unresolved Function
    Fortran Unresolved Include File
    Fortran Unresolved Subroutine

 Variable
    Fortran Block Variable
    Fortran Variable
    Fortran Namelist Variable

Fortran Reference Kinds

Below are listed the general categories of fortran reference kinds, both forward and inverse relations. When these categories are used literally, as filters, the full kind names that match have been listed beneath them.

 Call (Callby)
    Fortran Call
    Fortran Call Ptr

 Contain (Containin)
    Fortran Contain

 Declare (Declarein)
    Fortran Declare

 Define (Definein)
    Fortran Define
    Fortran Define Implicit
    Fortran Define Private

 End (Endby)
    Fortran End
    Fortran End Unnamed

 Equivalence (Equivalenceby)
    Fortran Equivalence

 Include (Includeby)
    Fortran Include

 InterfaceRef (Interfacerefby)
    Fortran InterfaceRef

 ModuleUse (Moduleuseby)
    Fortran ModuleUse
    Fortran ModuleUse Only

 Ref (Refby)
    Fortran Ref

 Set (Setby)
    Fortran Set

 Typed (Typedby)
    Fortran Typed

 Use (Useby)
    Fortran Use

 UseModuleEntity (UseModuleEntityby)
    Fortran UseModuleEntity

Java Entity Kinds

 Class
    Java Abstract Class Type Default Member
    Java Abstract Class Type Private Member
    Java Abstract Class Type Protected Member
    Java Abstract Class Type Public Member
    Java Class Type Anonymous Member
    Java Class Type Default Member
    Java Class Type Private Member
    Java Class Type Protected Member
    Java Class Type Public Member
    Java Final Class Type Default Member
    Java Final Class Type Private Member
    Java Final Class Type Protected Member
    Java Final Class Type Public Member
    Java Static Abstract Class Type Default Member
    Java Static Abstract Class Type Private Member
    Java Static Abstract Class Type Protected Member
    Java Static Abstract Class Type Public Member
    Java Static Class Type Default Member
    Java Static Class Type Private Member
    Java Static Class Type Protected Member
    Java Static Class Type Public Member
    Java Static Final Class Type Default Member
    Java Static Final Class Type Private Member
    Java Static Final Class Type Protected Member
    Java Static Final Class Type Public Member

 File
    Java File
    Java File Jar

 Interface
    Java Interface Type Default
    Java Interface Type Private
    Java Interface Type Protected
    Java Interface Type Public

 Method
    Java Abstract Method Default Member
    Java Abstract Method Protected Member
    Java Abstract Method Public Member
    Java Method Constructor Member
    Java Final Method Default Member
    Java Final Method Private Member
    Java Final Method Protected Member
    Java Final Method Public Member
    Java Method Default Member
    Java Method Private Member
    Java Method Protected Member
    Java Method Public Member
    Java Static Final Method Default Member
    Java Static Final Method Private Member
    Java Static Final Method Protected Member
    Java Static Final Method Public Member
    Java Static Method Default Member
    Java Static Method Private Member
    Java Static Method Protected Member
    Java Static Method Public Member
    Java Static Method Public Main Member

 Package
    Java Package
    Java Package Unnamed

 Parameter
    Java Catch Parameter
    Java Parameter

 Variable
    Java Final Variable Local
    Java Final Variable Default Member
    Java Final Variable Private Member
    Java Final Variable Protected Member
    Java Final Variable Public Member
    Java Static Final Variable Default Member
    Java Static Final Variable Private Member
    Java Static Final Variable Protected Member
    Java Static Final Variable Public Member
    Java Static Variable Default Member
    Java Static Variable Private Member
    Java Static Variable Protected Member
    Java Static Variable Public Member
    Java Variable Default Member
    Java Variable Private Member
    Java Variable Protected Member
    Java Variable Public Member

 Unknown
    Java Unknown Class Type Member
    Java Unknown Method Member
    Java Unknown Package
    Java Unknown Variable Member

 Unresolved
    Java Unresolved Method
    Java Unresolved Package
    Java Unresolved Type

 Unused
    Java Unused

Java Reference Kinds

 Call (Callby)
    Java Call
    Java Call Nondynamic

 Cast (Castby)
    Java Cast

 Contain (Containin)
    Java Contain

 Couple (Coupleby)
    Java Couple
    Java Extend Couple
    Java Extend External Couple
    Java Implement Couple

 Create (Createby)
    Java Create

 Define (Definein)
    Java Define

 DotRef (DotRefby)
    Java DotRef

 End (Endby)
    Java Endby

 Extend (Extendby)
    Java Extend Couple
    Java Extend External Couple

 Implement (Implementby)
    Java Implement Couple

 Import (Importby)
    Java Import
    Java Import Demand

 Modify (Modifyby)
    Java Modify

 Override (Overrideby)
    Java Override

 Set (Setby)
    Java Set
    Java Set Init

 Throw (Throwby)
    Java Throw

 Typed (Typedby)
    Java Typed

 Use (Useby)
    Java Useby