DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400 Tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400 Tapes

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download
Index: ┃ T V

⟦f66b4afc1⟧ TextFile

    Length: 34952 (0x8888)
    Types: TextFile
    Names: »V«

Derivation

└─⟦d10a02448⟧ Bits:30000409 8mm tape, Rational 1000, ENVIRONMENT, D_12_7_3
    └─ ⟦fc9b38f02⟧ »DATA« 
        └─⟦9b46a407a⟧ 
            └─⟦12c68c704⟧ 
                └─⟦this⟧ 
└─⟦5f3412b64⟧ Bits:30000745 8mm tape, Rational 1000, ENVIRONMENT 12_6_5 TOOLS 
    └─ ⟦91c658230⟧ »DATA« 
        └─⟦458657fb6⟧ 
            └─⟦220843204⟧ 
                └─⟦this⟧ 

TextFile

package Dependents is

    type Display_Kind is (Subsystems, Views, Units, Parents, Item_Kinds,
                          Units_And_Kinds, Units_And_Items, Parents_And_Items);

    type Dependents_Level is (Unfiltered, Immediate,
                              Reference_Closure, Demote_Closure);

    procedure Show (Name : String := "<CURSOR>";
                    Display : Display_Kind := Dependents.Units;
                    Level : Dependents_Level := Dependents.Unfiltered;
                    Limit : String := "<ALL_WORLDS>";
                    Global : Boolean := True;
                    Options : String := "");
    --
    -- invoke the dependents object_editor.
    --
    -- dependents are entities which depend on the identifier specified
    -- by the first argument. this dependence can be because of a direct
    -- naming of that identifier, because of being the second part of a
    -- two part item or because of a closure computation.
    -- dependents can be either compilation units or constructs
    -- within compilation units.
    --
    -- in the comments that follow the term "unit" will mean a
    -- compilation unit.
    -- the term "item" will refer to a construct within a compilation unit.
    -- the term "main_item" will refer to the unit or item whose
    -- dependents are being shown.
    -- the term "kind" will refer to the kind of an item.
    -- the term "parent" will refer to an ada program unit.
    --
    -- the first argument to dependents.show can be a naming expression
    -- which resolves to several def_ids in the same ada space.
    --   e.g. dependents.show ("directory.naming.resolve'spec");
    -- this will run the dependents analysis over all of the def_ids
    -- resolved to by the naming expression.
    -- one can also place marks on a group of def_ids in the same space
    -- and invoke the command as:
    --  dependents.show ("<marks>", options => "count=n");
    -- where n is the number of marks to be taken off the mark_stack.
    -- this will run the dependents analysis over all the def_ids
    -- removed from the mark_stack.
    --
    -- the line(s) of a dependents display before the first blank line
    -- denote the main_item(s).
    -- the succeeding nonblank lines denote dependents.
    --
    -- the display argument determines whether unit level or item
    -- level dependents are shown and how the information is presented.
    -- (see below).
    --
    -- the level argument determines what level of dependence should be
    -- shown initially. this can be changed after the display is brought up.
    --
    -- limit, if not defaulted, restricts the displayed dependents to
    -- those that occur within objects specified by the limit
    -- naming expression.
    --
    -- if global = false then only uses within the unit containing the
    -- identifier resolved to will be shown (by underlining them).
    --
    ---------------------------------------------------------------------------
    --
    -- explanation of the display kinds.
    --
    -- these different displays can be produced using the elide/expand
    -- and sort commands. the display kinds are ordered so that moving
    -- through them produces more specific information about the dependents.
    --
    --  Subsystems
    --    full names of subsystems containing views with dependents.
    --
    --  Views
    --    full names of views containing units with dependents.
    --
    --  Units
    --    names of compilation units that contain dependents or are
    --    themselves dependents.
    --    see below for how to control how compilation unit names
    --    are displayed.
    --
    --  Parents
    --    names of ada program units containing dependents.
    --    these will be the names of procedures, functions, packages,
    --    tasks, generics, or record_types which immediately contain
    --    dependent items.
    --    this display lists the parent name followed by the unit name.
    --    example:
    --
    --       set_value    STACK_MANAGER'BODY !L1.L2.L3
    --       get_value    STACK_MANAGER'BODY !L1.L2.L3
    --       add_element  TEST'BODY          !U1.U2
    --
    --    this says that program unit set_value contains a dependent
    --    as does get_value and add_element.
    --
    --    in the case where the parent ada program unit is itself a
    --    compilation unit or in the case where an entire compilation
    --    unit is a dependent, the parent name field will be given as
    --    *comp_unit*.
    --
    -- Item_Kinds
    --    this display shows the kind of the nearest ada construct
    --    enclosing a dependent, followed by the parent name.
    --    the constructs will be from the categories statements,
    --    declarations, etc.
    --    there will be one line per dependent construct.
    --    example:
    --
    --       assign  set_value    STACK_MANAGER'BODY !L1.L2.L3
    --       if      get_value    STACK_MANAGER'BODY !L1.L2.L3
    --       call    add_element  TEST'BODY          !U1.U2
    --
    --    the first line says that an assignment statement in the
    --    program unit set_value which is in the compilation unit
    --    !L1.L2.L3.STACK_MANAGER'BODY has a dependent within it.
    --
    --    if the display level is demote_closure (see below) then
    --    the construct shown will be the nearest enclosing demotable
    --    item containing dependents.
    --
    --    sometimes an item level dependent will be an entire comp unit.
    --
    -- Units_And_Kinds
    --    this display shows the same information as the previous one
    --    but it presents each compilation unit first, followed by its
    --    list of dependents. with a blank line between each comp unit.
    --    example:
    --
    --       STACK_MANAGER'BODY !L1.L2.L3
    --         assign set_value
    --         if     get_value
    --
    --       TEST'BODY          !U1.U2
    --         call   add_element
    --
    -- Units_And_Items
    --    this display is similar to the previous one in that it
    --    shows the name of each compilation unit preceded by a blank
    --    line; but rather than showing just the name of the kind of
    --    construct which has a dependent, it shows a compressed one
    --    line form of the text of the ada construct.
    --    the place within the construct that has a reference to the
    --    main_item will be underlined. (not shown here).
    --    example:
    --
    --      STACK_MANAGER'BODY !L1.L2.L3
    --         Abc := Def (3);
    --         if Def (5) then
    --
    --      TEST'BODY          !U1.U2
    --         Foo (Stack_Manager.Def (4));
    --
    -- Parents_And_Items
    --   this display is similar to the previous one with the change that
    --   the one line form of the text of an ada construct is replaced
    --   by a group of lines of the form
    --
    --        parent_kind parent_name
    --          line 1 of ada text
    --          ...
    --          line n of ada text.
    --
    --   example:
    --
    --      STACK_MANAGER'BODY !L1.L2.L3
    --         proc_body set_value
    --           Abc := Def (3);
    --
    --         func_body get_value
    --           if Def (5) then
    --               Mumble;
    --           end if;
    --
    --      TEST'BODY          !U1.U2
    --         proc_body add_element
    --           Foo (Stack_Manager.Def (4));
    --
    ---------------------------------------------------------------------------
    --
    -- compilation unit and library names are always shown in upper case.
    -- parent names and item kinds are shown in lower case.
    --
    -- full names of compilation units can be displayed either
    -- with the library unit name first, some space, and then the
    -- library name; or as the standard pathname with library name
    -- first, followed immediately by the library unit name.
    --
    -- there is an option to control which format is used.
    -- this option is either set when the command is invoked;
    -- or if it is not explicitly given in the option string,
    -- the session switch:
    --    Dependents_In_Order_Pathnames is checked.
    -- furthermore after a display has been brought up the value of this
    -- option can be changed by the In_Order command
    --
    -- if pathnames are being shown in transposed order there is an option
    -- to control whether library names are shown.
    -- there is also a corresponding session switch called:
    --    Dependents_Show_Library and a command called Libraries.
    --
    -- there is an option to control whether compilation states are
    -- shown for the units or items in a display.
    -- there is also a corresponding session switch called:
    --    Dependents_Show_Unit_State and a command called States.
    -- compilation states will be shown as a single letter from
    -- S, I, C, preceding the unit or item.
    --
    -- there is a session switch called
    --    Dependents_Delta0_Compatibility (which defaults to true)
    -- which if set implies in_order pathnames and controls the
    -- format of the first line.
    -- this switch also controls the contents of the first line
    -- in obsolescence windows.
    --
    ---------------------------------------------------------------------------

    -- dependents_level meanings:
    --
    --   unfiltered
    --     dependent units directly from the ddb are shown without
    --     checking if they actually have references to the main_item.
    --     sometimes more units will be listed than those that actually
    --     have dependents. this can occur in the case of a main_item
    --     which is overloadable; or in the case of a unit which once had
    --     a dependent but no longer does. also the unit containing
    --     the main_item is always listed as a potential dependent.
    --     this display is only possible for unit displays.
    --     if an elision command is given to change the display to an
    --     item display the units will be automatically filtered.
    --     also if the main_item is a record field the initial display
    --     will always be filtered.
    --
    --   immediate
    --     units are checked for references.
    --     only units which actually have dependents are shown.
    --
    --   reference_closure
    --     in addition to showing immediate references:
    --
    --     * for types, packages, subprograms, exceptions
    --     references to renames and derivations are included.
    --     * for items in generic specs -  references to the corresponding
    --     id in instantiations of that generic are shown.
    --     * for subprogram parameters - parameters passed in calls
    --     are shown.
    --     * for generic parameters - actual parameters passed to the
    --     parameter in instantiations are shown.
    --
    --     also, for any main_item which can occur as a default value for a
    --     subprogram parameter, any call which uses the default will be
    --     marked as a dependent of the main_item.
    --
    --   demote_closure
    --     units or items which have to be demoted to demote the
    --     main_item are shown.
    --
    --     for the demote/promote commands when region selections are used,
    --     which display kind is being shown, determines whether whole
    --     compilation units are demoted/promoted or individual items
    --     within compilation units are demoted/promoted.
    --     if the display kind is Units then comp units will be
    --     demoted/promoted. otherwise items will be demoted/promoted.
    --     (even though comp_unit names occupy a separate line in
    --     certain elision levels and may be included in the selection).
    --
    --     when item level demote_closure is being shown, contiguous
    --     dependent items will be merged into one line in the display.
    --     (and will be demoted as a group).
    --
    --     scenario for editing the main_item:
    --
    --     * bring up an initial unit display.
    --     * if you wish to demote item level dependents.
    --       create a command window and type: items;
    --       this will change the display kind to item level dependents.
    --     * press the complete key.
    --       this will change the display to demote_closure
    --     * select the entire display.
    --     * press the demote key.
    --       this will demote all dependents and the main_item to source.
    --     * to edit the demoted main_item or any of the demoted dependents
    --       put the cursor on the line which represents that item or unit
    --       and press the edit key.
    --       this will bring up a window on the unit or item.
    --     * make any changes, committing the windows.
    --       when all changes have been made, return to dependents menu and
    --     * select the display.
    --     * press the promote key.
    --       this will promote all source units or items in the display
    --       to installed.
    --       if any items fail to install they can be fixed and promoted
    --       again with single line selections or if a region is selected and
    --       it contains a mix of both source and installed items only the
    --       source items will be promoted.
    --
    -- remember that certain kinds of items which one can produce an xref of
    -- cannot be incrementally edited. these include enumeration literals,
    -- record fields, subprogram and generic parameters.
    --
    ---------------------------------------------------------------------------
    --
    -- options on show command.
    --
    --   IN_PLACE
    --      brings up the window on top of the current window.
    --      default is false.
    --
    --   NEW_WINDOW
    --      always create a new window for this display.
    --      default is to reuse an existing dependents window.
    --      previous contents of a reused dependents window can be
    --      revisited using object undo/redo or the Contents command.
    --
    --   MENU_ALWAYS
    --      if menu_always is false (the default) and the only dependents
    --      are within the same unit as the main_item then no window is
    --      brought up and the dependents are underlined.
    --      if menu_always is true then a window is always brought up
    --      if there are any dependents.
    --
    --   COUNT=<integer>
    --      count > 1 specifies that count-many contiguous def_ids
    --      starting at the one selected are to have their dependents
    --      shown. default is 1.
    --
    --   STATES
    --      show unit/item compilation states, default is false.
    --
    --   IN_ORDER
    --      show comp unit names with library first, default is false
    --
    --   LIBRARIES
    --      show library names, default is true.
    --
    --   SOURCE
    --      default is false.
    --      search source units which are registered in the ddb
    --      for dependents. also search source bodies/subunits of
    --      units whose specs/bodies have been checked.
    --      checking for dependents within source units will not in
    --      general be exact. in the absence of semantic information
    --      a heuristic approach is taken which in most cases (if the
    --      identifier of the main_item is distinctive) will find
    --      the set of dependents (and possibly some other items which
    --      aren't actually dependents).
    --
    --   CHECK=<naming_expression>
    --      check any source units in the naming expression for references.
    --
    --   RESTRICT = <argument>
    --      see Restrict command below for legal argument values.
    --
    ---------------------------------------------------------------------------
    --
    -- common commands which can be applied when the cursor is in a
    -- dependents window.
    --
    -- * common.definition
    --    visit the entity denoted by the line the cursor is on.
    --    if the line denotes a compilation unit or parent with dependents
    --    then they will be underlined and the cursor positioned to the
    --    first of them.
    --    if line denotes an item then the cursor will be positioned
    --    on that item, which will be selected.
    --    if the cursor line has a parent or unit name in it and the cursor
    --    has been moved onto that parent or unit name then that parent
    --    or unit will be visited.
    --    if the cursor line is showing full ada text and the cursor has been
    --    moved to a using identifier the definition of the using identifier
    --    will be visited.
    --    the node which would be visited by definition is the node which
    --    this editor returns when name resolution of <CURSOR> is run
    --    against it. so if while reading an xref display one wants to
    --    run another xref off an item in the display this can be done
    --    by positioning the cursor on the desired item in the xref
    --    display and invoking the xref command.
    --
    -- * common.edit:
    --    (demote if necessary and possible and) edit the item
    --    of the line the cursor is on.
    --    if the item is in the installed (or greater) state it
    --    must be selected.
    --
    -- * common.enclosing:
    --    find the image of the object for which these items are dependents.
    --
    -- * common.demote:
    --    demote the entities corresponding to the set of lines selected.
    --    if the entire image is selected the goal state will be source.
    --    otherwise it will be the predecessor of the current state of the
    --    entity.
    --
    -- * common.promote:
    --    promote the entitites corresponding to the set of lines selected.
    --
    -- * common.format
    --    if display is unfiltered, change it to immediate.
    --
    -- * common.semanticize
    --    if display is unfiltered, change it to immediate.
    --    if display is immediate, change it to reference_closure.
    --
    -- * common.complete
    --    change display to demote_closure.
    --
    -- * common.undo and redo
    --    move thru the images in this window.
    --
    -- * common.revert:
    --    recompute the current dependents set of the main_item.
    --
    -- * common.object.delete
    --    destroy the item selected.
    --
    -- * common.expand and elide
    --    relative motion among the display kinds.
    --    repeat count > 1 moves multiple steps.
    --    if there is no selection the entire display is moved to a
    --    new elision level.
    --    if there is a selection, only the selected entity will be
    --    expanded/elided.
    --    if a selected item is at the final elision level and expand
    --    is typed, the display will be replaced by the ada text
    --    for an enclosing construct of that item.
    --    this will continue with further expands until the program unit
    --    containing the item fills the display.
    --    if the display is showing just an expanded_item,
    --    elide will transition the display back to the full dependents
    --    display.
    --
    -- * common.sort_image
    --    absolute addressing of display kinds based on format parameter.
    --    1 = subsystems, 2 = views, 3 = units, 4 = parents, 5 = item_kinds,
    --    6 = units_and_kinds, 7 = units_and_items, 8 = parents_and_items.
    --    if a display has some lines at a different elision level from
    --    the entire display level, 0 as a sort prefix will change all
    --    lines to the current display level.
    --
    -- * common.object.child
    --    if no selection, select the item under the cursor, otherwise
    --    expand the item under the cursor.
    --    if the entire display is showing an expanded_item, this command
    --    will not require a selection to expand.
    --
    -- * common.object.next/previous
    --    if no selection, select the item under the cursor.  If there is a
    --    selection, move it to the next/previous item.

    -- * common.object.parent
    --    if no selection, select the item under the cursor.  If the item is
    --    selected, expand the selection.
    --
    ---------------------------------------------------------------------------
    ---------------------------------------------------------------------------
    --
    package Commands is
        -- commands which can be run off of a dependents window

        procedure Items;
        -- change the display to an item level display

        procedure Units;
        -- change the display to a unit level display

        procedure Parents;
        -- change the display to a parents display

        procedure Immediate;
        -- change the display to an immediate dependents display

        ----------------------------------------------------------------------

        procedure Libraries (Show : Boolean := True);
        -- control whether library names are displayed

        procedure States (Show : Boolean := True);
        -- control whether unit states are displayed

        procedure In_Order (Value : Boolean := True);
        -- control whether comp unit names have library names shown first

        procedure Contents;
        -- show a table of contents for the images in this window.

        ---------------------------------------------------------------------

        procedure Keep;
        -- if there is a selection then remove any units not selected
        -- from the display. it there is no selection remove all but the
        -- line the cursor is on.

        procedure Remove;
        -- it there is a selection then remove selected units from the
        -- display. if there is no selection remove the unit the cursor is on.

        procedure Show_All;
        -- redisplay any units removed by keep, or remove.

        procedure Limit (To : String := "<ACTIVITY>");
        -- limit the set of units displayed.

        procedure Unlimit;
        -- show any units that were removed by a limit command

        ------------------------------------------------------------

        procedure Uncode;
        -- demote all coded units selected in the display to installed

        procedure Source;
        -- demote all units selected in the display to source

        procedure Installed;
        -- promote all units selected in the display to installed

        procedure Coded;
        -- promote all units selected in the display to coded

        procedure Remake;
        -- promote all units selected in the display to their state when
        -- first displayed.

        ----------------------------------------------------------------------

        procedure Look_Through (Name : String := "<ACTIVITY>";
                                Limit : Boolean := False);

        -- the main_item must be in a spec.
        --
        -- if name is an activity:
        --   if the main_item is in a load_view find its corresponding
        --   id in the spec view implied by the activity and
        --   display that id's dependents.
        --   if limit is true then limit the dependents to views in the
        --   activity.
        --
        --   if the main_item is in a spec_view find its corresponding
        --   id in the load view implied by the activity and
        --   display that id's dependents.
        --   limit is not relevant is this case.
        --
        -- if name is a view or world:
        --   find the corresponding id for the main_item in the given
        --   view or world and display that id's dependents.

        procedure Succ (Repeat : Integer := 1);
        -- reconstruct the display with the next def_id after the
        -- current main id

        procedure Pred (Repeat : Integer := 1);
        -- reconstruct the display with the prior def_id to the current
        -- main id

        procedure Diana_Edit;
        -- run diana_edit on the node the cursor is on.

        ------------------------------------------------------------

        procedure Restrict (To : String);

        -- restrict the display to a particular kind of reference.
        -- the argument can be a sequence of one or more of the following
        -- restriction kinds:
        --
        --   internal       - show only uses of the main_item (which must
        --                    be in the visible part of a package)
        --                    which are within that package
        --   external       - show only uses of the main_item (which must
        --                    be in the visible part of a package)
        --                    which are outside of that package
        --   defaulted      - show calls where a parameter is defaulted.
        --   nondefaulted   - show calls where a parameter isn't defaulted.
        --   used_ops       - show only operators made visible by a use clause
        --   used_ids       - show only non operators made visible by a
        --                    use clause
        --   closure        - show only references which are in the
        --                    reference_closure and not in the immediate set.
        --   writes         - show places where an object is assigned to.
        --
        --   variables, constants, numbers, exceptions, types,
        --   subtypes, generics, tasks, parameters, withs, uses,
        --   subprograms, specs, bodies, renamings, instantiations,
        --   compound_types, record_types, array_types,
        --   derived_types, access_types, numeric_types, enum_types,
        --   stmts, alternatives, handlers, accepts, assigns,
        --   calls, loops, ifs, cases, returns, raises, selects,
        --   aggregates, allocators, relationals, conversions,
        --   pragmas
        --
        -- any unique prefix of a restriction kind can be given.
        -- several restrictions can be given in one command by
        -- separating them by a space. e.g.
        --    restrict ("external alternatives"); or
        --    restrict ("ext alt");
        -- this means only show case alternatives which are external to
        -- the package containing the main_item.
        --
        -- a restriction kind can be negated by prefixing it with
        -- a not sign (~). e.g.
        --    restrict ("~withs ~parameters);
        -- this means only show contructs that aren't with clauses and
        -- aren't parameter declarations.
        --
        -- restrict ("?"); displays the names of all restriction kinds.


        procedure Unrestrict;
        -- show any items that were removed by a restrict command

        ------------------------------------------------------------

        procedure Display (Constructs : String);

        -- find transitive uses of a main_item which is a type
        -- or record field in a particular kind of construct.
        -- possible values of the argument are:
        --    aggregates,
        --    allocators,
        --    assigns,
        --    cases,
        --    creates,
        --    assign_closure,
        --    create_closure.
        --
        -- any unique prefix of the argument name can be given.
        -- several arguments can be given by separating them by spaces.
        --   e.g. display ("creates create_closure");
        --
        -- aggregates shows all aggregates over the main_item if it is
        -- a compound type (record, array);
        -- if the main_item is a discrete type it shows array aggregates
        -- whose index type is the main_item.
        --
        -- allocators shows all allocators whose result type is the main_item.
        --
        -- assigns show assigment statements where an object of the type
        -- is assigned. in the case of compound types it also shows where an
        -- assignment to a subcomponent is done.
        --
        -- cases shows all cases statements over the main_item
        -- (which must be discrete type).
        --
        -- creates shows places where a variable or constant of the type
        -- is declared; or where an allocator of an object of the type
        -- is done.
        --
        -- assign_closure, create_closure run the analysis over compound types
        -- which contain the main_item as a subcomponent.

        -- object undo will change the display back to a regular
        -- dependents display.
        --
        ------------------------------------------------------------

        procedure Replace (Target : String := "";
                           Replacement : String := "";
                           Wildcard : Boolean := False;
                           Main_Also : Boolean := True);
        -- edit each source item in the display and do a search/replace
        -- of the target with replacement.

        ------------------------------------------------------------

        function Names return String;
        -- return a string of the form [u1,u2,...un]
        -- where ui is the ith unit showing in the display
        -- or in the selection if there is one.

        ---------------------------------------------------------------------------

        procedure Delete;
        -- for a window with a set of images within it,
        -- remove this image from the set and redraw the window
        -- with the prior one in the history.

        ---------------------------------------------------------------------------

        procedure Subunit_Levels (Number : Integer := Integer'Last);
        -- number of parent library unit names to show for the non in_order
        -- unit name field.
        -- a value of 1 means show the name of the innermost enclosing
        -- subunit only (if the enclosing unit is a library unit it
        -- will always be shown).
        -- a value of 2 means show the names of at most 2 of the innermost
        -- enclosing subunits and so on.
        -- a value of integer'last causes full names to be shown again.
        -- a value of 0 means don't show subunit names just show the
        -- library unit name.
        -- a value of integer'first means don't show the unit name field
        -- at all in the items and parents elision levels.
        -- a value of -x means remove abs (x) names from the front of
        -- a name.

        procedure Parent_Levels (Number : Integer := Integer'Last);
        -- number of parent names to show in the parent name field.

        procedure Unit_Length (Max : Integer := Integer'Last);
        -- max length name to display in the unit name field.

        procedure Parent_Length (Max : Integer := Integer'Last);
        -- max length name to display in the parent name field.
    end Commands;

    ---------------------------------------------------------------------------
    ---------------------------------------------------------------------------

    procedure Window (Kind : String := "xref";
                      Restart : Boolean := True;
                      In_Place : Boolean := False;
                      Wrap : Boolean := False);

    -- make visible a menu window.
    -- choices for kind include:
    --  xref, find, unused, errors, holds, ada_menu, menu.
    -- if restart = true bring up the most recently created.
    -- if there are multiple windows of the kind specified and
    -- restart = false then cycle thru the windows with successive calls.
    -- when at last window, wrap controls whether to go back to first.

    ---------------------------------------------------------------------------

    procedure Find (Pattern : String := "";
                    Units : String := "$@?";
                    Display : Display_Kind := Dependents.Units_And_Kinds;
                    Wildcard : Boolean := False;
                    Ignore_Case : Boolean := True;
                    Options : String := "");

    -- search the ada units specified by units for the given pattern.
    -- any units with occurences will be displayed in a menu.


    procedure Unused (In_Units : String := "<CURSOR>";
                      Check_Other_Units : Boolean := False;
                      Display : Display_Kind := Dependents.Units_And_Kinds;
                      Options : String := "");

    -- show the declarations in units that are not referenced.
    -- any units with unused declarations will be displayed in a menu.

    -- for find and unused the following are allowed.
    --
    -- options:
    --   in_place, new_window, restrict, libraries, states, in_order,
    --   menu_always.
    --
    -- common commands:
    --  definition, edit, enclosing, demote, promote, delete,
    --  elide, expand, sort, next, previous, parent, child, undo, redo,
    --  revert (for unused only).
    --
    -- dependents commands:
    --  libraries, in_order, states, items, units, parents,
    --  limit, unlimit,  restrict, unrestrict,  keep, remove, show_all,
    --  contents, replace, names, diana_edit,
    --  uncode, source, installed, coded, remake.
    --
    ---------------------------------------------------------------------------

    procedure Menu (Units : String;
                    First_Line : String := "";
                    Name_Field : String := "";
                    Options : String := "");

    -- display a menu of the units resolved to by units.
    --
    -- options allowed:
    --   in_place, new_window, libraries, states, in_order.
    --
    -- common commands:
    --   definition, edit, enclosing, demote, promote, parent, child,
    --   next, previous, undo, redo
    --
    -- dependents commands:
    --   replace, limit, unlimit, keep, remove, show_all, contents,
    --   in_order, states, libraries, uncode, source, installed, coded, remake.

    ---------------------------------------------------------------------------

    procedure Errors (Units : String := "<CURSOR>"; Options : String := "");

    -- display a menu of the error messages in the units specified.
    -- if <cursor> is given and the cursor is on a node with error messages
    -- then just display the messages on that node.
    --
    -- if an error message refers to another node that node can be accessed
    -- from the menu by moving the cursor to the end of the error message
    -- text and doing definition.
    --
    -- options allowed:
    --   in_place, new_window, in_order, libraries, menu_always,
    --   kind =
    --      all_errors - the default, show all messages.
    --      warnings   - show only warnings messages
    --      errors     - show only error messages, no warnings.
    --
    --   if menu_always is false then no menu will be brought up. the
    --   error nodes will be underlined in the ada unit.
    --
    ---------------------------------------------------------------------------

    procedure Holds (Count : Integer := 10; Options : String := "");

    -- show a menu of the items on the hold stack.


    pragma Subsystem (Object_Editor);
    pragma Module_Name (4, 2227);

end Dependents;