SCA$NEUTRAL_HELP.HLB  —  SCA Topics, Glossary

1  –  analysis_data_file

    A file produced by a compiler which contains information that
    describes the source code to SCA. It may contain one or more
    analysis data modules.

2  –  analysis_data_module

    A module containing all the information used by SCA for one
    compilation unit.

3  –  appearance

    One of the attributes of an occurrence. It tells you whether the
    name of the occurrence is visible or hidden. You can instruct SCA
    to show only occurrences with a particular appearance by using the
    "occurrence=" attribute selection. For example, you can ask for
    hidden occurrences by specifying "occurrence=hidden."

4  –  associated_declaration

    Any declaration which is not a primary declaration. Typically,
    associated declarations provide information needed by the compiler
    to refer to an object.

5  –  attribute_selection

    A way of limiting a result of a query to those occurrences which
    match certain characteristics. You can select the following
    attributes: NAME, SYMBOL_CLASS, OCCURRENCE, DOMAIN, or FILE_SPEC
    attributes. In the query language, you use phrases like name=foo,
    symbol=argument, occurrence=declaration, domain=module_specific,
    and file="foo.c" to specify which attributes you want. You combine
    these phrases with AND, OR and NOT operators.

6  –  attribute_selection_expression

    A query question which combines one or more attribute selections
    (such as name=foo, symbol=routine) using AND, OR, NOT, and XOR.
    Some examples are:

      name=foo and symbol=routine and occurrence=primary
      name=foo_module and occurrence=compilation_unit

7  –  call_graph

    Shows what procedures and functions are called from a subroutine,
    and all subsequent calls in the call graph.

8  –  CALLED_BY

    See the SCA_Topics CALLED_BY help topic.

9  –  CALLING

    See the SCA_Topics CALLING help topic.

10  –  compilation_line_number

    A line number generated by the compiler which starts at 1 for
    the first file used during the compile and goes up by one for
    each line read. If there is an include file, the compilation line
    number is increased by one for each line in the include file. By
    default, the line numbers in the query display produced by the
    FIND or INSPECT commands are compilation line numbers.

11  –  compilation_unit

    A compilation unit is the smallest piece of source code that
    can be separately compiled. For example, in FORTRAN, this is
    a subroutine or function; in C, this is a single file. Some
    languages allow you to compile more than one compilation unit
    at once. Even if you compile more than one unit at a time, SCA
    considers the units to be separate.

12  –  consistency_checks

    A check that INSPECT makes in which all occurrences of a symbol
    are checked for consistency. For example, you can ensure that
    all calls to a routine have the correct number and type of
    arguments. In this type of check, each occurrence is compared
    with a single occurrence selected by INSPECT to be the standard
    against which all occurrences are checked. In this type of check,
    each particular occurrence is either correct or incorrect.

13  –  CONTAINED_BY

    See the SCA_Topics CONTAINED_BY help topic.

14  –  CONTAINING

    See the SCA_Topics CONTAINING help topic.

15  –  declaration

    Tells the compiler about an object before the compiler uses it.
    This can make the compiler create the object, or it can tell the
    compiler about an object that was created elsewhere. A declaration
    has a position in the source code with both a start and an end,
    and can contain other declarations or references. A declaration
    can be either a primary declaration or an associated declaration.

16  –  declaration_class

    Tells you what symbol class a declaration is (subroutine,
    function, variable). For example, both procedures and functions
    (in Pascal terms) belong to the routine symbol class, but their
    declaration classes are different. The declaration class tells
    the user whether a declaration is a primary declaration or
    an associated declaration. SCA uses the declaration class to
    decide what to display as the occurrence class in the result of a
    FIND command. The user can find the declaration class using the
    callable interface.

17  –  diagnostic_error_messages

    The error messages that INSPECT produces. The query result from
    an INSPECT command is like that of a FIND command, but with error
    messages attached to each occurrence.

18  –  display_line

    A line in the display resulting from a FIND or INSPECT command.
    SCA numbers these lines if you use /DISPLAY=NUMBER. This feature
    is most useful when you are saving the output in a file.

19  –  explicit

    See expression.

20  –  expression

    One of the attributes of an occurrence. The expression attribute
    tells you whether the occurrence is one that you the user placed
    in the source code, or is one which the compiler created for
    the user. An occurrence can be either explicit or implicit.
    Explicit occurrences are those placed by the user in the source
    code; implicit occurrences are those created by the compiler on
    behalf of the user. For example, in the following FORTRAN program,
    there are three references to i which are explicit. There is one
    implicit declaration of i which is created by the FORTRAN compiler
    when it sees the first reference to i.

      program test
      i = 0
      i = i + 1
      end

21  –  handle

    A data type used by the SCA callable interface. If you are using
    the callable interface, see the on-line SCA guide to
    platform specific information for more information.

22  –  hidden

    See both appearance and hidden modules.

23  –  hidden_modules

    A module in one of the libraries in the current library list which
    is also present in a library which is earlier in the library list.
    The module in the earlier library is visible. The same module in
    any later library is a hidden module, hidden by the first module.

24  –  implicit

    See expression.

25  –  indicated

    Uses the current cursor position for the query, when used with
    a FIND or GOTO DECLARATION. If the cursor is in a query display,
    SCA uses whatever occurrence on which it is positioned. If the
    cursor is in a buffer, SCA uses the name on which the cursor is
    positioned and the file the cursor is in to guide the query. SCA
    relaxes the search criteria, if necessary, (for example, allowing
    different versions of the source file) to find the indicated
    occurrence.

26  –  intersection

    The operation performed by the AND operator, which indicates
    that SCA will accept any occurrence that matches both X and Y
    as follows:

      FIND X AND Y

27  –  library

    Generic term usually referring to a physical library.

28  –  library_list

    A list of one or more physical libraries which compose the virtual
    library. The order of the physical libraries is important. A
    module found in one physical library in the library list hides
    the same module in other physical libraries that come later in the
    library list.

    For example, suppose you have three libraries. Library 1 contains
    module A. Library 2 contains modules A, B, and C. Library 3
    contains modules C and D. SCA uses module A from Library 1,
    modules B and C from library 2, and module D from library 3.

29  –  library_number

    Refers to the position of a single physical library in a library
    list. This can be used with any command that refers to a library
    already in the library list. For example, the command SET
    NOLIBRARY 1 removes the first library from the library list, and
    the command LOAD/LIBRARY=2 FOO.ANA loads the file FOO.ANA into the
    second library on the library list.

30  –  module

    Represents a single compilation unit. You can list the modules
    with the SHOW MODULE command. Each module shown represents a
    single compilation unit - the smallest piece of source that can
    be separately compiled. Even if several of these are compiled at
    once (which is common in languages such as FORTRAN and BASIC),
    each compilation unit appears separately.

    In the query language, SYMBOL=MODULE specifies a certain type
    of symbol. This is not the same as a compilation unit. You can
    have modules which are not compilation units, and compilation
    units which are not modules. How a module is defined varies from
    language to language.

31  –  name

    A string of characters used to identify symbols in your source
    code. Legal characters for a name are defined by whatever language
    you use. Each name has zero or more characters. Any character
    may appear in a name. Special characters that appear in a name
    must be quoted using double quotes. You do not need to quote the
    following: $, _, *, %, &, -, alphanumeric characters.

32  –  name_selection_expression

    Selects occurrences with a particular name. For example, you can
    specify the following:

      FIND name=xyz

    You can use wildcards in the name expression. Unlike other
    atttributes, you can omit "name=" from the expression and only
    specify the following:

      FIND xyz

33  –  nonstructured_relationship_expression

    A relationship query (such as CONTAINED_BY, CALLED_BY, CALLING)
    which requests that structure information be excluded. You can
    specify RESULT=NOSTRUCTURE, RESULT=BEGIN, or RESULT=END as one
    of the parameters to the relationship function. If you specify
    RESULT=BEGIN or RESULT=END, this is displayed like any query
    which does not have a relationship function. If you specify
    RESULT=NOSTRUCTURE, this is displayed like any query which does
    not have a relationship function, but has all the occurrences that
    would be present if the structure were present.

34  –  nonstructured_set

    A query result that contains occurrences, but does not contain any
    relationships between occurrences. These are produced by queries
    that do not involve relationship functions, or queries that do
    involve relationship functions but specify RESULT=NOSTRUCTURE,
    RESULT=BEGIN, or RESULT=END.

35  –  occurrence

    An occurrence is any instance of an entity in your program. An
    entity can be any language construct, such as a variable, a
    routine, or a constant. To further clarify this, consider the
    following code fragment (not written in a particular language):

      1   MODULE myprog;
      2
      3   VAR i,j;
      4
      5   ROUTINE foo()
      6   BEGIN
      7       i = 5;
      8       j = i;
      9   END;
      10  END;

    The code contains four entities: myprog, foo, i, j. There is one
    occurrence each of the module myprog, and the routine foo. The
    variable i, however, has three occurrences, and the variable j has
    two.

36  –  occurrence_checks

    A check that INSPECT performs on a single occurrence. For example,
    INSPECT can check whether an occurrence is an implicit declaration
    of a variable without having to look at any other occurrences.

37  –  occurrence_class

    One of the attributes of an occurrence that tells you what kind of
    occurrence it is. The occurrence class indicates if an occurrence
    is a declaration, a reference, or another class. It also indicates
    what kind of declaration or reference it is. You can instruct SCA
    to show you only occurrences with a particular occurrence class
    using the OCCURRENCE= attribute selection. For example, you can
    ask for write references using OCCURRENCE=WRITE.

38  –  occurrence_selection_expression

    The expression containing the occurrence class for each occurrence
    you want to find.

39  –  physical_library

    A single directory containing an SCA database. The directory
    should not contain anything else. SCA always locks an entire
    physical library when it accesses it. When you are reading a
    physical library (for example, with a FIND command), other users
    are not allowed to write to the physical library, but other users
    are allowed to read the physical library. When you are writing
    to a physical library (for example, using LOAD), no other user is
    allowed to read or write to the physical library.

40  –  primary_declaration

    Any declaration which affects how a particular object, such as a
    routine or a variable, is implemented.

41  –  primary_library

    The first library in the library list. Commands which change the
    SCA library, such as LOAD and REORGANIZE, apply to the first
    library, unless you use the /LIBRARY qualifier to instruct SCA
    to use another library.

42  –  query

    The question you ask SCA together with the information you receive
    from SCA. The question uses the SCA query language with the FIND
    or INSPECT commands. The answer is called a query result. You use
    the FIND or INSPECT commands to display the query result. You can
    also use the query result as part of the question for a subsequent
    query.

43  –  query_result

    A query result is the information you get when you evaluate a
    query, using the FIND or INSPECT commands. It consists of a set of
    occurrences, and relationships between occurrences.

44  –  reference

    The use of some object in the source code. For example: X = X + 1
    In this example, there are two references to the variable X. One
    (to the left of the =) is a write reference; the other is a read
    reference. A reference has a position in the source code, but it
    is a single point and cannot contain anything.

45  –  relationship

    An association between two different occurrences. For example, the
    CALLED_BY relationship in SCA associates a primary declaration of
    a procedure with call references to other procedures and functions
    in that procedure. A relationship has both a source and a target.
    A relationship also has a relationship type. Relationships go in
    both directions. For example, the CALLED_BY relationship is the
    inverse of the CALLING relationship.

46  –  relationship_type

    The kind of relationship between two occurrences. For example, a
    CALLED_BY relationship between a declaration of a routine FOO and
    a reference to a routine BAR shows that routine FOO calls routine
    BAR. The relationship types that are valid for SCA are: CALLED_BY,
    CALLING, CONTAINED_BY, CONTAINING, TYPED_BY, and TYPING.

47  –  set

    The occurrences that result from each query.

48  –  static_analysis

    The analysis of a software system performed by looking at the
    source code. This is in contrast to dynamic analysis, which is
    analysis of the software while it is running.

    SCA has some commands which do static analysis. These commands are
    the INSPECT command, which does consistency checking, the REPORT
    command, that can generate reports about modules, imported and
    exported objects, and so forth, and some uses of the FIND command,
    to generate call graphs and type graphs.

49  –  structured_relationship_expression

    A query that uses a relationship function (such as CONTAINED_
    BY, CALLED_BY, or TYPED) which asks for structure information.
    Structure information shows the relationships between occurrences
    found as well as the occurrences found. Structure information is
    provided by default.

50  –  structured_set

    A query result which has both occurrences and relationships
    between occurrences. These are produced by queries which involve
    relationship functions.

51  –  symbol

    Any object in a program. For example, a FUNCTION, a VARIABLE, a
    CONSTANT, or any of the entities with which a programmer typically
    deals.

    A symbol has occurrences. For example, the declaration of
    a variable is an occurrence, and uses of the variable are
    occurrences. SCA determines which occurrences belong to which
    symbols using the rules of the language you are using. For
    example, you may have two different variables named INDEX in
    separate subroutines. According to the rules of your language,
    these are usually different variables, so they are different
    symbols for SCA.

    It does not matter whether all occurrences of a symbol are in
    a single compilation unit, or spread over several compilation
    units. All the occurrences still belong to the same symbol. For
    example, you may have a subroutine SUB1 in one module, and calls
    to that subroutine in several other modules. These all appear as
    occurrences of the same symbol, named SUB1.

    The programmer and SCA should have the same definition of what
    constitutes a unique item. SCA's term for a unique item is symbol.

52  –  symbol_checks

    A check that INSPECT performs on all occurrences of a symbol.
    For example, INSPECT can ensure that there are both read and
    write references to a variable. In this type of check, no single
    occurrence is either correct or incorrect. If there are problems,
    the problems are with the symbol as a whole.

53  –  SYMBOL_CLASS

    An attribute selection that identifies the type of symbol. Tells
    you whether the symbol is a variable, constant, or some other
    class. You can use the FIND command to find only symbols with
    a particular symbol class. For example, you can specify "FIND
    symbol=argument." You can abbreviate both "symbol" and "argument".

54  –  symbol_class_selection_expression

    The expression containing the symbol class for each symbol you
    want to find.

55  –  type_graph

    A set of occurrences and relationships that describes a complex
    data type. For example, a declaration of a record consists of a
    record and some record components. Each record component has a
    type, which may be another record, a pointer to the same record,
    a basic data type such as integer, and so forth. In SCA, the type
    graph connects all these together, with relationships connecting
    the record to its components and the components to their types.

56  –  TYPED_BY

    See the SCA_Topics TYPED_BY help topic.

57  –  TYPING

    See the SCA_Topics TYPING help topic.

58  –  union

    The operation performed by the OR operator, which indicates that
    SCA will accept any occurrence that matches either X or Y as
    follows:

      FIND X OR Y

59  –  virtual_library

    A library that allows you to split your SCA library into pieces.
    Each piece is called a physical library. SCA works the same way
    whether your virtual library has only one physical library or
    several physical libraries.

    Some of the reasons for using more than one physical library are
    as follows:

    o  Physical libraries can be placed on more than one disk, if
       there is not enough room on a single disk.

    o  Analysis date files can be loaded into more than one physical
       library at the same time, to make LOAD run faster.

    o  A small personal physical library can be used to keep track of
       your personal changes without affecting other users.

    o  A separate physical library can be used for each major
       component in your system.

    A single virtual library is a list of one or more physical
    libraries. The order is important. A module in one physical
    library hides the same module in physical libraries later on in
    the list. This list of physical libraries is called a library
    list.

60  –  visible

    See both appearance and visible modules.

61  –  visible_modules

    Modules that SCA can examine when performing a FIND or INSPECT
    command. The current library list tells you what modules are
    visible. All modules in the first library in the library list
    are visible. Modules in the second library which are not in the
    first library are visible. Modules in the third library which are
    not in the first or second libraries are visible. Any module which
    is not visible is hidden.

62  –  wildcards

    Wildcards are used to match more than one name at once. There
    are two wildcards in SCA: the asterisk (*) and percent (%). For
    example, in the name expression A*, the wildcard * will match any
    number of characters, so this would match A, AB, ABC, AXYZ, and
    so forth. The * wildcard matches any number of characters, and %
    wildcard matches just one character. If you do not want SCA to use
    * or % as a wildcard, you use an ampersand (&) to quote it. For
    example, to find the single name *, you would use &*.
Close Help