Status of Eiffel 5.4.0515
=========================
This file documents the status of release 5.4.0515 of ISE Eiffel on Solaris 8.
Some of the following "bugs" may not actually be bugs if the language
definition in the book "Eiffel: The Language" has been changed. Also,
I may have made a few mistakes. If you think a bug which is still on
the list has been fixed, please contact me.
======================================================================
Not fully implemented
---------------------
1. System-level validity
2. Conformance
3. Repeated inheritance
4. Class renaming in Lace
======================================================================
ETL Needs to be Updated
-----------------------
1. A class with a Multi_branch whose only Choice seems to be
syntactically illegal (uniq1..-3) is accepted by the compiler.
ETL page 239. [illegal-multi-branch]
======================================================================
Possible bugs
-------------
1. I'm not certain this is a bug, but it is rather inconsistent.
The inspect instruction below fails with "Unmatched inspect value".
This seems counter-intuitive.
Also, compiler accepts `when c then' where `c' is of type INTEGER_64
but won't accept `when 0x7FFFFFFFFFFFFFFF then' even though the
constant `0x7FFFFFFFFFFFFFFF' is the value of `c'.
Are these bugs? Should I report them? Enquiring minds want to know.
class TEST
create
make
feature
make is
local
b: INTEGER_64
do
b := 0x7FFFFFFFFFFFFFFF
inspect b
when c then
print ("Matched%N")
-- If uncomment this line, reports VOMB(2) error
-- when 0x7FFFFFFFFFFFFFF0 then
end
end
c: INTEGER_64 is 0x7FFFFFFFFFFFFFFF
end
2. Compiler correctly reports a VOMB(2) error on this class, but reports
the wrong line number for the error (reports line with the `print'
instruction instead of the line containing `x').
class TEST
create
make
feature
make is
do
inspect 1
when 1 then
print ("Matched%N")
when x then
end
end
x: INTEGER
end
3. Compiler correctly reports a VEEN error on this class, but reports
the wrong line number for the error (reports line with the `print'
instruction instead of the line containing the call to `make').
class TEST
create
make
feature
make is
do
try
end
try is
indexing
attribute: create {TEST2}.make
end
do
print ("Weasel");
end
end
4. Documentation for VGCC constraint, both in new ETL3 and in estudio
delivery, says that a creation procedure cannot be `once'. But the
compiler does not enforce this restriction. I'm assuming that the
documentation needs to be corrected or that this issue is still
being debated. Let me know if this is a bug for which a test
should be added.
5. Compiling a class that has a manifest string with 20000 null characters
(actual nulls - not %/0/) takes 98 seconds! If each null
character in the string is replaced by %/0/, compilation finishes
in 3.5 seconds.
======================================================================
Known syntax bugs: syntax should be accepted but is not
--------------------------------------------------------
1. An empty Choices in a When_part of a Multi_branch is reported as
a syntax error. ETL page 239. [empty-multi-branch-choices]
[I argue that spec is correct and compiler is wrong. If Choices
is empty then that branch is never executed. Manu says he could
fix it but is not sure whether he should. 05-jun-2003]
2. The free operator `prefix "##%%"' should be legal, since non-first
characters may be any printable characters. But the compiler
reports a syntax error for a declaration of this free operator.
ETL page 419. [free-operator-reject]
[Syntax of free operator still in flux. 05-jun-2003]
3. An assignment whose source is an address expression `$x' (which is
of type pointer) and whose target is of type POINTER should be
accepted, but the compiler reports a syntax error. Replacing `$x'
with `ptr ($x)', where `ptr' just returns its argument, causes the
compiler to accept the class. [assign-addr-expr-to-pointer]
4. A class with a declaration and call of an operator feature which
contains an embedded double-quote character (written %") appears to
be valid but the compiler reports a syntax error.
[weird-operator-feat-name]
[Syntax of free operator still in flux. 05-jun-2003]
5. An external routine has a Special_external_decl which casts the
arguments. If the type to which an argument is cast is "(long,
float, int * (*) (long, float, void (*) (long, long)), struct
weasel, enum wimp)", the compiler reports a syntax error.
[cast-arg-type-with-parens]
[Manu says to leave the test. He thinks he should add function pointer
as an allowed Type_identifier. 06-jun-2003]
6. A class with an attribute right before a trailing indexing clause
causes the compiler to report a syntax error, but only if
the attribute declaration does not end with a semicolon.
[trailing-indexing-no-semicolon]
[Manu says to leave it as an error until ECMA resolves issue.
Caused by compiler assuming that indexing is the indexing clause of
attribute, so it thinks there is no final "end" to the class. 05-jun-2003]
7. A generic class with a Constraint_creators that has an empty
Feature_list should be accepted, but the compiler reports a syntax
error. [generic-create-empty-feat-list]
Known syntax bugs: syntax should not be accepted but is
--------------------------------------------------------
1. A number of words which are supposed to be reserved words are
actually not reserved, since one can declare a feature with their
names. ETL page 418. [reserved-words-not]
[Compiler currently accepts the following reserved words as
feature name: assign, attribute, pure, reference, TUPLE]
2. The character constant ''' is accepted, but should not be.
ETL page 423. [syntax-disagreements-2]
[Manu says lexer has comment that this is not valid Eiffel, but
allows it anyway. Says he will add a warning and support it
for awhile longer. 06-jun-2003]
3. A manifest string in the extended form which contains lines with
only white space (blanks and tabs) but no leading and trailing
percent sign is accepted, but should not be. ETL page 390.
[manifest-string-blank-lines]
[Manu says he will discuss with ECMA. 06-jun-2003]
4. A manifest string which contains the illegal "character" '% '
(percent followed by space) is accepted, but only if there are an
even number of consecutive occurrences of this invalid character.
ETL page 420. [manifest-string-percent-space]
[Manu says he will discuss with ECMA. 06-jun-2003]
5. Compiler accepts but completely ignores many characters at certain
positions inside an external routine declaration. These characters
include !#$%^-=+\|`~{}[];'./?%/0/%/1/ and probably others.
[external-nonwhite-chars-ignored]
Known syntax bugs: possible language design flaw
-------------------------------------------------
1. An anchored declaration whose anchor is the final name of an
operator feature is rejected by the compiler as a syntax error.
This is really a language design problem. ETL page 197.
[valid-anchored-decl]
2. An operator feature which is a prefix feature implemented as an
attribute cannot be named in a strip expression. This is
(possibly) a language design problem rather than a compiler bug,
since ETL allows only a list of Identifiers inside the parentheses
of a strip expression. ETL page 397. [strip-no-prefix-opers]
======================================================================
Known validity bugs: validity constraint not fully enforced
------------------------------------------------------------
1. An assignment with source type `PARENT' and target type `like
Current' is incorrectly allowed in a feature of the class PARENT.
ETL pages 225-226. [inherited-assign-violation]
[Sent my comments to Manu, indicating that I think compiler is wrong.
He agrees that compiler should complain about the descendant class.
06-jun-2003]
2. A feature name appears in the Redefine subclause and the Features
part of the class contains a redeclaration which effects the
feature. The compiler does not complain although this appears to
violate VDRS4. ETL page 159. [redefine-subclause-violation]
[Sent my comments to Manu, indicating that I think compiler is wrong.
07-jun-2003]
3. A class with an external or deferred routine whose Locals part is
just `local', with an Entity_declaration_list which is completely
empty, violates VRRR but the compiler accepts the class.
ETL page 113. [validity-vrrr-basic]
[Sent my comments to Manu, indicating that if the compiler is
right then the spec must be changed so that it is only a VRRR(2)
error if the Entity_declaration_list is not empty. 07-jun-2003]
4. A system has a class which inherits from another class three times,
renaming one of its features in two of the Parent parts and
selecting the renamed feature twice. This violates the letter of
VMRC(2), but the compiler does not complain. ETL page 191.
[replicated-feat-multiple-select]
5. An assignment of an entity of type DOUBLE to an entity of type
REAL should be a VJAR violation, but the compiler accepts it. ETL
pages 229 and 311. [double-assigned-to-real]
6. Class A has an operator feature exported only to itself and its
descendants. When class B (which is not a descendant of class A)
tries to call this feature, the compiler should report a VUEX(2)
error. Instead, it accepts the invalid classes. If the feature
is an identifier feature, the compiler correctly reports VUEX(2).
[operator-feat-export-to-self]
7. A routine with a secret precondition does not violate VAPE because
the routine itself is also exported to {NONE}. But the class
containing this routine is inherited by another class and the
routine export status is changed to {ANY}, yielding a generally
available routine with a secret precondition. The compiler does
not detect the VAPE error. [secret-precondition-heir-export]
8. The type `expanded TEST1 [DOUBLE]' should not conform to the type
`expanded TEST1 [STRING]'. But the compiler accepts an assignment
involving these two types. Executing the resulting system
naturally ends in disaster. [expanded-generic-conformance]
9. An Ace has a visible clause for a class which exists but is not
reachable from the root class, which violates VD31. If the class
is in a cluster which is not part of a precompiled library, the
VD31 violation is not detected. [vd31-nonprecompiled-sneak]
[Sent message proposing that this one be changed to pass, since
it looks like VD31 has been abandoned. 17-jun-2003]
10. An Ace has two clusters with path names that are identical except
that one has a trailing "/" character. This violates the spirit
of VD28, but the compiler does not detect the VD28 error.
[vd28-trailing-slash]
11. A system has an Ace which specifies a visible class FOO, where FOO
is reachable from the root class. After initial compilation where
the system is frozen or finalized, a local is removed, making class
FOO unreachable from the root. When the system is recompiled, the
compiler correctly detects the VD31 error. But when the local is
added back in and compilation is resumed, the compiler dies during
degree -3 (during dead code removal if system was finalized).
Note: with 4.3, the VD31 error is not detected at all, even
without incrementality.
[make-visible-class-unreachable]
[Sent message proposing that this one be changed to pass, since
it looks like VD31 has been abandoned. 17-jun-2003]
12. Compiling a system whose Ace has a visible clause with an export
restriction which lists a nonexistent feature name does not cause
the compiler to report any validity violations.
[visible-export-nonexistent-feat]
13. The compiler accepts variable and constant attributes which
violate VFFD1 because they have a Formal_arguments part, even
though its Entity_declaration_list is empty. [illegal-attributes]
14. The precursor construct is used in a routine inherited twice from
the same generic class with different actual generic parameters.
The compiler thinks the precursor routine returns one type, but
it actually returns a child type so system execution fails.
If the order of the parent clauses is switched, the compiler
reports a VJAR error instead of accepting the classes.
[two-generic-precursors]
15. A reference to `$Result' is allowed in a class invariant,
but should be a VEEN(2) error. [invariant-result-address]
16. A class inherits from a second class and renames two effective
features to a new name, redefining that new feature name.
The redefinition calls precursor. The compiler should report
a VUPR(3) error, but it accepts the classes. [two-precursors-same-parent]
17. A system's root class has a `create make' clause. The Ace file specifies
`default_create' as the root creation procedure. The compiler
should report a VD27 error, but does not. [default-create-no-vd27]
18. According to page 229 (and general conformance on page 219), NONE
does not conform to an expanded type or to a Bit_type. But the
compiler accepts assignment of Void to entities declared of these
types. [none-conform-bit-expanded]
19. A creation instruction `create {C} f' where f is of type C
becomes invalid in a descendant when the type of f is redefined to
be a descendant of C. The compiler should report some kind of
validity violation, but it does not. [inherited-vgcc]
20. An assignment `e1 := e2' where e1 and e2 are both of type E
becomes invalid in a descendant when the type of e1 is redefined to
be a descendant of E. The compiler should report some kind of
validity violation, but it does not. [inherited-vjar]
21. A call to a static feature `feature {FOO [DOUBLE]}.value' where
FOO is declared as FOO [G -> STRING] should elicit a VTCG error
but the compiler accepts the invalid type.
[generic-static-vtcg]
22. A class TEST1 that contains an attribute of type "like Current" is used
in a declaration for a local of type "expanded TEST1". This
creates an expanded client cycle, so the compiler should report a
validity error, but does not. [indirect-vlec]
23. A class has a generic parameter G of type XXX with a generic
creation clause `create default_create end'. It also has a
creation instruction whose target is an attribute of type G. If
XXX is a deferred class, the compiler should report a VGCC(1)
error but it does not. [generic-create-deferred]
24. A class whose generic parameter is constrained by `DD [BIT name]',
where "name" is an unknown identifier, is accepted by the compiler
but should not be. [bit-identifier-in-generic]
25. A class has a call to a static feature `feature {FOO [BIT weasel]}.value'
where FOO is an unconstrained generic class, but `weasel' is an
unknown identifier. The compiler accepts the class but should
not. Executing melting system prints "Error: could not read
Eiffel update file". [bad-bit-identifier-in-static]
26. An assignment of `expanded TEST2' to `expanded TEST1' where TEST2
inherits from TEST1 should be a VJAR error, but the compiler
accepts it. [expanded-expanded-conformance]
27. A precompiled library includes a cluster whose tag is `foo',
which contains a class TEST. An Ace file that uses this
precompiled library also includes a cluster with tag `foo' that
has its own class TEST, but this cluster has a different path.
The compiler should report a VDCN error but does not.
[precompiled-vdcn-sneak]
28. A call `io.put_string (<< << "A" >> , << 47 >> >> @ 2 @ 1)' should
be rejected as a VUAR(2) error but the compiler accepts it.
[nested-manifest-array-vuar]
Known validity bugs: valid but compiler reports validity violation
-------------------------------------------------------------------
1. A system with a case of repeated inheritance which appears to be
valid is reported to violate the Feature Name rule. ETL page 170.
[valid-repeated-inheritance]
2. In a generic class TEST1 [G, H -> NONE], an assignment of Void
(which is of type NONE) to an entity of type G is permitted. But
an assignment of an entity of type H (which conforms to NONE) to an
entity of type G is rejected as a violation of the Assignment Rule
(VJAR). [conformance-inconsistency]
3. An attribute of type `TEST1 [TEST1 [DOUBLE]]' where TEST1 is
declared as an expanded class causes the compiler to report a VLEC
error. But TEST1 has no attributes at all so there cannot be an
expanded client cycle. ETL page 94. [nonexistent-vlec]
4. A class calls (on an entity of another type) a feature which is
exported to it. The compiler rejects the class as violating
VUEX(2), but only if the feature is an operator feature.
[selective-export-operator-feat]
5. A class TEST calls (on an entity of type TEST1) a feature which
should be exported to it. The compiler incorrectly rejects the
class as violating VUEX(2). If an export restriction is changed
from `{TEST1}' to `{NONE}', which if anything ought to make fewer
features exported to TEST, the compiler correctly accepts the
classes. [join-features-invalid-vuex]
6. The compiler incorrectly reports a VUEX(2) error on class which
tries to call a feature on an entity of type FOO. If the order of
the parent clauses in the inheritance inside FOO is switched the
VUEX error magically disappears. [switch-parents-vuex-gone]
7. A system has a generic class with constraint `-> ARRAY [TEST2]'.
If another class inherits from the generic class, providing
`ARRAY [TEST2]' as actual generic parameter *and* if TEST2 is an
expanded class, then the compiler incorrectly reports a VTCG
error. [bogus-vtcg]
8. A feature `z: TEST2 [like w, like w]' where TEST2 is a generic
class with two unconstrained formal generic parameters should be
valid, but the compiler says it violates VTAT(1).
[two-anchored-actual-generics]
9. Two features are both declared as `z: like out' in separate
classes. A third class inherits from both of these classes. The
features appear to have identical signatures, since they both have
the same version of `out', but the compiler reports a VDJR error.
[merge-anchored-bogus-vdjr]
10. A class inherits twice from the same parent and renames the single
inherited feature, thereby replicating it. But when an heir of
this class tries to give these two feature the same name by
renaming one of them (sharing under repeated inheritance) the
compiler reports a VMFN error. [replicate-then-share]
11. A generic class with an explicit creation type in an instruction that
creates an attribute of a generic type appears to be valid, but
the compiler reports a VGCC(3) error.
[simple-explicit-generic-create]
12. A class has Generic #2 constrained by Generic #1, but the
compiler won't use this fact to allow an inheritance of
another generic class that requires Generic #2 to conform
to Generic #1. [generic-constraint-not-used]
13. A class inherits twice from another class, redefining the single
feature and also renaming it. When the redefinition attempts to
call precursor, the compiler reports a VUPR(2) error though it
appears that it should accept the classes. [bogus-vupr2]
14. A call to a static feature `feature {FOO [like Current]}.value' where
FOO is declared as FOO [G] causes the compiler to report a VSTA(1)
error, which says to make sure "FOO [like Current]" is just a
class name and not a type specification. But the compiler accepts
`feature {FOO [STRING]}.value' and "FOO [STRING]" is a type
specification. [inconsistent-vsta1]
15. A class A has a deferred routine with an argument anchor to an attribute
`a'. A second class B inherits A and has an identical deferred
routine with the same name, where the routine in B is also
anchored to `a'. Class C inherits both A and B. The compiler
incorrectly reports a VDJR error.
[anchored-argument-bogus-vdjr]
16. A class that has an assignment of a manifest INTEGER constant
whose value is the minimum value for an INTEGER (-2147483648)
is rejected by the compiler as a VJAR error. Similarly for INTEGER_8,
and INTEGER_16 (INTEGER_64 works correctly).
[assign-minimum-integer-vjar]
17. A class has a routine with a single argument `a: ARRAY [like c]' where
`c: expanded TEST1'. A call to this routine with actual argument
<< c >> should be accepted but is rejected as a VUAR(2) error.
If `c' is not of an expanded type, compiler accepts the class.
[pass-manifest-array-expanded]
18. An Ace file with a cluster which explicitly includes one of
the files (test.e) contained in the corresponding directory
causes the compiler to report a VSCN error, even though there
is really only one file containing a class named TEST.
The error message is quite confusing.
[cluster-include-std-class-file]
19. A class that attempts to undefine an external routine causes
the compiler to incorrectly report a VDUS(2) error.
[undefine-external-vdus2]
Known validity bugs: possible missing or incomplete constraint
---------------------------------------------------------------
1. In the Undefine, Redefine and Select inheritance subclauses,
ETL does not address the case where `fname' is the final name in C of
more than one feature inherited from B, due to renaming. How
can one merge two features inherited from the same class, one of which
is effective and the other deferred, and have the resulting feature
be deferred? [undef-mult-precursors]
2. A class has a secret procedure with a precondition which references
a secret attribute. This procedure is available to {ANY} as a
creation procedure. The compiler should report a VAPE violation
but it accepts the class. Actually, I believe that VAPE may need
to be extended to say that "every feature whose final name appears
in any Assertion_clause is also available to every class to which
`r' is available for *creation*". Otherwise, the creation
procedure can have a secret precondition. [creation-proc-secret-precond]
3. A class with a clients part that includes two or more occurrences
of the same class name should possibly be a validity violation,
but there is no validity constraint which prevents this.
[clients-duplicate-class-name]
Known validity bugs: undocumented or wrong validity code reported
------------------------------------------------------------------
1. If both class A and B inherit from A, then there is an
inheritance cycle which involves only A. But if A is a client of
B, then the compiler incorrectly reports that both A and B are
involved in an inheritance cycle. The error code is correct; only
the names of the classes involved in the cycle is wrong.
[a-inherit-a-client-b]
2. A multi-branch with a unique constant which occurs in more than one
"when" branch is reported as violating VOMB(4), which is correct.
But the compiler also reports a spurious VOMB(3) error (VOMB(3)
does not apply since there are no non-Unique inspect constants in
the example). [all-unique-bogus-vomb-3]
3. A call `!!x' with `x' of type TEST1 where TEST1 has a Creators part
with no creation procedures listed should be a VGCC(5) error but
the compiler reports VGCC(6). [vgcc5-called-vgcc6]
4. A call `!!x.make' with `x' of type TEST1 where TEST1 has no
Creators part at all should be a VGCC(4) error but the compiler
reports VGCC(6). [vgcc4-called-vgcc6]
5. A constant attribute which has declared type of `like Current'
causes the compiler to report a bogus VFFD(7) error when the
constant used in the declaration is a string or a bit type (i.e.
in addition to the VQMC(5) or VQMC(6) error). [vqmc-extra-bogus-vffd7]
6. An assignment to a feature which is a function violates VJAW. When
this function takes no arguments, the compiler reports VJAW. But
when the feature which is the target of the assignment takes
arguments, the compiler incorrectly reports a VUAR(1) error. This
cannot be correct since no feature calls are involved in the
instruction. An attempt to add arguments to the feature produces
a syntax error. [vjaw-called-vuar1]
7. A system with two classes of the same name in different clusters
causes the compiler to incorrectly report a VSCN violation.
[validity-vscn-diff-cluster]
8. A creation instruction whose target is a procedure or function should be
a VGCC violation. The compiler instead reports a VUAR(1) error,
but only if the routine takes arguments. [vgcc-called-vuar1]
Known validity bugs: wrong or missing information in error message
-------------------------------------------------------------------
1. Specifying `assertion ("require")' in the Ace results in an error
message which says "Invalid option value: require". This could be
very confusing since `require' is definitely a valid value for the
`assertion' option. [lace-quoted-option-value]
2. Using an unsupported language in a Generate or External clause in
the Ace correctly elicits a VD33 or VD34 error. But the error
message says that only `C' is supported. In fact, `Object' is also
allowed. [lace-vd33-vd34-object-ok]
3. A class that declares `bit_constant: BIT 2 is 1111b' correctly
elicits a VQMC error, but the compiler says the type of the
constant is BIT 0 instead of BIT 4.
4. A VMFN error is correctly reported when two inherited
infix features are renamed into the same feature without redefining
that feature. But the feature names given are `infix ""'
instead of `infix "+"' and `infix "-"'. [infix-missing-name]
5. A constrained generic class with a creation clause that names
an existing attribute `x' causes the compiler to report
that "feature `x' does not exist". Also, a generic creation clause
that names an existing feature that is not an attribute but is also
not a procedure or not a creation procedure causes the compiler to
report a very confusing error message. [bad-generic-creation-constraint]
======================================================================
Known incrementality bugs: silent premature compiler termination
when "automatic_backup" is true
-----------------------------------------------------------------
1. After initial compilation, a cluster in the Ace file is changed from
the form "all root_cluster" to a list of the two specific clusters
in the root cluster directory. Recompilation works fine. However,
when the Ace is then changed to indicate a new root class and
and the class name inside one file is also changed, a second
recompile ends with a segmentation fault in `backup_directory'.
This only happens if "automatic_backup" is true.
[backup-directory-disaster]
Known incrementality bugs: silent premature compiler termination
(terminates with exception trace if `fail_on_rescue (yes)'
-----------------------------------------------------------------
1. After initial compilation, a constraint is added to the formal
generic parameter of a class which is used in the generic
constraint of another class. When the system is recompiled, the
compiler correctly reports a VTCG error. But when the newly
added constraint is removed and compilation is resumed, the
compiler dies with a segmentation fault during degree 5.
[vtcg-in-generic-constraint]
2. After initial compilation, the type of an entity in a generic class
is changed from `FOO [G]' (where G is the name of the formal
parameter of the enclosing generic class) to `FOO [STRING]', thereby
introducing a VEEN error. When the system is recompiled, the
compiler terminates with a bus error during degree 5.
[generic-veen-sneak]
3. After initial compilation, an extra unused formal generic parameter
is added to a generic class and an extra actual generic parameter
is added to the only generic derivation of this class. When the
system is recompiled, the compiler terminates during degree 5.
[add-unused-formal-generic]
4. After initial compilation, a constraint on a formal generic
parameter of a class that is used in the generic constraint of
another class is changed. When the system is recompiled, the
compiler correctly reports a VTCG error. But when the constraint
is changed back to its original valid form and compilation is
resumed, the compiler dies with a bus error.
[add-remove-constraint-vtcg]
5. A pair of generic classes that mention each other in their
formal generic constraints is invalid. When some of the actual
generic parameters are NONE, the compiler correctly detects the
VTCG error. But when compilation is resumed without any change to
the classes, the compiler dies with a bus error.
[resume-vtcg-none-actual]
6. A pair of generic classes that mention each other in their
formal generic constraints is invalid. After the compiler
correctly detects the VTCG error, one of the actual generics in the
constraint is changed. Compilation then terminates with a
segmentation violation and no exception trace at all.
[constraint-cycle-change-generic]
7. A system compiles correctly without a precompiled cluster. Then
file "any.e" is excluded from the kernel cluster. After the VD23
errors are reported, the exclude clause is removed. When
compilation is resumed, the compiler dies with a run-time panic.
[exclude-any-add-back]
8. A system has a class that inherits a deferred feature `value',
which is of type string, and effects it with a string constant.
After initial compilation, the effecting feature name is changed,
introducing a VCCH(1) error. When compiler reports the error,
feature is changed back to `value' and compilation finishes.
But when the system is then frozen, the compiler dies
with a segmentation fault in `real_body_id'.
[In 5.4.0403, after the change back to `value', compilation finishes
but system execution fails with a segmentation fault.]
[add-remove-vcch-freeze]
9. After initial compilation, a generic class TEST1 [G] is changed to
a non-generic class and the class that inherits from TEST1 is
changed correspondingly. When the system is frozen, the compiler
dies in degree -1. [remove-formal-generic]
10. A class with a generic parameter with a constraint
`-> STRING create xxx end' is compiled. The compiler correctly
reports a VTCG error. When `xxx' is changed to `make' and
compilation is resumed, compilation should finish but the compiler
dies in degree 4 on the class. [change-generic-create]
11. A generic class whose formal generic parameter G is constrained by
STRING has a call to `n.count' where `n: G'.
After initial compilation, the generic constraint is removed.
When the system is recompiled, the compiler does not detect
the newly introduced VEEN error and dies during degree 2 on
the class. [remove-constraint-veen-die]
12. An expanded class with an attribute of type `like Current'
is correctly reported as a VLEC error. But when compilation is
resumed with no change to any classes, the compiler goes into
infinite recursion in SKELETON.equiv.
[expanded-like-current-vlec]
Known incrementality bugs: invalid class or system accepted
------------------------------------------------------------
1. When a second precompiled cluster is added to the Ace after
compilation and the system is recompiled, the VD38 violation is not
detected. [vd38-sneak]
2. After initial compilation, an `adapt' clause which specifies that
another cluster should be ignored is deleted from the Ace. When
the system is recompiled, the compiler does not detect the VSCN
error introduced by this change. [delete-adapt-vscn-weasel]
3. After initial compilation, an inherited integer constant attribute
which is an inspect constant in the heir is changed to a function
with no arguments. The compiler does not detect the VOMB error.
[vomb-sneak]
4. When an inherited constant integer attribute used as the number of
bits in a BIT type is changed to a function with no arguments, the
compiler does not detect the newly introduced VTBT error if the
modified class is not an immediate ancestor. [vtbt-granddad-weasel]
5. A system with two classes compiles fine. A violation of the
Expanded Client rule (VLEC) is introduced and the compiler detects
it. But when the formal generic parameter of the class violating
the rule is removed, compilation is resumed and then the formal
generic parameter is added back, the VLEC violation is still there
but the compiler does not detect it. [vlec-sneak]
6. After initial compilation, the value of a constant integer
attribute is changed, thereby introducing a VTBT violation in a
type used as an actual generic parameter. When the system is
recompiled, the compiler does not detect the VTBT violation.
[actual-generic-vtbt-sneak]
7. After initial compilation, an actual generic parameter in a
generic constraint is changed, thereby introducing a VTCG error.
When the system is recompiled, the compiler does not detect the
error, but only if the generic class is also an expanded class.
[vtcg-sneak]
8. After initial compilation, a creation feature named in
a generic constraint is removed entirely from the class.
When the system is recompiled, the VTCG validity error is
not detected. [vtcg-remove-creation-feat]
9. After initial compilation, the creation procedure named in a generic
constraint is removed from the creation clause in its class, but the
feature is left there. When the system is recompiled, the VTCG
validity error is not detected. [vtcg-remove-creation-clause]
10. After initial compilation, a VJAR error is introduced and the
system is recompiled. The compiler does not detect the VJAR
error. This case involves changing an actual generic parameter
in an inheritance clause from G to STRING. The redefined
function calls precursor. [vjar-sneak]
11. After initial compilation, a VUPR(3) error is introduced by
removing an inheritance clause, yielding no effective precursors.
The compiler does not detect the VUPR(3) error. [vupr-sneak]
12. After initial compilation, formal generics in an inheritance
clause are switched, causing a class to no longer conform to the
generic constraint. The class is used as an actual generic in a
generic constraint. The compiler does not detect the newly
introduced VTCG error. [switch-generics-tricky-vtcg]
13. After initial compilation, an inheritance clause is deleted,
thereby introducing a VTCG error because actual generic #2
no longer conforms to actual generic #1, as required by generic class.
The compiler does not detect the error. [delete-parent-vtcg-sneak]
14. After initial compilation, formal generics in an inheritance
clause are switched, causing a type involved in a redefined
feature to no longer conform to the ancestor feature's type. The
compiler does not detect the newly introduced VDRD(2) error.
[switch-generics-tricky-vdrd]
15. After initial compilation, two routines which were declared separately
are changed so that they share a single redeclaration, which calls
precursor. When the system is recompiled, the compiler does not
detect the VUPR(1) error. [make-synonyms-vupr-sneak]
16. A system with a generic class with formal parameter G compiles
fine. When a new class G is added to the universe and the system
is recompiled, the compiler does not detect the VCFG error.
[vcfg-sneak]
17. After initial compilation, an integer constant attribute is
changed to a function with no arguments. The compiler does not
detect the newly introduced VSTA error (reference to a static feature
which is not a constant or external). [vsta-sneak]
18. A system with two classes is compiled. Both classes are in the same
cluster and the Ace file uses "all" to include all classes in the
entire directory tree. Then a new sub-directory is created and a
class with the same name is added to it. When the system is
recompiled, the compiler does not detect the VSCN error.
[new-cluster-vscn-sneak]
19. After initial compilation, a VGCC(6) error is introduced by
removing an inheritance clause, making a feature that is
selectively available for creation no longer available. The
compiler does not detect the error. [vgcc-weasel]
20. After initial compilation, a VTEC(2) error is introduced by removing
an inheritance clause. When the system is recompiled, the
compiler does not detect the error. [vtec-weasel]
21. After initial compilation, a procedure name is removed from
a generic constraint. When the system is recompiled, the
VGCC(8) error is not detected. [vgcc-remove-generic-creator]
22. After initial compilation, the tag in an indexing clause is changed
from "weasel" to "attribute". This introduces a VEEN error but
the compiler does not detect it. [chg-indexing-tag-to-attribute]
23. After initial compilation, a VUPR(2) error is introduced by
removing an inheritance clause for ANY, where a routine is calling
`{ANY} precursor'. The compiler does not detect the newly
introduced VUPR(2) error. [uninherit-any-vupr2-sneak]
24. A generic class whose formal generic parameter G is constrained by
STRING has a call to an agent whose open target is {G}.
After initial compilation, the generic constraint is removed.
When the system is recompiled, the compiler does not detect
the newly introduced VEEN error.
[remove-constraint-veen-sneak]
25. Class A has a qualified call to one of its own features, where the
feature is exported only to B and its descendants. This is valid
since class A is a descendant of B. But when the inheritance
clause is removed, so that A is no longer a descendant of B, and
the system is recompiled, the VUEX violation is not detected.
[vuex-weasel]
26. After initial compilation, a VUPR(3) error is introduced by
changing an inherited deferred feature to effective, so that a
routine calling precursor has two precursors. On recompile, the
compiler does not detect the VUPR(3) error. [vupr-weasel]
Known incrementality bugs: valid class or system rejected
----------------------------------------------------------
1. A system with an Expanded client rule violation (VLEC) is compiled.
When the compiler correctly detects the violation, the violation is
removed and the compilation is resumed, but the compiler still
reports a VLEC violation. [vlec-compiler-wrong]
2. The compiler correctly detects and reports a VCFG(1) violation when a
generic class has a formal generic parameter with the same name as
a class in the universe. But when an inheritance clause is
deleted, thereby removing the generic class from the universe, the
compiler still reports a VCFG(1) violation on the generic class.
[bogus-vcfg]
3. After initial compilation, the type of an actual generic parameter
which is part of a generic derivation is changed. When the system
is recompiled, the compiler reports a nonexistent VLEC violation.
[bogus-vlec]
4. A system whose root class inherits from a class TEST2 which exists
in two different clusters correctly elicits a VSCN error report
from the compiler. But when the Ace is changed to indicate a
different root class, which does not depend on TEST2, the compiler
still reports a VSCN error. If the final versions of the classes
are compiled from scratch, no errors are reported.
[new-ace-root-still-vscn]
5. After initial compilation an inherited variable attribute in a
grandparent is changed to a constant attribute, thereby introducing
a VDRS(2) violation. But when the constant attribute is changed back
to a variable attribute, the compiler still reports a VDRS(2) error
though none is present. [bogus-vdrs]
6. After initial compilation, the Ace is changed to indicate a new
root class, which happens to be generic. The compiler detects the
VSRC(1) error. But when the Ace is changed to indicate a new (and
newly added) root cluster with a valid root class the compiler
reports a bogus VSCN error. [new-root-cluster-bogus-vscn]
7. A system has an Ace which specifies the precompiled cluster EiffelBase
and also has a cluster with Cluster_tag `kernel'. After initial
compilation, the tag `kernel' is changed to `other' and the system
is recompiled. The compiler then reports an erroneous VD28 error.
[bogus-vd28]
8. A system with two classes is compiled. The compiler detects the
syntax error on the second class. Then the root class is changed
so that the second class is no longer reachable from the root.
When compilation is resumed, the compiler still reports a syntax
error on the unreachable class.
[unreachable-syntax-error]
9. A system with two classes is compiled, where one of the classes
is mentioned in an option clause in the Ace file. Both classes are
in the same cluster and the Ace file uses "all" to include all
classes in the entire directory tree. Then a new sub-directory is
created and the class is moved into that sub-directory. When the
system is recompiled, the compiler reports a bogus VD16 error.
[move-class-bogus-vd16]
10. A system with one cluster preceded by the keyword "all" in the Ace
file is compiled, where the cluster does not exist. The compiler
correctly reports a VD01 error (nonexistent cluster path in Ace
file). Then the cluster is created with one sub-cluster `sub'
which contains the root class. When compilation is resumed, the
compiler reports a bogus VD30 error. [create-sub-cluster-bogus-vd30]
11. After initial compilation an expanded class is changed to a
deferred class but another class still tries to create an instance
of it. The compiler correctly detects the VGCC(2) error. But
when the create instructions are removed, the compiler reports a
bogus VTEC(1) error. [bogus-vtec]
12. A system has its own STRING class, excluding the one from
EiffelBase. This STRING class does not inherit from
TO_SPECIAL [CHARACTER], which causes a VEEN error. After
the compiler correctly detects this error, the missing inheritance
clause is added to STRING. The compiler then reports a bogus
VGCC(5) error in class MISMATCH_CORRECTOR. [own-string-bogus-vgcc5]
Known incrementality bugs: wrong error reported
------------------------------------------------
1. After initial compilation a constant attribute in an ancestor class
is changed from a unique constant to a constant integer, thereby
introducing a VOMB(5) error. When the compiler detects the error,
the constant integer is changed to an integer function with no
arguments. The compiler still reports a VOMB(5) error when there
is actually a VOMB(2) error. [vomb2-called-vomb5]
2. A class with a once function whose return type is a formal generic
parameter is correctly reported to violate VFFD(7). Then a class
with the same name as the formal parameter is added to one of the
clusters. When compilation is resumed, the compiler still reports
VFFD(7) instead of VCFG(1). [vcfg1-called-vffd7]
3. After initial compilation, a class is changed to an expanded
class. The compiler detects the newly introduced VDRD(2)
violation. When an invalid creation instruction is added, the
compiler reports a bogus VDRD(2) error instead of the
expected VGCC error. [vdrd-weasel]
Known incrementality bugs: exception displaying error message
--------------------------------------------------------------
1. A generic class has a formal generic parameter constrained by
a nonexistent and invalid creation procedure `infix "@"'. The
compiler correctly reports VTCG error. Then a syntax error is
added to the class. The compiler detects the error, but says
"Exception occurred while displaying error message" when it tries
to print the name of the class. [vtcg-then-syntax-error]
Known incrementality bugs: wrong results when melting involved
---------------------------------------------------------------
1. The "Hello weasel" program compiles and executes fine with
`assertion (all)' and no precompiled cluster. Then file "string.e"
is excluded from the kernel cluster. When the system is
recompiled, it compiles fine but execution ends with an exception
trace. [name-exists-invariant]
2. A class has an attribute of type `BIT Weasel_bits', where
`Weasel_bits' is a very large constant integer. After initial
compilation where the system is melted, the integer value is
changed to a very small number. But system execution still ends
with an "unknown attribute type" panic. [reduce-bit-attribute-size]
3. After initial compilation, a class TEST2 which is used as an actual
generic parameter (where the corresponding formal generic parameter
is used to declare an attribute) is changed so that it is an
expanded class. When system is recompiled, system execution should
call the creation procedure of TEST2 but it does not.
[expand-generic-no-creation-call]
4. After initial compilation where the system is melted, the name of a
routine in a parent class is changed, yielding a third inherited
version of a redefined feature. The new inherited version of the
feature has no precondition, which should make the alternative
precondition of the redefined feature true. But the precondition
is violated when the system is executed. Execution works correctly
when the system is melted from scratch.
[add-alternative-precondition]
5. A class inherits from a generic class which has a routine that
creates an entity of the generic type and prints its generating
type. After initial compilation where the system is melted, the
printed result is correct. Then the type of the actual generic is
changed from STRING to SEQ_STRING and changes are melted.
Execution then produces the wrong result (the same result as
before). [change-created-actual-generic]
6. After initial compilation where the system is melted,
the default assertion level for a cluster obtain from a "Use" file
is changed from "no" to "require". When changes are melted and the
system is executed, preconditions are not monitored.
[change-use-assertion-level]
7. A system creates an instance of a class and prints the value
of its only feature, which is a constant INTEGER attribute. After
initial compilation, the constant is changed to an INTEGER
variable. System execution still produces the correct result.
Then the feature is changed back to an INTEGER constant and
changes are melted. System execution then dies with a
segmentation violation. [constant-variable-constant]
8. After initial compilation where the system is frozen, a class
with routines which raise and rescue a developer exception is
modified to add another routine into the call chain. Also, the
routine that raises the developer exception is modified by adding
a `print (Void)' instruction. After melting changes, system
execution uses an enormous amount of memory (nearly 2 GB) before
execution ends with a segmentation fault. [huge-memory-leak]
9. After initial compilation where the system is melted, an expanded
class with no creation procedure adds a redefinition of
default_create. The system is recompiled without error but the
creation procedure of the expanded class is called twice (it is
only called once if final classes are compiled from scratch).
[expanded-add-default-create]
10. A class creates an instance of a second class, stores it in a file
using `independent_store' and then opens the file and retrieves
what was previously stored. After initial compilation, system
execution works correctly. Then an instruction is added to a
routine and changes are melted. Execution then incorrectly ends
with a mismatch retrieval error. [melt-retrieval-mismatch]
11. After initial compilation, a class TEST2 which is used as an actual
generic parameter (where the corresponding formal generic
parameter has creation procedures specified and is used to declare
attributes) is changed so that it is an expanded class. One of
the creation procedure names is also removed from the generic
constraint. When the system is recompiled, system execution dies with
a segmentation fault. [expand-generic-remove-creation]
12. After initial compilation, a class TEST1 is changed so that it
is no longer expanded. A class that inherits from TEST1 should
now conform to it, but when changes are melted
`type_conforms_to (dynamic_type (t2), dynamic_type (t1))' returns
False. [unexpand-class-no-conformance]
13. A generic class whose formal generic parameter G is constrained by
non-expanded class FOO has a routine that takes an argument of
type G and passes it as the target in a call to an agent with an
open target of type FOO. A second class inherits this class and
provides FOO as actual generic parameter. The actual argument in
the call to the routine is of type `expanded FOO'. After initial
compilation where the system is frozen, the actual generic
parameter is changed to `expanded FOO' and changes are melted.
Then the actual generic is changed back to `FOO'. System
execution then dies with a segmentation fault.
[expand-unexpand-agent-target]
14. A simple system is frozen. Then the system name is changed in the
Ace file and changes are melted. System execution then dies
with "Error could not open Eiffel update file ./eiffelbase.melted".
[change-system-name]
15. A system creates an instance of a class and prints the value
of its only feature, which is a function returning INTEGER. After
initial compilation where the system is frozen, the constant is
changed to an INTEGER attribute and changes are melted. System
execution still produces the correct result. Then the feature is
changed to an INTEGER constant and changes are melted. System
execution then produces the wrong result (the value returned by
the original function). [function-attribute-constant]
16. A system is compiled with an Ace file which specifies a nonexistent
library via `object: "-lweasel"'. Then the `object' clause is
removed completely from the Ace and system is melted.
When the previously generated C code is compiled, it won't link because
the (nonexistent) library is still referenced.
[remove-ace-object-clause]
Known incrementality bugs: wrong results when refreezing involved
-------------------------------------------------------------------
1. Initially, the system is frozen with an Ace file using no precompiled
library that specifies either `multithreaded (yes)' or
`shared_library_definition ("/foo/bar")'. Then the Ace file is
changed to indicate `multithreaded (no)' or to delete the line with
the shared_library_definition specification and the system is
refrozen. The compiled C code is not removed first, so the
non-multithreaded code won't link.
[turn-off-multithreaded]
2. After initial freezing of a generic class FOO whose formal
generic parameter is constrained by DOUBLE, the constraint is
changed to TEST2 with a generic creation procedure `default_create'
and all references to FOO [DOUBLE] are removed.
When the system is refrozen, the C code won't compile.
[chg-constraint-add-create]
Known incrementality bugs: wrong results when refinalizing is involved
-----------------------------------------------------------------------
1. After initial compilation where the system is finalized, a creation
procedure is changed to take an argument, introducing a VUAR error.
When the system is re-finalized, the compiler detects the error.
Then the error is removed and compilation completes successfully,
but the generated C code won't compile, due to conflicting declarations
for the creation procedure's routine. [add-vuar-remove-finalize]
2. A system has a root class which explicitly names `default_create'
as creation procedure and redefines `default_create' to print
something. The Ace file specifies the root class, but does not
specify a creation procedure. After initial compilation where the
system is melted, system execution correctly calls the redefined
default_create. But when the system is finalized with no changes,
the finalized system produces no output and the redefined
`default_create' has been removed by dead code removal.
[implicit-def-create-finalize]
3. A class has a routine `try (t: like n): like t' which just returns
its argument, where `n: INTEGER is 47'. After initial compilation
where the system is melted, the declaration of `n' is changed to
`n: DOUBLE is 13.25' and the system is finalized. System execution
then produces the wrong result (13 if finalized with inlining, -NaN
if finalized without inlining and -O2, internal compiler error in
gcc 3.2.2 if finalized without inlining and -O3).
[change-anchor-type-finalize]
Known incrementality bugs: wrong results when recompilation involved
---------------------------------------------------------------------
1. After initial compilation, a constant integer attribute referenced
in a BIT type which is the return type of a function is given a
different (larger) value. After recompilation, the function should
return a larger BIT type during system execution but it does not.
The initial compilation and recompilation can each be either a melt
or a freeze - the problem occurs regardless. [bigger-bit-func-wrong-value]
2. After initial compilation where the system is frozen, but without
C code compilation, an inheritance clause is removed, which removes
a class from the system. Changes are melted. When system cannot be
executed (because C code wasn't compiled), an attempt is made to
compile the C code. However, it won't link due to an undefined
symbol. [freeze-no-c-compile-melt]
Known incrementality bugs: wrong results when re-precompilation involved
-------------------------------------------------------------------------
1. After initial compilation where a class plus EiffelBase is precompiled
the system is precompiled again using precomp.epr file. The
compiler dies with a segmentation fault in FILE_NAME.make_from_string.
Compiler should probably say that project is read-only.
[precompile-again]
Known incrementality bugs: wrong results when interrupt involved
-----------------------------------------------------------------
1. After initial compilation, a system is recompiled with no changes
made. When the message "Melting changes" is displayed, control-C
is typed immediately, resulting in the message "Error: could not
write to ./EIFGENs/test/project.eif" and a resume prompt. Then the
compilation is resumed and it appears to complete successfully.
However, a subsequent attempt to run the compiler again results in
the message "Project in: . is corrupted. Cannot continue".
[control-c-corrupts-project]
2. After initial compilation, a system is recompiled with no changes
made. When the message "Melting changes" is displayed, control-C
is typed immediately, resulting in the message "Error: could not
write to ./EIFGENs/test/project.eif" and a resume prompt. Then `q' is
typed to quit the compilation. However, a subsequent attempt to
run the compiler results in an infinite loop.
[control-c-infinite-loop]
3. After initial compilation where the system is finalized, a small
change is made (doesn't matter what the change is) and the system
is refinalized. If a control-C is typed after dead code removal is
finished but before degree -3 starts, the compiler starts degree -3
instead of terminating execution. [control-c-interrupt-ignored]
======================================================================
Known melting bugs: exception or panic when melted, but not when frozen
------------------------------------------------------------------------
1. A routine which conditionally raises an exception has a rescue
clause which at first calls the routine itself before retrying,
then later just unconditionally retries. Executing the system
gives the expected output when the system is frozen, but when it is
melted a run-time panic occurs during execution.
[raise-exception-call-self]
2. A class has a procedure with a local entity of type BIT N, where N
is >= 2 ^ 24. The system compiles fine, but when executed it dies
with a run-time panic if it was melted. Frozen code works fine for
BIT sizes up to at least 200_000_000. [bit-two-to-the-twenty-four]
3. A routine passes `clone (b)' where `b' is of type BIT 8 to a
routine whose formal argument is of type BIT 8. If the system is
melted, system execution ends with a "Create on deferred"
exception. Frozen code works fine. [cloned-bit-actual-argument]
4. A class has a call to a function which takes an argument of type
BIT N and just returns its argument. The system compiles fine,
but when executed it dies with the exception "object allocation:
No more memory" if it was melted and if N >= 32768 (2 ^ 15).
Frozen code works fine for BIT sizes up to at least 1_000_000.
[bit-two-to-the-fifteen]
5. Melting a system which prints the address of an attribute works fine,
but when the system is executed it dies with an illegal
metamorphose type panic. [melted-attribute-address]
6. A system has a call whose target is of an expanded type `expanded FOO',
where class FOO is not declared as an expanded class. The call is
to a function whose return type is `like Current'. Melting the
system works fine but when the system is executed it dies with a
segmentation fault. Frozen code works fine.
[melted-expanded-like-current]
7. A system with a class name longer than 256 characters compiles fine
when melted but dies with a run-time panic when executed. Frozen
and finalized code work fine. [melted-long-class-name]
8. A class has a routine which prints `t.count' where `t' is of type
`expanded LINKED_LIST [like Current]'. The root class, which is expanded,
inherits this routine and makes it a creation procedure.
If the system is melted, execution dies with a segmentation fault.
Frozen code works fine. [expanded-list-like-current]
Known melting bugs: wrong result when melted, but not when frozen
------------------------------------------------------------------
1. A class has a routine with a postcondition which references `old
arg' where `arg' (the routine's argument) is of an expanded type.
When postconditions are monitored and the system is melted,
evaluation of the postcondition appears to incorrectly cause some
creations of objects of the expanded type. Frozen code works as
expected, with no hidden object creations.
[old-expanded-melted-creations]
2. A routine has a postcondition which references an "old" expression.
The body of the routine raises an exception which is retried by the
rescue clause. When postconditions are monitored and the system is
melted, the "old" expression is incorrectly evaluated again when
the retry instruction is executed. Frozen code does not
re-evaluate the "old" expression when it does a retry.
[evaluate-old-when-retry]
3. A routine has a local of an expanded type, where the base class of
this type has a creation procedure that raises an exception. If
the system is melted, the recipient of the exception is not the
routine containing the declaration of the local but that routine's
caller. If the system is frozen, the routine containing the
declaration of the expanded local is the recipient of the
exception. [who-gets-exp-local-exception]
4. A routine has a precondition, postcondition, old expression in the
postcondition and a local entity of an expanded type. The local of
expanded type is initialized at the wrong time (before the
routine's precondition is even checked), but only if the system is
melted. Frozen code works correctly.
[when-init-expanded-local]
5. A routine has a manifest array, each of whose elements is a
function call. The elements of the array are evaluated in reverse
order of their appearance when the code is melted, but in order of
appearance when frozen. [manifest-array-elem-eval-order]
6. A routine has a postcondition which includes more than one `old'
expression. The old expressions are evaluated in reverse order of
their appearance when the code is melted, but in order of
appearance when it is frozen. [old-expression-eval-order]
7. A routine whose rescue clause tries to display the meaning of the
exception gives incorrect output if the original exception is two
levels down, the called routine also has a rescue clause and the
code is melted. Frozen code works fine. [melted-two-level-rescue]
8. A system which calls a once function whose result type is BIT type
should execute correctly, but gives wrong output if melted.
[once-bit-type-result]
9. A routine `try' which has a precondition calls another routine `try2'
which raises an exception. If the calling routine catches the
exception and retries, the precondition is evaluated again if code
is melted. Frozen code works correctly - it does not re-evaluate
the precondition in the routine which catches the exception.
[eval-precondition-on-retry]
10. A system calls a routine `double_to_integer (n: DOUBLE): INTEGER'
and passes `i.bit_shift (1)', where `i' is an INTEGER. If the
system is melted, execution ends with an "illegal cast operation"
panic. Frozen code works correctly. [melt-pass-bit-shift]
11. A class that does an inspect of `x', whose type is INTEGER_64
and which has value 1, does not match value 1 but only when code
is melted. Frozen and finalized code work correctly.
[inspect-integer-64-one]
12. A system whose Ace specifies `profile (yes)' is melted.
When the system is executed with the EIFGENs/test/W_code directory as
the current directory with the MELT_PATH environment variable not
set, system execution fails with "Unable to open to output file
for profile". [melted-profile-system]
13. Executing a system with a class invariant violation works
correctly when melted and invariants are monitored.
However, the top of the exception trace shows Invalid_object
as the object when code is melted. Frozen code works correctly.
[melted-invariant-invalid-object]
14. A system creates a TWO_WAY_LIST, each of whose elements is
an object of an expanded type. The list is stored in a file,
using `independent_store'. When the list is retrieved, system
execution dies with a retrieve error but only if the system is
melted. [melted-retrieve-list-expanded]
15. A system puts a string into a list 3 times and then calls `referers'
from class MEMORY and prints its count. If the list is a local
(not an attribute) and if code is melted, execution incorrectly
prints 0 instead of 3. [melted-local-referers]
16. A system whose Ace specifies `profile (yes)' is melted.
When the system is executed with the EIFGENs/test/W_code directory as
the current directory with the MELT_PATH environment variable not
set, system execution attempts to create the "profinfo" file
in the wrong place (not in the EIFGENs/test/W_code directory).
[melted-profinfo-wrong-dir]
17. A root class has an attribute of type `expanded TEST1 [STRING]'
where the creation procedure of TEST1 declares a local
of type `expanded TEST2 [like Current]' and prints its
generating type. Code compiles fine when melted, but dies with
a panic when executed. Frozen and finalized code work correctly.
[expanded-generic-anchored-local]
18. A function that returns an expanded type has a postcondition that
states that `old Result' is not equal to the value of the
function, where the body of the function sets an attribute of
Result to a non-default value. Melted code incorrectly violates
the postcondition, while frozen code does not.
[melted-old-expanded-result]
Known freezing bugs: wrong result when frozen, but not when melted
-------------------------------------------------------------------
1. In a call to a routine whose formal argument is a BIT type with a
larger number of bits than the actual argument, the actual argument
is not extended with trailing zeros but only when the code is
frozen. [bit-arg-extend-frozen]
2. A routine has a postcondition with an `old' expression which
involves a function call. An exception is raised during execution
of this function. If the system is frozen, the recipient of the
exception is not the routine containing the `old' expression, but
that routine's caller. If the system is melted, the routine
containing the `old' expression is the recipient of the exception.
[who-gets-old-exception]
3. A routine `f' has a local of an expanded type, but does not
reference this local in the routine body. The base class of the
expanded type has a creation procedure. When the system is
executed, the creation procedure of the expanded class is not
invoked when `f' is called, but only if the system was frozen. A
melted system works correctly. [expanded-local-no-creation]
4. A routine has a local of an expanded type. The body of the routine
raises an exception which is retried by the rescue clause. If the
system is frozen, the expanded local is incorrectly initialized
again when the retry instruction is executed. Melted code works
correctly. [init-expanded-local-when-retry]
5. A routine redefines an inherited routine that returns an expanded
type or a BIT type and replaces it with an attribute. It also
includes references to the attribute. The code compiles fine, but
dies with a segmentation fault or "feature applied to void
reference" if it was frozen. Melted code works fine. This appears
to be a code generation bug. [redefine-expanded-to-attribute]
6. A class has a routine which obtains the address of a procedure via $p.
A descendant class redefines procedure `p'. In the descendant, $p
incorrectly returns the address of the ancestor's version of the
routine instead of the redefined routine. [address-of-redefined-routine]
7. A class has agents which are calls to a routine that takes a numeric type
(DOUBLE, REAL, INTEGER_64, INTEGER, INTEGER_16, INTEGER_8) and
prints its argument. If a lighter type is passed as the actual
argument (e.g., INTEGER_8 is passed to a routine expecting an INTEGER)
the arguments are passed incorrectly, resulting in wrong output,
but only if the routine is frozen. Melted code works fine.
[frozen-agent-lighter-argument]
8. A class with a prefix feature that is an attribute compiles fine
when frozen, but the generated C code won't compile. Melted code
works fine. Fixing the generated C code by adding the missing "\"
escape characters before double quote characters inside a C string
allows the code to compile and produce the correct result.
[frozen-prefix-attribute]
9. A class which prints `<< i16 + i8, i >> @ 1' prints -32642 when
code is melted, but 32894 when frozen. [tuple-i16-plus-i8]
10. A class calls a routine and violates its precondition. The
exception is not rescued but printing of exception trace on
failure is turned off. The class has a `dispose' routine which
does nothing, but has an empty rescue clause. System execution
ends with a segmentation fault when the system is frozen. Melted
code works correctly. [dispose-with-rescue]
11. A class has a routine `value (r: DOUBLE): like r' which
just returns the value of `r'. When the routine is called with
an INTEGER_8 actual argument, the result is wrong but only if
the system is frozen. Melted code works correctly.
[anchored-double-function]
Known finalizing bugs: wrong result when finalized, but not when melted/frozen
-------------------------------------------------------------------------------
1. Finalizing a particular system with a couple of levels of expanded
types which are generic and using `BIT 8' as actual generic at the
top level generates C code which produces the wrong output. If the
system is instead melted or frozen, system execution works as
expected. [finalize-expanded-generic-bit]
2. A system has an attribute of an expanded type, where the base class
of this type also has an expanded attribute. The system compiles
fine when finalized, but when the system is executed the creation
procedures are called in the wrong order. If the system is instead
melted or frozen, system execution works as expected.
[finalize-expand-creation-order]
3. A C routine tries to get the address of an Eiffel routine which is
actually implemented as an external C routine, using the Cecil
library. If the system is finalized, the address of the external
routine cannot be obtained. In a frozen system, the address of the
external routine can be obtained and the routine can be called.
[finalize-external-routine-address]
4. System execution does not check the class invariant before and
after a qualified call to a routine, but only if the system is
finalized and assertions are kept.
[finalize-skip-invariant]
5. A generic class `TEST1 [G]' has a routine `value2: G is do end'.
If the actual generic parameter is an expanded class, then `value2'
returns Void when the system is finalized with inlining, but should
not. Melted code, frozen code and finalized code without inlining
work correctly. [expanded-generic-return-type]
6. A class `TEST1' has a routine `f (x: like Current): like x'
with body `Result := x'. A second class `expanded TEST2' inherits
from TEST1. A third class calls `f' and passes it an object of
type TEST2. System execution dies with a segmentation fault, but
only if the system is finalized with inlining. Melted code, frozen
code and finalized code without inlining work
correctly. [inline-pass-expanded]
7. A class creates an ARRAYED_LIST [FOO] where FOO is an expanded class
and appends two elements to it and then prints the `value'
attribute of the first item in the list. The system dies
with a bus error but only if the system is finalized
with inlining. [inline-arrayed-list-expanded]
======================================================================
(non-incrementality)
Known compiler termination bugs: silent premature termination before freezing
(terminates with exception trace if `fail_on_rescue (yes)'
------------------------------------------------------------------------------
1. A system which appears to violate the Call rule on page 367 causes
silent termination of the compiler. The example involves a class
which inherits from a constrained generic class and provides NONE
as actual generic parameter. [none-as-actual-generic]
2. Specifying the system-level option `precompiled' without any
parenthesized value after it causes the compiler to terminate
silently. Specifying one of the system-level options
`dead_code_removal', `fail_on_rescue' or `exception_stack_managed'
without any parenthesized value after it now causes the compiler to
correctly report a VD15 error. [system-option-no-parens]
3. A deferred function of type INTEGER in an inherited class is
effected by an attribute of type NONE. The compiler does not
report any validity violations, but it terminates silently while
melting changes (after pass -3 if freezing system).
[def-int-func-redefine-none]
4. A system is compiled with an Ace which specifies NONE as the root
class and also specifies a root creation procedure. Compilation
proceeds without problems until the compiler tries to melt
changes, when it silently terminates. Also dies if the system is
frozen. [root-none-creation-proc]
5. A class with a `strip' expression which references an attribute of
type NONE causes silent termination of the compiler during pass 2.
[strip-attribute-of-type-none]
6. A system name which includes characters special to the shell causes
compiler to die. [lace-system-special-chars]
7. A generic class has a function with a generic result type. If
this function tries to reference the delayed call expression
`Result~make', the compiler dies in degree 3.
[generic-delayed-call-result]
8. A generic class with the header
"class TEST2 [G -> STRING create make end, H -> G create make end]"
causes the compiler to die in degree 4. [creation-constrained-by-generic]
9. A generic class with the header
"class TEST2 [G -> NONE create make end]"
causes the compiler to die in degree 4. [generic-constrained-by-none]
10. A generic class whose generic parameter is constrained by itself
(G -> G) and that also creates a result of this generic type
causes the compiler to go into infinite recursion in
`internal_conform_to' and eventually run out of memory and die.
[generic-constrained-by-self]
11. An Ace file that specifies a "use" file which looks like part of
a normal Ace file with no clusters causes the compiler to die with
a segmentation fault in `process_options'.
[use-file-like-ace]
12. An Ace file with a cluster named "a/b" causes the compiler to die
while trying to create a directory in `backup_directory', but only
if "automatic_backup" is true. [slash-in-cluster-tag]
13. A long class name (130K characters) causes the compiler to
die while trying to compile the class, but only if "automatic_backup"
is true. [long-identifiers]
14. The classes below are compiled fine, but trying to get the flat form of
of `TEST.make' causes "ec" to die.
class TEST
creation
make
feature
make is
local
a: A
s: STRING
do
s := "weasel"
create a.make (clone (s) + Constant_string)
end
Constant_string: STRING is "stoat"
end
class A
create
make
feature
make (s: like name) is
do
end
name: STRING
end
15. The class below compiles fine, but trying to get the flat form of
of `TEST.try' causes "ec" to die (estudio doesn't die but cannot
display the flat form or clickable form of TEST or the flat form
of `TEST.try').
class TEST
creation
make
feature
make is
do
end
try is
local
a, b, c: STRING
do
c := my_list (a, b).first
end
my_list (c, d: STRING): LIST [like d] is
do
end
end
16. A class with a creation expression `create {like x}' where `x: NONE'
causes compiler to die during degree 3.
[creation-expr-anchor-none]
Known compiler termination bugs: silent premature termination while freezing
(terminates with exception trace if `fail_on_rescue (yes)'
------------------------------------------------------------------------------
1. An Ace file that specifies a long system name (512 characters)
causes the compiler to die after generation of auxiliary files with
"file name too long". If the system is melted instead, the
compiler does not die but reports the problem creating the file.
[long-system-name]
2. An inspect instruction with when clause `when 0..2000000000 then'
causes the compiler to die with "no more memory" when the system
is frozen. The problem does not occur if code is melted instead.
[inspect-big-range]
Known compiler termination bugs: silent premature termination while finalizing
(terminates with exception trace if `fail_on_rescue (yes)'
------------------------------------------------------------------------------
1. The creation procedure of a class creates an instance of another
class and calls a feature on it which contains a "strip"
expression. If the system is finalized and the Ace specifies
`inlining (yes)' the compiler dies during degree -3 on the first
class. [finalize-inline-strip-expr]
2. A generic class whose formal generic parameter is constrained by
NUMERIC has a function `value: G is do Result := x + x end'
where `x' is of type G. Another class has a call to this function.
If the system is finalized with inlining, the compiler dies during
degree -3 on the class. [inline-numeric-plus-numeric]
Known compiler nontermination bugs: infinite loops
--------------------------------------------------
1. A violation of VLEC involving an expanded client cycle where both
classes in the cycle are generic should cause the compiler to
report a VLEC error. Instead, the compiler goes into an infinite
loop. [vlec-cycle-with-generics] [validity-vlec1-other-generic]
======================================================================
Known Lace syntax bugs: syntax should be accepted, but is not
-------------------------------------------------------------
1. There are some identifiers which are not supposed to be reserved
words in Lace, but they are: make, assertion, debug, optimize, c,
object. ETL page 518. [lace-keywords]
2. A Cluster_tag is an optional part of a Cluster_clause. But es3
reports a syntax error if the tag is missing. ETL page 520.
[lace-opt-cluster-tag]
3. An Ace with a Visible section which has just one Class_visibility
that consists of a Class_name without any Visibility_adaptation
should be syntactically legal. But es3 reports a syntax
error. ETL page 531. [lace-valid-visible]
4. In most places in an Ace where a comma-separated or
semicolon-separated list can appear, extra leading and trailing
separators can appear without causing the compiler to report a
syntax error. In addition, a separator may be replaced by multiple
separators. For example, `option debug (yes): A,,B,,, C ,,,'
is allowed. But there are exceptions to this rule, which are
presumably bugs. The known exceptions are:
A. The File_list of an Include or Exclude (no leading
or multiple semicolons allowed, but one trailing semicolon
is allowed)
B. The Cluster_rename_clause of a Cluster_adaptation_list
(no leading, trailing or multiple commas allowed)
C. The Target_list of an Option_clause
(no leading commas allowed, but trailing and multiple commas
are allowed)
D. The Externals clause
(no leading semicolons allowed before the first
Language_contribution, no multiple semicolons allowed, no
leading semicolons before first File_list, no trailing
semicolons after File_list)
[lace-extra-separators]
Known Lace validity bugs: valid, but not accepted
--------------------------------------------------
1. A Visible clause in the Ace which names a class (or a feature in
its export subclause) is case-sensitive if the name is enclosed in
double quotes, but should not be since it does not refer to an
outside element. The compiler incorrectly reports a VD25
violation. In the case of a feature, the compiler does not
lower-case the name so the feature is removed by dead code removal.
[visible-cluster-case-sensitive]
2. Syntactically legal Ace with no cluster properties not accepted.
[lace-no-cluster-props]
Known Lace validity bugs: accepted, but should not be
------------------------------------------------------
1. A class named NONE should probably elicit some kind of validity
error (VD??) from the compiler. [class-named-none]
2. An Ace which includes the option `assertion' or `profile' or
`debug' without any parenthesized value after it is accepted by the
compiler without any complaints, but should be a VD15 error.
[assertion-option-no-parens]
3. An Ace with a Visible clause which makes two classes visible to
external software under the same name is accepted by the compiler,
but should not be. Similarly, an Ace with a Visible clause which
makes two features in a class visible under the same name should
not be accepted. [visible-under-same-name]
Known Lace validity bugs: wrong error reported
-----------------------------------------------
1. An Ace which uses the precompiled "base" cluster and uses the same
cluster tag for its added cluster as one of the cluster tags used
in the precompiled cluster should be reported as a VDCN error (two
clusters have the same name). Instead, the compiler reports a VD20
error (unknown root class). This problem only occurs when a
precompiled cluster is used. This is extremely confusing to a
beginning user, who is certain that he/she has a class with the
name specified for the root class in the only cluster listed in
the Ace. [vdcn-called-vd20]
2. If an Ace uses an environment variable which has not been set in
one of its path names, the unset variable is treated as though it
is set and has the value "" (the empty string). This can cause the
compiler to report a VD01 error (non-existent or unreadable cluster
path in Ace file) with a bogus path name instead of a more obvious
error like "unset environment variable FOO". It also causes the
compiler to accept path names like `/dragon/mypath$weasel' for
`/dragon/mypath' if `$weasel' is not set in the environment.
[lace-unset-environment-var]
Known Lace operation bugs: incorrect behavior
----------------------------------------------
1. An include or exclude in a Lace "Use" file has no effect.
[use-include-exclude]
======================================================================
Known operation bugs: generated C code won't compile or link
-------------------------------------------------------------
1. Class with assignment `Void := Void' compiles fine, but generated
C code won't compile. [void-gets-void]
2. A class with a declaration and call of an operator feature which
ends with a backslash character appears to be valid and the
compiler accepts it. But the generated C code won't compile.
Also, the same problems with characters %" and \ occur with debug
keys. [weird-operator-feat-name2]
3. A function which has a local of type `x: expanded FOO' has as its
body `Result := x'. When the system is finalized, the code
generated for the enclosing class won't compile.
[finalize-expanded-to-reference]
4. Finalizing a system with a call to a particular prefix feature on another
object generates C code which won't compile if system is finalized,
but only if `inlining (yes)' is specified. [inline-prefix-call]
5. A system has a debug instruction with every character except null
in its debug key. When the system is frozen, the generated
C code won't compile. Melted and finalized code work correctly.
[all-chars-debug-key]
Known operation bugs: generated C code yields warnings when compiled
---------------------------------------------------------------------
Known operation bugs: wrong results formatting
-----------------------------------------------
1. A class has a routine that violates a loop variant. It compiles
fine and produces an exception trace that indicates a loop variant
violation, but the text is poorly formatted (doesn't line up with
"Nature of exception" column).
-------------------------------------------------------------------------------
TEST make stoat:
<000000000080ABA0> Non-decreasing loop variant or negative value reached.
Fail
-------------------------------------------------------------------------------
class TEST
create
make
feature
make is
do
from
variant
stoat: 0
until
false
loop
end
end
end
Known operation bugs: wrong results when executed
--------------------------------------------------
1. REAL does not conform to double according to `conforms_to'.
[real-conform-double]
2. If the precondition is violated on the first call to a once
routine, the body of the routine is not executed on that call
(naturally) or on any subsequent calls to the routine.
[once-routine-precond-fail]
3. A divide by real zero (0.0) should trigger an exception, but does
not. When the result of the division is printed, it comes out as
`Inf' or `NaN'. [divide-by-real-zero]
4. A system with a generically derived type whose actual generic
parameter is itself a generic derivation results in a class TEST1
with an attribute of an expanded type. When an instance of TEST1
is created, the attribute is not initialized to the appropriate
default value. Instead, it seems to be Void, which should not be
possible for an entity of an expanded type.
[expanded-but-void-attribute]
5. A class inherits different versions of a routine with the same name
and signature from different parents, but redefines the feature.
The flatshort form looks as expected, with all preconditions of
redefined versions of the feature in the expected order. But when
the system is executed, the preconditions are checked in a
different order than that indicated by the flatshort form. Same
problem for postconditions. Actually, the flatshort form now has
the wrong order for preconditions and postconditions (alternative
precondition and extra postcondition should be first in their
respective lists) so the problem seems to be with the flatshort
form itself. [wrong-alt-precondition-order]
6. A class redefines an inherited function into an attribute. The
function has a postcondition, but this postcondition is not added to
the class invariant. [attribute-postcondition-lost]
7. The class invariant is not monitored for the root class, even with
`assertion (all)'. Test cannot be automated because EiffelWeasel
doesn't support it. [root-no-class-invariant]
8. A class inherits a deferred feature from one class and an
effective feature of the same name from another class. Both
features have a precondition and a postcondition. The flatshort
form of the heir class looks as expected, with all alternative
preconditions present. But when the system is executed, the
precondition and postcondition of the deferred precursor feature
are not monitored. [skip-deferred-feat-assertions]
9. The bit values `00B' and `11B' are deep equal according to
deep_equal. [diff-bit-constants-deep-equal]
10. Calls to `clone' with integer, boolean or character arguments do
not return the expected result. Also, frozen and melted code
produce different results. [clone-integer-boolean-character]
11. The class invariant should be checked after
creation/initialization of an entity of an expanded type, but it
is not. Invariant checking works correctly for non-expanded
types. [expanded-skip-class-invariant]
12. An internal routine A with no rescue clause calls a second
internal routine B, passing it some feature addresses. Routine B
raises an exception. After initial compilation where the system
is frozen, the routine B is modified to cause it to be melted.
When routine A is called repeatedly, more and more C memory is
used, which seems to indicate a memory leak.
[internal-exception-memory-leak]
14. A non-expanded class FOO has a routine `bar' which passes Current
to a routine which uses it to set an attribute in the object
referenced by the passed argument. Another class declares an
entity of type `expanded FOO' and calls `bar' on it. The
attribute in this entity is changed by the call, though it should
not be. [expanded-pass-current]
15. A class creates an instance of a second class which has a
`dispose' procedure that causes a floating exception. When this
instance is garbage collected, the `dispose' procedure is called
and the exception is correctly raised. However, garbage
collection is turned off. A subsequent creation and collection of
another object causes program termination. [exception-in-dispose]
16. A routine calls another routine and violates its precondition.
The routine's rescue clause calls another routine to display the
exception status and this routine calls a third routine. If this
last routine also has a non-empty rescue clause, then the meaning
of `exception' is not available. [rescue-show-exception-meaning]
17. Routine `is_integer' from STRING completely ignores null characters,
which is incorrect ("%/0/1%/0/" is not a valid integer). So do
routines `is_real' and `is_double'.
[is-integer-ignores-null]
18. Trying to print INTEGER_8 value -127 or INTEGER_16 value -32768
when system was compiled with assertion (all) results in violation
of class invariant "sign_times_abs". [print-max-negative-smallint]
19. A class FOO inherits a generic class twice providing different actual
generic parameters and renaming the single routine `f' in the
generic class. Routine `f' creates a local of type G and prints
its generating type. The root class creates an instance of FOO
and calls both versions of `f'. The system compiles fine, but
produces the wrong results when executed.
[generic-generating-type]
20. A class has agents which are calls to a routine that takes a numeric type
(DOUBLE, REAL, INTEGER_64, INTEGER, INTEGER_16, INTEGER_8) and
prints its argument. If the argument is left open and a lighter
type is passed as the actual argument in a tuple at the time of
the call (e.g., INTEGER_8 is passed to a routine expecting an
INTEGER), the argument is passed incorrectly in some cases.
[agent-lighter-tuple-arg]
21. The creation procedure is not called for an entity of an
expanded type, but only if the creation procedure is the implicit
`default_create' instead of an explicitly named creation procedure
and only if entity is a local and class has no attribute of the
same expanded type. [expanded-no-default-create]
22. Compiling a system with a debug instruction with debug key that
contains an interior null character ("weas%Uel") works fine, but
when the system is executed with an Ace file that specifies `debug
("weas%Uxx")' the debug instructions inside the block with the tag
are executed, but should not be. [interior-null-in-debug-key]
23. Bit operations on INTEGER_64 do not always works correctly.
Bit_shift causes an "operational stack botched" panic when code is
melted. Some of the values computed are wrong for
frozen/finalized code - shift of 64 positions doesn't work
correctly and all values are wrong for bit_shift.
[bit-64-operations]
24. Printing `(<< << "A" >> , << 47 >> >>).generating_type' displays
"ARRAY [ARRAY [STRING]]" but should display "ARRAY [ARRAY [ANY]]".
[nested-manifest-array-gen-type]
25. A class has a creation instruction `create {expanded TEST1} x.make' where
`x' is of type TEST1, which is not an expanded class.
The system compiles fine but dies with a segmentation fault when
executed. [explicit-expanded-creation]
26. A routine which prints `(create {like Current}).generating_type'
is written in class A and inherited by class B. When the routine
is called on an object of type B, it prints "A" instead of "B".
If `create {like Current}' is assigned to an attribute of type
`like Current', the generating type of this attribute is also
incorrect in class B. But if it is assigned to a local instead,
the generating type in B is correct. [inherit-create-like-current]
27. A class creates an object of type `ARRAY [BIT 70000]' and prints
its generating type. The generating type prints as "ARRAY [BIT
4464]" instead of "ARRAY [BIT 70000]" or "ARRAY [BIT_REF]". C
compiler issues warnings about "overflow in implicit constant
conversion". [array-bit-two-to-sixteen]
28. A class has an inspect of a local of type INTEGER_64, which has
value 12345678912345. When executed, the value does not match
a when clause whose constant value is 12345678912345. It does not
matter whether code is melted, frozen or finalized.
[inspect-big-integer-64]
29. A constant declared as `value: INTEGER is -0xD' is accepted by
the compiler, but is interpreted as 13 instead of -13.
[negative-hex-constant]
30. A system repeatedly creates one thread (which has an empty
`execute' procedure) and then calls join_all to wait for it to
terminate. As the number of threads which have been created
increases, the memory used by the executing system keeps growing,
apparently without limit. After 4000 threads have been created,
system memory usage is about 90 MB. [multithreaded-memory-leak]
Known operation bugs: exception trace / panic / core dump / loop when executed
-------------------------------------------------------------------------------
1. A class with a routine which has 1000 local variables compiles fine
and the C code compiles (as long as one doesn't use the -O option).
When the system is executed, it dies with an "out of locals"
run-time panic. [out-of-locals]
2. A system which allocates a number of fairly large strings (approx
0.4 MB each) and calls routines allocate_tiny, full_collect and
full_coalesce in class MEMORY compiles fine. When the system is
executed it eventually runs out of memory, which appears to
indicate a memory leak. [memory-leak]
3. A clearer example of a system which obtains a reference to
a sub-object and uses it to change that sub-object.
[clearer-ref-to-sub-object]
4. A routine which conditionally raises an exception has a rescue
clause which always retries, but which first calls the routine
itself recursively the first time the rescue clause is executed.
Executing the system with garbage collection off causes a run-time
panic if the number of retries is moderately large (500 or
greater). [rescue-recurse-many-retries]
5. A routine passes `clone (k)' where `k' is of type INTEGER to a
routine whose formal argument is of type DOUBLE. If the system is
melted, system execution ends with an "Illegal cast operation"
run-time panic. Frozen code instead produces incorrect output.
[cloned-int-passed-to-double]
6. A routine repeatedly does `deep_clone (b)' where `b' is of type
BIT 32. System execution ends with an exception trace (on the
first iteration if system is frozen or after a large number of
iterations if system is melted). [deep-clone-bit]
7. A routine has a rescue clause and a local of an expanded type.
The creation procedure of this type's base class raises an
exception. In the rescue clause, the expanded local is void
which causes execution to terminate with a segmentation fault.
[expanded-local-void-in-rescue]
8. A class has a routine which has 1000 instructions, each of which
is `a := << 1 >>'. The system compiles fine when frozen and the C code
compiles (as long as one doesn't use the -O option). When the
system is executed, it dies with an "out of locals" run-time
panic. [manifest-array-waste-locals]
9. A class inherits twice from a generic class, using DOUBLE and
STRING as the actual generic parameter and renaming the single
routine in the generic class to replicate it. The system compiles
fine, but dies with a bus error when executed due to the fact that
the wrong routine is being called. [inherit-generic-wrong-call]
10. A class has a recursive routine `f' which at the depths of its
recursion calls a routine `weasel' which raises an exception.
Routine `weasel' has a rescue clause which first calls `f' and
then retries and succeeds. When the system is executed, it dies
with a panic (segmentation fault) if the depth of "exception in
rescue clause" nesting is greater than 256. (Now it dies when
depth of original recursion is 0 and depth of "exception in
rescue clause" nesting is only 2). [deep-exception-in-rescue]
11. A class calls the `strip' operator and has an attribute of an
expanded type. Executing the system results in a run-time panic.
[strip-with-expanded-attr]
12. An expanded feature is redefined as an attribute in a descendant class.
System execution fails when assertion (all) is specified.
[redefine-expanded-as-attribute]
13. A class repeatedly generates a small manifest array, each of whose
elements is `strip ()'. The system compiles fine, but when executed
for a large number of iterations it eventually runs out of memory,
which appears to indicate a memory leak. [strip-memory-leak]
14. A class declares an attribute of type `expanded A', where A
contains an attribute of type `expanded B' (a sub-object).
Neither classes A nor B are themselves expanded. Class B has a
function which returns `Current' as its result. It appears that a
caller is able to get and save a reference to a sub-object.
Wasting memory to cause a garbage collection then causes execution
to terminate with a run-time panic. [reference-to-sub-object]
15. A class calls a routine which recurses a few times and then raises
a developer exception. The exception is rescued and the rescue
clause calls another routine which calls the recursive routine and
retries the exception. System execution should terminate
normally, but ends with the second developer exception.
[safe-call-from-rescue]
16. A class repeatedly calls a routine which creates a tuple with
400 elements, each element being itself the tuple [13].
The system compiles fine when melted or frozen, but dies with a
bus error when executed, even if garbage collection is off.
[create-tuple-of-tuples]
17. A class creates a hash table of ANY indexed by INTEGER. Inserting
an element under index 0 causes a postcondition violation.
[insert-hash-table-zero]
18. A class creates an instance of a second class and calls a boolean feature
`is_value_required' on it. The second class has an invariant that
changes the value of a CHARACTER attribute, which affects the
result returned by `is_value_required'. Code compiles fine when
frozen with all assertions turned on, but when the system is
executed it dies with a segmentation violation. Finalized code
does not die, but it incorrectly prints "False" instead of "True".
[invariant-changes-current]
19. A class tries to retrieve an object which was stored into a file
using `independent_store'. If the file contents is manually
modified to delete a character (to simulate a corrupted file), the
retrieve operation goes into an infinite loop.
[retrieve-corrupted-file]
20. A class calls a routine with a long name (> 600 characters)
and the routine raises an exception. The caller rescues the
exception and then tries to get the exception trace.
System execution ends with a segmentation fault.
[long-name-exception-trace]
21. A system creates an instance of a class with 500 generic parameters,
where the class has one attribute for every generic parameter.
The system compiles fine when melted, frozen or finalized, but
dies when executed. [many-generic-parameters]
[Manu says there is currently a hard limit of 256 generic parameters.]
22. A class has an attribute of an expanded type, which has 100 expanded
attributes, where the class for each attribute has 100 attributes
of type DOUBLE. The system compiles fine when melted or frozen, but
dies with a panic when `full_collect' is called. Finalized code
works correctly. [gc-expanded-expanded-attrs]
23. A class inherits from a second class and redefines an external
"C inline" routine to an internal routine. The internal routine
calls precursor. The system compiles fine but goes into an
infinite recursion when executed. [external-precursor]
24. If the environment variable EIF_MEMORY_CHUNK is set to 200000000,
compiler dies with an "out of memory" exception.
[very-big-gc-chunk-size]
25. An external function `value: INTEGER' which is "C inline" has a
postcondition `value = 29'. If this feature is called via static
access `feature {TEST1}.value', system execution dies with a
segmentation fault in the postcondition. [external-static-access]
26. A "C inline" external function `value (n: G): G' in a generic class
has body "$n", so that it just returns its argument. If this
function is called normally from another routine in the class, the
result is correct. But if the function is called via a static
access and if there is more than one generic derivation of the
enclosing generic class, a class invariant is violated due to the
wrong routine being called. If code is finalized, generated C
code won't compile due to conflicting function prototypes.
[static-access-generic-function]
Known operation bugs: possible unspecified semantics
-----------------------------------------------------
Known operation bugs: performance problem
------------------------------------------
1. A class calls `print (a)' where `a' is an ARRAY [SOME_EXPANDED_TYPE].
The class compiles fine and system execution produces the correct
output, but execution time seems to be O(N^2), where N is the size
of the array. [slow-print-array-of-expanded]
Known operation bugs: features not fully implemented or wrong es3 behavior
------------------------------------------------------------------------------
1. If the root class is obsolete, no obsolete warnings are displayed.
Similarly, if the root class is not obsolete but the root creation
procedure is, no obsolete warnings are displayed. [obsolete-root-class]
2. According to the last right margin note on page 166, an
obsolescence message should be produced for a class which joins two
or more features at least one of which is obsolete. But the
compiler does not produce such a message. [obsolete-joined-feature]
Known class view bugs
---------------------
1. The flat and flatshort forms of class ANY show every feature repeated
twice.
======================================================================
Known optimization deficiencies
-------------------------------
1. Putting parentheses around an entity of type ARRAY [STRING] which
is a call target prevents the compiler from optimizing the
instruction it is part of, when the system is finalized and the Ace
specifies `array_optimization (yes)'. [parens-around-array-call-target]
2. When a system is finalized with `inlining (yes)', only the last
feature call in a multi-dot call is inlined. Breaking the
multi-dot call into the equivalent sequence of single dot calls
using explicit temporaries causes the compiler to inline all of the
calls. [multi-dot-call-inline-last]
3. When a system is finalized with `inlining (yes)', a routine which
contains only an assignment of a formal argument to a local is
inlined. The inlined code that is generated contains an RTAR macro
call, while the code generated for the routine that was inlined
does not. The RTAR call appears to be unnecessary.
[inline-extra-rtar]
======================================================================
Known library class bugs
------------------------
1. A call to UNIX_FILE routine `readchar' violates precondition
`is_readable' of `readchar' when the file is in fact a pipe.
Actually, now `is_fifo' does not work properly. [pipe-not-readable]
2. Calling `fill' in LINKED_LIST with a 20000 element ARRAY takes
approximately 4 minutes of CPU on a SPARC 10 when code is frozen
and `assertion (no)' is specified. This is so slow that `fill' is
useless for filling a LINKED_LIST from a container with a large
number of elements. [slow-linked-list-fill]
3. Routine `append' in UNIX_FILE has a precondition which is not
sufficient to guarantee that the routine can do its job.
[unix-file-append-weak-precond]
4. Routines `has' in CONTAINER and `grow' in RESIZABLE need stronger
preconditions. Currently, the weak preconditions they have result
in descendant routines which have incorrect preconditions
(involving `require else Precursor: True'). [precursor-true]
5. Routine `copy_to' in FILE does not work correctly if file which is
target of call is not positioned at beginning of file.
[file-copy-to]
======================================================================
Fixed bugs
----------
1. Class with no leading white space at all no longer causes VD10
violation to be reported. [no-leading-white-space]
2. Bit constants with uppercase B are now accepted.
[no-upper-bit-constants]
3. Empty Feature_list now allowed in Creation_clause.
[empty-creation-list]
5. Correct position is reported for syntax error in class even if
there are manifest strings preceding the position of the error.
[syntax-wrong-positions]
6. Empty Rename_list in inheritance clause is now accepted, instead of
being reported as a syntax error. [empty-rename-list]
7. Empty undefine, redefine and select subclauses are now allowed in
an inheritance clause. [empty-inheritance-clauses]
8. Program which allocates 1 MB string, 2 MB string, etc no longer
dies with run-time panic. [big-strings]
9. Class TEXT_O, feature is_read_only no longer violates VUAR.
10. Sequence of changes involving inheritance and unique attributes no
longer causes violation of precondition index_small_enough in
ARRAY put. [inherit-index-small-enough]
11. Creation "procedures" which are actually functions are now
correctly rejected as violating VGCP. [creation-proc-function]
12. Operator features are now forced to start with one of the four
allowed characters and cannot be completely empty (but invalid
characters are still allowed). [empty-free-operator]
13. Compiling a system, adding `class' to the indexing clause and
recompiling no longer causes report of syntax error. Instead, it
causes VD20 violation to be reported. [class-name-confusion]
14. A class with a feature which is both frozen and deferred no longer
causes an exception trace. Instead compiler correctly reports
violation of VFFD. [frozen-and-deferred]
15. An operator feature (infix or prefix) whose name is not all in
lowercase can now be called. Also, multiple declarations of the
same operator feature in the same class , differing only by case,
are no longer accepted. [case-sensitive-feature]
16. Violation of precondition `has_a_new_name' seems to be fixed.
[violate-has-a-new-name]
17. A violation of the Expanded Type rule is detected. When the
problem is fixed by removing the declaration of the offending
feature, compiler no longer dies later when it starts freezing the
system. [expanded-type-violation]
18. A creation instruction with an explicit creation type which is
expanded (violates constraint VGCC3) is now detected.
[invalid-creation-instruction2]
19. Classes which are invalid due to the actual generic parameter not
conforming to the formal generic parameter no longer cause an
exception trace. [invalid-actual-generic]
20. An empty Debug_key_list is now allowed in a Debug instruction.
[empty-debug-key]
21. A Multi_branch which does not include the optional When_part_list
is now accepted. [empty-when-part-list]
22. An actual generic parameter which is invalid (because it is a
generic derivation of a class which is *not* generic) is now
correctly reported as a VTUG violation, instead of causing the
compiler to die with an exception trace. [invalid-actual-generic2]
23. An actual generic parameter which is invalid (because it is itself
a generic class but no actual generic parameters are supplied) is
now correctly reported as a VTUG violation, instead of causing the
compiler to die with an exception trace. [invalid-actual-generic3]
24. An actual generic parameter which is invalid (because it is itself
a generic derivation but too many actual generic parameters are
supplied) is now correctly reported as a VTUG violation, instead
of causing the compiler to die with an exception trace.
[invalid-actual-generic4]
25. A complicated invalid generic derivation for an actual generic
parameter is now correctly reported as a VTUG violation, instead
of causing an exception trace after all pass 5's have completed.
[invalid-actual-generic5]
26. Occurrence of the predefined entity `Result' in a precondition is
now detected as a violation of the Entity rule. [result-in-precondition]
27. A system has a class which violates the Select Subclause rule
(same feature name appears twice). The compiler detects the VMSS
violation. Changing the inheritance structure and then hitting
return at the "Another compilation needed..." prompt no longer
causes an exception trace. [invalid-select-change]
28. A violation of the assignment rule in an inherited class is
correctly detected. When the client structure is modified by
removing two local declarations from the inheriting class and
is pressed to retry compilation, the VJAR violation is
reported instead of the compiler dying with an exception trace.
[assign-rule-client-change]
29. A class TEST has an entity of type TEST1 (non-BOOLEAN) as the
Boolean_expression in a conditional instruction. The compiler
correctly detects the VWBE violation and reports it. Removing an
inheritance clause from TEST1 and hitting return to retry the
compilation no longer causes the compiler to skip some passes on
both TEST and TEST1. It instead correctly reports the VWBE
violation again. [inherit-chg-skip-pass]
30. Compiling two classes fully, adding an inheritance clause to each
(one with an error) and then removing one of the newly added
inheritance clauses when the compiler correctly reports violation
of VDCC no longer causes the compiler to die with an exception trace.
Instead, it correctly reports the VDCC violation again.
[precond-valid-cursor-index]
31. A generic class constrains its single formal generic parameter to
conform to DOUBLE. A class which inherits from this class twice
with actual generic parameters of REAL and DOUBLE now gives the
correct output. [real-conform-double]
33. A Multi_branch with an Else_part whose Compound is empty no longer
triggers an "Unmatched inspect value" exception.
[multi-branch-empty-else]
34. A Multi_branch instruction with an interval now executes correctly
after melting. If the value of the inspect expression falls
within an interval, an "Unmatched inspect value" exception is no
longer triggered. [multi-branch-interval]
35. A Conditional with a true boolean expression and an empty Compound
in a Then_part now correctly does nothing (after melting), instead
of executing the "else" part of the conditional.
[conditional-empty-then]
36. A routine violates the precondition of a routine it calls. The
calling routine has a rescue clause. System execution no longer
ends with a PANIC and core dump after less than 500 attempts.
Instead it appears to keep running indefinitely, as it should.
[repeated-rescue-panic]
37. A procedure which is a `once' routine is now accepted as a
creation procedure. [creation-once-routine]
38. If the compiler discovers a validity violation on the root class class
(at least in pass 3) and stops and then the name of the root class is
changed so that it is the same as the name of another class in the
cluster, it no longer causes an exception trace. Instead, VSCN
violation is correctly reported. [cluster-modified-viol]
39. A particular root class has a validity violation discovered in
pass 3. If when the compiler stops the name of the root class is
changed so that it is different (but the class is left in the same
file so that file name root and class name do not match), but the
new class name does not match the name of any other classes in the
universe, it no longer causes an exception trace.
[chg-class-to-nonexistent]
40. An attempt to assign an entity declared of a BIT type to an entity
declared of type ANY no longer results in violation of validity
constraint VJAR. BIT types have now been implemented.
[bit-any-no-conform]
41. If the root class named in the Ace file cannot be found in the
universe, VD20 violation is reported. Hitting return to retry
compilation no longer causes an exception trace.
[nonexistent-root-class]
42. If a class in the universe has no class header or a malformed
class header, VD10 violation is reported. Hitting return to retry
compilation no longer causes an exception trace.
[missing-class-header]
43. Running es3 on an Ace file with a syntax error and then hitting
return at the "Another compilation needed..." prompt without
changing the Ace file at all no longer results in an exception trace.
[lace-syntax-error-retry]
44. An actual generic parameter `TEST1 [like Current]' does not
conform to a formal generic parameter constrained by `TEST2 [like
Current]'. The compiler detects the violation but dies with an
error trying to report it. [invalid-actual-generic6]
45. A boolean operator (and, or, and then, or else, xor, implies, not)
whose first operand is a constant True or False no longer causes
an exception trace. [const-and-boolean-op]
46. According to page 518, letter case is not significant for strings
in an Ace file which do not refer to outside elements and the
compiler now implements this correctly. [lace-string-case]
48. An Ace which is (presumably) invalid because the Class_name in the
Root part of the Ace is empty (the Manifest_string "") no longer
causes an exception trace. [lace-invalid-root-name]
49. An Ace which appears to be valid and which has a Option_clause in
the Defaults paragraph that lacks an Option_mark no longer causes an
exception trace. [lace-no-option-mark]
50. Options which do not exist (and are therefore presumably invalid)
in the Default section of an Ace now elicit a warning from the
compiler. [lace-nonexistent-options]
51. The class name which is an empty Manifest_string ("") as the first
name of a Class_rename_pair in Rename in an Ace no longer causes
an exception trace. [lace-null-class-name]
52. A class name which is an empty Manifest_string ("") in the
Target_list of an Option_clause in an Ace no longer causes an
exception trace. [lace-null-class-name2]
53. An Ace with an Externals section which has a non-existent Language
now elicits a warning from the compiler. [lace-bogus-ext-lang]
54. A class name which is an empty Manifest_string ("") in the Visible
of a Cluster_properties in an Ace no longer causes an exception
trace. [lace-null-class-name3]
55. Debug instructions which have a parenthesized list of debug keys
following the keyword `debug' are now executed when the Ace
specifies `debug (yes)'. [debug-with-keys]
56. A compilation is started, but the compiler correctly reports a
VSCN validity violation because there are two supplier classes
TEST1, each in a different cluster. If one of the clusters is
removed from the Ace completely, the compiler now proceeds instead
of just issuing the same VSCN error message. [lace-remove-cluster]
57. A class with debug statements with various combinations of debug
keys "1" and "2" executes the correct statements when compiled
with Ace specifying `debug ("1")'. It now also executes the
correct debug statements when this is changed to `debug ("2")'.
[change-debug-option]
58. After compilation, freezing and finish_freezing, a system prints
`true' when executed, which is correct behavior. When an
`io.new_line' line is removed and es3 is rerun, the resulting
system now still prints `true' instead of printing `false'.
[wrong-real-arithmetic]
59. A call `print (True)' or `print (False)' now works as expected,
instead of producing no visible output. [bool-const-no-output]
60. The C code generated for class HASH_TABLE (a very unique case)
no longer has to be corrected by hand before it will compile.
61. Finalizing a system (producing a final executable which contains a
copy of the run-time system and can be run on its own) now works.
[finalize-appl]
62. Compiling a system and then changing an inherited class so that it
is deferred causes a bogus VD27 error. [deferred-feature-call]
63. Compiling a class with an attribute whose type is anchored and
whose anchor has an expanded type works. Changing the anchor to a
constant and recompiling no longer causes an exception trace.
[expanded-anchor]
64. Changing an inherited class from non-generic to generic and then
recompiling no longer results in an exception traceback. Instead,
the compiler correctly reports the VTUG violation.
[nongeneric-to-generic]
65. Compiling a system where A inherits an effective feature from B
and undefines and redefines it works fine. If the feature in B is
changed to a deferred feature and es3 is rerun, the compiler now
correctly detects the violation of VDUS3 (Undefine Subclause
rule). [undefine-subclause-violation]
66. A small system compiles fine. When the type of an argumentless
function is changed from BOOLEAN to INTEGER, thereby violating
validity constraint VWBE, the violation now is detected.
[non-boolean-exit]
67. Compiling a system and then removing the creation procedure (which
is called) from one of its classes causes a violation of the
Entity Rule. The violation is detected and the compiler no longer
dies while reporting it. [entity-rule-violation]
68. Compiling a system and then making a particular sequence of
changes no longer causes the compiler to report a violation of the
Feature Name rule (VMFN), when in fact the error is violation of
VCCH on page 51. [misleading-vmfn-error]
69. A particular system is compiled, finish_freezing is done and the
system executes correctly. Then all instructions are deleted from
the body of the root creation procedure and es3 is rerun. The
compiler no longer does just pass 1 on class TEST and no longer
gets an exception trace when it is run again. [time-checker-error]
70. A system is compiled and frozen. Then a new feature with a
violation of the Entity rule is added. The compiler correctly
detects the violation and when it is corrected by adding an
inheritance clause, the Assignment rule violation that is thereby
introduced is now detected. [intro-assign-rule-viol]
71. A once function now returns the same value on the second call as
it does on the first call, after melting, [once-function-void]
----------------------------------------------------------------------
72. Adding an export restriction which causes a validity violation
after compilation and then recompiling no longer causes an
exception trace. Instead, compiler correctly reports the VUEX
violation. And now, when I hit return to retry, the compiler
still reports the VUEX violation instead of processing the class
without complaint. [vuex-violation]
73. A valid class compiles fine. An assignment to an anchored local
entity becomes invalid when the type of the anchor is changed and
es3 now detects the VJAR violation on recompile.
[invalid-local-entity-assign]
74. A particular sequence of changes no longer causes a compiler error
and violation of precondition `good_cluster'. Instead, the
introduced syntax error is correctly reported. [precond-good-cluster]
75. If a client A of a class B has a valid creation instruction to
create an instance of B, and B is then modified so that the
creation instruction in A is no longer valid, the error is not
detected. [creation-instruction-sneak]
76. Compiling a system whose root class has a formal generic parameter
causes the compiler to correctly report the VSRC violation.
Removing the formal generic parameter from the root class and
resuming compilation no longer causes an exception trace.
[generic-root-to-nongeneric]
77. Compiling a system whose Ace specifies creation procedure `make'
when the root class has no creation procedures causes the compiler
to correctly report a validity violation (VD27). When the
creation procedure specification is removed from the Ace, the
compiler now continues with the compilation instead of continuing
to report violation of VD27. [lace-remove-creation-proc]
78. According to page 245, letter case is not significant for a
Debug_key. A debug instruction with key "WEASEL" is now
executed when the Ace specifies `debug ("weasel")'.
[debug-keys-case-sensitive]
----------------------------------------------------------------------
79. A class with "identifiers" used as feature names which start with
underscore ("_") are no longer accepted. Previously, all the
leading underscores in such names seemed to be ignored.
[invalid-identifier]
80. According to page 120, an Assertion_clause is an optional Tag_mark
followed by an Unlabeled_assertion_clause. When the
Unlabeled_assertion_clause is a Comment, a preceding tag is
no longer rejected as a syntax error. [comment-assertion-with-tag]
81. In many contexts, the following characters are no longer
completely ignored: ~ % ? ` \ _ (tilde, percent, question mark,
backquote, backslash, underscore). Instead the compiler correctly
reports a a syntax error. [invalid-characters]
82. A class with a deferred feature but no "deferred" header mark is
now correctly reported to violate VCCH, instead of the
undocumented validity code VDCC. [deferred-feature-bad-header]
83. A routine with an invalid redefine subclause (references old
feature name) in inheritance clause is no longer accepted.
[invalid-redefine-subclause]
84. An inherited feature is renamed via a Rename subclause and the
compiler no longer accepts references to the old name in the
New_exports, Undefine, Redefine and Select clauses.
[old-name-inherit-clauses]
85. An assignment whose source appears to conform to its target
according to the definition of General Conformance is no longer
rejected as a violation of the Assignment rule (VJAR).
[general-conformance]
86. According to condition 1 of constraint VAOL on page 124, an Old
expression is not valid outside a postcondition. The compiler no
longer accepts an Old expression in a precondition.
[old-in-precondition]
88. Deleting an inheritance clause after compiler reports validity
violation and then retrying compilation no longer causes an
exception trace. [delete-inheritance]
89. Compiling a class, then removing an inheritance clause no longer
causes the exception trace "not_empty precondition violated in
make_byte_code". [melt-inherit-bug]
90. Changing the number of formal generic parameters in an inherited
class which is already generic no longer results in an exception
traceback. [change-generic-parm-count]
91. Violation of the Expanded Client rule (VLEC) is detected. When
the problem is corrected by removing the offending feature and
compilation is resumed, the compiler no longer dies later.
[expanded-client-violation]
92. Compiling a class and then introducing a violation of the Local
Entity rule VRLE1 by changing the name of an attribute to match
the name of a local of one of the routines no longer causes the
violation to go undetected. [local-entity-violation]
93. Compiling a class TEST which declares an attribute of type TEST
but is not an expanded class works fine. Changing the class to an
expanded class and rerunning es3 results in an undetected
violation of the Expanded Client rule (VLEC).
[hidden-expanded-client]
94. Compiling a system and then introducing a violation of the
Expanded Type rule in a particular manner no longer causes the
violation to escape detection by the compiler.
[expanded-type-hidden]
95. Introducing a type error by modifying the types of inherited
attributes and then fixing the error causes the compiler to not
recognize that the error has been corrected.
[add-delete-type-error]
96. Removing one of the formal generic parameters from a generic class
no longer causes the compiler to accept it as valid, when another
class now has an entity with the wrong number of actual generic
parameters. [generic-deriv-slide]
97. A procedure which prints out some real and double constants
executes correctly after first compile and freezing now also
prints them correctly after melting. [real-double-print]
98. A known sequence of changes no longer causes a system
execution-time PANIC with "unknown entity type".
[unknown-entity-type]
99. A class with a VUAR violation is compiled and the compiler detects
the error. When the type of the actual argument is changed to fix
the error and compilation is resumed, the compiler no longer dies
with an exception trace. [fix-vuar-error]
100. A trivial system compiles fine. When the Ace is changed to
indicate a different root class which is almost identical to the
original root class, but has one inheritance clause, the compiler
no longer dies with an exception trace while refreezing the system.
[freezing-good-type-id]
101. A correct system compiles fine. Then the generic constraint in
an inherited class is changed. The compiler correctly detects
the VTGG violation. When the generic constraint is changed back
to its original form, the compiler now accepts the correct class
instead of reporting a VD27 violation. [chg-generic-constraint]
102. A class with an external routine (which happens to be the root
creation procedure) compiles fine. When the routine is changed
to an internal routine with three different declarations for the
same local, the compiler detects the VREG violation. When the
error is corrected and compilation resumed, the compiler no
longer dies with an exception trace. [remove-external-routine]
103. A class with an internal routine compiles fine. When the
internal body is replaced by an external body and the system is
recompiled, a compiler exception trace no longer occurs.
[refreeze-table-size]
104. In a class which has an inheritance clause with a parent based on
a generic class, replacing the actual generic parameter with a
more complicated one and recompiling no longer causes an
exception trace. [inherit-generic-more-complex]
105. A particular sequence of changes no longer causes a segmentation
fault in routine `make_update' while melting changes.
[melting-make-update]
106. A class which redefines an inherited deferred feature and
introduces two new declarations for it (one deferred and one
effective) no longer causes an exception trace.
[invalid-feature-redeclaration]
107. Compiling a system where A inherits from B and B has an attribute
of type `expanded A' no longer results in an an illegal
instruction. Instead, the VLEC violation is reported.
[expanded-client-inherited]
108. Violation of the Expanded Client rule (VLEC) in a class is
detected and retrying the compilation by hitting return without
changing the offending class no longer resumes the compilation.
Instead, VLEC is reported again. [expanded-client-death]
109. Class with a loop invariant no longer causes exception trace with
violation of precondition of `generate_workbench_tes'.
[make-byte-code-void-ref]
110. A certain class no longer causes an exception trace in the
compiler during freezing. Previously it did, and adding the
following line to the only feature in the class and compiling
from scratch prevented the error from occurring:
io.putstring ("In violate_loop%N");
[unknown-problem]
111. A class with a constant attribute of type REAL or DOUBLE whose
value is negative (e.g. -.54) no longer causes a run-time PANIC
in the compiler. [real-const-attr-panic]
112. A class with a single procedure with an empty body which has 125
locals of type STRING no longer causes the compiler to die with
an exception trace. [many-locals]
113. A generic class which violates the Expanded Client rule
(constraint VLEC) no longer causes a compiler exception trace.
Instead, the VLEC violation is reported.
[generic-expanded-client]
114. The compiler now accepts an Ace without the optional Cluster_mark
part of a Root. [lace-opt-cluster-mark]
115. The possible values for option `assertion' (require, ensure,
invariant, loop, check, all) are no longer accepted as values
for the `collect' option. Then again, the collect option does
not seem to be implemented. [lace-invalid-collect-values]
116. Validity constraint VDOC on page 526 is enforced - the option
`collect (no)' is not accepted in a Cluster-level Defaults
clause. Then again, the collect option does not seem to be
implemented. [lace-cluster-level-collect]
117. An Ace with a Generation section which has a non-existent
Language now elicits an error message from the compiler.
[lace-bogus-gen-lang]
118. The Lace `assertion' option now works correctly. [lace-assertion-option]
119. Compiling a system without a precompiled cluster and then
removing a particular cluster from the Ace file and recompiling
violates VTCT, which compiler correctly reports. Adding the
cluster back in the Ace file and hitting return causes compiler
to resume, and it dies with an internal error. [lace-remove-cluster2]
120. A particular system compiles fine. Four clusters are removed
from the Ace and the compiler detects and reports the VTCT
violation. When the clusters are added back to the Ace and
compilation is resumed, it no longer causes a pass 2 exception
trace. [whip-that-ace]
121. Error messages (such as VSCN error) no longer have bad
formatting, with \n and \t strings. [bad-VSCN-format]
122. Obsolete clauses now causes warning messages to be issued.
[obsolete-warning]
123. Concatenation of a manifest array of BIT constants now prints out
correctly. [concat-manifest-bit-array]
----------------------------------------------------------------------
124. A type with zero generic parameters (e.g., GENERIC []) is reported
as a syntax error. [generic-zero-parms]
125. Semicolons are not optional in the places where they should be.
[semicolons-not-optional]
126. The assignment `b := 0 = 0 = True' is rejected as a syntax error.
[zero-equals-zero]
127. Some things ETL says are OK are called syntax errors by the
compiler. All related to string, character, integer and real
constants. [syntax-disagreements-1]
128. If a Creation_clause has a non-empty Clients part and an empty
Feature_list, it is reported as a syntax error even though it
conforms to the syntax on page 285. [creation-client-no-feats]
129. A strip expression with no attributes in its parenthesized
attribute list (strip ()) is reported as a syntax error.
[empty-strip-expression]
130. A manifest array with no expression in its list (<< >>) is
reported as a syntax error. [empty-manifest-array]
131. A declaration introducing an attribute whose type is a Bit_type
appears to be valid, since the Constant is of type INTEGER and has
a positive value (VTBT on page 210). But the compiler reports a
syntax error. [bit-type-with-plus]
132. A class with an Indexing part which has a completely empty
Index_list (no Index_clause's) should be legal according to page
49. But the compiler calls it a syntax error. [empty-index-list]
133. A generic class with a single formal generic parameter which is
constrained by `expanded TEST', which is not a Class_type, is
accepted by the compiler. [invalid-generic-constraint3]
134. A routine with postcondition `ensure (old (old n)) > 0' violates
constraint VAOL, but is accepted. [invalid-use-of-old]
135. A bit type which is `BIT 0' violates VTBT, but is accepted.
[invalid-bit-type]
136. A constraint on a formal generic parameter which is syntactically
illegal (and not even meaningful anyway since it references a
non-existent entity) is accepted by the compiler when all generic
derivations use the actual generic parameter NONE.
[illegal-formal-generic]
138. A violation of condition 2 the Expanded Type rule (VTEC) is not
detected, but only if the expanded type is introduced by by a
declaration of the form `expanded CT'. [expanded-type-violation2]
139. A generic class with a single formal generic parameter which is
constrained by the invalid Class_type ARRAY (actual generic
parameter missing) is accepted by the compiler.
[invalid-generic-constraint2]
140. A violation of export validity (constraint VUEX on page 368) which
involves a qualified call that is an operator expression (instead
of being in dot notation) is not detected. [export-validity-viol]
141. Compiler accepts a generic derivation which is invalid because the
class on which it is based is not a generic derivation. This only
seems to happen when this base class is a basic class (INTEGER,
REAL, DOUBLE, CHARACTER, BOOLEAN, POINTER). [basic-type-generic-deriv]
142. A valid feature rename in an inheritance clause (x ==> y, y ==> z)
is not accepted. [valid-feature-rename]
143. A Redefine subclause which lists a feature name which is `once'
routine in the parent class causes the compiler to complain about
violation of VDRS, regardless of whether the new declaration is a
`once' routine. [valid-once-redefine]
144. An attempt to list a `once' routine in an Undefine inheritance
subclause causes the compiler to report violation of validity
constraint VDUS. [valid-once-undefine]
145. A class which violates VDRD7 (Redeclaration rule) is not accepted
by the compiler, but the validity constraint code reported is not
VDRD7 but VE01, which is undocumented. [redecl-violation]
146. A violation of the Entity rule (VEEN) involving the predefined
entity `Result' is incorrectly reported by the compiler as a
violation of the Local Entity rule (VRLE). [local-entity-wrong-error]
147. The compiler correctly detects a VUAR violation, but reports it as
`Error VUAR2 (VUAR2)' instead of `Error VUAR (VUAR2)'.
[vuar-called-vuar2]
148. The compiler correctly detects a VTUG violation, but reports it as
`Error VTUG3 (VTUG3)' instead of `Error VTUG (VTUG3)'.
[vtug-called-vtug3]
149. After initial compilation, a VSCN violation is introduced. The
compiler detects the violation, but when return is pressed to
resume compilation the compiler proceeds instead of reporting the
VSCN violation again. [vscn-sneak]
152. After initial compilation, a boolean variable referenced in the
expression of a conditional is changed to an integer constant. The
compiler detects the VWBE violation. But when the declaration is
moved to a parent class, the compiler accepts the classes even
though the VWBE violation is still present. [vwbe-sneak]
153. After initial compilation, an attribute which is a string constant
is changed to a variable attribute of another type, thereby
introducing a VUAR violation. The compiler detects the violation,
but when return is pressed it continues with the compilation even
though nothing has changed. [vuar-sneak]
155. After initial compilation, an attribute is deleted, which
introduces a VEEN violation. The compiler reports the violation,
but when return is pressed it proceeds with and finishes
compilation, even though the violation is still there. [veen-sneak]
156. After initial compilation, an Expanded Type rule violation (VTEC)
is added. When the compiler detects the violation, the creation
clause is removed from the class which is being declared expanded
by the client, thereby removing the violation. But the compiler
still reports a VTEC violation. [vtec-compiler-wrong]
157. After initial compilation, the entire text of a class A is deleted
and the system is recompiled. The compiler correctly reports the
VD10 violation. But when compilation is resumed with no change to
any files, the compiler reports a syntax error at position 0 on
class A, though there is still no class A. [vd10-becomes-syntax-error]
158. When a system is compiled and then a violation of the Expanded Type
rule is introduced, the compiler detects the VTEC violation. But
when the offending class is returned to its original state (thereby
removing the violation) and compilation is resumed, an exception
trace results. [expanded-deferred-exception]
159. When one of the formal generic parameters is removed from a generic
class the compiler detects the VTUG violation thereby introduced.
But resuming the compilation with no change to any classes results
in an exception trace. [vtug-retry]
160. A root class with one formal generic parameter is correctly
reported to violate VSRC. When a 2nd formal generic parameter of
the same name is added, the newly introduced VCFG violation is
detected but the compiler dies with an exception trace while trying
to report it. [generic-root-vcfg]
161. A system compiles fine. Adding a feature to a generic class A
which references a new class B where B inherits from A and then
recompiling causes a compiler exception trace. [pass4-melt-exception]
162. Changing a deferred function to a constant attribute after initial
compilation and recompiling causes a compiler exception trace.
[deferred-to-const-attr]
163. After initial compilation, changing an actual generic parameter
from one expanded type to a different expanded type and
recompiling causes a compiler exception trace while melting
changes. [chg-expanded-actual-generic]
164. After initial compilation, the name of an attribute in an
inherited class is changed, thereby introducing a VHRC violation.
The compiler detects the violation, but when it is removed by
deleting both the attribute and the rename clause in the heir and
compilation is resumed, the compiler dies with an exception trace.
[cannot-update-types]
165. After initial compilation, a VWOE violation is introduced. When
the system is recompiled, the compiler detects the violation but
correcting it by returning the class to its original state and
resuming leads to a compiler exception trace. [intro-vwoe-precondition]
166. After initial compilation, a VWOE error is introduced in the class
invariant. When the compiler complains, the entire class
invariant is deleted and compilation is resumed. This causes a
compiler exception trace. [change-delete-invariant]
167. An `old' expression in a manifest array in a postcondition causes a
run-time panic (illegal metamorphose type), but only after melting.
[manifest-array-with-old]
168. A routine with precondition `false' is redefined with alternative
precondition `true' in a descendant. When the system is compiled
via melting both classes, system execution results in a
precondition violation (which is wrong). When the same system is
frozen and executed, there are no precondition violations.
[chained-assertion-melt]
169. A class which assigns a bit constant to a local and writes it out
compiles fine, but does not write anything out when executed.
[bit-out-wrong]
170. In certain cases, the functions `bottom_int_div' and `up_int_div'
in class BASIC_ROUTINES give the wrong results. [wrong-int-div]
171. The standard binary operator infix "+" should have lower precedence
(7) than a unary free operator (11), according to page 377, but it
does not. [plus-before-free-unary]
172. Binary free operators should have higher precedence than all other
binary operators, but they have lower precedence than most binary
operators. [free-binary-wrong-precedence]
173. All default initializations are supposed to be applied before the
creation procedure (if any) is called. In the case of nested
sub-objects, the creation procedures are called in the wrong
order. [expanded-creation-order]
175. A system which seems to be correct concatenates and prints the
strings of a manifest array many times, but eventually dies with an
exception trace. The trace indicates that the array of string
passed to the `concat' function contained a void reference, which
appears to indicate a compiler or run-time system bug, since the
actual argument is a manifest array with 3 elements which all look
like they can not be void. [manifest-array-concat]
176. Compiling a system with inheritance cycle results in an exception
trace. [add-inheritance-cycle]
177. A root class which does not contain the root creation procedure named
in the Ace causes an exception trace. [remove-root-creation-proc]
178. A constrained generic class which is syntactically illegal because
the constraint is `like Current' causes no complaints in pass 1 or
pass 2. But when es3 does pass 2 on the class which inherits from
the illegal class, it dies with an exception trace.
[like-current-generic-constraint]
179. A generic class with a single formal generic parameter which is
constrained by a class with an invalid actual generic parameter
(`STRING [STRING]') causes an exception trace.
[invalid-generic-constraint]
180. A generic derivation of a generic class with a constraint which is
a BIT type with (what looks like) a constant attribute expressing
the number of bits in the BIT type causes a compiler exception
trace. [bit-constraint-with-attr]
181. A class with the keyword `class' in the indexing clause causes the
compiler to get confused about what the actual name of the class
is and causes an exception trace when introduced after initial
compilation (equivalent to changing class name, apparently).
[class-name-confusion]
182. A violation of the Expanded Client rule (VLEC) is not detected
when it involves two classes, neither of which inherits from the
other. The compilation is terminated by an illegal instruction
after pass 5. [expanded-client-cycle]
183. Certain invalid es3 command line options cause an exception trace,
instead of printing an error message like "class not in system".
They are:
es3 -senders BAD_CLASS BAD_FEATURE (if class not in system or
no such feature in class)
es3 -fs BAD_CLASS (if class not in system)
es3 -descendants BAD_CLASS (if class not in system)
184. A class with many formal generic parameters (512) which all have
the same name causes the compiler to end with "illegal
instruction". [many-same-generics]
185. Renaming a feature to itself in an inheritance clause causes infinite
loop in compiler. [rename-feature-to-self]
186. A comment at the beginning of a class causes an infinite loop when
taking the flat-short form of the class. [flat-short-infinite-loop]
187. A class which inherits twice from one parent and simply renames
the single inherited feature both times appears to be valid, but
the compiler says it violates the Repeated Inheritance
Consistency constraint (VMRC). This was never really a bug - I
just didn't fully understand the notion of "potential version".
[repeat-inher-vmrc-violation]
----------------------------------------------------------------------
188. Trying to get the flat form of a particular class whose first
feature is secret and which has a second (generally available)
feature causes an infinite loop. [secret-feat-flat-loop]
189. A class with a multiple declaration which includes both an
immediate feature and an inherited feature uses assertion
redeclaration. A system with the class executes correctly, but the
flat and flatshort forms are incorrect. [wrong-flat-flatshort]
190. Trying to get the flat form of a particular class causes an
infinite loop, which eats up more and more memory.
[flat-loop-eat-memory]
191. Doing `es3 -flat two_way_circular' causes an exception trace.
192. Starting ebench, selecting a project directory for a new project
and then clicking on the `Run' icon causes ebench to die with an
exception trace. Starting a class tool before compilation of a
new project and typing a class name into its text field also
causes an exception trace. [run-new-project]
193. Various Eiffelbench bugs: part of following feature sometimes
displayed in Feature Tool. `End' missing in routines in flat form.
Cannot grab infix features in Flat form. [misc-eiffelbench-bugs]
194. After changing a class in Eiffelbench and recompiling, a feature
can have the wrong anchor point and the wrong text when it is
dragged into a Feature Tool. [wrong-feature-position]
195. Freezing a system, setting breakpoints and executing the system
via `execute/debug' works correctly. When the system is melted
(with no change to class texts or the Ace) and the same Feature
Tool is used to set breakpoint and execute, the system being
executed dies with a run-time panic. [melt-debug-panic]
196. When the debugger reaches a breakpoint set on a routine which has
locals, it seems to stop but the display of the breakpoint
information in the Project Tool flashes by and then is invisible.
[debug-locals-flash]
197. For certain syntax errors, the correct line number is printed but
the arrow showing the position of the error points to the wrong
character. The position shown is wrong if the white space before
the incorrect token is composed of tabs, but not if it is
composed of blanks. [leading-tabs-wrong-position]
198. A standard operator name which is not completely in lower case
(has one or more uppercase letters) is not accepted, but it
should be. [std-operator-case-sensitive]
199. Operator features with the wrong number of arguments or results are
accepted. Operator features with invalid names are accepted, such
as infix "| |", infix "& ", infix "&", infix "not".
[bad-infix-feature]
200. An external or deferred routine with local declarations is accepted
without complaint (i.e. constraint VRRR is not enforced).
[invalid-local-rescue]
201. A routine with a formal argument that has the same identifier as
a local entity of the routine is accepted (i.e. constraint VRLE
is not enforced). [local-same-as-formal]
202. A feature rename clause which renames an infix feature to a prefix
feature and *should* be invalid is accepted. [rename-infix-to-prefix]
203. A class which violates the Creation Instruction rule (page 286)
constraint VGCC5 causes an exception trace.
[invalid-creation-instruction]
204. Validity constraint VZAA on page 405 of ETL states that in an
actual argument of the Address form ($arg), `arg' must be the
final name of a feature of the enclosing class which is not a
constant attribute. But the compiler does not enforce this
constraint. [illegal-address-use]
205. A class TEST which violates the Expanded Type rule by declaring
an attribute of an expanded type, where the creation procedure of
the expanded type's base class is secret (not available to TEST)
is accepted by the compiler without complaint.
[expanded-type-avail-viol]
206. An invalid generic derivation (STRING [STRING], which is invalid
because STRING is not a generic class) is accepted by the
compiler, but only when it is used as explicit creation type in a
creation instruction. [bad-generic-deriv-creation-type]
207. A class with a formal generic parameter G constrained by ARRAY
[STRING] declares an attribute of type G. An assignment of one
of the elements of the attribute to the attribute itself violates
the Assignment Rule, but the compiler does not detect the VJAR
violation. Compiler dies. [generic-parm-conform]
208. A system with a root class which is deferred violates the Root
Class rule (VSRC) [as modified by Bertrand following my
suggestion], but is accepted by the compiler. Executing the
system results in a "Create on deferred" exception.
[deferred-root-class]
209. A generic derivation of a class with a constrained formal generic
parameter (using `like Current' as actual generic parameter) is
rejected as violating validity constraint VHPR, but only when
used as a type in an inheritance clause. Hitting return to retry
compilation with no change causes an exception trace.
[valid-like-generic-deriv]
210. A case of repeated inheritance with renaming of the single
inherited feature seems to be valid (according to ETL), but the
compiler reports violation of the Feature Name rule (VMFN).
[valid-repeated-inheritance2]
211. A class with a multi_branch instruction which appears to be
syntactically legal and valid (according to ETL page 239) is
rejected as violating validity constraint VOMB.
[multi-branch-empty-intervals]
212. The free operator infix "@@@" can be declared, but when I try to
use it, the compiler complains that there is no feature
`_infix_@' in class TEST. [op-feat-cant-be-used]
213. The type `TEST1 [INTEGER, ARRAY [INTEGER]' where TEST1 is
declared as `TEST1 [G, H -> ARRAY [G]]' causes a compiler
exception trace. [valid-actual-generic]
214. In some cases, a validity violation involving a construct
enclosing an Entity rule violation (validity constraint VEEN) is
reported, instead of the Entity rule violation, which is the true
cause of the problem. This is misleading and confusing.
[veen-called-other-viol]
215. A call which seems to be export-valid (obeys VUEX) and violates
argument-validity (constraint VUAR) is reported as violating VUEX
instead. [vuar-called-vuex]
216. A BIT type whose length is specified by a constant attribute
which is not an integer correctly elicits a VTBT violation
report, but the compiler also reports a VTAT violation though no
anchored types are used. [spurious-vtat-on-bit]
217. A creation instruction has an explicit creation type which
violates VGCC3. The compiler reports this violation, but also
erroneously reports a VGCC2 violation if the target entity of the
creation is of a type based on a deferred class. [spurious-vgcc2]
219. An `old' expression which would be valid in a postcondition
elicits an incorrect VAOL(2) error report if it appears in a
precondition. [old-in-precond-bogus-vaol2]
220. The expression `old Result' is accepted in a postcondition, as it
should be according to ETL. This was never really a bug. [old-result]
221. An expanded class which has more than one creation procedure in
separate Creation_clause's violates the Creation_clause rule
VGCP(4) but the compiler does not complain. Actually, the
example class does not technically violate VGCP(4), but it
violates the spirit of this constraint since the class will never
be able to be used as an expanded type.
[expanded-multi-creation-procs]
223. Compiling a valid class with a multi-branch and then changing the
type of one of the choices (which is a constant attribute) from
INTEGER to DOUBLE and recompiling causes the VOMB violation to go
undetected. [chg-inspect-const-type]
224. After initial compilation, a class header is changed to make the
class expanded. This introduces an Assignment Attempt rule
violation, but the compiler does not detect it. [vjrv-sneak]
225. After initial compilation, the value of a constant integer
attribute is changed, thereby introducing a VTBT violation. When
the system is recompiled, the compiler does not detect the VTBT
violation. [vtbt-sneak]
226. After initial compilation, a class which is not reachable from
the root is modified so that it has the same name as the root
class. The Ace file does not specify what cluster the root class
is in. When the system is recompiled, the compiler does not
detect the VD29 violation. [vd29-sneak]
227. A system with a VTCT violation is compiled and the compiler
detects it. But when the name of a class is changed so that the
missing class is present and the compilation is resumed, the
compiler still reports the same VTCT violation. [chg-class-name]
228. After initial compilation, the names of two classes are switched.
When the system is recompiled, the compiler reports a VSCN
violation although none is present. [switch-class-names]
229. After initial compilation, the class header of a class which is
part of the signature of a redefined feature is changed so that
the class is expanded. When the system is recompiled, the
compiler reports a VDRD violation although there is no violation.
[vdrd-compiler-wrong]
230. After initial compilation, an Ace file with an include has its
last modification date changed but its contents are unchanged.
When the system is recompiled, the compiler reports a bogus VD09
error. [vscn-compiler-wrong]
231. A generic derivation of a class with a constrained formal generic
parameter (using `like Current' as actual generic parameter) is
rejected as violating validity constraint VHPR when used as a
type in an inheritance clause. Hitting return to retry
compilation with no change causes an exception trace.
[valid-like-generic-deriv]
232. Changing an argumentless function in a class which is repeatedly
inherited to an attribute and recompiling causes an exception
trace. [repeated-func-to-attr]
233. A known sequence of changes causes an exception trace in the
compiler during freezing. Based on the trace, it seems to be
related to external functions. [external-info-exception]
234. A known sequence of changes causes an exception trace in the
compiler during pass 3 type checking. [mystery-bug]
235. A known sequence of changes causes an exception trace in the
compiler during pass 4. [dispatch-unit-exception]
236. After initial compilation, deleting the feature to which another
feature is anchored and recompiling results in a compiler
exception trace. [unsolved-type]
237. After initial compilation, changing the name of the root class in
class text and recompiling causes a compiler exception trace.
Sometimes it seems to notice the VD20 violation (can't find root
class). [chg-root-class-name]
238. A system without a needed cluster is compiled without
precompilation info. When the compiler correctly detects the
VTCT error, the kernel cluster is removed and compilation is
resumed. The VD23 error is detected. But when the kernel
cluster is added back to the Ace, along with the missing needed
cluster and compilation is resumed again, the compiler dies with
an exception trace. [del-add-kernel-cluster]
239. After initial compilation, a constraint is added to an
unconstrained formal generic parameter of a generic class,
thereby introducing a VTCG violation. When the system is
recompiled, the compiler dies with an exception trace.
[add-generic-constraint]
240. A class with a VEEN violation in the invariant is compiled and
the compiler detects the violation. Then the invariant assertion
is deleted and the compilation completes fine. But when the same
invalid assertion is added back into the invariant and the system
is recompiled, an exception trace results.
[delete-add-invariant]
241. Unique attributes added to an existing unique declaration can
sometimes get the same value as an existing unique attribute when
melting is involved. [unique-not-unique]
242. Attributes declared as unique and introduced in the same feature
declaration are supposed to have consecutive values according to
page 266. But deleting a unique attribute and rerunning es3 can
sometimes result in unique attributes which should have
consecutive values, but do not. [unique-not-consecutive]
244. After initial compilation, a class header is modified so that the
class is expanded. The system is recompiled without incident,
but when it is executed, an attribute which is now of an expanded
type does not get initalized properly (creation procedure of
expanded class is not called). [expanded-class-bad-behavior]
245. A class which inherits from itself is correctly reported to
violate VHPR. But when the inheritance clause is removed, the
compiler still reports a VHPR violation although none is present.
[remove-inheritance-cycle]
246. When a secret attribute inherited from another class has its name
changed after initial compilation, the compiler does not detect
the VEEN violation when the system is recompiled.
[rename-secret-attribute]
247. When a VSCN violation is introduced after initial compilation,
the compiler does not detect it. The violation is introduced by
changing the name of an existing class to match the name of a
class in the kernel cluster. [add-vscn-violation]
248. After initial compilation, the type of an attribute is changed
from `TEST1' to `expanded TEST1'. The system recompiles fine,
but when it is executed it dies with a segmentation fault instead
of printing "Weasel". [expand-attribute]
249. Compiling a valid class with a multi-branch which has unique
inspect constants and then changing the value of one of the
choices (which is a constant attribute) from 0 to a positive value
results in an undetected VOMB violation. [chg-inspect-const-value]
250. An `old' expression in a class invariant is correctly reported to
violate VAOL. But when the `old' is removed, the compiler still
reports a VAOL violation. [bogus-vaol]
251. An explicit creation type which is an expanded type violates
VGCC(3), but the compiler does not detect the violation when it
is introduced after initial compilation by changing a class
header to `expanded class'. [vgcc-sneak]
252. A known sequence of changes involving changes to actual generic
parameters of the genericly derived return type of an external
function causes a compiler exception trace.
[change-generic-derived-external]
253. A generic class which violates the Expanded Client rule
(constraint VLEC) causes an infinite loop in the compiler.
[generic-expanded-client2]
254. The division `40 / 5' executes correctly after compiling and
freezing. When the enclosing feature is modified and the compiler
is rerun (presumably causing melting), the system prints the wrong
value (it used to die with a run-time PANIC). [divide-melt-panic]
255. Passing an actual argument which is a reference type to a routine
whose corresponding formal argument is the expanded version of
that reference type compiles fine, but when the resulting system
is executed an exception trace occurs. The exception trace only
occurs when the classes are melted, not when they are frozen.
[ref-actual-expanded-formal]
257. A system does arithmetic with two REAL operands, at least one of
which is a constant and assigns the result to a variable of type
DOUBLE. Executing the system causes a run-time panic with
"illegal cast operation", but only if the routine which does the
arithmetic is melted. [real-const-arith-to-double]
258. An expression which consists of the application of three
different unary operators (free operators in this case) compiles
OK, but after melting the innermost one is called three times
instead of each one being called once. [multiple-unary-free-ops]
259. A procedure which prints out some double constants prints correct
values, but `print' does not print many of the significant digits
(io.putdouble does). [print-double]
260. The call `io.putreal' often does not print the correct value of a
real number when the calling routine is melted. [melted-putreal-wrong]
261. The expression `old Current' is not equal to Current (using `=')
in a routine postcondition, where the routine call is an
unqualified call. [old-current-ne-current]
262. The power operator (infix "^") gives incorrect results for
INTEGERs, REALs and DOUBLEs. [power-operator]
263. A routine with no precondition (i.e., an implicit precondition of
`true') is redefined in a descendant with alternative
precondition `false'. The full precondition of the redefined
routine is therefore `true or else false'. But when the system
is compiled with `assertion (require)' and executed, the
redefined routine's precondition is violated. [redecl-implicit-precond]
265. The routine `readline' in class UNIX_FILE does not work properly
on long lines. The first 256 characters are returned as one
complete line. [readline-long-line-wrong]
266. A class with a `strip' expression compiles fine, but doesn't
execute correctly when frozen - gets a "create on deferred"
exception. (It executes fine when melted). [strip-wont-c-compile]
267. A Strip expression with Void in its Attribute_list is accepted
(and seems to be valid, since Void is a variable attribute of the
class, at least technically). But the generated C code appears
to be incorrect and dies with a run-time panic when executed.
[strip-with-void]
268. A system which seems to be correct concatenates and prints the
BIT constants of a manifest array many times, but eventually dies
with a run-time panic. [manifest-array-of-bits]
269. The argument to the root class creation procedure is not
initialized. [uninit-root-class-arg]
270. Equal dies with a bus error when used with integers or characters
(and possibly other expanded types), as in `equal (1, 3)'.
[int-equal-int]
271. A manifest array used as the target of a feature call causes an
exception trace during compilation (violation of assertion
`has_generics'). [manifest-array-call-target]
272. A manifest array used as the target of a feature call causes an
exception trace during compilation (violation of assertion
`last_type_exists'). [manifest-array-call-target2]
273. An external feature with an alias which is the empty string ("")
causes a compiler exception trace while freezing.
[empty-external-feat-alias]
274. A system has a class which declares a local that is of a
non-basic expanded type and calls a routine on that local. When
the system is finalized, the compiler reports that it cannot
generate C code. [expanded-local-panic]
275. An invalid type (ARRAY, which is invalid because ARRAY is a
generic class but no generic parameter is supplied) is accepted by
the compiler, but only when it is used as explicit creation type
in a creation instruction. [bad-generic-deriv-creation-type2]
276. An Ace which references a precompiled cluster causes an exception
trace if it does not list all the clusters which were
precompiled. [precompiled-missing-cluster]
277. A class with a constant attribute which is of a Bit_type is
reported to violate VQMC if the length of the Bit_constant is not
identical to the length specified in the Bit_type.
[bit-constant-diff-length]
278. A VREG violation involving a formal argument is reported once for
each occurrence of a duplicate argument, but if it involves a
local entity it is reported (number of occurrences - 1 times).
It should be reported once for each duplicate identifier.
[vreg-formal-multiple]
279. Incorrect `what to do' explanation for a VRLE(1) violation.
[incorrect-vrle1-explain]
280. After initial compilation, an actual generic parameter is changed
from `expanded A' to `A'. The system recompiles fine, but
executing it results in a run-time panic instead of the expected
"feature applied to void reference" exception.
[expanded-generic-exec-panic]
281. After initial compilation, an include in the Ace file is
commented out. This change effectively removes the root class
from the universe. But when the system is recompiled, the
compiler dies with an exception trace. [vd20-sneak]
282. A class with header `class TEST1 [G -> TEST1 [REAL]]' which has
no assignments in it causes the compiler to incorrectly report a
VJAR violation and then die with an exception trace in the middle
of reporting the (non-existent) violation.
[generic-constrained-by-its-class]
283. A system with a generic class whose single generic parameter is
constrained by the type `ARRAY [STRING]' causes an exception
trace. [generic-constr-by-generic-deriv]
285. An Ace which includes a file twice (once in an include in a "use"
file and once in an include which appears directly in the Ace)
causes the compiler to incorrectly report a VD09 violation.
[double-include-vscn-wrong]
286. An Ace with no creation procedure specified is accepted, even if
the root class has a creation clause with zero or multiple creation
procedures listed. [lace-no-creation-proc]
287. A Cluster_mark in the Ace indicating which cluster the root class
is in is case-sensitive, but should not be since it does not
refer to an outside element. [root-cluster-case-sensitive]
288. A syntax error in an Ace file sometimes has the wrong position
reported if there are Manifest strings preceding the position of
the error. This bug has been fixed for syntax errors on classes.
[ace-wrong-positions]
289. Non-existent options specified in a cluster-level `default'
clause or in an `option' clause cause the compiler to incorrectly
report a VD36 violation (cluster-level option clause uses
system-level option). [lace-nonexistent-cluster-options]
290. An Ace file with a Use clause in a Cluster_properties causes es3
to die with an exception trace if the Use file has a syntax
error. [lace-use-file-error]
291. An Options_clause in the Options section of a Cluster_properties
which does not have a Target_list causes a run-time panic.
[lace-option-no-target]
292. An Ace with a Cluster_properties containing an Include or Exclude
with a completely empty File_list causes an exception trace.
[lace-empty-include-exclude]
293. An Ace with a `use ' causes an exception trace if the
is one of the following directories: ".", "..", or
"/". [lace-use-file-is-dir]
294. A cluster_adaptation part with an include or exclude which has a
trailing semicolon causes a compiler exception trace. Leading
semicolons and extra semicolons between files to be included or
excluded do not seem to cause this problem.
[lace-include-trailing-semicolon]
296. Removing an unneeded cluster from the Ace and recompiling causes
an exception trace. [remove-unneeded-cluster]
297. When both arguments of the boolean operator `implies' are either
boolean constants (true or false) or local variables, the
generated C code won't compile. [implies-wont-c-compile]
298. According to page 418 of ETL, all characters are significant in
identifiers. This is now true. [not-all-chars-significant]
299. After initial compilation, the Ace is changed to indicate a
different root class, which happens to be a generic class. The
compiler does not detect the VSRC violation. Actually, this was
never really a bug - I just had an error in my test control file.
[validity-vsrc1-new-root]
301. A system with an Ace which specifies NONE as the root class and
also specifies a cluster name (which is supposed to be the
cluster where the root class is found) is accepted without
complaint, even though class NONE does not actually exist and so
is not in any cluster. This was never really a bug: the only
cluster name which is accepted is the one which refers to the
kernel cluster. [root-none-cluster-name]
302. When a VTAT violation is introduced after initial compilation, it
causes the compiler to terminate with an internal error message.
[vtat-sneak]
303. When a violation of VDRD(7) is introduced after initial compilation
by changing an inherited routine with an internal body to have an
external body, the compiler does not detect it. [vdrd7-sneak]
304. A system with a VDRD violation is compiled and the compiler
detects the violation. Then the offending external routine is
deleted and a routine with the same name but a `do' body is added
to the inheriting class. When compilation is resumed, the
compiler dies with an exception trace while freezing the system.
[move-external-make-do]
305. An entity of type `HASH_TABLE [STRING, DOUBLE]' is correctly
reported to violate VTCG. But when the error is fixed by
changing DOUBLE to STRING (which does conform to HASHABLE) and
compilation is resumed, the compiler dies with an exception
trace. [fix-constrained-actual-generic]
306. When a violation of VTEC(2) is introduced after initial
compilation by adding a creation clause with two creation
procedures to the class being used as an expanded type, the
compiler does not detect it. [vtec-sneak]
307. After the compiler detects a VJAW violation, the feature which is
the target of the assignment is changed from an argumentless function
to an attribute. When compilation is resumed, the compiler later
reports that it cannot write the .UPDT file. [cannot-write-updt]
308. An `old' expression in a postcondition references an unknown
identifier. But when the reference to this identifier is
removed, the compiler still reports a VAOL violation. [bogus-vaol2]
309. After initial compilation, a rename subclause of an inheritance
clause is deleted, which introduces a VRFA violation. The
compiler detects the violation, but when the rename subclause is
added back and compilation is resumed, the compiler reports a
bogus VD27 error. [bogus-vd27]
310. After initial compilation, a VCCH(2) error is introduced. When
it is detected, it is removed, which produces a VMFN error. But
when the offending feature is deleted in the inherited class the
compiler reports a bogus VD27 error, instead of the VWOE error.
[bogus-vd27-2]
311. After initial compilation, several infix features of the same
name (differing only by case) are introduced. When the system is
recompiled, the compiler detects the VMFN violations but also
reports a nonexistent VMRC violation. [nonexistent-vmrc]
312. After initial compilation, the name of the single creation
procedure is removed from the creation clause, leaving it empty.
When the system is recompiled, the compiler detects the VD27
violation. Then the creation procedure name is added back but
twice, resulting in `creation make, make'. The compiler detects
the VGCP(3) error but dies with an internal error trying to
report it. [del-creation-proc-add-two]
313. After initial compilation, a class invariant is removed and a
VLEC error is also introduced. The compiler detects the VLEC
error, but when it is removed by making the involved class no
longer generic the compiler dies after pass 3. Note that having
and removing the class invariant is necessary for the failure to
occur. [invariant-expanded-generic]
314. After initial compilation, the type of an inherited attribute
referenced in the invariant of the heir class is changed from
BOOLEAN to INTEGER. When the system is recompiled, the compiler
dies with an exception trace. [chg-invariant-expr-type]
315. After initial compilation, the file with class FINITE (in a local
directory) is deleted. When the system is recompiled, the
compiler detects the VTCT violation. Then FINITE is added back
to the cluster and compilation is resumed. The compiler later
dies with an exception trace. [delete-finite-add-back]
316. After initial compilation, the type of an attribute is changed
from one expanded type to another. System execution should call
the creation procedure of the new expanded class but it does not.
[change-attr-expanded-type]
317. After initial compilation, an inherited variable attribute
referenced in a `strip' expression is changed to a function with
no arguments. When the system is recompiled, the compiler does
not detect the VWST violation. [vwst-sneak]
318. When an inherited constant integer attribute used as the number
of bits in a BIT type which is a formal argument type is given a
smaller value, the compiler does not detect the newly introduced
VUAR error. [vuar-weasel]
319. After initial compilation where the system is frozen, the value
of an inherited constant INTEGER attribute is changed and the
system is refrozen. System execution should print a longer bit
string, but it does not. [chg-bit-length-refreeze]
320. A system is frozen and then executed, producing the correct
output. Then a class which was expanded is modified so that it
is no longer expanded and changes are melted. When the resulting
system is executed, it dies with an exception trace while trying
to create an instance of the now non-expanded class.
[create-chg-to-nonexpanded]
321. After initial compilation, an inherited feature which is
redefined is marked as frozen in the ancestor class. The
compiler detects the violation VDRS violation, but when the
`frozen' keyword is deleted and compilation is resumed, the
compiler reports a bogus VD27 error. [frozen-feat-bogus-vd27]
322. When a small valid class is compiled with `assertion (all)' and
executed, assertion `empty_property' of the invariant of class
UNIX_FILE is violated. [invariant-empty-property]
323. A system has a class TEST1 with 10 attributes of an expanded
type, where the base class of the expanded type does not contain
any attributes (doesn't matter if it has attributes or not).
Repeated creation of instances of TEST1 causes a run-time panic
when executed. [expanded-creation-panic]
324. According to page 130 of ETL, the Expression in a Variant is
valid if and only if it is of type INTEGER. But the compiler
accepts an expression (Void) of type NONE and later reports an
internal error. [void-as-variant]
325. A violation of the Expanded Client rule (VLEC) is not detected
when more than 2 classes are involved in the cycle, at least if
the expansion is done in the attribute declarations rather than
in the class headers. Compilation ends with "illegal
instruction". [expanded-client-3-cycle]
326. A class has a creation instruction whose target is a double
constant with a negative value. The compiler starts reporting a
VGCC(7) error and dies while trying to report it.
[create-negative-double-const]
327. A Cluster_mark in the Ace in an Adaptation clause indicating
which cluster should be adapted is case-sensitive if the name is
enclosed in double quotes, but should not be since it does not
refer to an outside element. The compiler reports a VD03
violation though there is none. [adapt-cluster-case-sensitive]
328. When a system is being finalized and the Ace specifies that the
class STRING should be visible, the `finish_freezing' step fails
due to undefined symbols. [visible-finalize-wont-link]
329. Finalizing a particular system with `assertion (no)' but allowing
dead code removal to be done produces C code which will not
compile. The C compiler reports a parse error near void.
[finalize-void-parse-error]
330. For a class with invariant `0 = 0', the compiler generates C code
which will not compile. [invariant-zero-equals-zero]
331. The C code generated for some bit operations will not compile. I
believe these operations are `not', infix "^" and infix "#".
[frozen-bit-operations]
332. According to page 518 (VDCN) the Cluster_name must be different
for each cluster in an Ace. But an Ace which violates this rule
causes the compiler to report a VD28 error, instead of a VDCN
error. This was never really a bug; since a precompiled cluster
was used, the kernel path name is looked up in the precompiled
cluster to determine the cluster tag, which is `kernel'. Then
two different clusters (kernel and support) have the same path
name. [lace-unique-cluster-names]
334. Void, which is of type NONE (not BOOLEAN or INTEGER) is accepted
as a boolean expression and as an integer expression in some
contexts. According to ETL, it should not be. [void-as-bool-or-int]
335. Validity constraint VHRC(4) is not enforced: a feature with invalid
signature can be renamed to a prefix feature. [validity-vhrc4-basic]
336. Validity constraint VHRC(5) is not enforced: a feature with invalid
signature can be renamed to an infix feature. [validity-vhrc5-basic]
337. Incorrect `invalid assertion clause' listed (precondition instead
of postcondition) for a VDRD(3) violation on a redeclared routine
which uses just `ensure' to introduce its postcondition, instead
of `ensure then'. [wrong-vdrd-assertion-clause]
338. When an inherited constant integer attribute used as the number
of bits in a BIT type is changed to a non-constant (even one of
another type) or a constant of another type the compiler does not
detect the newly introduced VTBT error. [vtbt-weasel]
339. A inherited function of type `like Current' is called from the
inheriting class. The violation of the class invariant at
execution time is reported. However a run-time panic also occurs
when the classes are melted, but not when they are frozen.
[invariant-melt-panic]
340. After initial compilation and freezing, the type of a formal
argument to routine is changed from `TEST1' to `expanded TEST1'
and changes are melted. Since the actual argument is Void, a
"void assigned to expanded" exception should occur when the
system is executed. Instead, execution terminates with "illegal
instruction" and no exception trace. [melted-void-expanded-arg]
341. An anchored type which appears to be valid according to ETL (page
214) causes the compiler to report an internal error and
terminate. The example involves the type `x: ARRAY [like x]'.
[actual-generic-anchor-feat]
342. A class with a declaration `x: REAL is -13' causes the compiler
to report an internal error and terminate. [real-decl-integer-constant]
343. A system has one cluster, initially with only the root class in
it. Each class the compiler says is missing (via a VD23 error or
a VTCT error) is copied into the cluster's directory. The result
is a set of classes which, when compiled from scratch, cause a
compiler exception trace. [minimal-set-of-classes]
344. A system with an attribute whose type is a BIT type with a large
number of bits (2 million) generates C code which won't compile.
Actually, the number of bits can be quite small (5) and the
generated C code still won't compile. [big-bit-attribute]
345. A class which inherits from a generic class and provides a
generically derived type as actual generic parameter has the
wrong flat and flatshort forms. [generic-wrong-flat]
----------------------------------------------------------------------
346. A routine with a precondition which references an entity not
available to all classes to which the routine is available is
accepted (i.e. constraint VAPE is not enforced). ETL page 122.
[invalid-precondition]
347. A routine which is not a redeclaration of another routine has
`require else' and `ensure then' in its precondition and
postcondition. The compiler does not complain. ETL page 152.
Test changed to match clarified language definition, which allows
`require else' and `ensure then' even if routine is not a
redeclaration. [require-else-ensure-then]
348. A reverse assignment attempt `x ?= proc' is accepted, where
`proc' is a procedure. The compiler should report a validity
violation, such as VKCN. If system is frozen, compiler
terminates silently while freezing the system. ETL page 341.
[vkcn-sneak]
349. After initial compilation where the system is frozen, an
attribute is changed from a BIT_REF to a BOOL_STRING and the
instruction which creates it is modified accordingly and changes
are melted. System execution then ends with a run-time panic
which states "invalid assertion level". [invalid-assertion-level]
350. After initial compilation, a Cluster_name in the Ace is changed.
The Ace does not say explicitly which cluster the root class is
in. Nothing has changed, but both classes are recompiled.
[chg-cluster-name-make-work]
351. Finalizing a system whose root creation procedure is an external
routine produces C code which won't link.
[finalize-ext-root-creation-proc]
352. Repeatedly clicking on the system button of the Project Tool
(probably have to do it fast too, but I'm not sure) causes
Eiffelbench to report that it has lost its license.
[click-sys-lose-license]
353. When es3 starts, it reports `version 3.2 level 0'. But the
release I have is supposedly version 3.2.2 so it should report
level 2. [es3-wrong-level-number]
354. A system with a root creation procedure which is an external
routine is finalized. It doesn't link properly, which is a
separate problem that has already been reported. Then the
external procedure is changed to an internal procedure. When the
system is re-finalized ebench dies with an exception trace just
before starting dead code removal. (This problem does not occur
if `es3' is used instead). [ebench-finalize-extern-intern]
355. A system with many calls to a conversion function that interfaces
to sprintf is frozen and then executed, producing the correct
output. Then a single number is changed, causing melting of the
root creation procedure. When the resulting system is executed,
it dies with a run-time panic after several thousand iterations.
Changes to the initial classes which seem quite irrelevant, such
as deleting unused routines (or even deleting the instructions in
the body of an unused routine), prevent the panic from occurring.
[weird-sprintf-melt-panic]
356. An inheritance clause which exports features to a class which is
not in the universe is accepted without complaint (i.e. validity
constraint VLCP is not enforced). ETL page 101.
[class-not-in-universe]
357. A call to deep_clone on a deep object structure (>= 43664 on my
machine) causes system execution to end with "illegal
instruction". This problem is actually caused by stack overflow
in the garbage collector. It can be fixed by using csh command
"limit stacksize unlimited". [very-deep-clone]
358. A system which builds a fairly long linked list compiles fine,
but ends with "illegal instruction" when executed. This problem
is actually caused by stack overflow in the garbage collector.
It can be fixed by using csh command "limit stacksize unlimited".
[long-linked-list-fails]
----------------------------------------------------------------------
359. A valid multi-branch containing another valid multi-branch in one
of its `when' clauses is rejected by the compiler as violating
VOMB(2). The problem only seems to occur when one of the inspect
expressions is of type INTEGER and the other is of type
CHARACTER. First reported by Timur Tabi on comp.lang.eiffel.
[inspect-char-inside-inspect-int]
360. A multi-branch instruction lists an inspect "constant" which is
actually a local variable. The compiler should report a VOMB(2)
error but it instead reports VEEN (unknown identifier) on the
local entity which is non-constant and/or of the wrong type.
[vomb2-called-veen]
361. After initial compilation, a VJAW error is introduced. When the
compiler detects it, the creation clause is removed from the root
class and the cluster mark and creation procedure name are
removed from the Ace. When compilation is resumed, the compiler
detects the VJAW error but terminates silently while trying to
report it. [vjaw-delete-creation-clause]
362. After initial compilation, an attribute listed in a strip
expression is changed to a constant attribute, which elicits a
VWST(1) error report. Then an inheritance clause is added and
the constant attribute is moved to an heir class. The compiler
still reports VWST(1), but terminates trying to display the
feature name. [vwst-cant-find-feature]
363. A system with a root class which has an external routine with an
alias compiles fine and is correctly frozen even if only melting
is requested. Then the Ace is changed to indicate a new root
class, which does not have any external routines. When the
system is recompiled, the compiler terminates silently after pass
5 on the new root class. [external-with-alias-new-root]
364. A system with a class which has an external routine with an alias
compiles fine and is correctly frozen even if only melting is
requested. Then the Ace is changed so that the class containing
the external routine is found in a different (newly added)
cluster with a new cluster tag, but the class text is identical.
When the system is recompiled, the compiler terminates silently
after pass 6 on the new cluster. [ext-with-alias-new-cluster]
365. After initial compilation, an attribute which is the target of a
creation instruction is moved to a parent class and changed to an
external function. The compiler detects the VGCC(7) error. But
when the inheritance clause for the parent is deleted from the
heir and compilation is resumed, the compiler reports a VEEN
error but dies in the middle of reporting it. [veen-cant-find-feature]
366. After initial compilation with a root class of NONE, one of the
clusters is removed from the Ace file. When the system is
recompiled, the compiler terminates silently right after
announcing the compiler version number. [root-none-remove-cluster]
367. After initial compilation, a BOOL_STRING is changed to a BIT_REF.
The compiler correctly detects and reports a VEEN error. But
when the offending line is deleted and compilation is resumed,
the compiler dies during pass 3 on the class with the message
"object allocation: No more memory" or "segmentation fault".
[bool-string-to-bit-ref]
368. After initial melting of a root class whose creation procedure
has an empty body, a local of type LINKED_LIST [STRING] is added
and the routine body is modified to create the linked list and
extend it with one string. The assertion level is `ensure'.
When the system is recompiled and executed, system execution ends
with a segmentation fault in `go_to' of LINKED_LIST.
[ensure-extend-linked-list]
369. The expression `True xor Current /= Void' incorrectly evaluates
to True when code is frozen, but correctly evaluates to False
when code is melted. Compiling the generated C code elicits
compiler warnings such as "illegal combination of pointer and
integer, op !=". This appears to be a precedence problem since
fully parenthesized expressions involving xor produce the correct
result when frozen. [frozen-xor-precedence-error]
370. A pattern of object allocation, resizing and reclamation which
was derived from a simple merge-sort program compiles fine when
it is frozen, but dies with a run-time panic when executed with
certain large values (e.g. 99999). Many other large values do
not cause a run-time panic. [merge-sort-panic]
371. A class with an inheritance clause which renames some inherited
features violates either VHRC(2) or VHRC(3) and also violates
VHRC(1) is not reported as violating VHRC(1). It seems to me
that it should. If `old_name' is not the final name of a feature
of the named parent, then `old_name' is not even valid. This
seems like a more fundamental error than renaming a valid feature
name more than once or renaming a valid feature name to itself.
This was not fixed; I just decided it wasn't really a bug.
[misleading-vhrc2-and-vhrc3]
372. After initial compilation (without using a precompiled library),
the text of the root class is modified to give the class a
different name. When the system is recompiled, the compiler
should report a VD30 error (cannot find root class), but it
instead terminates silently after pass 6 on the root cluster.
The error does not occur if a precompiled base library is used.
[no-precomp-chg-class-name]
373. An expanded class with header `expanded class TEST1 [G -> TEST1
[STRING]]' causes silent termination of the compiler after pass
5. [expanded-generic-constr-by-self]
374. A particular pair of classes which each have two formal generic
parameters and which each have a constraint on one of the
parameters which is a generic derivation of the other class
causes silent termination of the compiler after pass 5.
[generic-constraint-cycle]
375. An effective explicit creation type which inherits from a generic
deferred class causes termination of the compiler during pass 2.
Actually, the parent class does not have to be generic; the
creation procedure invoked in the creation instruction just needs
to be absent in the parent class. [explicit-create-def-gen-parent]
376. A class with header `class WEASEL [G, H -> WEASEL [G, G]]' causes
silent termination of the compiler during pass 5.
[formal-generic-in-constraint]
377. A generic class has a constraint `-> TEST2 [STRING]' on its
formal generic parameter, which is invalid since TEST2 is indeed
a generic class but its formal generic parameter is constrained
by `LIST [STRING]'. The compiler correctly reports a VTCG
violation, but dies while trying to report the name of the class
on which the error occurred. [vtcg-expanded-generic]
378. Finalizing a system whose root creation procedure is an inherited
(rather than immediate) feature produces C code which won't link.
It does not matter whether the Ace includes any `visible' clauses
for the involved classes. Even turning off dead_code_removal
does not help. [finalize-inh-root-creation-proc]
379. A system has an Ace which specifies a nonexistent cluster path.
The compiler correctly reports a VD01 error. But when `q' is
typed to terminate `es3', it says "System recompiled" (which is
definitely not the case). [ace-error-quit-sys-recompiled]
380. Running `es3 -loop' and melting (`I' then `C') works fine. If
there is a compilation error, `Q' correctly returns you to the
`Command =>' prompt of `es3 -loop'. However, a subsequent
attempt to compile via `C' causes termination of es3 with the
message "You have lost your licence". [es3-loop-compile-quit-compile]
381. Under certain (unreproducible) circumstances after a number of
changes, a system has a VOMB(5) error on one of its classes. The
compiler correctly detects and reports the error, but says "No
help available for this error". This bug has been retired because
it is unreproducible. [no-help-for-vomb5]
382. Incorrect C code is generated for a routine which passes the
address of a procedure to an external routine. When the system
is executed, it dies with an illegal instruction. This was never
really a bug; my C routine should have declared the argument
which accepted the procedure address as being of type POINTER
rather than ANY. Of course, the compiler should have caught my
error but did not. [wrong-procedure-address-passed]
----------------------------------------------------------------------
383. An external routine with a non-existent Language_name is accepted
by the compiler without complaint. No constraint prohibiting
this but compiler shouldn't accept it. ETL page 402.
[bad-external-language]
384. An argument of the Address form is of type POINTER. But when the
corresponding formal argument is declared to be of type POINTER,
the compiler rejects the class as violating constraint VUAR(2).
ETL page 405. [addr-args-not-pointer]
385. After initial compilation where the system is finalized, the
types of two local variables are changed so that they no longer
involve expanded types and the system is finalized again. The
resulting C code compiles, but will not link due to an undefined
symbol. [finalize-remove-expanded-type]
386. A generic class with formal generic parameter `G' has a routine
`foo' with a local entity of type `G'. The body of the routine
calls `generator' on this local. Another class inherits from the
generic class and provides an expanded type as actual generic
parameter. When the system is executed, it correctly prints the
local's generating class, but then dies with a panic if the system
was melted. Frozen code works fine. [generic-local-expanded-actual]
387. A class has two functions which each have the same expanded type
as return type. One of the functions just lets Result get set by
the default initializations applied to locals, while the other
one does an explicit creation with Result as target. The two
functions return results which should be equal but are not, but
only if the system is finalized. [finalize-expanded-not-equal]
388. A system has class with a manifest array of STRINGs, one of whose
elements is an expression which is a function call with an
argument that involves another feature call. When the system is
finalized, the generated C code will not compile.
[finalize-manifest-array-call]
389. Finalizing a particular system with a function call whose
argument is a manifest array produces C code which compiles fine.
But when the system is executed, a segmentation fault occurs. If
the system is instead melted or frozen, system execution works as
expected. This appears to be a code generator problem.
[finalize-pass-wrong-argument]
390. A system has one cluster, initially with only the root class in
it. Each class the compiler says is missing (via a VD23 error or
a VTCT error) is copied into the cluster's directory. The result
is a set of classes which, when compiled from scratch, cause the
compiler to report a VEEN error on `default' in feature
`is_hashable' in class HASHABLE. [veen-on-hashable-default]
391. A root class has a single formal generic parameter constrained by
`-> TEST1 [STRING]' where TEST1 is a generic class which is also
expanded. The compiler correctly reports a VSRC(1) error, but
prints "Exception occurred while displaying error message" when
trying to display the name and formal generics of the root class.
[root-expanded-generic-constraint]
392. A system has two classes of the same name, in different clusters.
The compiler correctly detects the VSCN error, but the name
reported for the second file with the same class is incorrect.
It appears to be the name of the class which occurs twice rather
than the name of the second file containing the repeated class.
[vscn-second-file-wrong]
393. A system with a syntax error is compiled. When the error is
reported, the Ace file is deleted or renamed. When compilation
is resumed, the compiler dies with exception tag "No such file or
directory". [delete-ace-resume-compile]
394. A system with a 1000 class deep client dependency chain compiles
fine. But when the root class attribute declaration which links
it to the client dependency chain is cut (thereby removing all
client dependencies) and the system is recompiled, the compiler
dies with a run-time panic. [cut-long-client-chain]
395. A class has an external procedure with no formal arguments and a
call to this procedure, but the C code expects a single argument.
After initial compilation where the system is frozen, a formal
argument of the correct type is added to the procedure and an
actual argument is added to the call. When changes are melted,
system execution produces the wrong output.
[external-procedure-add-argument]
396. After initial compilation, the order of two attributes (which are
each of an expanded type) is switched. After recompilation,
system execution should initialize the expanded attributes in a
different order but it does not. The initial compilation and
recompilation can each be either a melt or a freeze - the problem
occurs regardless. This one was retired, since the order of
evaluation of expanded attributes (if a class has more than one)
is not specified in the language definition.
[switch-expanded-attributes]
397. After initial compilation, a new attribute is added to a parent
of a class containing a `strip' expression. After recompilation,
system execution produces the wrong output (different than the
output of a system compiled from scratch). The initial
compilation and recompilation can each be either a melt or a
freeze - the problem occurs regardless. This one was retired,
since the order of evaluation of expanded attributes (if a class
has more than one) is not specified in the language definition.
[add-attribute-wrong-strip]
398. After initial compilation, the order of two parent classes in an
inheritance clause is switched. After recompilation, alternate
postconditions of an inherited routine should be evaluated in a
different order, but they are not. Same problem for
preconditions. This one was retired, since the order of
evaluation of expanded attributes (if a class has more than one)
is not specified in the language definition.
[switch-parents-assertion-order]
399. A class with a function which takes 3000 arguments of type
INTEGER and one call to that function causes the compiler to die
with a PANIC. [function-with-many-args]
400. A long chain of anchored feature declarations (200 long on my
machine) causes the compiler to die with a run-time panic on pass
4 of the class with the declarations. [long-anchored-decl-chain]
401. A boolean expression which has 200 occurrences of an `and' or
`or' operator causes the compiler to die with a panic during pass
3 on the enclosing class. [heavy-anded-bool-panic]
403. A class with an assignment of a 20000 element manifest array of
strings to an attribute of type ARRAY [STRING] causes termination
of the compiler during pass 4 on the class, but only under very
particular circumstances. Innocuous changes cause the system to
be compiled correctly. [no-precomp-big-manifest-array]
404. A class calls a function whose return type is an expanded type.
The expanded class on which the expanded type is based has a
creation procedure. If the system is finalized with dead code
removal on, the generated C code will compile but won't link.
This appears to be a dead code removal problem.
[expanded-dead-code-removal]
405. Finalizing a system with an expanded class which has an inherited
(rather than immediate) creation procedure produces C code which
won't link. Turning off dead_code_removal does not help.
[finalize-inh-exp-creation-proc]
406. A class which inherits from INTEGER and evaluates the expression
`Current \\ 29' compiles fine but generates C code which won't
compile. If the code is instead melted, the result is a panic
with the message "operational stack botched". Compiler now
reports a VWOE error. [inherit-integer-call-remainder]
407. A generic class has a routine with a local whose type is the
formal generic parameter. Another class inherits from the
generic class and provides an expanded type as actual generic
parameter, where the expanded type's base class has a creation
procedure. If the system is finalized with dead code removal on,
the generated C code will compile but won't link.
[expanded-generic-dead-code]
408. The instructions `c := '1'; print (c.is_digit)' where `c' is of
type CHARACTER print the wrong result. If `io.putbool' is used
instead of `print' the output is correct. [print-char-dot-is-digit]
409. When a class has two or more parents, the invariant of the heir
class is supposed to start with the invariants of all parents in
the order of appearance of the parent clauses in the heir. But
when the system is executed, the invariants are monitored in
reverse order of the parent clauses.
[parent-invariants-reverse-order]
410. A class repeatedly creates a LINKED_LIST [STRING] whose number of
elements is guided by a random number generator and then deep
clones this list several times. The system compiles fine, but
dies with a run-time panic when executed. [deep-clone-panic]
411. A class calls a recursive routine which creates 255 strings, all
fairly short. If the depth of recursion is 22 or greater, a
run-time panic occurs when the system is executed. If the
routine only creates 200 strings, then the system executes
correctly up to a recursion depth of at least 1000.
[many-locals-deep-recursion]
412. A class has a routine which repeatedly applies the `strip'
operator to the current object and puts the resulting array in a
local variable. The class has 4 INTEGER attributes. Executing
the system results in a run-time panic. Reducing the number of
attributes to 3 or turning off garbage collection allows the
system to execute correctly for a huge number of iterations.
[keep-on-stripping]
413. A class calls a recursive routine which takes a substring of a
string. If the recursion is fairly deep (approximately 350) and
garbage collection is enabled, a run-time panic occurs when the
system is executed. [few-locals-deep-recursion]
415. A class with an attribute of type BIT 1000 has a routine which
calls `out'. The system compiles fine, but system execution
terminates with an "out of memory" exception.
[out-of-memory-on-out]
416. The descriptive text in the Title bar in a Feature Tool is
shortened too much for the Implementers, Ancestor Versions and
Descendant Versions formats (and possibly others). Drag `equal'
from GENERAL into a Feature Tool. Select one of these formats
and look at Title bar. Even if there is more room very little of
the title is shown. [ebench-feature-short-titles]
417. A system is frozen with no assertions monitored. Then a stop
point is placed on `count' in class SPECIAL. Clicking the Step
button causes a stop on the first instruction of `count'. But
subsequent clicks never cause a stop after the single instruction
in `count'. [debugger-step-skip-stop-point]
418. A system is frozen with no assertions monitored. Then execution
is single-stepped past the first instruction, which creates a
string. If the created string is long (greater than roughly 1950
characters on my machine), nothing is displayed when the string
is dragged into an Execution Object Tool.
[debugger-long-string-blank]
419. The `es3 -help' option output is missing a few vertical bars
indicating alternatives (end of lines 4 and 5). [es3-help-option]
420. The output of `es3 -help' is a lot more readable if each "|" is
replaced by " | ". [es3-help-more-spaces]
421. The option `-file File' is accepted and even seems to be validity
checked, but the output of compilation or browsing operations
does not go into the file. Instead, an empty file is created.
[es3-file-option]
422. Executing a trivial system from ebench with the Run button and
then clicking on the End Run button immediately after clicking on
the Run button works fine. But repeating this sequence over and
over eventually causes ebench to be killed, usually within 10-15
repetitions of the sequence. [repeatedly-run-end-run]
423. The descriptive text in the Title bar in a Class or Feature Tool
is not updated when the class or feature occupying the tool is
modified, system is recompiled and then the tool is synchronized
by clicking on its upper left button. [ebench-titles-not-synced]
424. Dragging a use of a formal generic parameter as a type into the
class hole of a Feature Tool terminates ebench with a
segmentation fault. [ebench-generic-in-feat-tool]
425. The flat form of a class with an entity `x: expanded TEST1',
where TEST1 is not an expanded class, has the feature `x: TEST1'.
The fact that `x' is of an expanded type is omitted. This seems
like important information since the semantics of copying,
argument passing etc are different for expanded types.
[expanded-type-bad-flat]
426. Routine `forth' in UNIX_FILE skips every other character.
[unix-file-forth-skip-chars]
427. Calling routine `start' of UNIX_FILE (from class FILE) on an open
file which has zero characters causes violation of precondition
`is_readable' of `readchar'. [unix-file-start-precond-error]
428. When using the debugger in ebench, if I create an Execution
Object tool on the root object it works fine. But if I step
repeatedly until an object referenced by this root object (an
ARRAY [STRING]) is no longer referenced and gets garbage
collected and then try to examine that referenced object from the
old Execution Object tool, ebench dies with an exception trace.
[examine-collected-object]
----------------------------------------------------------------------
429. A declaration of an external routine which uses "c" for the
language name instead of "C" should be accepted, but is not.
[external-lower-case-c-lang]
430. A class with an external feature which is a procedure and which
includes a signature that specifies a return type should be
called a syntax error (or validity error), but the compiler
accepts it. When the system is frozen, the generated C code
won't compile since a void function cannot return a value.
[external-proc-sig-return-type]
431. An external routine which does not take any arguments is declared
as a macro and includes the signature `(EIF_INTEGER)'. The
compiler detects an error during degree 3, but prints "exception
occurred while displaying error message". Repeatedly resuming
the compilation causes compiler termination after about 40
attempts. [external-arg-signature-mismatch]
432. After initial compilation where the system is frozen, an external
routine which has a Special_external_declaration, Signature and
Include_files has its External part simplified to just `external
"C"'. When the system is refrozen, the C code incorrectly uses
the old information about the external routine (prior to the
change). Same problem with finalizing and re-finalizing code.
[remove-part-of-external-decl]
433. A class assigns a manifest array with elements which are integer
constants to a local of type ARRAY [DOUBLE] and prints one of
these elements. Executing the system yields the wrong results
when the class is melted, but not when it is frozen.
[manifest-array-int-double]
434. A class repeatedly allocates a string whose length is determined
by a random number generator and fills the string with blanks.
When the system is frozen, system execution quickly ends with a
panic. [random-string-blank-panic]
435. A class repeatedly allocates an array whose length is determined
by a random number generator. When the system is frozen and then
executed, it goes into an infinite loop.
[random-array-alloc-loop]
437. A very long comment causes the compiler to terminate
during pass 5 on the class with the comment. [long-comment]
438. A long stretch of consecutive white space (6000 characters)
causes the compiler to terminate during pass 5 on the class with
the white space. [long-white-space]
439. An external routine which refers to a DLL16 or DLL32 and appears
to be valid causes the compiler to terminate during degree 5
(presumably only on a non-Windows platform).
[non-windows-dll-external]
440. An external function which takes one argument is declared as a
macro, but the signature omits the argument and supplies only the
return type `:EIF_INTEGER'. The compiler accepts the class, but
terminates during degree -2. [external-omit-signature-args]
441. An external routine which takes two arguments includes the
signature `(long, long, long)' causes the compiler to die on
degree 3 on the class. [too-many-signature-arguments]
442. Start ebench and melt a system. Start a Feature Tool on a feature.
Drag a class into this Feature Tool which has no version of the
feature. Get message such as:
No version of feature make
for class CHILD
Click on class name CHILD. Highlights all of class name, but also
highlights to end of line after class name. [ebench-highlight-too-much]
443. Under certain unreproducible circumstances, get warning messages:
Warning:
Name: vbar
Class: XmScrollBar
The specified scrollbar value is less than the minimum
scrollbar value.
Retired because not reproducible. [ebench-vbar-scrollbar-warning]
444. Start ebench. Click on Melt. Select file `Ace' in current
directory. Click on System. Click on Open in System Tool.
Select file `fake' in current directory, where `fake' contains a
single line with "weasel". Click on Melt. When syntax error in
Ace is reported, click on Open in System Tool and select file
`Ace' again. Click on Melt. Ebench dies with segmentation
fault. [ebench-switch-to-bad-ace]
445. Start ebench. Click on System. Select file `Ace' in current
directory. Click on Save As in System Tool. Click in Selection
box near bottom of "Select a file" popup and add "/fake" to end
of existing selection (which ends with `Ace'). Click on OK.
Ebench dies with "No such file or directory" exception.
[ebench-save-to-ace-subdir]
446. Setting the tabulation step in the System Tool has no effect on
the Clusters format. Since it does affect the Text, Modified
Classes and Indexing Clauses formats this may be a bug rather
than a feature. [ebench-cluster-format-no-tabs]
447. Setting the tabulation step in the Class Tool only affects the
Text, Clickable, Flat, Short and Flatshort formats. It does not
have any effect on any of the other formats, which is most
annoying. Similarly, the tabulation step has no effect on the
Callers format in a Feature Tool (in this case, it seems to
affect all the other formats). [ebench-tab-step-no-effect]
448. After switching Ace files by using Open button in the System
tool, one cannot edit the new Ace file by clicking on the Shell
button. The Shell button has no effect. To reproduce: Start
ebench. Click on System button. Select file Ace in current
directory. Click on Open button in System tool. Select a
different file in current directory. Click on Shell button. No
editor comes up. [ebench-switch-ace-no-shell]
449. Under some circumstances, the slice bounds in an object tool
cease to be effective. [ebench-slice-bounds-stuck]
450. When ebench pauses after displaying a syntax or validity error,
dragging an explanation, system or class stone into the Stop
Points hole brings up a message that says one cannot use the
debugging facilities since the current version of the system has
not been successfully compiled. [ebench-pause-stop-on-class]
451. When ebench pauses after displaying a syntax or validity error,
control left-clicking on any of the four debugger mode buttons in
the lower left corner of the Project tool causes a small window
to flash on top of the Project tool and then disappear.
[ebench-flashing-window]
452. Making an existing tool (System, Feature, Class, Explanation,
Object) minimum width causes warning messages about `hbar' for
class XmScrollBar about slider sizing being less than one and
scrollbar value being too big. These messages are displayed in
the window from which ebench was started. [ebench-resize-tool-narrow]
453. Under certain unreproducible circumstances, ebench dies with a
segmentation fault. The problem may be caused by moving the mouse
while a Feature tool is being created. Retired because not
reproducible. [ebench-create-tool-move]
454. Repeatedly creating 5 Class tools targeted to the root class and
then clicking on the Exit button of each such tool causes ebench
to rapidly use more and more memory. [ebench-gets-bigger]
455. Start ebench. Click on OK. Click on Melt. Put mouse over
Choose button in Warning popup. Hold down Return key for about
5-10 seconds. The Project window is still visible, but will not
respond. Both the Warning popup and Select A File popup are gone
and are nowhere to be found. [ebench-hold-down-return]
456. Start ebench. Click on OK. Click on Melt. Select Ace file and
compile system. Replace contents of class TEST with contents of
Ace file. Click on Melt. Start class tool on class TEST.
Select Clickable, Flat, Short or Flatshort format. Class tool
displays error message "Syntax error at line 2 in
Cluster_properties "Use" file". [clickable-format-wrong-contents]
457. Start ebench. Click on OK. Click on Melt. Select Ace file and
compile system. Bring up class tool on class ACTIVE. Click on
Explanation to bring up an Explanation tool. Drag the occurrence
of formal generic parameter G in `BAG [G]' in inheritance clause
of class ACTIVE into middle of Explanation tool. Ebench dies.
[drop-generic-stone-in-explain]
458. Dragging a stop point into an Explanation tool causes the text
window of the tool to display "No help available for this
element", which is reasonable. But the title bar of the
Explanation window is blanked instead of displaying the identity
of the entity for which the user requested an explanation.
[stop-point-no-explain-title]
459. Start ebench and bring up a tool of each type (Explanation,
System, Class, Feature, Object). Iconize Project tool. All
other tools are iconized as well inside it (nice). De-iconize
Project tool. Now iconize individual tools one by one, iconizing
the Project tool last. De-iconize the Project tool. All other
tools are also de-iconized *except* the System tool.
[ebench-deiconize-project-tool]
460. Start ebench and bring up a Feature tool. Click in first text
field and type `make'. Hit tab to move to second text field (for
class name) and just hit . The warning popup comes up
and says "Please specify a feature". It should say "Please
specify a class". [ebench-empty-class-name]
461. Start ebench and melt a system. Start two Feature tools on a
routine which has some instructions in its body. In one of these
tools, select Stop Points format and put a stop point on one of
the instructions. Switch back to Text format in this same tool.
The tool used to set the stop point has "(stop)" in its title
bar. The other tool should also have "(stop)" in its title bar
but does not. Clicking on the Feature button in the upper left
corner of the tool causes the title bar to be updated to include
"(stop)". [ebench-title-bar-no-stop]
462. Start ebench and melt a system. Bring up System tool. Click in
the text area and add some blank lines at the beginning of the
Ace file, then click on Save. Right click on the name of the
root class. The wrong area is highlighted. If I perform a
similar sequence in a Class tool, right clicking is disabled
because the text has been modified. The System tool should
behave the same way. [ebench-ace-bad-highlight]
463. Running `es3 -loop' and entering `S' then `A' causes es3 to
terminate with an error. [es3-loop-show-ace]
464. The PostScript filter (file
$EIFFEL3/bench/filters/PostScript.fil) produces output which does
not work on an HP Laserjet 4si Postscript printer. The
Postscript commands are printed instead of the class text
suitably formatted. Removing the third character (which is a
space character) of the file that is produced results in a file
which prints properly. [ebench-bad-postscript-filter]
465. Clicking on Save As in a Class tool or System tool and saving the
contents to another file affects the tool so that nothing is
clickable. Switching to another format or resynchronizing by
clicking on the upper left button fixes the problem.
[ebench-save-as-no-click]
466. Start ebench and melt system with a class having a long line (250
characters). Start class tool on the class. Place mouse in the
slider part of the horizontal scroll bar area a little to the
left of the right arrow. Click repeatedly with left mouse button
and watch text as slider indicating position moves to the right.
Window shows far right extent of text when slider is
approximately in the middle of the scroll bar area.
[ebench-bad-scroll-bar-position]
467. Dragging a class which is not in the system from the Clusters
format of the System tool into a Class tool which is in Clickable
format does not retarget the Class tool. If the Class tool is in
any format other than Clickable, then it is retargeted to the new
class and is put in Text format. [retarget-clickable-class-tool]
468. Start ebench. Melt a system. Bring up empty Class tool. Enter
class name FOO in its text field. Get New Class popup with
cluster `'. Click on Create. Get "Invalid cluster
name" warning popup. Click in warning popup window. It should
go away but does not. Click on Cancel. Now clicking in warning
popup makes it disappear. [click-wont-dismiss-warning]
469. Start ebench. Melt a system. Bring up empty Class tool. Enter
class name A in its text field. Get New Class popup. Change
cluster to `root_cluster' (match a cluster name in Ace). Click
on Create. Now enter class name WEASEL in Class tool text field.
New Class popup shows `ss name: WEAS' instead of `Class name:
WEASEL'. The size of the New Class popup seems to be fixed the
first time it is needed. [ebench-trunc-new-class-name]
470. Start ebench. Select a particular long and syntactically illegal
Ace file. Melt. Bring up System tool and open new Ace file
which is a short and valid Ace file. Melt. Ebench dies.
[ebench-long-ace-then-short]
471. Start ebench. Melt a system. Control-left-click on the Run
button. System is melted, but is then run twice instead of once.
[ebench-melt-run-twice]
472. Doing a control-click on the Run button while system execution is
in progress but is stopped at a stop point causes a melt and run
but in the wrong order. First, system execution is resumed as
though one had just clicked on Run. Then the popup which asks
whether to stop current system execution appears. If one says
"yes", the system is melted but is not executed after the melt.
[ebench-executing-melt-run]
473. If execution of a system is stopped at a stop point, adding a new
external to a class and clicking on Melt or Freeze freezes the
system. Ebench claims that it is launching C compilations in the
background, but it does not seem to do so. Soon, a file named
`core' appears in the project directory.
[ebench-omit-c-compilations]
474. After initial compilation, the Ace file is deleted and the system
is melted again. Ebench reports a VD22 error (unable to open
file) on the Ace file, which is quite reasonable. But it also
displays "System recompiled" after the error.
[ebench-delete-Ace]
475. Start ebench and freeze a particular system. Then single-step
execution single-stepped past the first instruction, which
creates a string. Drag the string object into an Object Tool.
Right-click on Slice button. Ebench dies if string is long
(approximately 2000 characters). [debugger-long-string-slice]
476. Putting a stop point on `make_area' in TO_SPECIAL results
modifies the behavior of a simple system, causing it to end with
a segmentation fault. Trying to examine the object in which the
system stopped terminates EiffelBench with a segmentation fault.
[debugger-stop-on-make-area]
477. Miscellaneous comments about filters:
A. The symbol `..' does not appear in `template.fil' in
the Symbols section, but it should
B. A feature declaration seems to trigger substitution
of the surrounding text twice instead of once.
(Cannot check this one right now since EIF_FILTER_PATH
doesn't work).
[ebench-filter-comments]
478. The first time a Filter Selection window is brought up by
right-clicking on the Filter button in a Class tool, the command
to be executed cannot be changed. Clicking on the text window
and typing into it simply has no effect. After clicking on
Execute or Cancel (both of which cause the Filter Selection
window to disappear) and bringing up the window again, the
command to be executed can be modified.
[ebench-filter-command-stuck]
479. A system allocates and fills an array of strings and then checks
to see that they have the expected value. System execution ends
with a run-time panic, but only if the system is finalized and
array_optimization is on. [finalize-array-optimization]
480. A pattern of object allocation and resizing guided by a pair of
random number generators and a pair of size limits compiles fine
when it is frozen, but dies with a run-time panic when executed
with certain large values. Many other values do not cause a
run-time panic. (I corrected the class involved to use
`make_filled' instead of `make' on the ARRAYED_LIST. It now
passes). [random-memory-alloc-panic]
481. There is a type in the error message for a VD41 error. It reads
"What to do: make sure that the directory specified in the Ace
file does indeed contains a precompiled system." Word `contains'
should be `contain'.
482. A class with an external routine which is declared as a macro and
which has either a signature or an include specified causes
refreezing of the system whenever it is modified. The refreezing
occurs even if the the change involves only white space or even
if the file is just "touched". [ext-touch-file-refreeze]
483. Using `es3 -precompile' with an Ace which specifies a precompiled
library should elicit a validity error, but does not. When
compilation completes, running finish_freezing results in an
error due to the fact that file `Makefile.SH' does not exist.
[precompile-with-precompiled-lib]
484. A system has a root class whose creation procedure takes an
argument (of type ARRAY [STRING]. When the system is executed
(melted or frozen) with a command line with 100 arguments, each
of which is 1000 characters long, a segmentation fault occurs
during the root object's creation. If the system is frozen and
the C code is modified to turn off garbage collection, then
executing the system with 800 arguments works fine. Increasing
the number of argument to about 400 (1000 chars long each) causes
a panic now. (Now it works even with 800 arguments).
[many-long-cmd-line-args]
485. A simple system which uses CECIL and appears to be correct
compiles and links fine. But when the system is executed, a
run-time panic occurs. [cecil-panic]
486. A system which calls malloc, free and str_blank and also calls
routines allocate_tiny, full_collect and full_coalesce in class
MEMORY compiles fine. Executing the system results in an exception
trace while garbage collecting. [malloc-free-collect-coalesce]
487. A system whose root class has a very long creation procedure
compiles and executes correctly, but `es3' does not do the soft
link to the precompiled driver. [long-feature-skip-soft-link]
488. Precompiling a library via `es3 -precompile -ace
$EIFFEL3/precomp/spec/$PLATFORM/base/Ace' generates a file
`Makefile.SH' which references the obsolete file name `.UPDT'
instead of the new name `melted.eif'. [precompile-makefile-refs-updt]
489. A class tries to create a very large string (50 MB). Under
certain very particular circumstances (system finalized,
exception stack managed, garbage collection on during string
creation attempt) system execution ends with a run-time panic
while trying to print the "out of memory" exception trace.
[out-of-memory-panic]
490. An assignment whose source is an address expression `$x' (which
is of type pointer) and whose target is a reference type other
than ANY should be rejected, since POINTER does not conform to
any reference type besides ANY. But the compiler accepts the
assignment. ETL page 405. [pointer-ref-conformance]
491. One cannot put a stop point on any of the routines defined
directly in HASH_TABLE (e.g., `add_space' or `internal_search')
when using a precompiled cluster and melting a trivial system.
(Actually, one can put a stop on these routines if
there is a generic derivation of HASH_TABLE in the system).
[debugger-no-hash-stop]
----------------------------------------------------------------------
492. The class name in the comment at the end of the class (e.g., `--
class TEST') should be clickable in the Clickable Flat, Short and
Flatshort formats, but it is not. [ebench-class-end-noclick]
493. Start ebench. Click on OK. Click on Melt. Select Ace file and
compile system. Bring up class tool on class GENERAL. Drag the
occurrence of `other' in the single instruction in the body of
routine `conforms_to' in GENERAL into the Stop Points hole in
project window. Ebench dies. Note that dragging this same
entity into an Explanation tool also kills ebench. Can't check
this one out now because Text format of GENERAL kills ebench.
[put-stop-on-argument]
494. Right-clicking on the type of feature `void' in class GENERAL
(this type is NONE) and dragging it into an Explanation tool
causes ebench to die with an exception trace. Cannot check this
one since class tool on GENERAL kills ebench.
[ebench-explain-class-none]
495. Taking the flat form of a particular class in a simple system
kills ebench. The problem does not occur if `es3 -flat' is used
instead. Originally encountered while browsing and taking the
flat form of the EiffelVision class DASH in ebench.
[ebench-flat-form-of-dash]
496. Starting ebench and melting a particular class with two routines
which each contain 3500 routine calls works fine. But starting a
Class tool on the class and selecting the Clickable, Flat, Short
or Flat/Short format kills ebench. If I first choose some other
formats, such as ancestors etc., then Clickable and friends work
just fine. I suspect this may be a GC problem. (Now ebench
seems to go into an infinite loop). [ebench-many-calls-flat-form]
497. Starting a Class tool and trying to look at the Text format of a
simple class kills ebench. Originally encountered while trying
to look at the Text format of class STRING.
[ebench-text-form-of-string]
498. Start ebench. Add to the text in the Selection box one parent
directory component `..' for every element in the path name
separated by slashes and then one more `..' component. For
example, if Selection box has `/dragon/test4/subdir', then add
`../../../..' to end of Selection box text. Click on OK. Ebench
incorrectly accepts the selection. Click on Melt and select an
Ace file. Ebench dies with "no such file or directory".
[ebench-too-many-parent-dirs]
499. Start ebench. Clear text from Selection box and type `/'.
Ebench responds with a popup which says "Directory: does not
exist". But directory `/' does exist. Also, the message has no
directory name in it (the same response as if I clear the
selection box completely and click on OK). If I instead type
`/..' into the Selection box, ebench says that the project in /..
cannot be retrieved. This seems wrong because there is no
project in this directory (which is the same directory as just
`/'). [ebench-weird-project-dirs]
500. Start ebench. Clear text from Selection box and type
`/etc/spool/Comp_Color'. Click on OK. Ebench says "Project in
/etc/spool/Comp_Color Cannot be retrieved. Check permissions and
please try again." But there is no project in this directory
(i.e., no EIFGENs/test subdirectory in it). Even worse, is that if I
try to select this directory as the project directory twice more
via the above procedure, ebench accepts it on the third try. A
subsequent Melt kills ebench since the directory is not writable.
[ebench-unwritable-dir-third-try]
501. Start ebench. Melt trivial system. Repeatedly do the following:
left-click on Run and then immediately control-left click 5 times
very fast on End Run. Ebench soon dies (actually, it is killed).
[ebench-run-quick-end-run]
502. Start ebench. Melt trivial system. Start Feature tool on `make'
from STRING. Click on Text format, then on Callers format.
Output fine. Click on Flat or Stop Points format, then on
Callers format. First line of output is indented one tab stop,
but should not be. [ebench-feature-callers-after-flat]
503. Setting the tabulation step in an Object Tool which is in
Attributes format has no effect (the attribute names should be
indented one tab step). In "Once functions" format, the once
function names are also not indented one tab step, but the "Not
yet called" is indented one tab step if present.
[ebench-object-tool-tab-step]
504. A particular sequence of melting, setting stop points and running
a system causes a "byte code botched" run-time panic which
terminates ebench. [debugger-byte-code-botched]
505. A simple system is melted and stop points are put on the first
instruction of `copy' and `remake' from class STRING. The melt
operation and placement of stop points is repeated twice more.
When the system is then executed, the result is a segmentation
fault. [debugger-melt-stop-three-times]
506. A simple system is repeatedly melted and then a stop point is put
on `copy' from class STRING. When the system is executed, a
segmentation fault results (previously reported). If the system
is melted immediately at that point and the stop point is added
back in, executing the system results in a stop but no call stack
is displayed. Another melt at this point and replacement of the
stock and re-execution results in an "unknown entity type" panic.
[debugger-melt-stop-repeat]
507. A particular sequence of compilations and class browsing in
ebench usually causes a "free-list inconsistency" panic.
[ebench-free-list-inconsistency]
508. A simpler sequence of compilations and class browsing in ebench
which causes a panic. (Now, this one doesn't cause ebench to
die, but it insists on checking the old root class WEASEL and
finding a syntax error even after the root class is changed to
TEST which does not depend on WEASEL). [ebench-simpler-panic]
509. A system compiles correctly. Then most of the class header of
one of the (generic) classes is deleted, except for the word
class. When the system is recompiled, the compiler detects the
VTCT error but terminates silently in the middle of reporting it.
[delete-generic-class-header]
510. After initial compilation, a feature which is the target of an
assignment is changed from a variable attribute of type TEST1 to
a constant attribute of type STRING. The compiler does not
detect the VJAW error. [vjaw-sneak]
511. A class has an assignment where the target entity is of an
expanded type and the source entity is of an expanded type which
inherits (indirectly) from the target type base class, but adds
some attributes. After initial compilation where the system is
melted, the type of the source entity is changed to another
expanded type which is a parent of the original source entity
type and the system is frozen. System execution then ends with a
segmentation fault. [chg-expanded-source-freeze]
512. A class has a routine with an assignment whose source entity is
an an attribute of the class. After initial compilation where
the system is melted, the type of the source entity is changed to
another type which is a parent of the original source entity type
and the system is frozen. System execution then ends with a
segmentation fault. [melt-chg-attr-type-freeze]
513. A routine with the instruction `io.put_double (5 / 2)' gives
incorrect output, but only when melted. The instruction
`io.put_real (5 / 2)' gives correct output whether melted or
frozen. [put-double-five-over-two]
514. A system allocates an ARRAYED_LIST each of whose elements is an
ARRAYED_LIST [STRING]. It then randomly assigns into the main
list a random-length list of strings, each of whose STRING
elements is a random length. System execution ends with a
run-time panic, but only if the system is finalized and
array_optimization is on. [finalize-random-arrayed-list]
515. A class has a routine which repeatedly creates a manifest array
of 80 strings, each of whose elements is "w". The system
compiles fine when frozen, but execution soon ends with a
run-time panic. [manifest-array-of-tiny-strings]
516. An Ace which includes the option `inlining_size ("47_weasels")'
should provoke a VD15 error, but the compiler accepts it.
[inlining-size-non-integer]
517. A known sequence of changes which involves changing the name of a
class to elicit a VTCT error and changing the actual generic
parameter in a type in a generic constraint to elicit a VTCG
error causes the compiler to terminate with a segmentation fault
during degree 5. [vtct-vtcg-die-degree-5]
518. A system has a class which creates a manifest array of strings
with 25000 elements. The system compiles fine when frozen, but
when executed it dies with a run-time panic while creating the
manifest array. Turning off garbage collection allows the system
to execute correctly. [big-manifest-array-of-strings]
519. A class repeatedly creates an instance of type TEST1, where TEST1
inherits from MEMORY and redefines `dispose' to print (via C
code) which object is being disposed. All objects which are dead
but uncollected at the end of system execution or which are still
live do not have their `dispose' routine called.
[uncollected-objects-not-disposed]
----------------------------------------------------------------------
520. A system which prints the character constants `%/1/' through
`%/255/' compiles fine when frozen, but prints incorrect values
for characters `%/128/' and above. Melted code works correctly.
[frozen-high-bit-characters]
521. A class has a debug instruction with Debug_key "weasel". The Ace
specifies `debug ("weasel")' in the defaults section. The
Compound in the debug instruction is not executed, but only if
the system is finalized. It is executed if the Ace specifies
`debug (yes)'. [finalize-debug-inst-not-kept]
522. Finalizing the "Hello weasel" program with `assertion (ensure)'
produces C code which won't compile, but only if a precompiled
base library is used and `dead_code_removal (no)' is specified in
the Ace. [finalize-ensure-keep-dead]
523. A particular function `f' with a rescue clause calls another
function. When this called function raises an exception, the
rescue clause of `f' is not executed and there is no retry. The
rescue clause of the caller of `f' is executed instead. This
incorrect behavior only occurs if the system is finalized.
[finalize-skip-rescue-clause]
524. A class has pattern of creation of small STRINGs guided by a
random number generator. It also has an attribute which is a
BIT_REF and it calls deep_clone on the current object after each
STRING creation. The system compiles fine with `assertion
(all)', but violates postcondition `deep_equal' of routine
`deep_clone' when it is executed. [deep-clone-not-deep-equal]
526. Finalizing a trivial system with an Ace which specifies both
`inlining (yes)' and `dead_code_removal (no)' causes the compiler
to die during degree -5 on class GENERAL.
[finalize-inline-remove-dead]
527. Finalizing a system with a class which has a call to a deferred
routine with no descendants causes the compiler to die during
degree -5 on the class, but only if the Ace specifies `inlining
(yes). [finalize-deferred-feature-call]
528. Finalizing a system with an Ace which specifies both
`dead_code_removal (no)' and `array_optimization (yes)' causes
the compiler to die while generating `eplug.c'. Finalizing with
the -keep option to retain assertions suppresses dead code
removal so it also causes the compiler to die if array
optimization is on. [finalize-array-opt-remove-dead]
529. An option clause in an Ace file specifies that one debug key is
to be enabled for classes A and B and a second debug key is to be
enabled only for class A. When the system is executed, the
second debug key is monitored for both classes A and B.
Reversing the order of the debug clauses corrects the problem.
[lace-debug-key-subset]
530. Finalizing a system with `assertion (all)' specified in the Ace
produces C code which will not compile. [finalize-assertion-all]
531. A manifest string which contains the illegal "character" '% '
(percent followed by space) and which is continued onto the next
line immediately following the invalid character causes the
compiler to report the wrong error message ("incomplete string:
missing final quote" instead of "invalid character code after
percent"). Note: this was never really a bug, since the string
is not continued onto the next line (it doesn't end with a % as
last character on the line). [percent-space-extended-string]
532. A class which prints the address of a variable attribute compiles
fine. But when the system is executed, the value of the
attribute is printed instead of its address.
[variable-attr-wrong-address]
533. Start ebench. Click on System. Select file `Ace' in current
directory. Click on Save As in System Tool. Click in Selection
box near bottom of "Select a file" popup. Get rid of trailing
`Ace' on existing file name in Selection box and add
"/www/www/www/www". Click on OK. Ebench dies with "No such file
or directory" exception. [ebench-save-to-sub-subdir]
534. After an explicit exception is raised via `raise', the call stack
shown in the project window when stopped at a stop point is
wrong. It seems to omit some routines (possibly all but the root
creation procedure). In addition, the `@' button in a Feature
tool does not show the current instruction when it is part of a
Rescue clause, though single stepping and break points in a
Rescue clause appear to work correctly.
[exception-wrong-call-stack]
535. Start ebench and melt a system with a particular class. Change the
class so that there is a VTAT violation (anchor cycle). When VTAT
error is reported, drag the class name into the Project Tool window
to start a Class Tool. Select Clickable format or Flat format.
Ebench dies with segmentation fault. [ebench-clickable-anchor-cycle]
536. Start ebench and melt a system with a particular class. Change the
class so that it inherits from itself, thereby introducing an
inheritance cycle. When VHPR error is reported, drag the class
name into the Project Tool window to start a Class Tool. Then
start a Feature Tool on the creation procedure of the class. Click
on Implementers button. Ebench goes into an infinite loop (used to
die with run-time panic). [ebench-inherit-cycle-implementers]
537. Start ebench. Click on OK. Click on Melt. Select Ace file and
compile a trivial system. Put mouse Class button in upper left
corner of resulting class tool and click a large and odd number of
times quickly (e.g., 21). Immediately move the mouse to some
random spot. When ebench gets done processing all of the clicks, a
draggable class stone appears and is anchored to the chosen random
spot. I cannot reproduce this any more. [ebench-odd-button-clicks]
538. Start ebench and melt a system with a particular class. Change the
class so that it has a syntax error and re-melt. When syntax error
is reported, drag the class name into the Project Tool window to
start a Class Tool. Select Flat format in the new class tool,
which just displays the syntax error message. Remove the syntax
error in the file with an editor (*not* via the class tool) and
click on Melt. Ebench dies. [ebench-remove-syntax-error]
539. Start ebench and melt system. Start Feature tool on feature
`internal_search' from HASH_TABLE. Select Homonyms format. Right
click on occurrence of `internal_search' in the resulting window
contents and drop it in the same window. The homonyms are computed
all over again, even though the feature to which the tool was
retargeted is the same as the original feature.
[ebench-recompute-homonyms]
540. Start ebench. Melt a system. Bring up empty Class tool. Type
something into its main text area (middle of window). Enter class
name AAA in its text field. Get New Class popup. Change cluster
to `root_cluster' (match a cluster name in Ace) and hit return.
Get "File has changed" warning. Click on OK. New class created
correctly, but get warning in window from which ebench was started
("Warning: XtRemoveGrab asked to remove a widget not on the list").
[ebench-remove-missing-widget]
541. New windows created in ebench are sometimes off the edge of the
screen. New windows which are up against the right side of the
screen are off screen a little bit. New windows which are against
the bottom side of the screen are off enough to hide the Format
buttons at the bottom of a tool. To reproduce, click on Class
button and then quickly move mouse to each corner of screen in turn
and compare window positions. Now they are way off the screen,
but it acts consistently (upper left corner of created tool is
where mouse is when window gets created). [ebench-windows-past-edge]
542. Running `es3 -loop', selecting Compile, Melt, Copy template and
entering a blank when prompted for the file name causes es3 to
terminate (this has been previously reported). But it also
prints the line "Usage: cp [-ip] f1 f2; or: cp [-ipr] f1 ... fn
d2", which seems undesirable. [es3-loop-blank-template-filename]
543. Running `es3 -flat xxx' in a directory where there is no EIFGENs/test
subdirectory (or one with incomplete information because no
compile has completed yet) causes the compiler to silently
terminate with no output at all. This might lead users to think
that there is no such class or that the output went somewhere
else. Es3 really should display some sort of message.
[es3-flat-no-eifgen-dir]
544. Selecting the flat format in a class tool for a particular
non-generic class causes ebench to terminate with a segmentation
fault. The class inherits from a generic class which has a
procedure which assigns one local of type G to another, where G
is the formal generic parameter of the parent class.
[ebench-flat-inherited-generic]
545. A class creates an object of type ARRAY [BIT 32]. Starting an
Object Tool on the object after it is created causes ebench to
hang. The mouse pointer remains a clock and ebench must be killed
from the command line. [debugger-examine-bit-array]
======================================================================
546. An External_declaration has a list of include files with more than
one file in the list. If the final include file name is missing
the final `>' or `%"' delimiter and there is no white space around
the comma separating the last two file names then the class is
accepted, but should not be. [include-missing-last-delimiter]
547. After initial compilation, the value of a constant integer
attribute is changed and the system is recompiled. System
execution should print a longer bit string, but it does not.
(Now, after the first melt system execution does not produce the
correct output so this is no longer an incrementality problem).
[chg-integer-const-value]
548. After initial compilation, an inherited feature which is a named
as a creation procedure in the heir is changed to an attribute or
a function. The compiler should report a VGCP(2) error, but it
is too lazy to do so. [vgcp-sneak]
549. A class with a generic parameter `G -> ARRAY [like weasel]' is
correctly reported as a VCFG(3) error. But when an empty line is
inserted and then deleted in the file containing the class,
thereby updating its date of last modification, and compilation
is resumed the compiler terminates silently after pass 5 on the
class. [anchored-constraint-touch-file]
550. A system is compiled with an Ace which references a precompiled
cluster that is invalid, so it cannot be retrieved. After the
VD41 error is reported, the Ace is changed to indicate a valid
precompiled cluster. But the compiler reports a VD41 on the new
(valid) precompiled cluster. [new-precomp-cluster-bogus-vd41]
551. Operations on BIT types work correctly after the system is
frozen. These same operations cause a run-time panic after
melting. (Now, the printed bit value is wrong when system is
melted, although there is no panic). [bit-melt-metamorphose]
552. A class calls a procedure and passes as actual argument a named
constant which is of type BIT 2. If the system is melted, a
segmentation fault occurs during system execution. Frozen code
works fine. [named-bit-constant-argument]
553. A class prints `x.out' where `x' is a constant of various types
(INTEGER, DOUBLE, BOOLEAN, etc). The system compiles fine, but
if it was melted system execution ends with an exception trace.
Frozen code works fine. [named-constant-call-out]
554. A class declares a named constant via `b: BIT 8 is 11B' and
prints `b'. When the system is frozen and executed, the value
displayed has not been extended with trailing zeroes and so is
only 2 bits long instead of 8 bits. [extend-short-bit-constant]
555. A class has pattern of creation of small STRINGs guided by a
random number generator. It also has an attribute which is a
BIT_REF and it calls deep_clone on the current object after each
STRING creation. The system compiles fine when frozen with
`assertion (all)', but violates postcondition `deep_equal' of
routine `deep_clone' when it is executed. Melted code seems to
work fine. [deep-clone-frozen-not-equal]
556. A routine has an assignment attempt whose source is of type
expanded FOO and whose target is of type FOO. When executed, the
assignment attempt correctly succeeds. However, after wasting
some memory and presumably causing garbage collection, system
execution ends with a segmentation fault. The generated C code
appears to be incorrect. [assign-attempt-exp-to-ref]
557. A procedure sets an attribute of type REAL to the value passed in
as an argument. Then the procedure checks whether the attribute
is equal to the value just assigned to it. If the system is
frozen then the attribute is not equal to the value assigned to
it. Melted code works correctly. [compare-frozen-real-arg]
558. A function which takes one argument of an expanded type and has
body `Result := arg' does not work correctly, but only if the
system is finalized. This appears to be a code generation
problem. [finalize-expanded-arg-result]
559. Equal does not give the correct results for bit strings of
different lengths. The shorter bit string is supposed to be
extended with either leading or trailing zeros (not sure which
one) before the comparison, but it is not. [bit-equal-wrong]
560. A class creates an ARRAY [expanded FOO] and then fills it up with
elements of type `expanded FOO'. When the system is frozen with
`assertion (ensure)' and then executed it dies with a
segmentation fault while evaluating the postcondition
`insertion_done' of `put' in ARRAY.
[array-of-expanded-insert-fails]
561. A system has a class TEST1 with 150 attributes of an expanded
type, where the base class of the expanded type has 110 STRING
attributes. Repeated creation of instances of TEST1 causes a
run-time panic when executed, even if garbage collection is
turned off. [big-expanded-attributes]
562. A procedure takes the negation (`not') of a local of type BIT
2_000_000 and prints the first and last bits of the result.
System execution ends with a run-time panic, but only if garbage
collection is on. [negate-big-bit-local]
563. A system repeatedly allocates a string of size `k', where `k'
starts at 1 and is incremented by one after each iteration. When
the system is executed, the amount of "used" Eiffel memory as
indicated by the memory statistics facilities of class MEM_INFO
soon becomes negative. [negative-eiffel-memory-used]
564. A class repeatedly creates a manifest array with a single element
of type BIT 32. Executing the system results in a segmentation
fault or run-time panic after a large number of iterations. If
garbage collection is off or the BIT 32 array element is not a
local entity, the system executes correctly.
[repeated-manifest-bit-array]
565. The instruction "print ('%U')" does not output a single null
character. It does not output anything. [print-null-get-nothing]
566. A class A repeatedly calls a procedure on an instance of another
class B. Class B has a class invariant with a call to a function
of class B, which in turn calls a function on an attribute of
type C. The system compiles fine, but when executed it quickly
runs out of memory if the system was melted and if `assertion
(invariant)' is specified in the Ace.
[melted-invariant-memory-leak]
567. A generic class with a single formal generic parameter G has two
attributes of type G. When the actual generic generic parameter
is a basic type and the two attributes have the same (default)
value, they are equal according to `=' but not according to
`equal'. [generic-attributes-not-equal]
568. A generic class which has a constraint `ARRAY -> [BIT Weasel_bits]'
on its formal generic parameter causes the compiler to correctly
report a VTCG violation, but the compiler dies while trying to
report the type to which the actual generic parameter should
conform. [generic-constraint-bit-type]
569. A system with a generic class with a formal generic parameter
constrained by `ARRAY [TEST]' causes the compiler to die while
freezing the system, but only if class TEST is expanded.
[generic-constraint-with-expand]
570. A class which tries to get and print the address of an external
feature (which is not a constant) compiles fine, but dies with an
exception trace when executed. Fixed because compiler now says
taking address of an external feature is not supported in release
4.1. [external-feature-address]
571. A routine has a local of an expanded type and the creation
procedure of the expanded type's base class raises an exception.
When the routine is called repeatedly, a run-time panic occurs if
garbage collection is on. [expanded-local-raise-exception]
572. An Ace with an Externals section which has more than one
Language_contribution causes es3 to report a syntax error. ETL
page 528. [lace-mult-ext-lang]
573. An expression with a division by constant 0 or 0.0 compiles fine,
but the generated C code won't compile using `cc'. However,
it will compile using `gcc', and `cc' is no longer supported on
SunOS since it isn't an ANSI C compiler. [divide-by-zero]
574. A routine with an assignment attempt whose source is of a basic
type (INTEGER, REAL, etc.) compiles fine when frozen, but
generates C code which won't compile.
[assign-attempt-basic-type]
575. A routine with an assignment attempt whose source is a `$x',
where `x' is a local which is of a basic type (INTEGER, REAL,
etc.) compiles fine when frozen, but generates C code which
won't compile. Compiler now reports a syntax error, so it won't
accept this code just like it won't accept "x := $y".
[assign-attempt-basic-local-addr]
576. Freezing a system with a feature which is an argumentless
external function that includes a signature in the
External_declaration produces C code which won't compile.
[external-func-with-signature]
577. A declaration of an external routine declares the external to be
a macro and specifies two include files whose names are delimited
only by white space (no %" or <> bracketing). If the white space
is a tab instead of a space, only one C include is generated with
the two file names run together, causing the C code not to
compile. [external-tab-between-includes]
579. A routine fills an ARRAY [POINTER] with its own address. If the
system is finalized with `array_optimization (yes)', the generated
C code won't compile. [finalize-array-opt-pointers]
580. A system's Ace has a visible clause which makes one routine of a
class visible. The class inherits the routine to be made visible
from another class along with another routine called by the first
and renames both routines. When the system is finalized with
`dead_code_removal (yes)', the generated C code won't compile.
[finalize-wont-trace-visible]
581. A system calls a routine which tries to create an instance of a
deferred type, where this invalid creation is not detected at
compile time because the target of the creation is anchored.
When the system is finalized the generated C code won't link,
even if dead code removal is off.
[finalize-create-deferred-type]
582. A feature with 100 nested calls to `clone' and a missing
parenthesis causes the compiler to terminate silently after pass
5. [deep-function-nest]
583. If a class renames inherited infix feature to an identifier
feature, the flat and flatshort forms of the class are incorrect
(in at least some cases). Feature name is `"time_less_than"'
instead of `time_less_than'. [rename-inherited-wrong-flat]
584. Changing a class after initial compilation and then taking the
flat form before recompiling causes the flat form to be incorrect
(basically an empty class in my example). [flat-after-change]
585. The flat form for a particular class which inherits both directly
and indirectly from a class with a deferred feature incorrectly
lists the same feature twice, with two different bodies. Only
one of the routine bodies is correct. [flat-feature-two-defs]
586. A class A inherits from class B and renames a deferred feature in
B so that it has the same final name as another (non-renamed)
effective feature from B. Class A is not deferred. But the flat
form for class A shows two declarations for the renamed feature,
one of which is deferred. [eff-class-flat-deferred-feature]
587. If a class renames an inherited identifier feature to a prefix or
infix feature, the flat and flatshort forms of the class are
incorrect. Feature name is `_prefix_@weasel' instead of `prefix
"@weasel"' and similarly for infix features.
[rename-inherited-bad-flat]
588. A class inherits from a parent class, renaming a feature `right'
which is called in another inherited feature. Feature `right' is
called on an entity of type `like first', but feature `first' is
redefined to change its return type. The flat form of the heir
class refers to `right' instead of using the new name assigned by
renaming. [redefine-anchor-rename-called-feat]
589. A class has a routine with no comment and the routine is the last
in a `feature' section. If the feature section has a comment (as
in `feature -- Properties'), the feature section comment is
incorrectly used as the comment for the routine in the Flat and
Stop Points formats in a routine tool.
[ebench-flat-use-next-comment]
590. In the Clickable, Flat, Short or Flatshort formats of a Class
tool (or in the Flat or Stop Points formats for a Routine tool),
the backquotes and quotes around entity names in a routine
comment are not preserved. [ebench-comment-entities-unquoted]
591. While stepping through routine `sequential_search' of
ARRAYED_LIST, the arrow in a Feature tool indicating the point
where execution is stopped disappears. Even the "@" button can't
bring it back. [debugger-hidden-stop]
592. After initial compilation, a non-generic class is changed to a
generic class by adding a single formal generic parameter FOO,
with the constraint `-> ARRAY [FOO]'. The system also happens to
have a class named FOO. The compiler correctly reports the
VCFG(1) violation but says "Exception occurred while displaying
error message" while trying to display the name of the class
involved. [make-generic-add-vcfg]
593. A system with a generic class also has a VLEC error. The
compiler detects the error, but says "Exception occurred while
displaying error message" while trying to display the name of the
class involved. [expanded-generic-vlec-exception]
594. After initial compilation, a VEEN error is added to a class.
When the compiler detects the error, it is corrected by
inheriting from a different class. This introduces a VRFA error
which the compiler catches, but it also says "Exception occurred
while displaying error message" while trying to display the name
of the feature involved. [fix-veen-add-vrfa]
595. A system has an Ace which makes a class visible under another
name FOO and an external routine which tries to get the type id
of class BAR. After initial compilation where the system is
frozen, system execution works as expected: no type id can be
obtained for BAR since the class was made visible as FOO instead
of BAR. The Ace is changed to make the class visible as BAR and
changes are melted. When the system is executed, no type id can
be obtained for BAR. [visible-class-change-name]
596. After initial compilation, the name of a formal routine argument
is changed, along with the single reference to it in the routine
body. After the system is recompiled, the flat form of a
descendant class shows the wrong body for the inherited routine.
The formal argument is renamed but the reference to it in the
routine body is not. [flat-change-argument-name]
597. A system sets a variable to the character constants `%/128/' and
`%/255/' and then checks to see if the variable is equal to the
value just assigned to it. The system compiles fine when frozen,
but thinks the variable is not equal to the character just
assigned to it for characters `%/128/' and above. Melted code
works correctly. [compare-frozen-high-bit-chars]
598. The collect option does not seem to be implemented. Invalid
values for the collect option are accepted without any complaint.
Retired because VD37 errors are issued every time the collect
option is specified, even though the values are ignored.
[lace-invalid-collect-values]
599. The trace option used in a system-level Defaults part in an Ace
does not seem to be implemented. An Ace which includes a valid
`trace(yes)' or `trace(no)' option does not elicit any warnings
from the compiler. [lace-system-opts-fail]
600. A class with no attributes and a strip expression `strip ()'
compiles fine, but the generated C code won't compile with `cc'.
It will compile with `gcc'. Retired because `cc' is not an ANSI
C compiler and only ANSI C is supported now.
[strip-empty-list-freeze-cc]
601. Freezing a system with a call `equal ($make, $make)' produces C
code which compiles, but the C compiler issues warnings about
"illegal pointer combination". [feature-addr-illegal-pointer]
602. A class inherits three deferred features and joins and effects
them. The flatshort form of the heir class looks as expected,
with all alternative preconditions present in the expected order.
But when the system is executed, only one of the preconditions of
the deferred features is executed. In this case, postconditions
seem to work correctly. [join-effect-precond-skipped]
603. Finalizing a system with a call `wimp ($make)' produces C code
which compiles, but the C compiler issues a warning about
"illegal pointer combination". The warning only occurs if the
system was finalized with `inlining (yes)'.
[inline-addr-illegal-pointer]
604. A system is compiled via ebench when there is not enough disk
space. The compiler runs out of disk space while writing the
`project.eif' file. A subsequent attempt to melt causes the
compiler to go into an infinite "no more disk space" loop.
[no-disk-space-loop]
605. A system is compiled via ebench when there is not enough disk
space. During degree 5, a "file system full" message is
displayed. Thereafter, attempts to melt the system result in a
warning panel which says "Read-only project: cannot compile".
This happens even if more disk space is made available.
[no-disk-space-read-only]
606. A routine whose body just allocates a lot of strings has a rescue
clause which just retries. The system is melted or frozen with
an Ace which specifies `assertion (invariant)'. When the program
is executed, repeatedly typing control-C characters usually
causes the program to terminate with a run-time panic. The
exception trace shows an invalid object.
[control-c-invalid-object]
607. An external routine has a signature specified (e.g., "C
(double)") to cause casting of an argument before it is passed to
the C routine. The external routine is redefined in a
descendant. In a call to the routine which cannot be statically
bound, the cast should not be applied to the argument in the
generated C code, but it is if the system is finalized. This
results in wrong results when the system is executed. A frozen
system works correctly. [finalize-redef-external-with-sig]
608. The position of a syntax error in an external declaration is shown
incorrectly (even by es3) when the declaration has any escaped
characters such as '%"'. Every such character seems to be
counted as one character instead of the number of characters used
to represent it in the class text.
[external-wrong-syntax-position]
609. Start ebench. Keep double clicking on parent directories until you
reach the root and then on directories `/bin' and
`/bin/sunview1'. Click on OK. Ebench correctly says that
`/bin/sunview1' does not have appropriate permissions. But two
warning messages appear in the window from which ebench was
started which say "The scrollbar page increment is less than 1".
Retired because no longer reproducible. [ebench-page-increment-lt-one]
610. If the general resource file in the $EIF_DEFAULTS directory does
not specify "progress_bar_color" explicitly then the Compilation
Progress bar is blue and the background for the labels for each
button/hole which pop up if one leaves the mouse there is light
yellow. However, if the resource file specifies
"progress_bar_color: green" then both the Compilation Progress
bar and the background for popup help labels over buttons are
green. [ebench-help-label-wrong-color]
611. The Once/Constant format for a constant of type STRING uses single
quotes around the value intstead of double quotes. The
Once/Constant format for a constant of type CHARACTER uses double
quotes around the value intstead of single quotes. These two seem
to have been switched. [ebench-once-constant-quote-mixup]
612. There is a number of wrong or strange behaviors associated with
compiling a system where the Ace is built by ebench.
A. Start ebench. Select OK. Click on Melt then on Build.
Click on Cancel to get rid of window, which is titled "Ace
builder_popup" (why is the "_popup" part needed?).
B. Click on Melt again, then Build. When the Ace builder
window comes up, it is wider than it was before (why?).
Click Cancel again.
C. Do the Melt, Build, Cancel sequence several more times.
Notice that each time you do this it takes 1-2 seconds
longer for the Ace builder window to appear.
D. In Ace builder window, change system name to "test", root
class name to "weasel" and creation procedure name to
"wimp". Click on Create Project. Compilation finishes,
but the name of the class displayed in the Compilation
Progress window is ROOT_CLASS rather than WEASEL, although
the Ace.ace file and the file weasel.e were both generated
correctly.
E. Notice also that the system is compiled multiple times
instead of just once (I believe there is one compilation
for each time the Ace builder window showed up).
[ebench-ace-builder-weirdness]
613. The underscores in lines of a routine which are "stepped" through
are erased and not redrawn, leading to a very confusing display in
the debugger feature window. For that matter, the text in white
again the red background that shows the current location in a
routine or in the call stack do not include white underscores
either (also very confusing). [ebench-debugger-erase-underscores]
614. Drag a class or feature into a Class tool which has a class in it
whose text has been modified. Ebench asks for confirmation (File
has changed since last save! Lose changes?). If one responds
affirmatively, the class or feature goes into the Class tool, but
the text input field with the class name (to right of Next
button) still shows the name of the previous class. Furthermore,
if you drag a feature into a Class tool with modified text, the
title bar of the Class tool shows "Feature: make Class: TEST"
(for example) and only the text of the new feature is shown
rather than the text of the entire class with the feature
highlighted. In other words, the title bar and text window of a
Class tool look like it is a Feature tool.
[ebench-target-changed-class]
615. If a user loses his license (e.g., due to a crash and reboot of the
machine on which the license daemon runs), trying to get
information twice by clicking on Info in the popup announcing the
loss of license causes ebench to terminate with a segmentation
fault. Retired because no longer reproducible.
[ebench-license-loss-info-twice]
616. Problems with Graphical preferences format of the Preference tool:
A. Switching to the Graphical preferences format of the
Preference tool is *very* slow (over 90 seconds on a SPARC
10). During this time, CPU utilization is near 100%.
[Seems to be OK on an UltraSPARC 2]
B. Right clicking on on of the font values (e.g., value for
Class font) brings up a Font selection box. The title of
the window is "Font Box_popup" (why is "_popup" needed?).
Also, the background color (and probably the foreground color)
is not the color I specified in my resource file, but
a fairly dark blue.
C. There are *two* boxes labeled "Progress bar color". One
has the value "LightYellow" and the other has the value
"blue". I suspect that one of them is misnamed and may be
affecting the background color of popup help labels.
Actually, changing either one or both of the boxes to have
the value "green" and clicking Apply does not change the
color of the progress bar or of the background for popup
help labels.
[ebench-graphical-preferences]
617. Files generated with PostScript filter do not print correctly on
HP LaserJet 4Si. The text of the Postscript commands prints.
Changing the first line from "%!PS-Adobe-1.0" to "%!PS-Adobe-2.0"
corrects the problem. [ebench-postscript-prints-wrong]
618. The "tab_step" resource does not seem to have any effect
when the preference file is read on startup. Changing tab step
in the preferences tool and applying the change does have the
appropriate effect.
619. Clicking twelve times quickly in a Feature tool in Stop Points
format seems to work correctly. But after ebench stops processing
the mouse clicks, selecting Flat format causes ebench to die.
Retired because no longer reproducible.
[ebench-twelve-feature-clicks]
620. Selecting Special/Reverse engineer before compiling a project
results in an appropriate error message. However, the message
says (note the missing word "has"):
Project not been compiled.
The project must be compiled before it can be reversed engineered
[ebench-reverse-engineer-early]
621. Holding down the left mouse button and moving the mouse to select
text in a class tool works fine. However, a subsequent click on
the middle mouse button to paste the selected text into an Emacs
window causes ebench to die with a segmentation fault.
[ebench-select-then-paste]
622. Holding down the Back Space key or the Delete key in a System tool
or Class tool (and presumably others, though I haven't tried them)
causes ebench to die with a bus error. [ebench-hold-down-delete]
623. The creation procedure `make' of BOOL_STRING has a precondition
`positive_size: n > 0'. This should be `nonnegative_size: n >= 0'.
[create-zero-len-bool-string]
624. The clickable form, flat form and flat short form of a class show
prefix features as, for example, `prefix "@weasel "' instead of
`prefix "@weasel"'. That is, there is an extra space following
the name inside double quotes. See code in
[rename-inherited-bad-flat] to reproduce. [prefix-feature-extra-space]
625. Start ebench. Select OK, Melt, Browse and choose file Ace.
Immediately click on the File menu in upper left corner of Project
tool, while compilation is going on. As soon as the File menu is
displayed, click in the middle of the Project tool main window in
an area not over any menu item. Ebench finishes compiling and
then dies with a segmentation fault.
[ebench-compile-file-menu]
626. Clicking more than once in rapid succession on the Cancel button
in the Compilation Progress window during a compilation sometimes
causes ebench to go into an infinite loop or die with a panic.
[ebench-cancel-compile-twice]
627. An iconified Project tool is labeled ISE Eiffel 3 instead of ISE
Eiffel 4. Can't tell if this is fixed since cannot see the number
in icon on Solaris version. [ebench-iconified-project-wrong-version]
628. The "Case sensitive" push button in the Search window which comes
up when the Find button is clicked (in any tool that has a Find
button) does not work properly. Searches are always
case-insensitive regardless of whether this button is pushed in or
not. In release 4.2, searches don't seem to work at all - nothing
is highlighted. [ebench-case-button-ignored]
629. If the Debugger Feature window contains a feature and is in a
format other than Stop Points and the window is hidden via
Formats/Hide Feature then shown again via Formats/Show Feature,
then the Stop Points button in the debugger feature window is
inoperative until another format is selected first.
[ebench-debugger-stop-points-inoperative]
630. Melting a system from ebench and then trying to precompile it via
Compile/Precompile menu causes ebench to die with a segmentation
fault. [ebench-melt-then-precompile]
631. Changing the symbol color in the Graphical Preferences window
causes ebench to die with a segmentation fault under particular
circumstances. [ebench-change-symbol-color]
632. Changing a color or font in the Graphical Preferences window
causes ebench to popup a warning that states "System is not
running" when the change is applied, but only if there is an empty
Object tool present. [ebench-system-not-running]
633. Interrupting compilation by clicking on the Cancel button in the
Compilation Progress window usually works fine. However, if the
compilation is a precompilation started via Compile/Precompile,
the error message says "Reverse engineering interrupted" instead
of "Compilation interrupted". [ebench-interrupt-precompile]
634. Dragging the class name NONE from the declaration for feature
`Void' in class GENERAL into a Shell Hole, the Stop Points hole or
the Clear Stop Points hole causes ebench to die with a
segmentation fault. [ebench-drop-class-none]
635. If the Debugger Feature window is in a format other than Stop
Points *and* if the feature in the window is the first one to be
stopped in then when the debugger stops the Feature Tool is not
switched to Stop Points format. When a different feature is
brought into the Debugger Feature window, the format always seems
to be changed to Stop Points format.
[ebench-debugger-no-format-switch]
636. Finalizing a particular simple program without inlining reduces
system execution time by more than half, as compared with a version
where inlining is on. [faster-without-inlining]
637. A type `STRING [STRING]' should be a VTUG(1) error since STRING is
not a generic class. The compiler reports a VTUG(2) error for this
type, but only when it is used in a constraint on a formal generic
parameter. Other uses are correctly reported as VTUG(1).
[vtug1-called-vtug2]
638. A type `ARRAY' should be a VTUG(2) error since ARRAY is a generic
class with one generic parameter. The compiler reports a VTUG(1)
error for this type, but only when it is used in a constraint on a
formal generic parameter. Other uses are correctly reported as
VTUG(2). [vtug2-called-vtug1]
639. An attribute `weasel' of a generic class is anchored to another
attribute whose type is the formal generic parameter. A second
generic class has a constraint involving the first. This second
class has a multi-dot call involving a nonexistent feature, but it
is not detected. [attribute-anchored-to-generic]
640. A system with an invalid generic derivation of a generic class
with two formal generic parameters A and B, where B is constrained
by `LIST [A]' is accepted by the compiler, but should not be.
This results in an undetected type error and a segmentation fault
when the system is executed. [tricky-constraint-with-generic]
641. Class A calls a feature in class B which is exported only to B and
its descendants. This is valid since class A is a descendant of B.
But when the inheritance clause is removed, so that A is no longer
a descendant of B, and the system is recompiled, the VUEX violation
is not detected. [vuex-sneak]
642. Depending on the order of formal generic parameters in a class (one
constrained and one unconstrained), the compiler interprets G as
either a formal generic or as a class. It seems that if there is a
class G, then G should be interpreted as a class (and a VCFG error
signaled). If there is no class G, then G should always be treated
as a formal generic parameter, regardless of order so a VTCG error
should always be reported (instead of reporting VTCT for formals `H
-> G, G'). [generic-constrained-by-generic]
644. A class has an external function which specifies a cast of the
return type (i.e., `external "C :EIF_INTEGER"'). After initial
compilation where the system is frozen, system execution works but
produces the wrong result. Then some white space is added inside
the Language_name portion of the external, leaving its semantics
unchanged and the system is melted. System execution then ends
with a segmentation fault. [cast-external-add-white-space]
645. A class calls a routine and the routine calls its precursor.
After initial compilation, system execution works correctly. Then
a rename is removed, which causes the routine with the precursor
call to have a different precursor. Recompilation works but
execution output is wrong. [rename-get-new-precursor]
646. A generic class has a reference to `<< x >>' where the type of
attribute `x' is the single formal generic parameter of the
enclosing class. Another class has a generic derivation of the
first class, using a non-basic expanded type as the actual generic
parameter. The system compiles fine, but when executed it dies
with an exception trace if it was melted. Frozen code works fine.
[manifest-array-expanded-generic]
647. A class repeatedly does `clone (clone (c))' where `c' is of an
expanded type. If the system is melted and garbage collection is
enabled, a segmentation fault occurs when the system is executed.
Frozen code works fine. [expanded-clone-of-clone]
648. A class repeatedly creates an instance of another class which has
one attribute of an expanded type. The base class of the expanded
type has a creation procedure which allocates a small amount of
memory to initialize the value of a string attribute. If the
system is melted, a segmentation fault occurs when the system is
executed. Frozen code works fine. [expanded-creation-alloc-memory]
649. A routine with a local of type ARRAY [EXPANDED_TYPE] dies with a
segmentation fault if finalized with `array_optimization (yes)'.
If array optimization is off, the generated C code works fine.
[finalize-array-opt-expanded]
650. A system with classes that use the `precursor' construct produces
incorrect output when the system is finalized with inlining.
[finalize-inline-precursor]
651. A class creates an ARRAYED_LIST [STRING] and then clones it. The
class compiles fine, but when the system is executed the
postcondition of `clone' is violated. Using the debugger to look
at the objects reveals that the clone is not working properly.
[arrayed-list-clone-not-equal]
652. A class inherits a feature `weasel: TEST3 [like Current]' where
TEST3 is an expanded class. In an instance of the parent class
`weasel' is non-Void (it better be since it is of an expanded
type). But in the inheriting class `weasel' is Void, which should
be impossible. If some Class_type is used as the actual generic
parameter, instead of `like Current', then the attribute is
non-Void in both parent and child. [expanded-generic-like-current]
653. An object of type `TEST1 [STRING]' conforms to an object of type
`TEST1 [SEQ_STRING]' according to `conforms_to'. This is
obviously not the case and system execution later pays the
ultimate price. [conforms-to-with-generics]
654. A root class has two attributes of an expanded type. The base
class of this expanded type has a creation procedure which creates
a single large string in an attribute. System execution ends with
a run time panic, but only if garbage collection is on.
[expanded-create-big-string]
656. A function with return type of NONE causes silent termination of
compilation (during pass -1 generation if freezing system or
during pass 1 if not freezing system). [function-returning-none]
657. A class which inherits a deferred feature `feat' once from one
class and an effective feature `feat' with the same signature
twice from a second class (as both `feat' and `renamed_feat') and
also redefines `feat' so that its return type is anchored to
`renamed_feat' causes silent termination of the compiler after
pass 1. [redef-anchored-to-self-version]
658. An external routine which takes an expanded argument and also
specifies a cast in the Special_external_decl compiles fine when
frozen, but the generated C code won't compile.
[expanded-arg-with-cast]
659. After initial compilation, a constant integer attribute referenced
in a BIT type is given a larger value. This introduces a VNCB
violation (assigning `BIT n' to `BIT p' where n > p), but upon
recompile the error is not detected. [vncb-sneak]
660. A class has a routine with 2000 copies of an instruction that
prints a BIT constant which is 370 bits long. When the class is
compiled, the compiler dies with a run-time panic during degree 2.
[many-long-bit-constants]
661. Finalizing a system with a simple root class causes the compiler to
die during degree -5 on the root class, but only if the Ace
specifies `inlining (yes)' and a very large value of `inlining_size'
(1000000). Now the compiler signals a VD15 error, so I don't know
if the bug is still there. [finalize-big-inline-size]
662. Putting a stop on a once routine in a very small and simple system
and then executing the system causes system execution to terminate
with a segmentation fault. The system executes correctly without
the stop on the routine. [ebench-debugger-once-routine-stop]
663. The Clickable, Flat, Short and Flat-Short formats in a Class tool
repeat the keyword expanded twice (e.g., "x: expanded TEST1" is
shown as "x: expanded expanded TEST1" in these formats).
[ebench-too-much-expansion]
664. Setting a 0 or negative or very large width or height for the
Project tool in the Preferences tool causes ebench to terminate
with an X error. This also happens for width/height for some
other types of tools, but not all. [ebench-zero-project-width]
665. When precompiling a system where one of the classes has an error
(in this case a VEEN error - unknown identifier) the error is
detected. If the error is corrected and then one forgets one is
doing a precompilation and instead clicks on the Melt button then
the compilation restarts but suddenly hangs before completion. No
CPU is used but the mouse pointer is the familiar clock indicating
the program is busy. Now ebench dies with a seg fault.
[ebench-precompile-then-melt]
666. Holding down the left mouse button and moving the mouse to select
text in a class tool does select the text. But the text is not
highlighted so you cannot see what is selected. Perhaps I have
something set wrong in my preferences file.
[ebench-select-text-no-highlight]
667. An attribute `weasel' of a class has the type of the formal
generic parameter, which is constrained by `LINKED_LIST [STRING]'.
The expression `weasel.i_th (1)' should therefore be of type
STRING. But an assignment to a local of type STRING is rejected
as a VJAR error. The compiler seems to think the expression is of
type `Generic #1'. Note: the 4.3 compiler accepts this code,
but melted system dies. Frozen system works fine.
[generic-attr-call-bad-type]
668. After initial compilation, a constrained generic parameter [G -> STRING]
is added to the root class. When the compiler detects the VSRC(1)
error, the generic parameter is removed. The compiler then dies.
[add-remove-root-generic]
669. A class has an attribute of type `expanded TUPLE'. After initial
compilation where the system is frozen, the type is changed to
`TUPLE [BIT 32]'. When changes are melted, system execution
dies with a panic. [change-expanded-tuple-bit]
670. A routine has 400 locals of an expanded type, where the base class
of the expanded type has 400 attributes of type DOUBLE. The
system compiles fine, but dies with a segmentation fault when
melted if garbage collection is on. [many-big-expanded-locals]
671. A class has an attribute `x' of type `LINKED_LIST [like weasel]',
where weasel is of type `LINKED_LIST [STRING]'. A reference to
the first item of the first list in `x', which is of the form
`x.i_th (1).i_th (1)' causes termination of the compiler after
pass 3 on the class. [anchored-generic-multi-dot-call]
672. Finalizing a system with two small classes causes compiler to die
while inlining. [finalize-inline-small-classes]
673. A class with a generic class whose constrained generic parameter
names a nonexistent feature in the constraining class causes
compiler to die. [generic-nonexistent-creator]
674. After initial compilation, the name of a cluster (the tag) is
changed in the Ace file. When the system is recompiled, the
compiler accepts the class instead of issuing a VD19 validity error.
[chg-cluster-name]
675. Freezing a class with a creation expression whose type is a generic
(create {TEST1 [STRING]}) produces C code that won't compile.
[freeze-generic-creation-expr]
676. A class A declares an entity of type `expanded B [like Current]'.
Since B inherits from A, there should be an expanded client cycle
involving only B. But the compiler does not detect the VLEC
error. If the entity type is instead `expanded B [A]' the VLEC
error is detected. [like-current-generic-vlec]
677. A class has a feature of type `HASH_TABLE [STRING, NONE]'. After
the compiler correctly detects a VUAR error, NONE is changed to
STRING, thereby making the class correct. When compilation is
resumed, the compiler dies with a segmentation fault during degree
-1 on HASH_TABLE. [none-then-string-generic]
678. A class has a feature of type `PROCEDURE [TEST, NONE]'. After
the compiler correctly detects a VJAR error, NONE is changed to
TUPLE, thereby making the class correct. When compilation is
resumed, the compiler dies. [none-then-tuple-generic]
679. After initial compilation where the system is melted, the root
class is changed so that it is expanded and the system is
frozen. The resulting C code will not compile in eparents.c.
[make-root-expanded-freeze]
680. A class declares a local entity of an expanded type and then calls
a feature on the entity, passing the local itself as an actual
argument in the call. The called feature evaluates `arg =
Current'. When the system is executed, it dies with a run-time
panic and the message "operational stack botched", but only if the
system is melted. Frozen code works fine.
[expanded-melted-equal-current]
681. A class repeated creates a manifest array whose elements are an
expanded type. If the routine which does this creation the array
and the elements are all melted and there are four or more elements
in the manifest array, a segmentation fault occurs when the system
is executed. Frozen code works fine. [manifest-array-of-expanded]
682. Freezing a system with a class with a routine which takes one
argument of type NONE, clones it and assigns the result of the
clone to a local of type NONE causes silent termination of
compilation while freezing. [unusual-none-use]
683. A class which provides NONE as actual generic parameter in a
generic derivation of LINKED_LIST causes silent termination of the
compiler during pass 3. [none-as-actual-generic2]
684. A system with a reference to `Current.Void' causes silent
termination of the compiler while freezing. [current-dot-void]
685. Finalizing a class with a BIT attribute produces C code that
won't compile in esize.c. [finalize-bit-attribute]
686. A generic class CHILD has an inheritance clause `TEST1 [CHILD]',
which should elicit a VTUG(2) error. Instead, the compiler
reports a VTCG error in the generic constraint of a different
class. But in order to discover the VTCG violation, the compiler
should have had to analyse CHILD enough to detect the VTUG error,
which is the real problem. I decided compiler's behavior is
reasonable. [vtcg-instead-of-vtug2]
687. An Ace with a cluster which references a nonexistent "use" file
causes the compiler to terminate with a "No such file or directory
error" during degree 6 on the cluster. [nonexistent-use-file]
688. A routine with the instruction `s := create {NONE} s.make' where
s is a STRING causes compiler to die. [assign-creation-expression]
689. A generic class with a formal generic parameter constrained by
a TUPLE type causes compiler to die. [generic-constrained-by-tuple]
690. A class with a generic class whose constrained generic parameter
names a nonexistent infix feature in the constraining class causes
compiler to die. [generic-nonexistent-infix]
691. A internal routine which just retries exceptions a specified
number of times and then returns successfully calls an external
routine which raises an exception. When the internal routine is
called repeatedly, more and more C memory is used, which seems to
indicate a memory leak. [external-exception-memory-leak]
692. A system which calls a once function whose result type is an
expanded type should execute correctly, but dies with an exception
trace or with illegal instruction if it is partially melted.
[once-expanded-result]
693. A routine creates does a creation on an attribute of type `TEST1
[BIT 8]' where TEST1 [G] has a creation procedure with a single
formal argument of type G. This creation procedure calls `out' on
the formal argument to display it. The system compiles fine, but
dies with a precondition violation in `put' of BIT_REF.
[generic-formal-bit-actual-arg]
694. Null characters (%U) are completely ignored in a standard operator
name such as infix "and%U", but only when they are trailing nulls.
ETL page 68. [std-operator-trailing-null]
695. A syntax error with the invalid character Ctrl-@ or Ctrl-A causes
the compiler to terminate with a segmentation fault.
[null-or-ctrl-a-syntax]
696. There is no limit to the length of identifiers. But the compiler
reports a syntax error for identifiers longer than 511 characters.
ETL page 418. [fairly-long-identifier]
697. A declaration of a routine with zero arguments which includes the
parentheses around an empty argument list, such as `try () is do end'
should be accepted but is not. ETL page 109. [routine-empty-arg-list]
698. A Real constant `.e1' has both the integral and fractional parts
absent, making it invalid, but the compiler accepts it. The
generated C code will not compile (melted code gives wrong
results). [point-e-one-real-constant]
699. A qualified call to a feature whose name is `e' followed by an
unsigned integer (e.g., `e47') should be legal, but the compiler
reports a syntax error. The `.e47' in the call `my_feature.e47' is
misinterpreted as a Real constant. First reported by Bertrand
Meyer on NICE Eiffel Language mailing list.
[qualified-call-e-forty-seven]
700. The name NONE is accepted as formal generic parameter in a generic
class. ETL page 52. [none-as-formal-generic]
701. When a class with a postcondition containing the assertion `(old
(old Result)' is compiled, the compiler correctly reports a syntax
error. But when the extra parenthesis is removed, the compiler
issues a VEEN(22) error (local entity may not be used in this
context) naming the entity `y'. It should instead report a VEEN(2)
error (illegal use of Result). If the class is compiled from
scratch, a VEEN(2) error is correctly reported. [veen2-called-veen22]
702. When a class having an invariant with a syntax error is compiled,
the compiler correctly reports a syntax error. But when the
missing parenthesis is added and compilation is resumed, the
compiler reports a bogus VEEN error instead of the expected VUAR(1)
error. [vuar1-called-veen]
703. A sequence of changes where a VSRC(2) error is added and then
removed causes the compiler to die. [add-remove-vsrc]
705. A system with a class which does a creation instruction on a local
of type INTEGER and then tries to add 1 to that local compiles
fine, but when it is executed it dies with a panic and the message
"operational stack botched". [create-integer-then-incr]
706. A function which returns a BIT type includes an explicit creation
instruction `!!Result'. The class compiles fine, but when the
BIT type is printed it is wrong. Removing the explicit creation
instruction causes system execution to produce correct output.
[bit-function-explicit-creation]
708. A set of fairly deeply nested multi-branch instructions (49 deep)
causes the compiler to silently terminate after pass 5 on the
enclosing class. Same thing for deeply nested conditionals.
[deeply-nested-when]
709. A class with an invariant which has any reference to a feature
address `$x' causes the compiler to terminate with a segmentation
fault during degree 3. [feature-address-in-invariant]
710. Finalizing a class with a routine with an argument of type
ARRAY [EXPANDED_TYPE] causes compiler to die while inlining.
Actually, I'm not sure that is the cause of the problem but
the compiler does die.
[finalize-inline-array-expanded]
711. Finalizing a system with a function whose body is
`Result := create {SEQ_STRING} .make (47)' causes compiler to die.
[finalize-creation-expression]
712. A class with a reference to `s~make' in the invariant causes
compiler to die. [invariant-delayed-closed-target]
713. In a generic class, an attempt to use 8 or more formal generic
parameters causes the compiler to report a syntax error. ETL page
52. [vtct-on-generic-5]
715. An Ace which specifies a precompiled cluster with a very long path
name (a little longer than 512 characters) causes the compiler to
die with a run-time panic and not return the license. Similarly,
specifying a long string for an assertion level kills the compiler.
In fact any long string in the Ace file kills the compiler.
[long-precompiled-path-name]
716. A class with two creation clauses (`creation make' and `creation')
where `make' is a procedure of the enclosing class causes silent
termination of the compiler after pass 4 on the class.
[two-creation-clauses-one-empty]
717. Selecting Special menu and Version menu item in an empty Class tool
causes ebench to die with a segmentation fault.
[ebench-empty-class-version]
718. Selecting File/Feature/Print or File/Object/Print causes ebench to
die with a segmentation fault, regardless of whether or not there
is a feature or object in the window whose contents are to be
printed. [ebench-print-debugger-feature]
719. A class with a call `f ("#",a,"%N")' should be valid but
the compiler reports a syntax error. Adding white space
before the `a' eliminates the error.
[bogus-string-syntax-error]
720. A valid class with an indexing clause with either an Index_tag or
an identifier Index_term which includes `class', even as a proper
substring, causes the compiler to report VTCT on the enclosing
class. [vtct-on-valid-class]
721. An external routine has a signature specified (e.g., "C (double):
long") to cause casting of a result before it is passed back to the
Eiffel side. The external routine is redefined in a descendant.
In a call to the routine which is statically bound, the cast is not
applied to the result of the function call in the generated C code
if the system is finalized. This results in wrong results when the
system is executed. A frozen system works correctly.
[finalize-cast-func-result]
722. A manifest string constant with 400000 characters should be
allowed, but the compiler dies while trying to compile class.
[long-string-constant]
723. A bit constant which is 300000 bits long causes the compiler to
die while trying to compile the class.
[long-bit-constant]
724. A class calls `print (i = i.default)' on an INTEGER i.
T N and just returns its argument. The system compiles fine when
melted, but when executed it dies with "operational stack botched".
Frozen code works correctly. [compare-var-to-default]
725. An expanded class FOO has a function `weasel' whose return type is
`like Current'. A routine declares a local entity of type FOO and
calls `weasel' on it, passing this result to another routine.
[pass-expanded-like-current]
726. A class which inherits from an unconstrained generic class and
provides a BIT type as actual generic parameter, where the number
of bits is specified by an integer constant attribute, causes
silent termination of the compiler. If the class is instead a
client of the generic class with the same actual generic parameter,
termination does not occur. [valid-weasel-bits]
727. A class with a very long token (300K) causes the compiler to die.
[very-long-token]
728. Running es4 on a new project whose Ace specifies a precompiled library
and typing a control-C as soon as es4 announces that it is
retrieving the precompiled information causes it to repeatedly
print a PANIC CASCADE message. Es4 uses up more and more memory
until you kill the process via "kill -9". Presumably, it would
eventually run out of memory.
729. Finalizing a system with `assertion (all)' specified in the Ace
when precompiled EiffelBase is used produces C code which won't link.
NOTE: Test cannot be automated because can't tell EiffelWeasel
to keep assertions in final mode.
SECOND NOTE: EiffelWeasel has been enhanced with compile_final_keep
instruction and test has now been automated.
[finalize-precomp-assertion-all]
730. A routine has a call to `equal' where both operands are bit
constants which are all zeroes and the second operand is `0B'.
The call incorrectly returns false if the length of the first
operand is 63 bits or greater. [long-short-bits-not-equal]
731. A class with an attribute of type `expanded TUPLE' compiles when
frozen but system execution ends with a panic.
[freeze-expanded-tuple-attr]
732. A system has a deferred class with one attribute `weasel' and one
deferred feature. There is one effective descendant class which
effects the deferred feature. If the system is finalized, a
reference to the attribute via `x: PARENT; !CHILD!x; i := x.weasel'
is not statically bound, though it should be.
[finalize-attr-dynamic-binding]
733. A routine with an integer divide-by-zero terminates the program
with "Arithmetic Exception" and no exception trace. The rescue
clause is not executed. Melted code executes rescue clause once
and then prints "Floating exception" and
terminates. [rescue-floating-exception]
734. A class has a routine which repeatedly creates a manifest array,
each of whose elements is `strip ()'. The class has one
attribute, of type ARRAY [ANY]. Executing the system results in a
run-time panic. Reducing the number of "strip ()" elements below
49 or turning off garbage collection allows the system to execute
correctly for a huge number of iterations. [manifest-array-of-strip]
735. When an inheritance clause is deleted, a former CHILD class no
longer conforms to PARENT. This introduces a violation of the
Redeclaration rule (VDRD), but the compiler does not detect it.
[vdrd-sneak]
736. A class inherits an external routine and tries to redefine it, but
includes some locals in the redefined external routine. The
compiler catches the VRRR(2) error. Then the parent version is
changed to a deferred feature and the child version is changed to a
non-external routine. When compilation is resumed, the compiler
terminates silently after pass 2 on the parent class.
[redef-external-chg-to-effect]
737. A class has routines which take an argument of type INTEGER, REAL,
DOUBLE or ANY and calls to these routines passing an INTEGER. REAL
or DOUBLE constant or variable. After initial compilation where
the system is frozen, formal argument types are change to a more
general type (e.g., INTEGER is changed to REAL or DOUBLE or ANY,
etc). When changes are melted, system execution produces the
wrong output and then a segmentation fault.
[change-numeric-formal-argument]
738. After initial compilation, a VEEN error is introduced by changing
an identifier in a class invariant. When the compiler detects it,
the error is removed and compilation resumes and finishes normally.
But a subsequent attempt to freeze the system with no further changes
causes the compiler to die. [add-remove-veen-freeze]
739. After initial compilation, the inheritance clause in a class used
in a formal generic constraint is changed, introducing a VTCG
error. When the system is recompiled, the compiler does not
detect the error. [vtcg-weasel]
740. After initial compilation where the system is frozen, an inherited
external BOOLEAN function is changed to an internal BOOLEAN
function and changes are melted. System execution then ends with a
run-time panic which states "invalid assertion level". The problem
does not occur if the routine which gets modified is introduced
directly in the class which calls it, instead of appearing in an
heir. [chg-external-to-internal]
741. After initial compilation where the system is frozen, an entity
name in a postcondition is changed to the name of a nonexistent
entity. When the compiler reports the VEEN error, the entity name
is changed back to its original value and compilation completes.
But execution of the resulting system ends with a run-time panic
which states "invalid assertion level".
[postcondition-veen-then-restore]
742. After initial compilation where the system is melted, an entity
name in a class invariant is changed to the name of a nonexistent
entity. When the compiler reports the VEEN error, the entity name
is changed back to its original value and compilation completes.
But execution of the resulting system, which was compiled with
`assertion (all)', does not monitor class invariants. It does
monitor all other assertions. [invariant-veen-skip-invariant]
743. After initial compilation where the system is frozen, an inherited
internal INTEGER function with no arguments is changed to an INTEGER
constant and changes are melted. System execution then ends with a
run-time panic which states "invalid assertion level".
[chg-argless-func-to-constant]
744. A call to a routine which is implemented as an infix operator
sometimes gives the wrong results when the formal argument is of a
heavier type than the actual argument (e.g., formal is DOUBLE and
actual is REAL). Also, in some cases passing a REAL to a REAL
formal argument does not give correct results. In some cases,
frozen and melted code give different results.
[infix-integer-real-double]
746. A routine's precondition calls a routine which raises an exception
and then retries and succeeds. After freezing, system execution
works correctly except that after the last instruction of the root
creation procedure is executed system execution ends with a
segmentation fault. Melted code works fine.
[frozen-retried-precondition]
747. A system has a routine with a delayed call expression for a
deferred routine. When the system is finalized with inlining,
system execution produces incorrect output (actually, a
segmentation fault). [finalize-delayed-deferred-call]
748. Null characters (%U) are dropped from a manifest string.
(Execution ends with a panic if system is melted).
[null-char-in-string]
749. An actual argument of type INTEGER is not converted correctly when
passed to a routine whose corresponding argument is of type DOUBLE,
but only when the called routine is an infix operator feature.
[wrong-oper-int-convert]
751. A class does a comparison INTEGER_REF > INTEGER. This should be
legal, since INTEGER conforms to INTEGER_REF, and the compiler
accepts it. But executing the system results in an exception
trace (segmentation fault or bus error). Same thing for REALs,
DOUBLEs and CHARACTERs. [integer-ref-gt-integer]
752. A class has two attributes of type `expanded TEST1 [STRING]'.
TEST1 is a generic class with parent `ARRAY [expanded TEST1 [G]]'.
The system compiles fine, but dies with an exception trace when
executed. Turning off garbage collection allows the program to
run correctly. [inherit-array-of-expanded]
753. A class creates an ARRAY [BIT 32] and fills it with elements of
type BIT 32. Executing the system results in a run-time panic if
the size of the array is big enough (approximately 4500), but only
if garbage collection is on. If garbage collection is off, a
500_000 element array works fine. [big-array-of-bit]
755. A class with one attribute, which is of type LINKED_LIST [STRING],
repeatedly calls `strip ()' and checks the result. The system
compiles fine, but executing it yields some `strip' result arrays
whose first element does not conform to LINKED_LIST [STRING].
Trying to print the offending first element terminates system
execution with an illegal instruction. [strip-bad-linked-list]
756. A class with a routine that has a single instruction
`io.put_character ('%/255/')' compiles fine but dies with
an exception trace indicating I/O error when executed.
[put-character-255]
757. Finalizing a system with a delayed call and specifying `inlining (yes)'
causes compiler to die. [finalize-inline-delayed-call]
758. A function whose return type is an expanded type has a local of
this return type and body `Result := x'. When the system is
finalized, the code generated for the routine won't compile.
[finalize-expanded-return-type]
759. A function takes a BIT argument and just returns its argument.
When the system is finalized, the code generated for the routine
won't compile. [finalize-bit-return-type]
760. When a system with a VTCG error (creation procedure named in constraint
does not exist) is compiled, the compiler detects the error.
However, when the system is melted again to resume compilation,
the compiler dies. [vtcg-creator-try-again]
761. After initial compilation where a system is finalized, an attribute
is moved to a parent class and the parent's name is changed to
the child's name (child is renamed to something unused).
When the system is recompiled, the compiler dies.
[finalize-move-attribute]
762. A Generate or External clause in the Ace which names the valid
language `C' or `c' causes the compiler to report a VD33 or VD34
error (respectively), but only if the language name is enclosed in
double quotes. [quoted-gen-or-ext-language-name]
763. An Ace with a "use" file containing the single line `system test
root TEST1 end' causes the compiler to terminate with a
segmentation fault during degree 6. [use-file-containing-ace]
764. A function whose return type is NONE and which references the
predefined entity Result is reported to violate the Entity
rule (VEEN(2)). [result-in-none-func]
765. The expression `old Void' should be accepted in a postcondition,
but the compiler reports a VAOL(2) error. [old-void]
766. The expression `f = Void', where `f' is a procedure, violates VKCN
but the compiler accepts it. If the system is being frozen, the
compiler terminates during degree -2. [compare-procedure-to-void]
767. Putting a procedure call (rather than a function call) as an element
in a tuple causes the compiler to die in degree -1 if system is being
frozen. Melting is successful, but executing the resulting system
gives an "operational stack botched" error. Seems like there is a
missing validity constraint. [procedure-in-tuple]
768. A class calls a function which takes an argument of type `ARRAY
[BIT 500]', passing as actual argument a manifest array of bit
constants which are each only 1 bit long. After initial
compilation where the system is frozen, the return type of the
function is changed from `BIT 2000' to `BIT 2100' and changes are
melted. System execution then ends with a "bit copy panic (void
source)" run-time panic. [short-manifest-bit-array-arg]
769. A once function which calls itself before setting Result reveals
that Result is not properly initialized, but only if system
is melted. Frozen and finalized code work as expected.
[once-result-uninitialized]
770. An external routine implemented as a C macro is redefined in two
descendants. For a call to the routine which cannot be statically
bound, incorrect C code is generated if the system is finalized
(the `()' after the function call is omitted).
[finalize-redef-external-macro]
771. A class which repeatedly extends an ARRAYED_LIST [X], where `X' is
an expanded type, compiles fine. When it is executed, it quickly
dies with a segmentation fault in `auto_resize'.
[auto-resize-exp-arrayed-list]
772. A system creates an ARRAY [BIT 32] and tries to print item 1
without putting any items in the array. It compiles fine, but
dies with a run-time panic when executed (bit copy panic).
[bit-copy-panic-void-source]
773. A class with a generic creation which omits the constraint
(e.g., TEST1 [G create make end]) causes the compiler to die in
degree 4. [generic-creation-no-constraint]
774. A reference to the delayed call expression "{NONE}~weasel"
causes the compiler to die in degree 3. [none-delayed-call]
775. A deferred class which constructs a delayed call on a deferred
routine compiles fine when finalized, but the generated C code
won't compile when dead code removal is turned off.
[finalize-deferred-delayed-call]
776. A class with the inheritance clause `inherit GENERAL' should have
ANY added implicitly as an ancestor, thereby making the features
of PLATFORM accessible, but it does not. [inherit-any-not-ancestor]
[Retired because class GENERAL has been eliminated].
777. A class with an explicit creation type in a creation expression
that appears in the class invariant causes compiler to report
a VGCC(5) error. [invariant-creation-expr] [Test was wrong -
it has been corrected and passes].
778. Dragging the formal generic parameter G from the inheritance
clause for RESIZABLE in class ARRAY (when class is in Text format)
into a Shell Hole, the Stop Points hole or the Clear Stop Points
hole causes ebench to die with a segmentation fault.
[ebench-drop-formal-generic]
779. Putting a stop on the routines of a class, removing all references
to the class in the only class that references it and then
recompiling causes ebench to die with a segmentation fault.
Now the problem happens when select Clickable format in class tool.
[ebench-remove-stopped-class]
780. Putting a stop on a routine and then changing it to an attribute
and recompiling causes ebench to die with a segmentation fault.
[ebench-stopped-routine-attribute]
781. Putting a stop on an routine and then changing it to a deferred
routine or to an external routine and recompiling causes ebench to
die with a segmentation fault. [ebench-stopped-routine-deferred]
782. Start ebench and freeze a system with a root class whose creation
procedure body is `try1; try2'. Drag `try1' into Stop Points hole.
Click on Step button. Stops at first instruction of `try1'. While
stopped there, set a stop point on the call to `try2' in root
creation procedure. Click on either Run or Step button.
Application terminates instead of stopping on Stop point.
[debugger-skip-explicit-stop]
783. Run EiffelWeasel on `external-feature-address' using -k option.
Change to project directory used for test and start ebench. Start
feature tool on `make' from TEST. Set stop point on first
instruction. Click on Run twice. Program gets "illegal access to
Current" run-time panic. Retired because compiler now reports
a NOT_SUPPORTED validity error instead of accepting the class.
[debugger-illegal-access-to-current]
784. Under certain unreproducible circumstances involving incremental
changes (melting and freezing), a system gets into a state where
the debugger will stop at a stop point but displays `Void' as the
name of the feature in which it is stopped. Retired because not
reproducible (and probably fixed in new debugger). [debugger-void-stop]
785. Putting a stop point on `capacity' from STRING and all the routines
of a simple class causes the debugger to hang. It says system is
running, but no CPU is used and execution does not progress.
Clicking on Execution Status then terminates ebench with a
segmentation fault. For release 4.2 on Solaris, these symptoms
don't happen but the program being run gets a segmentation fault
although it appears to be valid. Appears to be fixed with new
debugger in 5.0.015. [string-capacity-debugger-hangs]
786. A compilation followed by a sequence of setting and clearing break
points and stepping a program causes ebench to terminate with a
"byte code botched" panic. Appears to be fixed with new debugger
in 5.0.015. [debugger-byte-code-botched]
787. A class which undefines `default_rescue' and then
tries to print $default_rescue generates C code which won't compile
when system is frozen or finalized. [address-of-default-rescue]
788. If the Project tool window is on far right side of screen,
selecting the Windows menu, then choosing a menu item which has a
submenu by clicking on the right side of it (near the arrow
indicating that there is a submenu) can cause selection of the
first item on the submenu, which is not what was intended. This
happens if the submenu's first item overlaps the parent menu item.
This also happens with other menu items that indicate submenus.
[ebench-menu-overlap-problem]
789. When stopped in the debugger, right clicking twice on the dots at
the beginning of a call stack entry to move down the call stack
and then putting a stop on one of the instructions of the routine
displayed in the debugger feature window causes incorrect display
of that feature. [ebench-debugger-down-stack]
790. Start ebench. Compile a class TEST with a syntax error. When
error is reported, start Class tool on TEST. Select Special menu,
then Stoppable. Ebench dies with segmentation fault.
[ebench-error-special-stoppable]
791. After initial compilation where the system is melted, a deferred
routine effected by an attribute is changed to a constant
attribute. When the VMFN error is reported, it is changed back
to a deferred routine and compilation finishes normally. Then a
new class with a deferred version of the routine is inherited and
called with dynamic type Current. After changes are melted,
execution ends with a segmentation fault.
[vmfn-new-deferred-ancestor]
792. After initial compilation where a system with an attribute of
type `expanded TUPLE' is frozen, the system is finalized with no
changes. The compiler dies in degree -2 with a panic in
`server_item' from FEAT_TBL_SERVER. [freeze-expanded-finalize]
Test does not fail with EiffelWeasel, but can reproduce manually
in /marten/yyyy:
1. cd /marten/yyyy
echo $EIFFEL5
/home/eiffel/Eiffel5.0.016
echo $PLATFORM
solaris-2.5+
which ec
/home/eiffel/Eiffel5.0.016/bench/spec/solaris-2.5+/bin/ec
2. Using test.e and test.ace (shown below):
ec -ace test.ace -freeze
3. cd EIFGENs/test/W_code
4. finish_freezing
5. cd /marten/yyyy
6. ec -project test.epr -finalize [compiler dies]
[Appears to be fixed. Not reproducible in 5.0.020]
793. After initial compilation where the system is melted, a constant
attribute is changed to a variable attribute and the system is
frozen. The resulting C code compiles, but will not link due to
undefined symbols. [make-const-variable-freeze]
794. After initial compilation where the system is melted, a constant
attribute is changed to a variable attribute and changes are
melted. Then the variable attribute is changed to a function with
no arguments and changes are melted. System execution then ends
with a segmentation fault. [constant-variable-function]
795. A call to an infix operator feature which passes `$x' as its second
argument (e.g., `Current @ $x') should be legal, but the compiler
reports a syntax error. [infix-pass-feature-address]
796. After initial compilation where the system is finalized, a once
routine is changed to a normal routine (non-once) and the system is
re-finalized. The resulting C code will not compile.
[change-once-to-do]
797. The creation procedure of the root class repeatedly calls another
routine, which has a rescue clause. This latter routine has a
qualified call of an exported feature in a class which has a class
invariant. If assertion level `ensure' is specified for the class
with the invariant, system execution appears to continue
indefinitely, as it should. If assertion level `invariant' is
specified *and* the class invariant is violated, system execution
quickly ends with a panic. Also, once the class invariant is
violated, it is never checked again. [class-invariant-fail-panic]
798. A generic class which inherits from ARRAY [Generic #2] and ANY
causes the compiler to terminate with the tag "Compiler error".
If the inheritance is from ARRAY [Generic #1], the compiler
correctly reports a VMFN error instead of dying.
In 5.0.020, test passes EiffelWeasel but output includes
"Exception occurred while displaying error message.
Please contact ISE to report this bug."
[inherit-generic-and-any]
799. A class with an external routine whose language is "C++"
causes the compiler to die in `external_name'.
[external-c-plus-plus]
800. A sequence of changes causes the compiler to die with a
segmentation fault in `byte_node'. [byte-node-disaster]
801. A sequence of changes tricks the compiler into accepting a class
with a VXRC error. If the system is compiled from scratch the
compiler detects the error. [vxrc-sneak]
802. A sequence of changes where system is melted several times,
with various errors but with no external or deferred routines
involved, causes the compiler to die with a segmentation fault in
`set_has_loop'. [set-has-loop-disaster]
805. An Ace file with a recursive sub-cluster specification
"all root_cluster (xxx)" where xxx is never defined causes
compiler to die with a segmentation fault in
`expand_recursive_clust' instead of reporting a VD51 error.
[recursive-cluster-bad-parent]
806. A system has a class with an external routine and another class
which inherits the first class and undefines the external
routine. There is also a call to the undefined version of the
external routine (which cannot work at run-time, of course).
When the system is finalized, the generated C code won't compile.
(Note: compiler now prohibits undefining an external routine -
reports VDUS(2) error). [finalize-call-undef-external]
807. Constraint VDRD(7) prohibits redefining an external routine as an
internal one or conversely. But a class which circumvents this
prohibition by first undefining the external routine is accepted
by the compiler. The resulting system dies with a run-time panic
when executed. (Note: compiler now prohibits undefining an
external routine - reports VDUS(2) error).
[undefine-external-make-internal]
808. An invalid type used as actual generic parameter in an explicit
type in a creation instruction should cause the compiler to report
a VTEC or VTCG error, but it does not. [creation-bad-actual-generic]
809. A routine has explicit creation instruction with an invalid actual
generic parameter. The creation procedure of the generic class
takes an argument of type `G' where `G' is the name of the formal
generic parameter. The compiler should report a VTCG error, but
it does not. Compilation ends prematurely with a segmentation
fault. [explicit-creation-bad-generic]
810. A generic class TEST1 [G -> TEST2] with an attribute `s: G' has a creation
instruction `!TEST2!s.make'. The compiler should report a VGCC(3)
error but does not. The generated code acts as if the creation
instruction was `!!s.make'. [nonconforming-generic-creation]
811. An invalid type used as actual generic parameters in an explicit type
in a creation expression or an agent expression should cause the
compiler to report a VTCG error, but it does not.
[agent-bad-actual-generic]
812. A sequence of changes where system is melted several times,
with varying versions of a routine (external, deferred, once)
moved back and forth between two classes and with several errors
along the way (VXRC, VDRD(7), VMFN, EXT_SAME_SIGN) causes the
compiler to die with a segmentation fault in `set_has_loop'.
[external-routine-madness]
813. After initial compilation where the system is melted, a parent
class is added to the root class. This parent has a deferred
version of a feature effected by the root class and the deferred
feature has a precondition and postcondition. When changes are
melted, executing the system does not execute the precondition or
postcondition but it should. [add-inherited-assertions]
814. Executing a system which assigns an INTEGER_8, INTEGER_16 or INTEGER_64
variable to itself results in an "unknown entity type" run-time panic,
if the system is melted. Frozen code works correctly.
[melted-short-integers]
815. A class has attributes of a generic type using INTEGER_8
as actual generic parameter. The generic class has a routine that
prints the generating type of its single generic attribute. When
code is frozen or finalized, the generating type displayed is
INTEGER instead of INTEGER_8. Melted code works
correctly. [integer-8-generating-type]
816. A prefix operator which is implemented as an variable integer
attribute compiles fine (whether freezing or not). But when the
resulting system is executed and tries to print the value of the
attribute, an exception trace results.
[prefix-oper-attribute]
817. A class with a feature of type ARRAY [BIT n] causes the compiler to
silently terminate while freezing when `n' is very large
(250_000_000 on my machine). [array-of-big-bit]
818. Finalizing a system with a class which has a prefix operator
implemented as a variable attribute causes the compiler to die
during degree -3 on the class. [finalize-prefix-attribute]
819. A class that undefines an inherited external routine and then
effects it with an internal routine that calls precursor causes
the compiler to die in degree 3. (Note: compiler now prohibits
undefining an external routine - reports VDUS(2) error).
[undef-external-call-precursor]
821. A generic class which prints $x and $y, where x and y are attributes
of a generic type, generates C code which won't compile when system
is frozen or finalized. [address-of-generic-attribute]
822. Finalizing a system with a call to a prefix feature which is
an inherited integer constant generates C code which won't link if
system is finalized, whether inlining or not.
[finalize-prefix-constant]
823. Finalizing a particular large system with over 600 classes causes the
compiler to die with a "no such file or directory" error in
SERVER_FILE. This is a real system, not a torture test. This is a
very serious bug that MUST BE FIXED before release.
[finalize-missing-server-file]
824. A creation instruction with an explicit creation type which is a
BIT type with (what looks like) a constant attribute expressing the
number of bits in the BIT type is rejected as a VGCC(3) error,
even if the type exactly matches the declared type of the target.
[bit-creation-type]
825. Start ebench. Compile a root class TEST which inherits from
itself. When VHPR error is reported, start Class Tool on TEST.
Select Flat format (or any of several other formats). Ebench dies.
[ebench-flat-inheritance-cycle]
826. Start ebench. Click on OK. Click on Melt. Select Ace file and
compile a system with a non-generic class. Start a Class tool on
this class. Change class to a generic class. Melt. The text in
the Class tool is changed so that it is correct but no other
formats can be selected. The title bar still shows the class as a
non-generic class and says "(not in system)". One has to click on the
Class synchronization button in the upper left corner to fix it.
[ebench-make-class-generic]
827. Start ebench. Melt system with routines "make" and "try". Bring
up Feature tool on "try". Change class to remove "try". Melt
again. While compilation is going on, drag "try" into Stop Points
hole. Ebench dies. [ebench-stop-nonexistent-routine]
828. The flat form of an attribute `a' (obtained via Flat format in
Feature tool) or via `flat CLASS a ASCII' from es4 -loop) includes
the associated comment if the containing class is precompiled, but
does not include this comment if the class is not precompiled.
Also, it seems that in text format the comment is only shown with
the attribute (whether class is precompiled or not) if attribute
declaration does not end with a semicolon.
[ebench-drop-attribute-comment]
829. A deep call stack (200 routine names or more) is not displayed
correctly. If the call stack is exactly 200 routines deep, only
the top routine on the stack is shown. It appears that every 200th
routine deep, the call stack display is truncated to one entry and
then allowed to grow up to 200 again. [debugger-deep-call-stack]
830. For a class invariant violation, the debugger displays a different
exception trace than the one produced when the program is run from
the command line. The top entry of the exception trace is missing.
In 5.0.015, ebench dies when I try to execute the system with
the invariant violation. [debugger-invariant-bad-call-stack]
831. Starting an Object tool on an object with an attribute of type BIT
600 and then ending run causes ebench to die with a segmentation
fault. Now it doesn't die, but the object is not displayed properly
(funny characters near the end). In 5.0.015, debugger won't
stop and program produces no output, though it should.
[debugger-examine-bit-object]
832. After initial compilation, the entire contents of the Ace file
is deleted so that it is a completely empty file, except for some
comments. When the system is recompiled, the compiler detects the
Ace syntax error. But when compilation is resumed, the compiler
accepts the invalid Ace file. [melt-then-empty-ace]
833. After initial compilation, a syntax error is added to the Ace file.
The compiler detects the syntax error. But when compilation is
resumed, the compiler accepts the Ace file even though the syntax
error is still there. [resume-ace-syntax-error]
834. A system whose Ace file specifies `dynamic_runtime (yes)'
generates a Makefile with a wrong library name, so C code won't
link for frozen or finalized case. The ".so" suffix is missing on
Solaris platform. [dynamic-runtime-bad-library]
836. A system has a deferred class with one feature `weasel' and one
effective descendant class which effects the feature. If the
system is finalized, a call to this feature via `x: PARENT;
!CHILD!x; x.weasel' is not statically bound, though it should be.
[finalize-no-static-binding]
837. After initial compilation, the root creation procedure is changed
from `make is do end' to `make (args: ARRAY [STRING]) is do end'
and changes are melted. System execution then ends with a
segmentation fault. [add-root-creation-arg]
838. A system involving several generic derivations has an
assignment attempt. A call `a2.f' works before the assignment
attempt, but the same call fails after the instruction `a ?= a2'
where a2 is the source of the assignment attempt.
[assign-attempt-affects-source]
839. A creation instruction with an explicit creation type `BIT Weasel'
where Weasel is not defined causes compiler to report VGCC(3)
instead of VEEN error. (Note: compiler used to die).
[explicit-bit-creation]
840. A sequence of changes where a rescue clause is added to
external routines, then removed and routines are made
deferred causes the compiler to die with a segmentation
fault in `has_rescue'. [missing-rescue-clause]
841. A manifest array with one element of type INTEGER should conform to
ANY, but the compiler reports a VJAR violation. ETL pages 219, 393.
[manifest-array-conform]
842. A routine with a precondition which has a function call that
references a secret argument violates VAPE, but the compiler
accepts it. [secret-func-arg-in-precondition]
843. An exported routine has a precondition `a.b'. Feature `b' is not
available to all classes so the compiler should report a VAPE
error but it does not. [precond-call-chain-vape]
844. A system has a generic class CLIENT with constraint `G -> SUPPLIER create
make end', where the creation procedure of SUPPLIER is exported to
{CLIENT}. If another class has an attribute `x: CLIENT
[SUPPLIER]' the compiler reports a VTCG error, though it should
accept the classes. [restricted-creation-wrong-vtcg]
845. A class which calls a feature on the manifest array target
`<< << "weasel" >> >>' causes termination of the compiler during
pass 3 on the class. [nested-manifest-array-feat-call]
846. After initial compilation with an invalid type `expanded STRING'
as an actual generic parameter, the type is changed to STRING.
Finalization completes normally, but the resulting C code will not
compile. [invalid-expanded-generic]
847. A routine with an insufficiently exported entity in a precondition
violates VAPE, but the compiler accepts it. It appears that the
compiler accepts any case where both the routine with the
precondition and the entity referenced in the precondition have an
export restriction and the entity is not completely secret.
[precondition-too-secret]
848. A routine with an insufficiently exported entity in a precondition
violates VAPE. The compiler accepts it, but only if the entity
Current is explicitly involved and the entity is an operator
feature (e.g. as `Current + value'). [vape-involving-current]
849. An assignment `b := a.new_b' in a generic class `C [G -> A]',
where a is of type A, b is of type B [G] and new_b is of type `B
[like Current]' should be accepted because the type of `a.new_b'
is effectively B [G], but the compiler reports a VJAR
error. [generic-like-current-vjar]
850. After initial compilation where the system is melted, a generic
class header is changed so that it is expanded and the system is
frozen. The resulting C code compiles, but will not link due to
multiply defined symbols. [make-generic-expanded-freeze]
851. After initial compilation, a redefined `default_create' with
an empty body is changed so that the body has an instruction.
After recompilation, the new version of `default_create' should be
executed but is not. [default-create-add-body]
852. A system has a cluster "base", whose path name contains and
environment variable enclosed in braces, and a subcluster of "base".
After initial compilation, the date of modification of the Ace file
is changed without changing the file's contents. When the system
is recompiled, the compiler reports a bogus VD01 error.
[env-in-braces-bogus-vd01]
853. A routine has a precondition. The body of the routine raises an
exception which is retried by the rescue clause. When precondition
are monitored and the system is melted, the routine precondition is
incorrectly evaluated again when the retry instruction is executed.
Frozen code works correctly. [eval-precondition-when-retry]
854. A class creates an instance of INTERNAL and uses it to print the
field count of the current object. The system compiles fine
when frozen and correctly prints 0 when executed. Then an
attribute is added to the class and changes are melted.
System execution then incorrectly still prints 0, instead of 1.
[wrong-field-count]
855. A system has a routine with a call to a procedure that takes
an argument of type NONE and clones it. When the system is
finalized with inlining, the compiler dies.
[finalize-inline-none-proc]
856. An exception is raised in a routine which is being called as part
of the evaluation of an assertion. The routine handles the
exception itself and retries it. Subsequent calls from the
"retrying" invocation of the routine monitor assertions, but
should not. [retry-forget-in-assertion]
857. A class declares a local of type `FOO [expanded DOUBLE]' where FOO
is a generic class with a single formal generic parameter
constrained by DOUBLE. A routine of the generic class assigns
something of type `Generic #1' to something of type DOUBLE. The
system compiles fine, but dies with an "illegal metamorphose type"
panic when executed. If the system is frozen, the C code for the
generic class won't compile. [generic-constrained-by-double]
858. INTEGER_64 numbers do not work correctly or maybe they just don't
print correctly. [print-integer64]
859. A routine calls `s.replace_substring (s, 4, 6)' to replace a portion
of itself with its original value. The replace_substring call
does gives the wrong result. [replace-substring-with-self]
860. A call to `print (0x12345081234567)' does not print the correct
answer. It prints -1 on Solaris and -2128394905 on Windows.
[print-big-constant]
861. A routine in class A does an assignment attempt whose target is an
attribute of type B and is the routine's class. A descendant A1
of class A redefines the type of the attribute to be a descendant
of B. When the routine is executed in A1 with a passed-in
argument that is used as the source of the assignment attempt, it
incorrectly allows the assignment attempt to succeed.
[assign-attempt-redefined-type]
862. A call `b.to_integer' where `b' is of type BOOLEAN compiles
fine when melted, but executing the system results in an "Illegal
cast operation" panic. Frozen code works
correctly. [melted-boolean-to-integer]
863. Negative INTEGER_8 values do not print correctly on some architectures.
[negative-integer-8]
864. A class which prints `(<< t >>).item (1)', where `t' is of a
non-basic expanded type compiles fine when melted, but system
execution ends with a segmentation fault. Frozen code does not
die, but the output is wrong (doesn't print anything).
[expanded-manifest-array-item]
865. A generic class `C [G]' has a function `f: LIST [C [G]]'
and also has a feature `item: G'. A descendant class redefines
the function so that its signature is `f: LIST [C [like item]]'
and it calls Precursor. The compiler dies in degree 3 when
compiling the system. [generic-anchor-call-precursor]
866. A class with the instruction `j := 32 \\ i' where `j' is of type
INTEGER causes the compiler to report a VWOE error.
[vwoe-on-integer-remainder]
867. If the Ace specifies a precompiled library that is an incompatible
version, the compiler correctly reports a VD52 error. But it also
prints "Exception occurred while displaying error message" when
reporting the error message. [precomp-lib-wrong-version]
868. A system is frozen without a precompiled library. Then an
instruction `print ((<>).item (1));' is added to the
body of the root creation procedure and changes are melted. System
execution then dies with a precondition violation
(index_small_enough), though it should not.
[freeze-print-int64-array]
869. A system which calls POINTER.memory_copy as passes $double_value
(address of a double) compiles fine when melted, but dies with a
segmentation fault when executed. Frozen code works
correctly. [melted-memory-copy]
870. Routine `is_integer' from STRING accepts `(+|-)[a-zA-Z]*[0-9]*'
which is incorrect (for example, returns True for
`("-wer123").is_integer'. [is-integer-accepts-invalid]
871. A call to a static feature `feature {FOO}.value' causes the compiler
to die with a segmentation fault if FOO is a generic class that
contains a constant integer feature `value'.
[generic-static-constant]
872. A system is finalized and assertions are discarded, using the
command line compiler. When the system is re-finalized while
keeping assertions, no new C code is generated so system execution
does not monitor assertions. [refinalize-with-assertions]
873. Freezing a system which calls a feature `r: REAL is 64.0'
generates C code that won't compile.
[frozen-real-constant]
874. A system has a routine that prints its argument, where the type of
the argument is `ARRAY [like item]' and item is `item: X [like
toto]' where `toto' is of type A. When the system is finalized,
the compiler dies during degree -3.
[print-array-anchored-generic]
875. Melting a system which evalutes `item >= feature {CHARACTER}.Max_value'
where `item' is of type INTEGER works fine, but when the system is
executed it dies with a panic. Frozen code works fine.
[melted-integer-compare]
876. After initial compilation, a constrained generic parameter is added
to root class with unknown actual generic in constraint. When VTCT
error is corrected, VCFG error is reported since parameter has same
name as a class. When it is fixed there is a VSRC(1) error since
root class cannot be generic. After this is corrected, compilation
dies in degree 1. [vtct-vcfg-vsrc-die]
877. After initial compilation, the creation clause in root class is
removed, introducing a VD27 error. Then a generic parameter is
added to root class and later removed. Finally, the VD27 error is
removed. The compiler dies in degree 4 with a run-time panic.
[alternate-vd27-and-vsrc]
878. After initial compilation where the system is finalized,
the Ace is changed to indicate a new root class and changes are
melted. Execution of the melted system then executes the old root
creation procedure instead of the new one. Note: this only
happens in ebench, where changes are melted in the same session as
the initial finalization. It does not happen with two separate
invocations of the command line compiler. Second note: In 5.0.031,
the melt does not generate any executable system. [finalize-then-melt]
879. Finalizing a system with a class which has a call to an infix operator
which is an external routine causes the compiler to die
during degree -3 on the class, but only if inlining (yes) is
specified. [finalize-inline-infix-external]
880. Melting a system which evalutes `x < x' where x is of type WIDE_CHARACTER
works fine, but when the system is executed it dies with an
operational stack botched panic. Frozen and finalized code work
fine. [wide-char-comparison]
[Retired because class WIDE_CHARACTER is now obsolete]
881. A system with an Ace file that uses a precompiled library compiles
fine if the path name of the precompiled library uses environment
variables, but the compiler issues a bogus VD43 warning at the
end of compilation. [bogus-vd43]
882. An when clause of an inspect instruction does not work
correctly if the constant is of type CHARACTER and is > '%/127/.
[inspect-high-bit-char]
883. An assignment attempt `a ?= << <<"A","1">> , <<"B","2">> >>'
where `a' is of type ANY causes the compiler to crash.
[assign-attempt-manifest-array]
884. A class that copies a string whose count and capacity are 10 into
a string whose capacity is 9 causes violation of invariant with tag
`valid_count'. [string-copy-valid-count]
885. A class with a particular nested if causes the compiler to crash
when the system is finalized. [finalize-nested-if]
886. A redefinition of a routine with no postcondition uses just
"ensure" for its postcondition, rather than "ensure then".
The compiler accepts it instead of reporting a VDRD(3) error.
[vdrd3-ensure-then]
887. After initial compilation where the system is frozen, a class that
prints the value of a boolean constant, which is False, works
correctly. When the constant value is changed to True and system
refrozen, the correct value is still printed. Then the system is
finalized and execution prints False. Similar problem for reals
and doubles. [freeze-const-freeze-finalize]
888. The creation procedure of a class assigns Void to the attribute to
which the creation procedure is being applied (by the root creation
procedure). Executing the system results in a segmentation fault,
but only if the system is melted. If non-Void value is assigned
instead, the result is incorrect system execution output.
[creation-proc-modify-target]
889. A creation instruction is applied to an entity (local or attribute)
which is already attached to an object and the current value of the
entity is passed to the creation procedure (e.g., !!x.make (x)).
If the code is melted, the newly created object is passed to the
creation procedure instead of the object to which the entity is
attached before the creation instruction. Frozen code works
correctly. [melted-creation-pass-target]
890. A class calls a feature that is a once function in another class, where
the target of the call is a creation expression. The once
function value is stated not be Void in the invariant of the
second class. If the system is melted, execution ends with an
invariant violation. Frozen code works correctly.
[invariant-melted-once-function]
891. A tuple composed of an integer and an expanded type works properly
when melted, but not when frozen or finalized. This appears to
be a code generation bug. [tuple-expanded-and-integer]
892. Melted/frozen, finalized and finalized-with-inlining code
give different results for some numerical operations (floor and
ceiling), as well as in cases where a real must be converted to a
double or an integer must be converted to a real.
[numeric-discrepancies]
893. A class has an agent whose target is an expanded type, is non-Void
and has no open operands. The system compiles fine when frozen or
finalized but dies with a "Feature call on Void target" exception
when executed. [agent-expanded-target]
894. A system involving several generic derivations prints out
the generating type of an attribute as `ARRAY [B2 [STRING]]'
instead of `ARRAY [B2 [C]]'. [wrong-generating-type]
895. A class does an `independent_store' of an object that has
two expanded attributes, then retrieves the previously stored
object. The values in the expanded attributes are incorrect after
retrieval. [store-expanded-retrieve-wrong]
896. A class does an `independent_store' of an object that has
two expanded attributes, where each expanded object has an INTEGER
attribute and another attribute of an expanded type. Freezing the
system works fine, but during execution when the stored object is
retrieved, a floating point exception occurs. Finalizing the
system produces C code that won't compile.
[store-expanded-retrieve-dies]
897. A system creates two objects of type ARRAY [X], where X is
an expanded class with attributes. The two objects should be
deep_equal, but they are not. [array-expanded-not-deep-equal]
898. A class does an `independent_store' of an object that has
two expanded attributes, where each expanded object has an INTEGER
attribute, another attribute of an expanded type and a third
attribute that is an array of expanded. Freezing the system works
fine, but during execution the retrieved object is not deep_equal
to the original stored object. [retr-expanded-not-deep-equal]
899. A class creates a linked queue and puts two elements in it, then
gets its linear representation. When system is executed, it
dies with a postcondition violation.
[linked-queue-linear-rep]
900. A class that calls `is_special_any_type' on the dynamic type of
the `area' of an ARRAY incorrectly returns False, but only if the
class also contains an array whose elements are of an expanded
type. [is-special-any-type-lies]
901. If a class does an `independent_store' of an ARRAY [STRING]
whose count is more than 65536, GC memory is corrupted which later
causes a crash. [indep-store-big-array]
902. A once function is supposed to return the value computed thus far
when called recursively, but doing a recursive call to a once
function shows that a creation instruction whose target is Result
incorrectly attaches the newly created object to Result before
calling the named creation procedure. [recursive-once-create-result]
903. A class which references `<< "weasel" >> @ 1' causes termination
of the compiler during degree 3. [manifest-array-at-sign]
904. A static call `feature {NONE}.value' causes the compiler to die
with a segmentation fault in degree 3. [static-call-on-none]
905. A class which inherits from CHAIN causes the compiler to
die in degree 4. [inherit-from-chain]
906. Procedure `default_create' is not called on all elements of a
SPECIAL being created, when the elements are of an expanded type.
[special-of-expanded]
907. Bug in generic conformance involving class with two constrained
generic parameters. [generic-conformance-two-params]
908. An invalid expanded type used as actual generic parameter in an
explicit type in a parent part in an inheritance clause should
cause the compiler to report a VTEC error, but it does not.
[inheritance-bad-actual-generic]
909. After initial compilation, an attribute of type STRING which is the
anchor for another feature is changed to a procedure with no
arguments. When the system is recompiled, the compiler does not
notice the newly introduced VTAT error. [intro-vtat-attr-to-proc]
910. After initial compilation, an attribute used as an anchor in a type
serving as actual generic parameter is changed to a procedure.
When the system is recompiled, the compiler incorrectly reports a
VTCG error (which is impossible since the involved generic class
has no generic constraints) instead of a VTAT(1) error.
[vtat1-called-vtcg]
911. A system with a class that has a C++ external is frozen. Then
the external feature is changed to a C external and the system is
refrozen. The resulting C code compiles, but will not link due to
calling "cpp" to do the link instead of "gcc".
[change-cplusplus-to-c]
912. A system has a class B that inherits from class A and redefines
a function into an attribute. After the system is frozen, class B
is changed so that it renames the function instead of redefining
it, but it still includes the attribute that was the redefinition.
When the system is refrozen, the resulting C code compiles, but
will not link due to an undefined symbol. [redefine-to-rename-refreeze]
913. Finalizing a system with `b or else True' and keeping assertions,
where b is a boolean in a system with a postcondition `ensure b'
produces code that violates the postcondition. [finalize-or-else-true]
914. A routine prints the value of `x * x', where `x' is a DOUBLE constant.
If the system is finalized, the wrong value is printed. Melted and
frozen code work fine. [finalize-mult-double-constant]
915. A class which redefines a feature of type `REAL' to be of type
`expanded REAL' is reported to violate VDRD(2). ETL page 226.
[expanded-redeclaration]
916. A real number 5_000_000.5 is read as 5 by the lexical analyzer.
[real-const-with-underscores]
917. A generic class with the header
"class TEST2 [G -> INTEGER create make end]"
causes the compiler to die in degree 4. [generic-constrained-by-integer]
918. A class creates an instance of a second class stores it in a file
using `independent_store' and then opens the file and retrieves
what was previously stored. After initial compilation, system
execution works correctly. Then a local of type `ARRAY [expanded
A]' is added and system is recompiled (frozen). Execution then
incorrectly ends with a mismatch retrieval error.
[freeze-retrieval-mismatch]
919. Invalid feature declarations of all kinds are now rejected as a
syntax error. However, the wrong line number is reported for
features like "f2 is 13" if they don't end with a semicolon.
The syntax error should be detected at the "13" but is only
detected at the next token. [bad-feature-decl]
[Decided this wasn't really a bug]
920. The Index tag is supposed to be optional in an Index_clause, but a
clause without an index tag is rejected as a syntax error.
ETL page 49. [no-index-tag]
[New ETL3 requires an index tag]
921. An attribute with an anchored type, whose anchor has a
Formal_generic_name for its type appears to violate VTAT1, but is
accepted by the compiler. ETL page 214. [anchored-formal-generic]
[New ETL3 allow anchor whose type is a Formal_generic_name]
922. Compiler accepts the following routine:
weasel is
external
"C!@#$%%^-=+\~`{[];'./?"
end
[external-with-punctuation]
923. After initial compilation, a generic parameter is added to root class,
then a creation clause. When VSRC error is reported, generics are
removed and creation procedure formal argument is changed to
nonexistent class G. When VTCT is reported, class G is added,
introducing a VCFG error. To correct the VCFG error, the name of a
formal generic parameter is changed. When compilation is resumed,
the compiler dies instead of reporting a VSRC(3) error.
[vsrc-vtct-vcfg-die]
924. Ending class comment constraint VCRN (class name must match) is not
enforced. ETL plage 53. [bad-class-end-comment]
[New ETL3 no longer includes this constraint - it's just a style
guideline.]
925. A routine with an entity named `integer' and an assertion tag
`integer' should be invalid since INTEGER is a reserved word, but
is accepted. Violates constraint VIRW. ETL pages 120 and 418.
[invalid-entity-assertion-tag]
[INTEGER is no longer a reserved word in new ETL3]
926. A class which appears to violate both VTAT1 and VTAT2, is accepted
by the compiler without complaint. ETL page 214.
[anchored-type-violation]
927. If the compiler dies with an illegal instruction, then the license
token is not returned. This is particularly noticeable if one has
only one license. I don't know of any way to avoid this problem
except to avoid executing illegal instructions.
[illegal-instruction-keep-license]
[Retired because no license manager any more]
928. A class with an anchored type as explicit creation type in a
creation instruction appears to be valid, but the compiler reports
that this construct is not supported. ETL page 285.
[anchored-creation-type]
929. After initial compilation, the root class is changed to a generic
class by adding a single formal generic parameter. When the system
is recompiled, the compiler detects the VSRC violation but first
does pass 5 twice on the root class. After the problem is
corrected by removing the formal generic parameter, the compiler
again does pass 5 twice. [generic-pass-one-twice]
[Retired because compiler no longer does pass one twice. Also,
even if it did I don't think we should be checking that anyway.]
930. A system sets an environment variable (via EiffelWeb class CGI_INTERFACE)
and then repeatedly gets the value of that variable and wastes some
memory. If garbage collection is on, the value of the environment
variable is soon overwritten, though it should not be.
[eiffelweb-overwrite-env-var]
[Retired because I think this has been fixed for quite awhile.]
931. Compiling the C code generated for the following features generates
warnings of the form:
/marten/test/EIFGENs/test/W_code/C1/pl13.c:334: warning: assignment makes integer from pointer without a cast
For example, the code generated for PLATFORM.minimum_integer includes this:
EIF_INTEGER_32 Fah89z3 (EIF_REFERENCE Current)
...
ti32_1 = (tp1 = RTLN(RTUD(71)), *(EIF_INTEGER_32 *)tp1 = Current,
(FUNCTION_CAST(EIF_INTEGER_32, (EIF_REFERENCE)) RTWPF(24, 3, RTUD(71)))(tp1));
The problem is with
*(EIF_INTEGER_32 *)tp1 = Current
The type of Current is EIF_REFERENCE and it is being assigned to
an EIF_INTEGER_32 without first casting it to that type.
The following features probably won't work correctly on some platforms:
INTEGER_8_REF.is_valid_character_code
INTEGER_16_REF.is_valid_character_code
INTEGER_16_REF.to_integer_8
INTEGER_64_REF.is_valid_character_code
INTEGER_64_REF.to_integer_8
INTEGER_64_REF.to_integer_16
INTEGER_64_REF.to_integer_32
INTEGER_64_REF.to_integer
INTEGER_64_REF.is_valid_character_code
INTEGER_REF.to_integer_8
INTEGER_REF.to_integer_16
PLATFORM.maximum_character_code
PLATFORM.maximum_integer
PLATFORM.minimum_character_code
PLATFORM.minimum_integer
932. Melting a system with a debug instruction with debug key that
contains a null character ("weasel%U") works fine, but when the
system is executed debug instructions inside a block with the tag
"weasel%U" are not executed. [null-in-debug-key]
[There was a bug in the test - test passes after fixing it.]
933. An Ace file which specifies `hide_implementation (yes)' or
`hide_implementation (no)' causes the compiler to report a VD15
error (invalid option value) if the system is melted, frozen or
finalized instead of being precompiled. [lace-melt-hide-implementation]
[Retired because compiler no longer recognizes this option at all.]
934. An empty Feature_list in a New_export_item in an inheritance clause
should be accepted, but the compiler reports a syntax error.
ETL page 101. [empty-export-feature-list]
[Suggested to Manu that compiler is wrong on this one.
Manu says he has fixed parser to allow this case. 05-jun-2003]
935. A declaration of an external routine which declares the external to
be a macro where the word `macro' is followed immediately by a tab
instead of a space causes the compiler to report a syntax
error. [external-tab-after-macro]
[Manu says he has fixed parser to allow this case. 05-jun-2003]
936. A class with a single argument `args: like x' where `x: ARRAY [STRING]'
should be accepted (since "like" is now just syntactic sugar) but
the compiler reports a VSRC(3) error.
[anchored-bogus-vsrc3]
937. A system whose Ace specifies `syntax_warning (yes)' is compiled
and the compiler issues warning about obsolete syntax. Then this
clause is removed from the Ace file and a new use of obsolete
syntax is added. The compiler warns about the new use of obsolete
syntax, but it should not. [remove-syntax-warning-yes]
938. Specifying the option `msil_generation (yes)' causes the compiler
to die, presumably only on an inappropriate platform.
[msil-generation-yes]
939. A class with a declaration `c: CHARACTER is "abc"' should
be rejected as a VQMC but the compiler accepts it. Also
incorrectly accepts other basic types (INTEGER, REAL, DOUBLE,
POINTER, BOOLEAN) when the constant is a manifest string.
[manifest-string-vqmc-sneak]
940. A sequence of changes where system is melted several times,
with varying versions of an external routine, then made deferred
which causes a VGCC(2) error, then made external again and then
melted causes the compiler to die with a segmentation fault in
`real_body_id'. [change-external-melt]
941. An expanded class has a call to an agent, which consists of
a call to an inherited function. After initial compilation the
return type of the inherited function is changed and changes are
melted. System execution then dies with a segmentation violation.
[change-agent-return-type]
942. A class has a call to an agent, which consists of
a call to an inherited function. After initial compilation the
return type of the inherited function is changed from BOOLEAN to
DOUBLE and changes are melted. System execution then dies with a
segmentation violation. [change-agent-noexp-return-type]
943. A system calls an external routine that takes a REAL and
returns a DOUBLE. The signature specifies that the argument
should be cast to double before being passed to the external
routine. After freezing, system produces correct output.
Changing the routine with the call and melting yields a system
that produces incorrect output.
[melt-call-real-external]
944. Preconditions, postconditions and class invariants are not monitored
for an external routine when the Ace specifies `assertion (invariant)'.
[external-routine-skip-assertion]
945. A system which is compiled using precompiled EiffelBase and
which declares an external routine identical to one that is
already in the precompiled library compiles fine when melted.
But executing the system results in a segmentation fault.
Frozen code works correctly. [melt-call-precomp-external]
946. A class creates several threads. Each thread repeatedly creates
a string whose length is determined by a random number generator
and fills the string with blanks. System execution ends with an
exception, but should not. [multithreaded-string-blank]
947. Floor and ceiling called on a REAL do not work correctly when
code is frozen. [frozen-floor-ceiling]
949. An external routine which takes an expanded argument and is
defined as a macro with a signature compiles fine when
frozen, but when executed the system dies with a segmentation fault.
[expanded-arg-macro-with-cast]
950. A system with one class is compiled. Then the root class is
changed to a different class, the system name is changed as well
and changes are melted. Finally, the system name is changed back
to its original value and system is recompiled again. The
compiler then dies with a bus error. [change-sysname-and-root]
951. Finalizing a system with an expanded class which has an external
(rather than internal) creation procedure produces C code which
won't link. [finalize-expanded-ext-creation]
952. Finalizing a system with a trivial root class when using
precompiled EiffelBase with dead code removal turned off produces C
code which won't compile in ececil.c. [finalize-precomp-no-dead]
953. For an external feature which is declared as an infix feature, the
compiler passes two arguments to the external C routine if there is
no signature specified in the External_declaration, but only one
argument if a signature is specified. It is not clear from ETL
which one is correct. Similar question for prefix features. ETL
page 421. [external-infix-feature]
954. A class creates a number of objects, guided by a random number
generator. If the EIF_MEMORY_CHUNK environment variable is set to
262143 before execution, system execution ends with a panic.
[odd-gc-chunk-size]
955. Try to compile a system after doing "setenv EIF_MEMORY_SCAVENGE 8193".
Compiler usually dies. Looks like the value needs to be a multiple
of 8, but run-time doesn't round to nearest multiple of 8.
[odd-memory-scavenge-size]
956. Finalizing a system with an expanded class which has an external
creation procedure that is inline C code generates C code which
won't compile. [finalize-ext-exp-inline-create]
957. An external routine which is used as the root creation procedure is
declared to take a single argument of type ARRAY [STRING]. When
the external routine tries to access the array, a segmentation
fault occurs. It is also impossible to declare an external root
creation procedure to take two arguments (one of type
ROOT_CLASS_NAME, the other of type ARRAY [STRING]) even though this
is what appears to be passed to the external routine.
[external-root-proc-with-args]
958. A class FOO has a generic parameter G of type XXX with a generic
creation clause `create default_create end'. Another class
declares an attribute of type FOO [XXX], where `default_create'
is not listed as a creation procedure of XXX. The compiler should
report a VTCG error but does not. [default-create-vtcg]
959. A external routine which is "C inline" without an alias to specify the
actual text of the C code is accepted by the compiler but should
not be. Compiler dies with a segmentation fault in degree -1.
[c-inline-without-alias]
960. An external "C++" routine which is a delete for a C++ class
is required to have a single argument of type POINTER.
An argument which is anchored to an attribute of type POINTER
is rejected as an EXT_CPP error, but should be accepted.
[cpp-delete-anchored-arg]
961. After initial compilation, a procedure is changed to a STRING and a
call of the procedure is changed to a `print' on this (Void)
string. After recompilation, system execution ends with a panic.
[call-proc-print-attr]
962. After initial compilation where the system is frozen, an attribute
of an expanded class is changed from a constant STRING to BIT 1.
The changes are melted. System execution then produces the wrong
output. [string-to-bit1]
963. After initial compilation where the system is frozen, an attribute of an
expanded class is changed from a constant STRING to BIT 1. The
changes are refrozen. System execution then produces the wrong
output. [string-to-bit-refreeze]
964. A class prints the generating type of the expression
`create {TEST1 [BIT n]}' where `n: INTEGER is 8'.
When the system is frozen, system execution works, except that
it prints "TEST1 [BIT_REF]" instead of the expected "TEST1 [BIT 8]".
When a trivial change is made to the routine and changes are melted,
execution ends with an illegal opcode panic. [bit-n-illegal-opcode]
965. A class calls an external routine with a precondition that is false.
When the system is executed, the precondition is violated and
an exception is raised, which is correct. Then the precondition
is changed so that it is true and changes are melted. System execution
still violates the precondition, but should not.
[external-make-precondition-true]
966. After initial compilation, an external routine which is "C inline"
has the order of its formal arguments changed. When changes are
melted, system execution produces the wrong output (same output as
before). Looks like the compiler needs to freeze when any changes
are made to the list of formal argument names.
[c-inline-change-arg-order]
967. A system has a generic class FOO with an inline C external function that
just returns its argument. When another class creates an instance of
FOO [DOUBLE] and calls the external function on it, the result is
correct. Then the type in the creation expression is changed to
FOO [ARRAY [DOUBLE]] and changes are melted. Finally the creation
expression type is changed back to FOO [DOUBLE] and changes are melted
again. System execution then produces the wrong output.
[chg-generic-c-inline-function]
968. A system has an external function of type INTEGER_8 which
is inline C. After initial compilation where the system is frozen,
the function return type is changed to INTEGER and changes are
melted. System execution then produces the wrong output.
[chg-external-function-type]
969. A system has a call to an agent with an open target of type TEST2.
After initial compilation where the system is frozen,
execution gives correct results. Then the target type of the
agent is changed to `expanded TEST2' and changes are melted.
System execution then dies with a segmentation fault.
[make-agent-target-expanded]
970. After initial compilation, a system which does repeated creation of
instances of an expanded type is modified: a second variable
attribute of an expanded type is added to an expanded class and
changes are melted. System execution then ends with a run-time
panic. [nested-expanded-creation]
971. Subtracting one from an INTEGER_16 attribute with
a large positive value gives the attribute a value of 0, but only
when code is melted. Frozen code works correctly. Other sizes
of integers work correctly whether code is melted or frozen.
[integer-16-minus-one]
972. A class tries to print the generating type of the expression
`create {TEST1 [BIT n]}' where `n: INTEGER is 8'.
When the system is melted, system execution ends with an
"out of memory" error. Frozen code works correctly, except that
it prints "TEST1 [BIT_REF]" instead of the expected "TEST1 [BIT 8]".
[bit-n-out-of-memory]
973. A class which prints `- (- d.truncated_to_integer)' where `d'
has value 1.3 correctly prints 1 when melted but prints 0 when
code is frozen. [minus-minus-double]
974. A call to a routine that multiplies two REAL values and returns
the result violates the routine's postcondition,
which is `Result = a_real * another_real'. This only happens
on some platforms (Windows) and only when code is frozen.
[real-times-real-postcondition]
975. An inspect with an INTEGER_8 constant that has value 0x8f does not work
correctly, but only when code is frozen.
[inspect-high-bit-integer8]
976. A routine does a bitwise "and" of an INTEGER_16 local with 0xFF00.
The result is wrong if code is frozen, but is correct when melted.
[frozen-bitwise-and-local]
977. A routine in a generic class has an assignment attempt whose right
hand side is of type Generic #1. If the actual generic parameter
is an expanded type and if the call to the routine is inlined,
system execution ends with a segmentation fault.
[inline-generic-assign-attempt]
978. A class creates an ARRAY [BIT 4096] and fills it with elements of
type BIT 4096. Executing the system results in a segmentation
fault if the size of the array is big enough (approximately 3000),
but only if the system is finalized and garbage collection is on.
[bigger-array-of-bit]
979. An external "C inline" function which sums its DOUBLE arguments gives
the wrong results if the function takes 10 or more arguments, but
only when code is finalized. [c-inline-function-ten-args]
980. A class creates a LINKED_LIST [FOO] where FOO is an expanded class
and appends two elements to it and then prints the `value'
attribute of the first item in the list. The wrong result is
printed if the system is finalized with inlining (47.250000007042502
instead of 47.25). [inline-linked-list-expanded]
981. A routine that compares an INTEGER local with
`feature {INTEGER}.Min_value' minus another local displays the
wrong result, but only when code is finalized.
[vicious-finalize-bug]
982. An external inline C routine used as a root creation procedure
tries to print the number of arguments passed to the program
but the wrong number is displayed. An external routine which
is not inline seems to work correctly as root creation procedure.
[inline-external-root-proc]
983. A class creates strings of size 1, 2, 3, etc. If the EIF_GS_LIMIT
environment variable is set to 5000 before execution, to set
`generation_object_limit', system execution ends with a panic.
[bigger-generation-object-limit]
984. A class enables GC time accounting, creates some objects and
then gets GC statistics. The incremental collector values
`collected' and `collected_average' are negative.
[negative-incremental-gc-stats]
985. An external routine which takes a string argument has a precondition
involving the argument. The code compiles fine (though the C
code compilation generates warnings) but the precondition is
violated when system is executed, though it should not be.
[external-precond-string-arg]
986. Finalizing a system with an expanded class that has 2000 attributes which
are of an expanded type causes the compiler to die with a "special
reallocation" exception. [finalize-many-expanded-attrs]
987. A generic class `TEST1 [G -> ANY create default_create end]'
declares a local of y: G and then does `create y'.
A client class declares a local of type `TEST1 [DOUBLE]'.
The system compiles fine when frozen, but the generated C code
won't compile. Melted code works fine.
[generic-create-double]
988. A class which prints `- - 3.5' works fine when melted, but
when frozen or finalized the generated C code won't compile.
[minus-minus-real]
989. Finalizing a system with a call to an inline C external routine
with 10 or more arguments, where the call passes a single local
for all the actual arguments, generates C code that won't compile.
[inline-c-ten-pass-local]
990. Compiling a system with a call to an inline C external routine
that has formal arguments `a, ab, abc: INTEGER' and alias
"$a + $ab + $abc" produces C code that won't compile.
Perhaps there needs to be a validity check that none of the
formal argument names is a prefix of another formal argument
name for a "C inline" external routine.
[inline-c-arg-prefix-other]
991. Routine `put' in EXECUTION_ENVIRONMENT is missing preconditions
that state that `value' and `key' cannot contain null characters.
Routine `get' may need a similar precondition.
[putenv-with-null]
992. A class has an external routine with an argument of an expanded
type. In a call to this routine which passes an entity of a
non-expanded type, the passed argument is not cloned first. This
results in incorrect system execution output.
[external-exp-arg-not-cloned]