This section contains some basic examples that show what SCA can
    do to help you with your programs. The examples have very little
    explanation. For a more detailed explanation of the underlying
    concepts, see the Basic_Query_Concepts help topic. The remainder
    of this section is written in terms that are specific to BLISS
    programs.

    If you want to follow along and try the examples, you will need to
    have an SCA library available. If you do not know how to create
    an SCA library, read the Building_An_SCA_Library help topic. The
    examples use generic variable names (such as i). You will have to
    substitute variable names that actually exist in your code when
    trying the examples.

    The first example is the easiest query. It lets you find all the
    items in your SCA library named i, and shows you all the places
    where they appear (all occurrences of i):

    FIND i

    You can search for any name in this manner, including using
    wildcard characters (for example, FIND i*).

    Now suppose you are looking for an occurrence, and you know that
    it occurs in a particular file. The following query finds all
    occurrences of items that are named i, but will then limit them to
    those that happen to occur in the file named PROG.B32.

    FIND i AND FILE_SPEC="PROG.B32"

    Another typical question you might ask is, "Find all the places
    where this item is assigned to (or read from, called, declared and
    so forth)." The next example finds all occurrences of items that
    are named i, but then limits them to only those occurrences where
    i is assigned a value:

    FIND i AND OCCURRENCE=WRITE

    (SCA understands many occurrence classes other then WRITE. See the
    help subtopics under Getting_Started for tables containing all the
    SCA attributes and their corresponding meanings in BLISS.)

    Often, you only want to know where (in what file or module) a
    particular routine is, so that you can go to it and edit it. You
    can use the first query (where i will be the name of the routine)
    and then look through the output. The output will include all
    occurrences of the routine, one of which will be its declaration,
    which you can then select. Or, you can ask SCA to limit the search
    for you by typing the following query:

    FIND i AND OCCURRENCE=PRIMARY

    In SCA terms, a primary declaration is the most significant
    declaration of an item. For a BLISS routine, this means the
    place where the routine is actually implemented. This is in
    contrast to FORWARD or EXTERNAL declarations, which are associated
    declarations.

    Another problem you might have is that there are many different
    items in your system having a given name. Some may be variables;
    others may be routines, literals, macros, and so forth. Suppose
    you want to find only the routines named i. Again, the query
    FIND i will give you what you wanted, but it will also give you
    much more. It is preferable to issue the following query:

    FIND i AND SYMBOL_CLASS=ROUTINE

    The last four examples have all selected information based on two
    attributes. The last example selected information based on a name
    attribute (in this case, i) and a symbol_class attribute (in this
    case, ROUTINE). Note how the attributes are combined using the
    boolean operator AND. In general, you can select items out of your
    library based on any combination of attributes, using AND as well
    as the other logical operators OR, XOR, and NOT.

    The next example shows another primary feature of SCA - the
    ability to display relationships between items. This example shows
    the most common use of this feature. It finds the complete call
    tree (that is, all routines called directly and indirectly) of the
    routine named i.

    FIND CALLED_BY (i, DEPTH=ALL)

    If you want to limit the depth of the call tree, replace the
    keyword ALL by any positive integer.

    The final part of this section describes how to go directly to the
    source code once you have issued a query. After issuing the query
    FIND i, for example, you can have an LSE query buffer containing
    something that looks like the following:

      I variable
          BLISS_MODULE\60     LOCAL declaration
          BLISS_MODULE\75     write reference
          BLISS_MODULE\79     read reference
          BLISS_MODULE\122    read reference
          BLISS_MODULE\144    write reference
          BLISS_MODULE\146    read reference
          BLISS_MODULE\149    write reference
          BLISS_MODULE\149    read reference
          BLISS_MODULE\150    read reference
          BLISS_MODULE\166    read reference

    The first two lines of this display will be highlighted. The first
    line represents the item you looked for (i), and the rest of the
    lines represent the different places in the code where this item
    occurred (that is, the occurrences of i). By using the up and down
    arrows on your keyboard, or by clicking on an occurrence with your
    mouse, you can choose the occurrence you want to see. Then, type
    CTRL/G (the keyboard equivalent of the GOTO SOURCE command) and
    LSE will bring the source file into a buffer and position you at
    the occurrence you chose.

    To obtain help on the following topics, request help as indicated.

    o  For help on query language, see the Basic_Query_Concepts help
       topic.

    o  For help on libraries, see the Building_An_SCA_Library help
       topic.