This query finds all routines named X.

3  TYPING
   The TYPING function is a relationship function. It finds the type
   of some occurrence. Occurrences related in this manner have a
   TYPING relationship between them. For example, if INTEGER is
   typing variable X, then these two occurrences are in a TYPING
   relationship. In its most common form, the function format is as
   follows:

   TYPING( <typee>, <type>, DEPTH={<number> | ALL} )

   In this format, <typee> and <type> can be any legal query
   expression, and <number> is a positive integer. A typical use
   of the function is to find the type of a variable. For example:

     FIND TYPING( X, *, DEPTH=1)

   This query finds the type of X, where X is some variable in the
   SCA database.

   The TYPING function also works on user-defined types. The defined
   type can have many levels, in which case the user can specify a
   depth as follows:

     FIND TYPING( user_defined_type, *, DEPTH=ALL)

   This query gives the full type tree for USER_DEFINED_TYPE.

   The TYPING function provides the power to return the exact type
   tree you want. The full format is as follows:

   TYPING( [ END=<typee> ],
           [ BEGIN=<type> ],
           [ DEPTH={<number> | ALL} ],
           [ RESULT=RESULT_KEYWORD ],
           [ TRACE=query_expression ] )

   In the previous format, <typee> and <type> is any legal query
   expression, <number> is a positive integer, RESULT_KEYWORD can
   be STRUCTURE, NOSTRUCTURE, ANY_PATH, BEGIN, or END, and QUERY_
   EXPRESSION is any legal query expression.

   For a full description of the TYPING relationship, see the
   on-line help file SCACOMMANDS.

3  TYPED_BY
   The TYPED_BY function is a relationship function. It finds
   occurrences that have a TYPED_BY relationship between them.
   For example, if variable X is typed by INTEGER, then these two
   occurrences are in a TYPED_BY relationship. In its most common
   form, the function format is as follows:

   TYPED_BY( <type>, <typee>, DEPTH={<number> | ALL} )

   In this format, <typee> and <type> can be any legal query
   expression, and <number> is a positive integer. A typical use
   of the function is to find what is being typed by INTEGER. For
   example:

     FIND TYPED_BY( INTEGER, *, DEPTH=1)

   This query finds everything that is of type INTEGER. The TYPED_BY
   function can also tell you the items that are in some way affected
   by a given type. The type can be predefined by language elements
   such as INTEGER, or can be user defined. For example:

     FIND TYPED_BY( user_defined_type, *, DEPTH=ALL)

   This query finds all the items that are directly or indirectly
   affected by USER_DEFINED_TYPE.

   The TYPED_BY function provides the power to return the exact type
   tree you want. The full format is as follows:

   TYPED_BY( [ END=<type> ],
             [ BEGIN=<typee> ],
             [ DEPTH={<number> | ALL} ],
             [ RESULT=RESULT_KEYWORD ],
             [ TRACE=query_expression ] )

   In the previous format, <type> and <typee> is any legal query
   expression, <number> is a positive integer, RESULT_KEYWORD can
   be STRUCTURE, NOSTRUCTURE, ANY_PATH, BEGIN, or END, and QUERY_
   EXPRESSION is any legal query expression.

   For a full description of the TYPED_BY relationship, see the
   on-line help file SCACOMMANDS.

3  \_(Pathname)
   The path name expression allows you to identify specific symbols
   based on the path of the expression. This is similar to the
   debugger pathname notation. The format of this expression is as
   follows:

   query_expression\query_expression[\query_expression...]

   Typically, you use this expression to identify a particular
   variable in a routine when you may have declared a variable of the
   same name in more than one routine. For example, RETURN_STATUS may
   be a common variable in multiple routines. Some typical queries
   are as follows:

     1. FIND MYROUTINE\RETURN_STATUS
     2. FIND MYMODULE\MYROUTINE\RETURN_STATUS
     3. FIND MYMODULE\SYMBOL_CLASS=ROUTINE

   The first query returns all occurrences of the RETURN_STATUS
   variable that are declared inside MYROUTINE. The second example
   returns all occurrences of the RETURN_STATUS variable which are
   declared inside MYROUTINE, where MYROUTINE is declared inside
   MYMODULE. The third example returns all occurrences of routines
   which are declared inside MYMODULE.

   You may also use the pathname when the exact path is not known.
   For example, assume that you know the module name and that XYZ is
   declared somewhere inside the MYMODULE, but you do not know the
   exact pathname. You can then use the following query:

     FIND MYMODULE\\XYZ

   This query locates the XYZ variable that is declared somewhere
   inside MYMODULE and returns all occurrences of XYZ.

3  @_(Query_Usage)
   A query usage function incorporates the results of previous
   queries into query expressions. The function has the following
   form:

   @( query_name )

   The value of this expression is that of the expression that is
   specified as query_name. The default query name is the current
   query, SCA$CURRENT_QUERY.

   You can see an example of its use in the following sequence of
   queries:

      FIND X
      FIND @(SCA$CURRENT_QUERY) AND SYMBOL=ROUTINE

   The advantage of using this notation is that the results of the
   previous query are not reevaluated. Thus the second query will be
   faster than the query:

     FIND X AND SYMBOL=ROUTINE