|
DataMuseum.dkPresents historical artifacts from the history of: Rational R1000/400 Tapes |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about Rational R1000/400 Tapes Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - downloadIndex: ┃ T V ┃
Length: 34952 (0x8888)
Types: TextFile
Names: »V«
└─⟦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⟧
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;