|
DataMuseum.dkPresents historical artifacts from the history of: Rational R1000/400 |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about Rational R1000/400 Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - download
Length: 23435 (0x5b8b)
Types: TextFile
Notes: R1k Text-file segment
└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
└─ ⟦5a81ac88f⟧ »Space Info Vol 1«
└─⟦f923cd6d9⟧
└─⟦this⟧
Known Problems
This report outlines some known bugs in the D_10_20_0 release of
the Environment; workarounds are suggested where these are known.
Rational recommends that each system user examine this list
before using the newly installed Environment. Note especially
the first problem described in the Editor section, which may
result in loss of meaningful data.
1. Switches
* With the session switch Notify_Warnings set True, compiler
system warnings result in "Semantic Errors" when a semanticize
is done, but a promote works fine.
* If you execute Switches.Associate with the default parameters
but the cursor is not in a selection containing a switch file,
then a directory object named "<selection>" will be created.
Many environment operations on this object result in errors.
The object may be selected and deleted (using Object-D).
2. Debugger
* There is a problem caused by the interaction of
Debug.History_Display and the Debug.Freeze_Tasks switch. The
History_Display command attempts to stop all tasks, displays
history, and then restarts them. It fails to recognize that
tasks may be stopped because of the Freeze_Task switch; such
tasks will be restarted by the History_Display command. Tasks
stopped explicitly with Debug.Stop or Debug.Hold will not be
restarted; this means that issuing Debug.Stop ("all") before
Debug.History_Display should avoid this problem. When the
Freeze_Tasks switch is off, the problem does not occur.
* The command Debug.Reset_Defaults will start a debugger if your
session never had one. However, if your session had a
debugger and you killed it, a new one will not be started.
3. Archive
* If you use package Archive to restore an Ada unit to a nested
directory within a frozen world, the operation does not
unfreeze the world; a result is that the insertion of links
for the Ada unit fails, leaving the unit as a nonterminal in
the directory. This happens because a link to the object
cannot be inserted in the enclosing world. To correct this
problem, you should unfreeze the world, promote the
nonterminal unit, and refreeze the world.
* Archive requires that controlled objects are already checked
out in order to restore them. An attempt to Archive.Restore
an object that is controlled but not checked out will fail.
\f
In this situation, you should manually check out the objects,
then retry the restore specifying the missing units.
* Occasionally, an Archive.Restore with the Remake option
specified will raise Storage_Error (Job_Page_Limit) for
seemingly random units. To avoid this situation, Rational
recommends that the Job_Page_Limit is raised from its default
of 8_000 pages. You may either set the session switch, or use
(for example):
System_Utilities.Set_Page_Limit (16_000);
in the job that does the restore or in the command window with
the restore command.
* Load_Procs cannot be saved with Archive.Save or copied with
Archive.Copy unless they are in the coded state.
* It is not possible to copy or restore a secondary view from a
D_10_20_0 system to a primary subsystem on a system with an
earlier release of the Environment, because the format of the
compatibility database (CDB) will be incorrect. If you do
this, you will need to destroy the CDB on the primary, demote
all units in all views of the primary to Installed, and
recompile. Copying to a secondary subsystem or view on a
system with an earlier release will work, but the secondary
must not be made a primary before the system is upgraded to
D_10_20_0.
* If you Archive.Copy or Archive.Restore a unit body without its
spec, you will see an error message implying that the unit
could not be restored. This message may be ignored; the unit
is properly restored. The count of restored units will not
include these unit body(s) (for example, if a single unit body
is copied or restored, the message will be "No units
restored/copied").
* If Archive.Copy or Archive.Restore operations are interrupted
-- by exception, aborting a job, or a system crash -- objects
may be left with incorrect ACLs or link packs. Repeating the
operation will not fix the damage because information about
the first attempt will have been lost.
* If an Ada unit which was imported into a code view is
destroyed, then saving and restoring that code view will
produce a view in which code cannot be executed or used to
code main procedures. This happens because the string name of
the destroyed imported unit is recorded incorrectly in the
code view.
4. CMVC
* If you use Cmvc.Accept_Changes for a unit in a join set for
which another member is checked out, CMVC will erroneously
\f
report that the unit you specify (or the unit in the view you
specify) is checked out, instead of indicating the joined unit
that is actually checked out. It will correctly accept
changes from the version most recently checked in. The
warning is misleading.
* If you spawn a set of views that includes load views with
cross-imported spec views, CMVC will build a set of views to
import into the new views which includes the working views
themselves. It will then issue a warning:
!!! A load view
(!REGRESSION.RELOCATION.DATA.DEPENDENT_SUBSYSTEMS.SPEC_LOAD.
... CROSSED_IMPORTS.RIGHT.RELOC1_WORKING) cannot be
imported.
!!! A load view
(!REGRESSION.RELOCATION.DATA.DEPENDENT_SUBSYSTEMS.SPEC_LOAD.
... CROSSED_IMPORTS.LEFT.RELOC1_WORKING) cannot be
imported.
The operation completes correctly. The warning may be
ignored.
* Consider a (working or released) view containing a main
procedure and a load_proc loaded from that main, and suppose
the main procedure with's other units in that view. Spawning
a new view from that view would leave the load_proc in the new
view in the installed state, and uncodable. This happens
because the with'ed units end up in the Installed state in the
new view and their code segments are deleted. Such a
load_proc cannot remain in the coded state. The load_proc
must be destroyed and reloaded after the corresponding main
procedure has been coded. Rational does not recommend placing
load_procs in load views unless they depend only on universe
specs.
* CMVC currently supports only a single switch file:
<view_name>.State.Compiler_Switches. Having switch files in
other directories can cause copies of that view to be
malformed, resulting in compilation failures without warning
to the user.
* A simple model name is resolved in !Model, not in the current
context as documented. A fully qualified pathname works
correctly.
* During an Accept_Changes operation with the goal state Source,
if destination objects are specified which are deleted during
the operation, the operation fails and reports VERSION_ERROR.
For example, if a non-R1000 target view is specified as the
destination then CMVC will examine all objects in the view --
including associated files such as <Obj>, <List>, etc.
Because these files may be deleted when their parent object is
updated, the Accept_Changes operation fails when checking for
those files. The workaround is to be explicit about which
\f
objects should be examined. This can be accomplished by using
the destination "?'c(ada)" rather than the name of the view.
This problem only occurs if the goal state is Source.
5. Access List
* The access list for !Machine.Switch_Definitions must include
Network_Public=>RW. If any user does not have write access to
this file, various Environment facilities will not work for
that user. Check_Universe_Acls has been updated to check
this.
* It is the system manager's responsibility to monitor Group Id
usage and run ACL compaction when the number of these gets
low. If the system manager does not do this, the machine will
crash when it runs out of group ids. To determine where you
are, create a group, say "foo", then run Show_Groups; look at
the id number next to "foo". The highest number is 1023. To
reclaim used group id numbers, run
Daemon.Set_Access_List_Compaction and the reclamation will be
done the next time the overnight daemons run. This operation
is described in the Environment reference manual, on pages
SMU-35 and SMU-61.
6. Editor
* RUNNING Library.Reformat_Image OVER AN ADA UNIT IN THE
ARCHIVED STATE MAY CAUSE THE UNIT TO BE LOST, AND REPLACED BY
AN [ERROR] PROMPT. Library.Reformat_Image SHOULD ONLY BE RUN
ON UNITS IN THE SOURCE, INSTALLED OR CODED STATE.
* Any comment line that has a sentence-ending character ('.',
'?', or '!') that is not followed by at least two spaces will
cause the Ada comment symbols from the following line to be
run in with the text.
* Under certain circumstances, editing an insertion point can
result in a [comp_unit] prompt, rather than a prompt for an
Ada statement ([statement] or [alternative]). This happens
when an insertion point is opened (with Object.'I') and then
the associated directory object (an object with a name like
_Ada_1) is manually deleted (e.g., selected and deleted with
Object.'D'). After this, if you demote the parent unit to
source, repromote it to installed, and select and edit the
prompt in the parent Ada unit, you will get a [comp_unit]
prompt in the minor window, with which you can do nothing.
Destroying the insertion's associated directory object can
lead to another erroneous situation, where asking for the
definitions of two different insertion points in an Ada unit
leads to the same associated directory object. The workaround
for these situations is to demote the parent Ada unit to
Compilation.Archived, and repromote it.
\f
* There is a problem in the pretty printer that causes line
counts to be corrupted, resulting in a message that includes
the phrase "brute force reparsing". No data is lost. This
problem is only encountered when alignment is enabled and a
number of other conditions are true.
* If you execute Show_Usage, and a window for an object in the
Show_Usage menu is already up, the display shows no underlines
when the definition key takes you to the object. If you
remove the window with Object-G, then press definition in the
Show_Usage window again, the underlines appear.
* If you open an insertion point in a library, type in only
comments over the prompt, then press the Format key, all
contents of the window will be lost. Nothing is lost if there
is something other than comments in the insertion point (a
statement, declaration, or the [comp_unit] prompt). To work
around this bug, enter comments in such a way that you do not
overwrite the [comp_unit] prompt. This bug only affects
insertions into a library, not insertions into an Ada unit.
* If an asynchronous line is enabled for login and it is
receiving invalid characters (e.g., noise on the line), the
system may report overruns and problems getting input. The
overrun errors are the key to identifying this as an invalid
input problem. The error log will contain messages indicating
which line is overrunning. Unfortunately, handling this
condition consumes much of the processor.
* Abandoning a CMVC Editor window (e.g., from the window editor
by selecting the entry and typing Object-D, or by typing
Object-G from the CMVC Editor window itself) will seem to be
successful. However, when you subsequently log out, your
session will hang for several minutes, and then a
Nonexistent_Page_Error will be reported on the operator's
console. In this situation, several temporary data heaps are
not deleted; they will remain on disk until after the next
boot of the system and subsequent running of the disk cleaner.
There is no workaround.
* When you execute Operator.Set_Password_Policy, you should
specify Change_Deadline to be something other than
Operator.Days'last. Otherwise, you will see the following
error message:
INTERNAL ERROR. UNEXPECTED EXCEPTION DURING LOGIN
The Warning and Deadline dates actually expire at midnight
after the dates reported by Operator.Show_Password_Policy.
Thus, the reported date is the last full day before a warning
will be issued after each login, or the last day before the
user will be forced to change his password (respectively).
\f
7. Force_Logoff and Logoff_On_Disconnect
* When Commit_Buffers is set to True for Operator.Force_Logoff,
the system tries to commit all modified buffers before logging
the user off. If it is unsuccessful at committing all of the
session's buffers after some period of time, it gives up and
isssues a message saying it couldn't commit the buffers.
Although some of its buffers have been committed, the session
is left unmodified and usable. In D_10_20_0, such a failure
will also raise Profile.Error, if the Response profile
includes Raise_Error or Propagate.
* If Logoff_On_Disconnect is specified for a line and a
disconnect occurs, Force_Logoff with Commit_Buffers => True is
done. If this fails to commit buffers, Force_Logoff is done
without commiting buffers because, in such cases, the current
session must be cleared from the line.
* The system might not be able to commit buffers during times of
heavy system load, or if the buffer is a large Ada unit which
has not been formatted for a time. By frequently formatting
Ada images, you can increase the chances that Force_Logoff
will successfully save all buffers.
* Programmatically, if Force_Logoff fails to commit buffers,
trying it again after a short delay may succeed in committing
some (if not all) of the remaining buffers and logging the
session off. If three attempts are all unsuccessful, then the
session has probably failed in some way, and the attempts to
commit buffers should be abandoned.
8. Compiler
* For an incomplete type declared in a package spec, completing
this type in the package body as an access type to an
incomplete type will result in an exception being raised
during code generation. There are two ways to work around
this bug. The incomplete type may be completed in the spec as
an access type to an incomplete type, with the target type
completed in the body as something other than an access type.
Alternatively, the incomplete type may be completed in the
body as an access type to a complete type. For example:
package Example is
type List is private;
private
type List_Data;
type List is access List_Data;
-- completing the type as follows will avoid
exceptions:
-- type Real_Data;
-- type List_Data is access Real_Data;
\f
end Example;
package body Example is
-- moving the following two lines to the private part
will
-- avoid an exception at code gen time:
type Real_Data;
type List_Data is access Real_Data;
type Real_Data is record
...
end record;
-- an alternative work around is to move the
completion
-- of List_Data here, following the complete decl of
Real_Data.
-- this works if Real_Data does not contain a
List_Data element
-- type List_Data is access Real_Data;
...
end Example;
* In a single task, if units are promoted to coded or demoted
from coded, and a code view or load proc is created, saved
with Archive.Save, restored with Archive.Restore, or copied
with Archive.Copy, the code generator may raise
Nonexistent_Page_Error. You can work around this either by
running the latter operation from another command window
(another job), or by running the second operation in another
task within the job (i.e., place the second call in a task
body within a declare block). Note that the
promotion/demotion may occur implicitly as the result of
running an Archive operation with any of the options Promote,
Remake or Goal_State => Coded option. For example:
Compilation.Make;
-- The above operation might also be Archive.Restore
or .Copy
declare
task Make_Code_View is
end Make_Code_View;
task body Make_Code_View is
begin
Cmvc.Make_Code_View;
end make_Code_View;
begin
null;
end;
\f
* In a package spec in a load view, if a representation spec for
a private type is placed in the private part, the package spec
must contain the pragma Open_Private_Part if it is to be
exported (put in a spec view). This is necessary because load
views have open private parts by default, but spec views have
closed private parts. When code is generated for the spec
with a closed private part, the code generator ignores the rep
spec, because it cannot see into the private part. In the
load view the code generator can see the rep spec in the
private part, so different code is generated and the spec and
load views are incompatible. The compiler should reject the
rep spec in the closed private part. The compiler ignores the
Open_Private_Part library switch.
* While coding the body of a unit whose spec contains a
constrained subtype declaration for an incomplete private
type, the code generator reports various INTERNAL_ERRORS and
the following message:
1: ERROR Unsupported constraining of an incomplete
discriminated record type
The INTERNAL_ERRORS may be ignored: they indicate the code
generator's inability to generate code for this unsupported
source construct.
* The range values in package Standard for type Float and type
Duration are displayed incorrectly by the editor. For the
correct new upper and lower bounds on these types, use (for
example):
Io.Put_Line(Float'Last); -- for the upper bound of
type Float
Io.Put_Line(Float(Duration'First)); -- for the
lower bound of
-- type
Duration
* There is a bug in the code generator which manifests itself in
library bodies containing separate tasks. The code generator
fails to recognize the correct coding order, and reports
problems with inconsistent offsets. To work around this
problem, demote the library body and its subunits to
installed, then recode the library body and its subunits.
9. Files
* When several tasks or jobs are deleting files in the same
directory at the same time, some are likely to get lock errors
(Io_Exceptions.Use_Error is raised). Putting a handler around
delete operations and trying again after a delay will allow
them to proceed normally.
\f
10. Facit Terminal
* On the Facit terminal, the Numeric Comma key is mapped to the
What.Load command instead of the Editor.Set.Argument_Prefix
procedure. This need not pose a problem, because the Facit
keyboard has a numeric keypad to enter argument prefixes.
11. Target Build Utility
* The Target Build Utility Max_Name_Length value does not
consider the suffix length when computing a file name length.
You should instantiate the generic using a Max_Name_Length
which adjusts for the length of the file name suffix.
12. Loader
* The loader terminates with an exception if an attempt is made
to promote a main unit that contains a generic instantiation.
The workaround is to make a skin for the unit and have the
skin (which does not have a generic instantiation) be the main
unit.
13. Activity Files
* Executing Activity.Create and specifying a source activity
file with Mode => Activity.Value_Copy will do nothing.
Specify Mode => Activity.Exact_Copy instead.
* The procedure Activity.Enclosing_View (and its functional form
Activity.The_Enclosing_View) report (or return)
<<CLASS_ERROR>> unless the argument resolves to an Ada unit.
* The procedure Activity.Enclosing_Subsystem (and its functional
form Activity.The_Enclosing_Subsystem) returns the nearest
enclosing world, whether it is a subsystem or a view. Its
argument must be a library.