mirror of
https://github.com/EiffelSoftware/eiffel-org.git
synced 2026-04-05 09:39:31 +02:00
Author:admin
Date:2008-09-17T13:53:28.000000Z git-svn-id: https://svn.eiffel.com/eiffel-org/trunk@3 abb3cda0-5349-4a8f-a601-0c33ac3a8c38
This commit is contained in:
jfiat
@@ -0,0 +1,23 @@
|
||||
[[Property:title|Assertions checking configuration changes]]
|
||||
[[Property:weight|0]]
|
||||
One of the major differences between 4.5 and 5.0 is how to specify the assertion checking in the ace file or in the project settings window. In 4.5, assertions of a certain type where checked if their level was below the requested level. Here is what the level hierarchy looked like:
|
||||
# require
|
||||
# ensure
|
||||
# loop
|
||||
# check
|
||||
# invariant
|
||||
# all
|
||||
|
||||
Meaning that you could not just check one type of assertions. With 5.0 this is now possible and we changed the presentation to follow the cost to evaluate a given type of assertions, the first one being the less expensive:
|
||||
# check
|
||||
# require
|
||||
# ensure
|
||||
# loop
|
||||
# invariant
|
||||
# all
|
||||
|
||||
The default assertion level has changed too. Not specifying any assertion level used to be equivalent to selecting the 'require' level. This is not the case any more in 5.0 it will be not checking assertions.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
[[Property:title|Compiler differences from 4.5 to 5.0]]
|
||||
[[Property:weight|1]]
|
||||
==What's new==
|
||||
* Implementation of new external syntax.
|
||||
* Implementation of verbatim strings.
|
||||
* Implementation of agents.
|
||||
* Implementation of agent creations on `Result' and `Current' object.
|
||||
* Improved incrementality of the C compilation: fewer directories will have their C files changed after a freeze.
|
||||
* New MSIL generation.
|
||||
* Introduction of 4 new basic classes: INTEGER_8, INTEGER_16, INTEGER_64, WIDE_CHARACTER.
|
||||
* Changed the storable mechanism so that we do not store POINTER objects with their value, instead we store a NULL value. As a consequence it is safe to store on disk objects that have references to C objects. Upon retrieval those references will be equal to `default_pointer'. This is now the default behavior, if someone wants to have the previous behavior, simply call `set_keep_pointer_value' from STORABLE.
|
||||
|
||||
==Improvements==
|
||||
* New run-time speed improvement (between 30 to 100% faster than the 4.5 release).
|
||||
* Compiler that is much faster (between 200 and 300% faster than 4.5).
|
||||
* Compiler now detects unused local variables (at freeze/finalize time only)
|
||||
|
||||
==Bug fixes==
|
||||
* Compiler now fixes incrementality issues with frozen/melted code.
|
||||
* Degree 4/Degree 3 crash on *_SERVER when doing an incremental recompilation has been fixed.
|
||||
* Fixed crash when using creation expression that includes a feature call.
|
||||
* Fixed creation of an ARRAY of BIT type.
|
||||
* CHARACTER has been extended to support the extended ASCII which means that the following expressions are now True instead of being False as it was in our previous version:
|
||||
** '%/127/' < '%/128/'
|
||||
** '%/127/' < '%/128/'
|
||||
** When using `independent_store', in case of retrieval error due to a name change in one of the class attributes we will display the original attribute name that was used to make the storable file. This will help when managing many storable files.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
[[Property:title|Major changes between ISE Eiffel 4.5 and ISE Eiffel 5.0]]
|
||||
[[Property:link_title|5.0]]
|
||||
[[Property:weight|-7]]
|
||||
* [[Assertions checking configuration changes|Assertions checking]]
|
||||
* [[Changes between 4.5 and 5.0|EiffelThread]]
|
||||
* [[Compiler differences from 4.5 to 5.0|Miscellaneous]]
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
[[Property:title|Major changes between ISE Eiffel 5.0 and ISE Eiffel 5.1]]
|
||||
[[Property:link_title|5.1]]
|
||||
[[Property:weight|-8]]
|
||||
==What's new==
|
||||
|
||||
|
||||
* .NET generation now includes:
|
||||
** Support for multiple inheritance.
|
||||
** Support for generics.
|
||||
** Partial implementation of generic conformance (same as what was supported up to and including ISE Eiffel 4.2).
|
||||
** Support for tuples and agents.
|
||||
** Support for any existing Eiffel code that does not use C externals.
|
||||
** Partial support for compiling Eiffel libraries using C externals (e.g. WEL)
|
||||
|
||||
And the following limitations:
|
||||
** Eiffel classes cannot inherit from non-Eiffel .NET classes (but they can be clients).
|
||||
** The compiler performances are rather poor now (both in terms of memory usage and speed)
|
||||
|
||||
Those limitations should disappear with 5.2 which will be the official release that fully supports .NET
|
||||
** Support for INTEGER_64 constants. Now a manifest integer value that is written in decimal or hexadecimal format that can't fit into an INTEGER_32 will be automatically promoted to an INTEGER_64 constant value.
|
||||
** New feature access syntax for accessing constants, C/C++ externals and IL static externals. [[Differences between ETL 2nd printing and Eiffel Software implementation|Check out more here]] .
|
||||
|
||||
|
||||
==Improvements==
|
||||
* Compiler that is about 20% faster than 5.0.
|
||||
|
||||
==Bug fixes==
|
||||
* Fixed <code>VAPE</code> errors that were not previously reported. Now <code>VAPE</code> errors are checked against arguments of a feature used in a precondition and are also checked for a qualified call.
|
||||
* Fixed a conformance bug that made a manifest array not conform to ANY.
|
||||
* Fixed a generic conformance bug where an assignment attempt would change the behavior of the execution.
|
||||
* Fixed a wrongly reported error by the compiler in the following case:
|
||||
In a system that 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 <code>VTCG</code> error, though it should accept the classes.
|
||||
|
||||
* Fixed a crash when one of the following command lines was used in a directory with no existing project that contains no default configuration file:
|
||||
<code>ec -flat -all
|
||||
ec -short -all
|
||||
ec -flatshort -all
|
||||
ec -flat -all_and_parents
|
||||
ec -short -all_and_parents
|
||||
ec -flatshort -all_and_parents</code>
|
||||
|
||||
* Fixed a bug in output display between standard output and error output. Doing the following:
|
||||
<code>io.put_string ("foo%N")
|
||||
io.error.put_string ("bar%N")</code>
|
||||
|
||||
you get the following output when simply launched from the command line:
|
||||
<code>foo
|
||||
bar</code>
|
||||
|
||||
however if you do:
|
||||
<code>my_program >& RESULT</code>
|
||||
|
||||
to redirect both standard and error outputs to RESULT you get in the RESULT file this incorrect content:
|
||||
<code>bar
|
||||
foo</code>
|
||||
|
||||
* Fixed a non reported <code>VTEC</code> or <code>VTCG</code> error when an invalid type used as actual generic parameters in an explicit type in a creation instruction.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
[[Property:title|Major changes between ISE Eiffel 5.1 and ISE Eiffel 5.2]]
|
||||
[[Property:link_title|5.2]]
|
||||
[[Property:weight|-9]]
|
||||
==What's new==
|
||||
* .NET generation now includes support for the following language features:
|
||||
** Support for multiple inheritance.
|
||||
** Support for generics.
|
||||
** Partial implementation of generic conformance
|
||||
** Support for tuples and agents.
|
||||
** Support for any existing Eiffel code that does not use C externals.
|
||||
** Support for compiling Eiffel libraries using C externals that are not related to the Eiffel Software C runtime.
|
||||
|
||||
And the following limitations:
|
||||
** Eiffel classes cannot inherit from non-Eiffel .NET classes (but they can be clients).
|
||||
** No support for `expanded' keyword.
|
||||
|
||||
|
||||
* .NET generation now supports assembly signing in enterprise edition.
|
||||
* .NET generation now supports precompiled libraries.
|
||||
* Supports for manifest integer constants of different sizes, i.e. you can now assign for example the value `8' to a location of type <eiffel>INTEGER_8</eiffel>, <eiffel>INTEGER_16</eiffel>, <eiffel>INTEGER</eiffel> or <eiffel>INTEGER_64</eiffel>, however you can only assign the value `254' to a location of type <eiffel>INTEGER_16</eiffel>, <eiffel>INTEGER</eiffel> or <eiffel>INTEGER_64</eiffel>.
|
||||
|
||||
==Improvements==
|
||||
* Compiler that is about 20% faster than 5.1.
|
||||
* Runtime is about 10-20% faster than 5.1
|
||||
|
||||
==Changes==
|
||||
* One cannot create an instance of a basic expanded class ( <eiffel>BOOLEAN</eiffel>, <eiffel>CHARACTER</eiffel>, <eiffel>INTEGER_8</eiffel>, <eiffel>INTEGER_16</eiffel>, <eiffel>INTEGER</eiffel>, <eiffel>INTEGER_64</eiffel>, <eiffel>POINTER</eiffel>, <eiffel>REAL</eiffel>, <eiffel>DOUBLE</eiffel>), you will now get a <code>VGCC(6)</code> error. Instead directly assign to it, or create an instance of its corresponding _REF class.
|
||||
|
||||
==Bug fixes==
|
||||
* Fixed memory corruption issue when trying to access an <eiffel>INTEGER_64</eiffel> value.
|
||||
* Fixed a problem with manifest <eiffel>INTEGER_64</eiffel> constants whose values were incorrectly interpreted.
|
||||
* Fixed <code>VAPE</code> errors that were not previously reported in 5.1. Now <code>VAPE</code> errors are checked against call to infix and prefix features.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,164 @@
|
||||
[[Property:title|Major changes between ISE Eiffel 5.2 and ISE Eiffel 5.3]]
|
||||
[[Property:link_title|5.3]]
|
||||
[[Property:weight|-10]]
|
||||
==What's new==
|
||||
* Finalized executable with option `exception trace' enabled will now display the instruction number (usually equivalent to the line number in the routine) being executed when a failure occurred. It was already displaying this information in workbench/melted mode, we have just extended this feature to finalize mode.
|
||||
* Incremental compilation is now available for .NET code generation. Meaning that if you modify one class, only this class is being recompiled. It dramatically improves development time when targeting .NET.
|
||||
* In .NET code generation, assertions can be turned on or off on a class per class basis without having to recompile those classes.
|
||||
* Implemented [[EiffelBase, The Kernel|recoverable storable]] to enable the retrieval of slightly different version of an object. It only applies for classic Eiffel.
|
||||
|
||||
==Improvements==
|
||||
* Enabled support for Borland C compiler in .NET.
|
||||
* Removed too many warnings during C compilation on Tru64.
|
||||
* Improved formatting of exception traces so that class names, feature names, exception tags are not truncated. Display limit has been pushed at about 256 characters.
|
||||
|
||||
==Changes==
|
||||
* Made `\\' follow the balancing rules for various integer types.
|
||||
* Precompiled libraries now precompiles all classes reachable from clusters defined in project settings only if root class is ANY, otherwise it will only precompile classes reachable from the root class. In 5.1 and prior version it was precompiling all classes reachable from clusters.
|
||||
|
||||
==Bug fixes==
|
||||
|
||||
===Language issues===
|
||||
* Fixed semantic of object creations to strictly follow definition given in "Eiffel: The Language". Namely, if you have x of type <eiffel>X</eiffel>:
|
||||
<code>create x.make is equivalent to x := create {X}.make</code>
|
||||
It implies some bug fixes which might break existing code. For example:
|
||||
<code>
|
||||
x: X is
|
||||
once
|
||||
-- If make calls back to x then it used to return
|
||||
-- a non-Void value for x, where it should have been Void.
|
||||
create Result.make
|
||||
end
|
||||
|
||||
x: X
|
||||
|
||||
-- If make accesses back the x attribute then it used to return
|
||||
-- new value of x rather than the old value.
|
||||
create x.make</code>
|
||||
Or in melted code only the following code now works properly, i.e. <eiffel>make</eiffel> gets the old value of x, not the new one <br/>
|
||||
<code>create x.make (x)</code>
|
||||
|
||||
* Fixed undetected <code>VDRD(3)</code> errors: compiler was not strict enough and accepted <code> ensure </code> where only <code> ensure then </code> was valid.
|
||||
|
||||
===Store/Retrieve issues===
|
||||
* Fixed issue in storable mechanism when retrieving expanded objects.
|
||||
* Fixed issue with independent_store where storing arrays of objects whose count was greater than 65536 will cause a memory corruption.
|
||||
* Added <eiffel>correct_mismatch</eiffel> on <eiffel>HASH_TABLE</eiffel> to enable retrieval of the 5.1 and older version of <eiffel>HASH_TABLE</eiffel>.
|
||||
|
||||
===Runtime/code generation issues===
|
||||
* Fixed incorrect C code generation in final mode when creating an <eiffel>ARRAY</eiffel> of expanded type.
|
||||
* Fixed incorrect C code generation in final mode when creating a complex object which contains expanded objects that have expanded objects.
|
||||
* Fixed random crash issue in finalized applications due to incorrect memory management when you have code similar to:
|
||||
<code> f (g: STRING): ANY is
|
||||
do
|
||||
Result := create {STRING}.make_from_string (g)
|
||||
end</code>
|
||||
|
||||
* Fixed issue with <eiffel>deep_equal</eiffel> on <eiffel>ARRAY</eiffel> of expanded types which was returning <code> False </code> where it should have returned <code> True </code>.
|
||||
* Fixed code generation issue with double constants where code below was not producing the expected result of 1e+030:
|
||||
<code> value: DOUBLE is 1.0e15
|
||||
print (value * value) </code>
|
||||
|
||||
* Fixed issue in melted code where computation such as <eiffel>INTEGER_X</eiffel> // <eiffel>INTEGER_Y</eiffel> will either crash or give an incorrect computation where X and Y represents integers that are either 8, 16, 32 or 64 bits long and X < Y.
|
||||
* Fixed incorrect C code generation of finalized code when your project configuration includes a precompiled library and that you cancel finalization process at degree -2, and then restart a finalization.
|
||||
* Fixed issue with incorrect C code generation of inspect instruction based on character values above 128.
|
||||
* Fixed compilation crash at degree 3 with following code:
|
||||
<code> local
|
||||
i: INTEGER
|
||||
do
|
||||
i := << 1 >> @ 2
|
||||
end</code>
|
||||
|
||||
* Fixed a crash in finalized mode with invariant checking enabled with following code and when checking the invariant triggers a garbage collection cycle: <br/>
|
||||
<code> value: INTEGER
|
||||
is_value_required: BOOLEAN is
|
||||
do
|
||||
Result := value = 1
|
||||
end
|
||||
</code>
|
||||
|
||||
* Fixed crash of compiler at degree 4 while trying to compile this incorrect class:
|
||||
<code>class CRASH
|
||||
|
||||
inherit
|
||||
CHAIN -- Missing generic parameter
|
||||
|
||||
create
|
||||
make
|
||||
|
||||
feature -- Initialization
|
||||
|
||||
make is
|
||||
do
|
||||
end
|
||||
|
||||
index: INTEGER is
|
||||
do
|
||||
end
|
||||
|
||||
duplicate (n: INTEGER): like Current is
|
||||
do
|
||||
end
|
||||
|
||||
end</code>
|
||||
|
||||
* Fixed issue with pathological memory allocation scheme that could trigger an `out of memory' exception where enough memory is still available.
|
||||
* Fixed incorrect allocation of expanded arrays where creation routine of expanded class was not called on all items of the newly created array.
|
||||
* Fixed incorrect creation type of attribute where attribute's type has some generic parameter. In some cases, instead of creating an <eiffel>ARRAY [B2 [C]]</eiffel> it would create an <eiffel>ARRAY [B2 [STRING]]</eiffel>.
|
||||
|
||||
===.NET issues===
|
||||
* Fixed issue in IL code generation where having a class that inherits from a non-Eiffel .NET class. And the class has the following features:
|
||||
<code> a: ARRAY [like f]
|
||||
f: STRING is
|
||||
do
|
||||
end</code>
|
||||
Then you could neither load nor execute the generated code.
|
||||
* Fixed incorrect C file naming when generating a .NET system that uses a C++ external (it should be .cpp, not just .c).
|
||||
* Fixed incorrect .NET code generation with following assignment attempts whose source is expanded:
|
||||
<code> local
|
||||
a: ANY
|
||||
o: SYSTEM_OBJECT
|
||||
do
|
||||
a ?= 12
|
||||
o ?= 12
|
||||
end</code>
|
||||
|
||||
* Fixed incorrect code generation in .NET for assertions checking with following code where precondition of <eiffel>test</eiffel> will not be checked although it should:
|
||||
<code> make is
|
||||
do
|
||||
test_which_fail_and_rescued
|
||||
test
|
||||
end
|
||||
|
||||
test is
|
||||
require
|
||||
should_be_checked: False
|
||||
do
|
||||
end
|
||||
|
||||
test_which_fail_and_rescued is
|
||||
local
|
||||
retried: BOOLEAN
|
||||
do
|
||||
if not retried then
|
||||
failure
|
||||
end
|
||||
rescue
|
||||
retried := true;
|
||||
retry
|
||||
end
|
||||
|
||||
failure is
|
||||
require
|
||||
should_be_checked: False
|
||||
do
|
||||
end</code>
|
||||
|
||||
* Fixed .NET verification issue where sometimes you could get the following message when checking an Eiffel assembly against peverify: [IL]: Error: Unverifiable PE Header/native stub.
|
||||
* Fixed incorrect code generation when creating and accessing a <eiffel>NATIVE_ARRAY</eiffel> of expanded type.
|
||||
* Fixed incorrect metadata heap generation to use standard CLI tables.
|
||||
* Fixed bug where content of <eiffel>NATIVE_ARRAY</eiffel> could not be looked up in .NET debuggers (cordbg, DbgClr or Visual Studio)
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
[[Property:title|Major changes between ISE Eiffel 5.3 and ISE Eiffel 5.4]]
|
||||
[[Property:link_title|5..4]]
|
||||
[[Property:weight|-11]]
|
||||
==What's new==
|
||||
* Support for assertion checking on external routines.
|
||||
* Removed limitation about implementing or redefining a non-external routine by an external one and vice versa.
|
||||
* Support for new C/C++ inline specification.
|
||||
* For .NET, allow calling of overloaded features for a .NET classes to be called without using disambiguated names. Disambiguated names are still needed when redefining inherited features from .NET classes.
|
||||
* Support for inclusion of .NET resources within Eiffel assemblies.
|
||||
* Launch C compilation when needed if "-c_compile" option is specified on the "ec" command line.
|
||||
* Added ability to define custom attributes on assembly. One as to define custom attributes under the new `assembly_metadata' index clause of the root class.
|
||||
* Limited support for new <code> convert </code> keyword (only on argument passing and assignments. Not supported when used with infix routines).
|
||||
|
||||
==Improvements==
|
||||
* Improved speed of compilation by about 20-30%
|
||||
* Improved run-time memory allocation speed and footprint so that it has a 15%-20% faster allocation scheme and takes less memory than before.
|
||||
* Reduced waiting time at the end of the degree 6 when performing a compilation from scratch (reduced to about 50% or more of the time it used to take)
|
||||
* Improved speed of <eiffel>TUPLE</eiffel> creation and <eiffel>TUPLE</eiffel> access which generates more compact C code.
|
||||
* Improved speed of agent calls by a factor of 2 to 3.
|
||||
* Improved speed of Eiffel calls from C (CECIL and use of $ operator on routines). It also makes generated executables smaller (about 1-5% smaller depending on number of routines used in this context)
|
||||
|
||||
==Changes==
|
||||
* Changed the way we generate calls to C/C++ external routines. It is possible that because of this change, code that used to C compile, will not compile anymore. This happens mostly when mixing C and C++ code and the C call being made is incorrect but was not previously checked against the C header files if provided.
|
||||
* In multithreaded mode, all C externals that could potentially block the execution of the system should be marked `blocking' as in: <br/>
|
||||
<code> sleep (m: INTEGER) is
|
||||
external
|
||||
"C blocking"
|
||||
end</code>
|
||||
Not doing it could generate dead-lock during the execution of a multithreaded system.
|
||||
* Static access on externals is now only authorized when external is a frozen external without assertions.
|
||||
* Compiler will now report a warning for assignments like those: <br/>
|
||||
<code>td: TUPLE [DOUBLE]
|
||||
ti: TUPLE [INTEGER]
|
||||
|
||||
td := ti</code>
|
||||
The warning will help you correct code using this pattern, because in the next release this will be rejected in order to conform to the Eiffel language specification.
|
||||
* Now we do not generate by default the .NET attribute <eiffel>ComVisibleAttribute</eiffel> with a False value. If needed it has to be done through the new compiler functionality to add custom attributes on assembly.
|
||||
* Changed indexing clause tag for specifying custom attributes for .NET systems. Now `attribute' is replaced by `metadata'. Now you can have:
|
||||
** metadata: generated for both interface and implementation classes
|
||||
** assembly_metadata: generated for assembly only when specified in root class of system
|
||||
** class_metadata: generated only for implementation class
|
||||
** interface_metadata: generated only for interface class
|
||||
|
||||
|
||||
==Bug fixes==
|
||||
|
||||
===Language issues===
|
||||
* Now checks for valid export status in agent creation. Meaning that in class <eiffel>MY_CLASS</eiffel>, the following agent creation <code> agent </code> <eiffel>target</eiffel>. <eiffel>call</eiffel> is valid if and only if <eiffel>call</eiffel> is exported to <eiffel>MY_CLASS</eiffel>.
|
||||
* Allowed type specification for open operands in agent creation, i.e. one can now write: <code> agent </code> <eiffel>f</eiffel> ({ <eiffel>A</eiffel>}).
|
||||
* Fixed bug which allowed compiler to accept the following incorrect code: <eiffel>char</eiffel>: <eiffel>CHARACTER</eiffel> <code> is </code> <code> "rdsf" </code>
|
||||
* Fixed bug in error reporting for incompatible <eiffel>BIT</eiffel> types involving bit manifest constants. It would always report <eiffel>BIT 0</eiffel>, instead of the actual number of bits in the bit manifest constant.
|
||||
|
||||
===Compiler issues===
|
||||
* Fixed non-detection of changes when changing code from <code> agent </code> <eiffel>call </eiffel>to <code> agent </code> <code> Current </code>. <eiffel>call</eiffel>. Which should check for the validity of export of <eiffel>call </eiffel> to current class.
|
||||
* Fixed creation and assignment attempts on generic types that have anchored types in their generic parameter, and the anchor is itself generic.
|
||||
|
||||
===Runtime/code generation issues===
|
||||
* Fixed issue when shared library definition file did not exist or was invalid. Now it will not produce any C compilation errors.
|
||||
* Fixed bug in recoverable storable when there is a mismatch. The first assignment attempt in <eiffel>internal_correct_mismatch</eiffel> from <eiffel>ANY</eiffel> would crash.
|
||||
* Fixed issue when retrieving storable files that contain TUPLE instances.
|
||||
* Fixed issues when using agents in a multithreaded application, they will sometimes disable the garbage collector and the application might quickly run out of memory.
|
||||
* Fixed random crashes when EIF_MEMORY_CHUNK, EIF_MEMORY_SCAVENGE and EIF_STACK_CHUNK environment variables had an incorrect value. Instead the runtime will now fix the value to an appropriate one.
|
||||
|
||||
===.NET issues===
|
||||
* Fixed bug in code generation with following statement: <br/>
|
||||
<code>l_time: TIME_SPAN
|
||||
print (l_time.total_milliseconds.out)</code>
|
||||
|
||||
* Fixed incorrect code generation with code accessing attributes of .NET expanded types.
|
||||
* Fixed incorrect computation of equal when used with basic types, e.g. equal (1, 1) would return False instead of True.
|
||||
|
||||
===Store/Retrieve issues===
|
||||
* Fixed memory corruption bug with recoverable storable when a mismatch was detected
|
||||
* Fixed issue where mismatch was not detected if attributes were dropped
|
||||
* Fixed issue with independent store when storing <eiffel>TUPLE</eiffel> objects where it would crash if storable did not include a reference to <eiffel>ANY</eiffel>.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,148 @@
|
||||
[[Property:title|Major changes between ISE Eiffel 5.4 and ISE Eiffel 5.5]]
|
||||
[[Property:link_title|5.5]]
|
||||
[[Property:weight|-12]]
|
||||
==What's new==
|
||||
* Full support for new <code>convert</code> keyword.
|
||||
* Made <code>Void,</code> previously a feature of <eiffel>ANY</eiffel>, a keyword. This prevents the renaming of <eiffel>Void</eiffel> into <eiffel>not_void</eiffel> previously possible when it was a routine of <eiffel>ANY</eiffel>.
|
||||
* Addition of the <code>reference</code> keyword used in generic constraints (See next point).
|
||||
* Added support for reference and expanded constraints on a formal generic parameter. In other word, one can now write:
|
||||
<code>class A [reference G] ... end
|
||||
class B [expanded G] ... end</code>
|
||||
to say that the valid actual generic parameters for <eiffel>A</eiffel> are always reference types, and for <eiffel>B</eiffel> are always expanded types.
|
||||
* Added support for Microsoft .NET 2.0 runtime.
|
||||
* Allowed agent creation on infix or prefix routines.
|
||||
|
||||
==Improvements==
|
||||
* Reduced, in classic mode, size of finalized executables by 10 to 50%.
|
||||
* Improved speed of evaluation of global onces, in a multithreaded system, by having a lock-free mechanism after a once has been evaluated.
|
||||
* Reduced memory usage of special of expanded which do not have any reference attributes. Before there was a 8 bytes (or 16 bytes depending on the platform) overhead per item in the special.
|
||||
|
||||
==Changes==
|
||||
* Compiler is now checking that you cannot redeclare a formal generic parameter into a reference type unless the formal generic parameter is being constraint to be always a reference type (See the '''What's new''' section above).
|
||||
* Removed obsolete <eiffel>eifcid</eiffel>, <eiffel>eif_expand</eiffel> and <eiffel>eifexp</eiffel>from the CECIL interface, one has to use <eiffel>eif_type_id</eiffel>instead.
|
||||
* In .NET, changed the naming conventions of resources included in an assembly. The extension `.resources' is appended for resources that are originally provided as `.resx' or `.txt' files. Other files are embedded as is in the assembly and the name of the resource is the name of the file.
|
||||
* In .NET, now all classes inherit from <eiffel>ANY</eiffel>. Before all classes inherited from <eiffel>SYSTEM_OBJECT</eiffel>. The consequences are:
|
||||
** You can write an Eiffel generic classes where the actual generic parameter is a .NET class.
|
||||
** If you used to inherit from .NET classes and Eiffel classes you can replace the inheritance clause below:
|
||||
<code>class A
|
||||
inherit
|
||||
APPLICATION_EXCEPTION
|
||||
undefine
|
||||
finalize,
|
||||
equals,
|
||||
to_string,
|
||||
get_hash_code
|
||||
end
|
||||
|
||||
ANY</code>
|
||||
by the much simpler inheritance clause:
|
||||
<code>class A
|
||||
inherit
|
||||
APPLICATION_EXCEPTION
|
||||
</code>
|
||||
|
||||
** If you were using a feature of <eiffel>SYSTEM_OBJECT</eiffel> directly on Eiffel classes, now you need to assign the value to a variable entity of type <eiffel>SYSTEM_OBJECT</eiffel>. In other word:
|
||||
<code>e: EIFFEL_CLASS
|
||||
o: SYSTEM_OBJECT
|
||||
...
|
||||
o := e
|
||||
o.feature_of_system_object</code>
|
||||
|
||||
** The following assignment attempt will succeed whereas it failed before because <eiffel>SYSTEM_OBJECT</eiffel> did not inherit from <eiffel>ANY</eiffel>:
|
||||
<code>a: ANY
|
||||
o: SYSTEM_OBJECT
|
||||
...
|
||||
check o /= Void and a = Void end
|
||||
a ?= o
|
||||
check o /= Void and a /= Void end</code>
|
||||
|
||||
|
||||
* New format of the independent storable files which takes into account internal changes made for a better generic conformance in classic mode.
|
||||
* New validity rule for expanded types: It is valid to use an expanded type of base class <eiffel>C</eiffel> in the text of a class <eiffel>B</eiffel> if and only if it satisfies the following conditions:
|
||||
** <eiffel>C</eiffel> is not a deferred class
|
||||
** <eiffel>C</eiffel>'s version of the procedure <eiffel>default_create</eiffel> (inherited from <eiffel>ANY</eiffel>) is one of the creation procedures of <eiffel>C</eiffel> available to <eiffel>B</eiffel> for creation.
|
||||
|
||||
* New validity rule for expanded class: An expanded class <eiffel>C</eiffel> needs to have the version of the procedure <eiffel>default_create</eiffel> (inherited from <eiffel>ANY</eiffel>) as one of its creation procedure.
|
||||
|
||||
==Bug fixes==
|
||||
|
||||
===Language issues===
|
||||
* Fixed issue about conformance checking of type containing a formal generic parameter. We would always evaluate the formal to its constraint, thus allowing the code below to be accepted where it should not have been:
|
||||
<code>
|
||||
class A [G]
|
||||
feature
|
||||
bug is
|
||||
local
|
||||
l_any: LIST [ANY]
|
||||
l_g: LIST [G]
|
||||
do
|
||||
l_any := l_g
|
||||
l_g := l_any
|
||||
end
|
||||
</code>
|
||||
The workaround is to use the <code>reference</code> keyword to guarantee that the formal generic parameter will always be instantiated with a reference type. For example the code below is correct:
|
||||
<code>
|
||||
class A [reference G]
|
||||
feature
|
||||
bug is
|
||||
local
|
||||
l_any: LIST [ANY]
|
||||
l_g: LIST [G]
|
||||
do
|
||||
l_any := l_g
|
||||
l_g ?= l_any
|
||||
end
|
||||
</code>
|
||||
|
||||
|
||||
===Compiler issues===
|
||||
* Enabled creation of <eiffel>SPECIAL</eiffel> instances, no need to create an instance of <eiffel>TO_SPECIAL</eiffel>or <eiffel>ARRAY</eiffel> to get a <eiffel>SPECIAL</eiffel>instance. Now you can simply do:
|
||||
<code>my_special: SPECIAL [INTEGER]
|
||||
create my_special.make (10)</code>
|
||||
|
||||
* Fixed incrementality issues with <code>strip</code> and static calls on external routines which could fail after a class has been added to or removed from the system.
|
||||
|
||||
===Runtime/code generation issues===
|
||||
* Fixed incorrect code generation which would result in a C compiler error in classic mode when assigning a Void entity to a formal generic parameter that will be instantiated as a basic type.
|
||||
* In multithreaded mode, fixed dead lock on Unix platforms when evaluating global onces.
|
||||
* In multithreaded mode, prevented dead lock when a thread is exiting.
|
||||
* In multithreaded mode, prevented memory corruption which could occur if the first thing that a thread performs when launched is to trigger a GC collection.
|
||||
* Fixed incorrect generic conformance data when manipulating expanded generic types. For example, the following code:
|
||||
<code>class A [G, H]
|
||||
feature
|
||||
item: H
|
||||
end
|
||||
|
||||
class C [G]
|
||||
end
|
||||
|
||||
class ROOT_CLASS
|
||||
create
|
||||
make
|
||||
feature
|
||||
make is
|
||||
local
|
||||
l_a: A [STRING, expanded C [ANY]]
|
||||
do
|
||||
create l_a
|
||||
io.put_string (l_a.item.generating_type)
|
||||
end
|
||||
end
|
||||
</code>
|
||||
would print
|
||||
<code>expanded C [STRING]</code>
|
||||
instead of
|
||||
<code>expanded C [ANY]</code>
|
||||
|
||||
* Fixed issue where you could get a bogus reference when trying to get a reference to the object associated to an ID (obtained through the <eiffel>IDENTIFIED</eiffel> class).
|
||||
|
||||
===.NET issues===
|
||||
* Fixed incorrect code generation of native arrays which would cause the code to be rejected in newer version of the .NET Framework.
|
||||
* Fixed incorrect computation of `max_stack' for a routine body which could make the generated code not verifiable.
|
||||
|
||||
===Store/Retrieve issues===
|
||||
* Fix some issues related to the use of recoverable storable when manipulating generic types.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,152 @@
|
||||
[[Property:title|Major changes between ISE Eiffel 5.5 and ISE Eiffel 5.6]]
|
||||
[[Property:link_title|5.6]]
|
||||
[[Property:weight|-13]]
|
||||
==What's new==
|
||||
|
||||
{{seealso|See also: [[Differences between standard ECMA-367 and Eiffel Software implementation|Differences between standard ECMA-367 and Eiffel Software implementation]] }}
|
||||
* Implemented once manifest strings. They can be used at the same places where normal manifest strings can be used, e.g.:
|
||||
<code>s := once "abc"
|
||||
io.put_string (once "Hello World!")</code>
|
||||
Once manifest strings are not created every time they are accessed. Instead one instance is created at the first access and then it is reused for subsequent accesses. In multithreaded application one instance is created for one thread.
|
||||
* Supported aligned and non-aligned verbatim strings. Aligned verbatim strings use characters <code>[</code> and <code>]</code> in opening and closing sequence respectively, non-aligned verbatim strings use <code>{</code> and <code>}</code>.
|
||||
* Added support for manifest type expression "{<eiffel>MY_TYPE</eiffel>}" which gives an instance of <eiffel>TYPE</eiffel> [<eiffel>MY_TYPE</eiffel>].
|
||||
* New syntax for manifest constants. Now they can be preceeded by a manifest type expression. For example <code>1</code> is of type <eiffel>INTEGER</eiffel>, whereas {<eiffel>INTEGER_8</eiffel>} 1 is of type <eiffel>INTEGER_8</eiffel>.
|
||||
* Support for <eiffel>NATURAL_XX</eiffel> types which are unsigned integers.
|
||||
* Supported new feature alias syntax to specify operator and bracket names:
|
||||
<code>negate alias "-": like Current ...
|
||||
multiply alias "*" (other: like Current): like Current ...
|
||||
item alias "[]" (index: INTEGER): G ...</code>
|
||||
The first two declarations can be used similar to features <code>prefix "-"</code> and <code>infix "*"</code>. The last one can be used to make feature calls with bracket expressions like
|
||||
<code>letter := letters [i]</code>
|
||||
Operator and bracket aliases can also be used in <code>rename</code> subclause to change an alias name associated with a feature.
|
||||
* Supported new feature assigner syntax to associate feature with an assigner command:
|
||||
<code>item alias "[]" (index: INTEGER): G assign put ...
|
||||
put (value: G; index: INTEGER) ...</code>
|
||||
Given the declaration above the following instructions become equivalent:
|
||||
<code>x.put (x.item (i + 1), i)
|
||||
x.item (i) := x.item (i + 1)
|
||||
x [i] := x [i + 1]</code>
|
||||
|
||||
|
||||
==Improvements==
|
||||
* Optimized .NET code generated for <code>inspect</code> instruction.
|
||||
* Optimized access to process-relative once routines to avoid heavy-weight synchronization primitives when possible.
|
||||
* Speed-up access to once routines in finalized multi-threaded applications.
|
||||
* Improved some error messages to be more precise.
|
||||
* Removed the requirement to freeze code that declares process-relative once routine.
|
||||
* Improved multi-threaded application performance in classic mode by using built-in support for thread-local storage provided by some ''C'' compilers.
|
||||
* Allowed underscores in hexadecimal literals.
|
||||
* Provided syntax highlighting for hexadecimal literals in editor.
|
||||
* Slightly improved reporting of syntax errors.
|
||||
* Made keyword operator names clickable in flat view.
|
||||
|
||||
==Changes==
|
||||
* Void does not conform to expanded types. As a consequence, assignments of Void to expanded entities will be rejected rather than throwing an exception at run-time. And comparison of expanded entities to Void will cause a <code>VWEQ</code> validity error.
|
||||
* Changed default behavior of once routines in .NET mode from once-per-process to once-per-thread to match behavior in classic mode.
|
||||
* Provided project options (<code>old_verbatim_strings</code> and <code>old_verbatim_strings_warning</code>) to support semantics of verbatim strings as in previous versions when they were not left-aligned.
|
||||
* Changed processing of hexadecimal integer literals to be consistent for different integer types. For example, <code>0xFF</code> gives <code>255</code> when assigned to a variable of type <eiffel>INTEGER</eiffel> rather than <code>-1</code> as before.
|
||||
* Due to the new {} syntax, a few older syntax constructs have been removed:
|
||||
** "{<eiffel>X</eiffel>} <code>Precursor</code> (..)" is rejected and should be replaced by "<code>Precursor</code> {<eiffel>X</eiffel>} (...)".
|
||||
** "<code>agent</code> <eiffel>f</eiffel> (?, {<eiffel>A</eiffel>})" is now rejected, as it would conflict with a manifest type expression, instead you should write "<code>agent</code> <eiffel>f </eiffel>(?, {<eiffel>A</eiffel>} ?)".
|
||||
|
||||
* In .NET, all usage of <eiffel>INTEGER_8</eiffel> from .NET libraries have been changed to <eiffel>NATURAL_8</eiffel>.
|
||||
* In .NET, renamed <eiffel>TYPE</eiffel>, <eiffel>ATTRIBUTE_</eiffel> and <eiffel>VOID_</eiffel> from the mscorlib assembly into <eiffel>SYSTEM_TYPE</eiffel>, <eiffel>SYSTEM_ATTRIBUTE</eiffel> and <eiffel>SYSTEM_VOID</eiffel>.
|
||||
* Changed exception handling for once routines so that exception raised during the first call is raised during any subsequent call to this routine.
|
||||
* Introduced upper limit for value of integer constant used in <code>BIT</code> type declaration and extended <code>VTBT</code> rule to cover this change.
|
||||
* To evaluate the type of a manifest array we now use the first item of the manifest array instead of the last one as a first guessed type.
|
||||
* Allowed for integer literals with intermediate underscores at arbitrary positions.
|
||||
* To ensure same behavior on various platforms, the standard output is now unbuffered (it previously was unbuffered on Windows and line buffered on Unix platforms).
|
||||
|
||||
==Bug fixes==
|
||||
|
||||
===Language issues===
|
||||
* Used <code>'%N'</code> as an end of line in verbatim strings regardless of the end of line sequence in source code.
|
||||
* Fixed incorrect handling of negative hexadecimal integer literals when sign before the literal was not taken into account. For example, <code>-0x1</code> could be interpreted as <code>1</code>.
|
||||
* Implemented checks for input ranges of integer constants and fixed issue with inability to assign minimum integer values to variables of the corresponding integer types.
|
||||
{|
|
||||
|+ Allowed integer values
|
||||
|-
|
||||
| Type
|
||||
| Integer interval
|
||||
| Unsigned hexadecimal representation
|
||||
|-
|
||||
| <eiffel>INTEGER_8</eiffel>
|
||||
| <code>-128 .. 127</code>
|
||||
| <code>0x0 .. 0xFF</code>
|
||||
|-
|
||||
| <eiffel>INTEGER_16</eiffel>
|
||||
| <code>-32768 .. 32767</code>
|
||||
| <code>0x0 .. 0xFFFF</code>
|
||||
|-
|
||||
| <eiffel>INTEGER_32</eiffel>
|
||||
| <code>-2147483648 .. 2147483647</code>
|
||||
| <code>0x0 .. 0xFFFFFFFF</code>
|
||||
|-
|
||||
| <eiffel>INTEGER_64</eiffel>
|
||||
| <code>-9223372036854775808 .. 9223372036854775807</code>
|
||||
| <code>0x0 .. 0xFFFFFFFFFFFFFFFF</code>
|
||||
|}
|
||||
|
||||
* Excluded nonsignificant leading zeroes from determination of allowed integer constant type, so that <code>00000000000000123</code> is now a valid <eiffel>INTEGER_8</eiffel> value.
|
||||
* Shared the same data accross once routines and string constant attributes from different generic derivations of the same class. Added a warning for once routines that appear in a generic class to notify about this change in semantics.
|
||||
* Correctly supported replication of once features when compiling for .NET.
|
||||
* Changed order of evaluation of once routines to check precondition with class invariant even when once routine has already been called.
|
||||
* Added a check that length of identifier, manifest string and free operator does not exceed a maximum value of 32767 bytes.
|
||||
|
||||
===Compiler issues===
|
||||
* Fixed crash of the compiler at the very end of a finalization of a system which has an assignment of a manifest type into a variable of type <eiffel>ARRAY</eiffel> [<code>like</code> <eiffel>anchor</eiffel>] where <eiffel>anchor</eiffel> is a feature being redefined with a different type in a descendant class.
|
||||
* Fixed an issue where compiler would report more than once the same error in an incremental recompilation.
|
||||
* Fixed issue where changing a normal routine to an external and having a compile error, and then reverting back to a normal routine while fixing the error would cause the compiler to crash.
|
||||
* Fixed some cases where project could be corrupted after a recompilation.
|
||||
* Now compiler reports <code>VTCT</code> errors at the end of degree 5, rather than during degree 5, so that you can collect all the <code>VTCT</code> errors at once.
|
||||
* Thanks to the improvement in <code>VTCT</code> errors reporting, now compiler will not generate an incorrect <code>VTCT</code> errors during an incremental recompilation for a class which has actually been removed from the system.
|
||||
* Supported recompilation of once routines when their status is changed from "process-relative" to "thread-relative" or back.
|
||||
* Supported output of multi-line obsolete messages.
|
||||
* Fixed a recompilation bug that resulted in incorrect (or even, in case of .NET, in invalid) generated code when incrementally finalizing a system without explicitly specified root creation procedure.
|
||||
* Fixed a bug with resolving some generic-like types (i.e., types that are processed in a special way: tuple, native array, typed pointer) that depend on anchored types: before they were converted to "normal" generic types thus loosing their special properties.
|
||||
* Fixed a bug that caused compiler to crash when finalizing a code that looks like
|
||||
<code>if true then [else(if) ...] end</code>
|
||||
i.e. has empty compound for a primary condition which is a constant <code>true</code>.
|
||||
* Fixed a bug in processing configuration option <code>precompiled</code> that caused a compiler to crash when no option value was provided.
|
||||
* Fixed a bug in incremental recompilation when multi-branch validity rules are violated in one class because constant attribute used in the multi-branch instruction is changed in another class, that declares them, into a non-constant feature.
|
||||
* Fixed multiple bugs in feature basic text view that caused truncated or extraneous output.
|
||||
* Fixed bug where if an actual generic parameter was an anchor, then if the type containing this actual was used for assignment attempt or for creation we would use an incorrect type for the actual generic. We were using the type of the anchor in the class were the code was written, instead of actually re-evaluating the type of the anchor for each descendant class.
|
||||
|
||||
===Runtime/code generation issues===
|
||||
* Fixed bug in <eiffel>deep_twin</eiffel> from <eiffel>ANY</eiffel> in .NET which would cause a call on Void target when applied on object of type <eiffel>STRING</eiffel> and possibly other types.
|
||||
* Corrected C code on Windows for constants of type <eiffel>INTEGER_64</eiffel>. Before constants of this type between <code>-2147483648</code> and <code>-1</code> could be processed as positive 64-bit values.
|
||||
* Fixed incorrect C and IL code generation for <eiffel>INTEGER_8</eiffel> and <eiffel>INTEGER_16</eiffel> arithmetic and shift operations that might produce incorrect result when combined in two or more operations in a row. For example,
|
||||
<code>i := (i + i) |>> 1</code>
|
||||
assigned <code>-128</code> to <code>i</code> of type <eiffel>INTEGER_8</eiffel> if the initial value of <code>i</code> was <code>-128</code>. Now this instruction assigns <code>0</code>.
|
||||
* Synchronized access to data of process-relative once routines to avoid race conditions when two or more threads simultaneously access the same once routine.
|
||||
* Avoided permanent blocking of a thread accessing process-relative once routine when this routine is concurrently evaluated in some other thread and raises an exception.
|
||||
* Fixed bugs in memory allocation in C code for result of a once function that returns basic type:
|
||||
** it might cause memory corruption when memory size required to store the result is greater than size of a pointer;
|
||||
** there was a memory leak.
|
||||
|
||||
* Fixed a bug in classic mode that caused last exception to be cleared after returning from a routine that has a rescue clause but returns normally.
|
||||
* Fixed several bugs related to handling of nested exceptions in classic mode.
|
||||
* Changed a limit of maximum class name length in melted byte code from 256 bytes to 32767 bytes.
|
||||
* Changed C code generation for long strings (that result from long manifest strings, identifiers, etc.) to avoid restrictions imposed by some C compilers on long string literals (in particular, by the Microsoft C compiler <code>cl</code> that issued error C2026).
|
||||
* Fixed a bug in finalized C code generation when calling <code>Precursor</code> in a routine which is recursively calling itself before the call to <code>Precursor</code>. Instead of generating the call to <code>Precursor</code> we would generate a recursive call to the routine.
|
||||
* Fixed a bug where calls to <eiffel>standard_is_equal</eiffel> from <eiffel>ANY</eiffel> on objects whose type is generic would yield <code>False</code> where it should have been <code>True</code>.
|
||||
|
||||
===.NET issues===
|
||||
* Corrected processing of literal floating point fields from external assemblies (such as <eiffel>System</eiffel><code>.</code><eiffel>Math</eiffel><code>.</code><eiffel>PI</eiffel>) to obtain proper values.
|
||||
* Fixed a bug where the value -1 was actually 255 on .NET.
|
||||
* Fixed issue where declaring a <eiffel>NATIVE_ARRAY</eiffel> of a .NET expanded type would be rejected by the compiler.
|
||||
* Fixed issue where assigning a .NET expanded type to an entity of type <eiffel>ANY</eiffel> would be rejected by the compiler.
|
||||
* Fixed a crash in the compiler when generating the code for a class which inherits from a .NET class and from an Eiffel class which has some anchored types.
|
||||
* Fixed a bug in assertion monitoring that could lead to wrong monitoring of assertions that are evaluated concurrently in different threads.
|
||||
* Fixed a bug in code generation for entry point of executable when root procedure is a redeclaration of a deferred feature that caused an exception <code>MissingMethodException</code> to be raised on startup of such an application.
|
||||
* Fixed a bug in code generation when solely inheriting from a .NET interface.
|
||||
* Fixed a bug in code generation when inheriting from a .NET class which has a routine whose name is identical to one of the routine of <eiffel>ANY</eiffel>.
|
||||
* Fixed a bug in code generation of custom attributes encoding in the case of a named argument whose base type is a .NET enum type.
|
||||
* Improved <eiffel>conforms_to</eiffel> from <eiffel>ANY</eiffel> so that even though full generic conformance is still not yet supported, it checks it properly when the base class are the same.
|
||||
|
||||
===Store/Retrieve issues===
|
||||
* Fixed an issue where the GC would be disabled after a failure in a retrieval operation.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
[[Property:title|Major changes between ISE Eiffel 5.6 and ISE Eiffel 5.7]]
|
||||
[[Property:link_title|5.7]]
|
||||
[[Property:weight|-14]]
|
||||
==What's new==
|
||||
|
||||
{{seealso|See also: [[Differences between standard ECMA-367 and Eiffel Software implementation|Differences between standard ECMA-367 and Eiffel Software implementation]] }}
|
||||
* Support for new expanded semantics defined in ECMA-367. The current limitations are: no copy semantics in the .NET code generation, and still no generic conformance.
|
||||
* Inline agents as defined in ECMA-367 with the limitation to only accept the do form.
|
||||
* Added possibility to define agents on attributes or externals.
|
||||
* Named tuples as defined in ECMA-367.
|
||||
* Added <eiffel>PREDICATE</eiffel> class for agent based on boolean queries.
|
||||
* Added <eiffel>CHARACTER_32</eiffel> for Unicode support.
|
||||
|
||||
==Improvements==
|
||||
* Improved memory management:
|
||||
** Ensure that if a block of allocated memory is not used it will eventually be freed. Before it will only be freed if it was the last allocated block.
|
||||
** Compaction is actually working. Before it was working if you had a lot of dead objects, now it will compact even if all you have is alive objects and that the memory is fragmented.
|
||||
** For large memory heap (i.e. larger than 1GB) improved speed of collections where there is a lot of dead objects.
|
||||
|
||||
* Changed the way we search melted file, it is done in the following order:
|
||||
** Directory specified by environment parameter MELT_PATH
|
||||
** Current working directory
|
||||
** Directory where application is launched
|
||||
** Original directory where .melted file was generated the first time.
|
||||
|
||||
* Improved speed of initial compilation of .NET projects as well as the speed for incremental compilation at degree 6 which went from a few seconds to no time if no new assemblies have been added to the system.
|
||||
* No freeze is required when adding an agent, saving you time since C compilation can be long for very large project.
|
||||
* Reduced the required disk space for a workbench compilation in classic mode (went from 1.8 GB to 1GB for a very large project).
|
||||
* Improved speed of agent calls in classic mode.
|
||||
* Support use of IL enumerations with underlying integer types different from System.Int32. In particular, the built-in features `to_integer' and `from_integer' now use the underlying type rather than System.Int32.
|
||||
* Support generation of IL properties as well as custom attributes for them.
|
||||
* Support the new syntax without the <code>is</code> keyword in the feature declaration.
|
||||
* Allowed bracket expressions to be used as a target of a qualified feature call (this is an extension to ECMA standard that does not permit this syntax at the moment).
|
||||
* Added checks for <code>VYCP(2,3)</code> and <code>VYCQ(2,3)</code> (validity rules for conversion features to prohibit conversion to conforming types).
|
||||
|
||||
==Changes==
|
||||
* <code>VWEQ</code> is not an error, but a warning that can be triggered or not depending on your configuration.
|
||||
* Inherited assertions are rechecked each time that a feature is redefined, meaning that some errors that were not previously detected by the compiler can now be found.
|
||||
|
||||
==Bug fixes==
|
||||
* Fixed an issue with x2c if you had inlined C code which contains comments with single or double quote. Then it will not properly convert .x into .c file.
|
||||
* Fixed bugs in code generation for once manifest strings that caused "index out of bounds" exception, void results.
|
||||
* Fixed a bug in processing synonyms of a routine with an indexing clause that might cause a compiler crash, in particular this could happen for synonyms of a global once routine.
|
||||
* Fixed a bug in recompilation of a once routine that changes its process-relative status into thread-relative one or back in multithreaded finalized mode that can cause C compilation to fail due to unresolved externals.
|
||||
* Corrected inlining of routines redeclared into attributes or into routines with a different internal/external status.
|
||||
* Fixed a bug in incremental recompilation of queries with assigner commands.
|
||||
* Added detection of a <code>VUEX</code> error for static feature calls used in intervals of a multibranch instruction.
|
||||
|
||||
===Compiler issues===
|
||||
* Added a new validity error <code>VTEC(3)</code> to report unsupported inheritance hierarchy under .NET when an expanded type is based on a class with an external ancestor.
|
||||
* Not supported reverse attachment of boxed built-in .NET value types to Eiffel reference types such as <eiffel>NUMERIC</eiffel>, <eiffel>HASHABLE</eiffel>, etc.
|
||||
|
||||
===Runtime/code generation issues===
|
||||
* Ensured that our runtime is async-safe for signals for all the runtime routines using some locking mechanisms.
|
||||
* Fixed a memory corruption issue in <eiffel>arycpy</eiffel> if a GC cycle was triggered as part of the processus of reallocating the SPECIAL object.
|
||||
* Fixed a bug with allocating memory for once routines that caused "no memory" exception at program startup when Borland run-time is used.
|
||||
|
||||
===.NET issues===
|
||||
* Removed limitation to inherit an Eiffel class which inherited from a .NET class.
|
||||
|
||||
===Store/Retrieve issues===
|
||||
* Fixed a memory leak in the recoverable retrieval when an exception is raised from a <eiffel>correct_mismatch</eiffel> routine call.
|
||||
* Fixed test#store008 regarding a crash when retrieving a type that does not exist in retrieved system.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
[[Property:title|Major changes between ISE Eiffel 5.7 and ISE Eiffel 6.0]]
|
||||
[[Property:link_title|6.0]]
|
||||
[[Property:weight|-7]]
|
||||
==What's new==
|
||||
|
||||
{{seealso|See also: [[Differences between standard ECMA-367 and Eiffel Software implementation|Differences between standard ECMA-367 and Eiffel Software implementation]] }}
|
||||
* Added support for multiple constraints in formal generic parameters.
|
||||
* The root class can now be a generic class, and thus one can now specify a root type.
|
||||
* The notion of creation readiness according to ECMA Eiffel standard (2nd edition, chapter 8.12.12) is implemented.
|
||||
* Added experimental option for full class checking. It can be enabled at the system, cluster or class level. However not all our code has been compiled with this option so don't be surprised if you get errors in our libraries. The next release should fix all the remaining issues.
|
||||
* Integers can now also be specified with binary and octal representation.
|
||||
* Manifest characters can now also be specified with binary, octal and hexadecimal representation. Manifest characters can be specified up to 32 Bit.
|
||||
* Supported reattachment of generic derivations with expanded parameters to generic derivations with reference parameters.
|
||||
|
||||
==Improvements==
|
||||
* The command line compiler doesn't need a configuration file to compile a system, one can simply provide a root class and the compiler will automatically use the current directory and EiffelBase. You can also add more libraries if needed.
|
||||
* Improved backup mechanism so that overridden classes are copied in the library where they are defined (they were previously copied in the library where the override cluster was defined).
|
||||
* Possibility for hidden/implementation clusters in libraries, i.e. clusters that are not accessible if the library is used (like libraries in libraries are not accessible).
|
||||
* Class names which don't match the source filename emit a warning.
|
||||
* The unique keyword will yield a syntax warning if enabled.
|
||||
* Static access on external routines is allowed even if not marked frozen (this simply applies a relaxed rule that was adopted by ECMA).
|
||||
* When an environment variable is being used to compile a system and if this environment variable value changes next time you use a project, you will get a prompt asking whether or not you want to update the value or keep the initial one.
|
||||
* Externals (includes, objects, resources, ...) can now be relative to the ecf file by using the new replacement $ECF_CONFIG_PATH.
|
||||
* UUID is not needed for non library systems. If no UUID is specified a random one will be generated.
|
||||
|
||||
==Changes==
|
||||
* Added supplier_precondition assertion level that enables to only check preconditions of trusted libraries. By default when importing an old project they are not enabled, thus assertions on the library you are using are most likely going to be disabled.
|
||||
* Added the platform value as part of the version info of the compiler. This will prevent trying to load a project compiled for a different platform instead of failing with a retrieval error.
|
||||
* The compiler can be compiled against the original EiffelBase version or with the FreeELKS version which is now the default one for EiffelBase.
|
||||
|
||||
==Bug fixes==
|
||||
* Fixed eweasel test#tuple006 showing a failure when calling <eiffel>deep_copy</eiffel> on a <eiffel>TUPLE</eiffel> instance.
|
||||
* Fixed bug#12782 where compiler would crash at degree 1 when removing a formal generic parameter of class (eweasel test#incr249 and test#incr284).
|
||||
* Fixed bug#12823 where specifying in the command line a target in a different case than the lower case version of the actual target name would fail to find the target in your configuration file.
|
||||
* Fixed bug#12698 where compiler was not processing the target extension properly if not specified in lower case.
|
||||
* Fixed bug#12591: compiler would not find classes from library referenced deeply using relative path. This also removes the extra `.' or `..' in the displayed path for a class.
|
||||
* Fixed issue with incorrect labeled tuples which were not detected in signature of features (see eweasel test#tuple008).
|
||||
* Fixed crash when checking an incorrect labeled tuple (e.g. <eiffel>TUPLE</eiffel> [a, a: <eiffel>INTEGER</eiffel>]) (see eweasel test#tuple009).
|
||||
* Fixed issue with inline agents where if you have one and during a compilation from scratch you have a compiler error, then fixing this error and recompiling, it would crash when melting or freezing (test#incr277).
|
||||
* Fixed issue with C compilation linking error when a generic class which have an invariant clause has its formal generics changed (test#incr278).
|
||||
* Fixed C compilation error on Windows for trying to compile empties Cxxx directories (test#ccomp061).
|
||||
* Fixed incorrect code generation of agents on attribute when target is open (test#exec264).
|
||||
* Fixed incremental bug when an agent creation based on a feature whose signature changes for less arguments (test#incr276).
|
||||
* Fixed a backup creation bug when two classes from the same cluster/library have the same original file name, the backup would only contain one or the other because we use the original file name. Now we use the original class name.
|
||||
* Fixed various issues with the processing of the Eiffel Configuration File.
|
||||
|
||||
===Compiler issues===
|
||||
* Adapted the compiler so that ISE_EIFFEL does not need to be defined with a short path name on Windows, since some file systems can disable support for short path.
|
||||
* Fixed incrementality bug with agents where finalizing and then freezing would cause some unresolved externals.
|
||||
|
||||
===Runtime/code generation issues===
|
||||
* Fixed a memory corruption which would occur once an invariant has been violated.
|
||||
* Fixed a memory corruption which could occur when performing a deep_twin on an object whose graph contains a TUPLE object. See test#tuple006.
|
||||
|
||||
===.NET issues===
|
||||
* Speed up consumer cache synchronization so working with large .NET caches or large assembly sets is much faster.
|
||||
* Fixed bug#12565 where a wrong EIFFEL_NAME_ATTRIBUTE custom attribute would be generated on .NET for Eiffel generic class where the actual generic parameter is a .NET value type..
|
||||
* Fixed bug in .NET resx to resource generation when using resx files with relative paths.
|
||||
* .NET Enums can be automatically converted to INTEGERs.
|
||||
* Indexing tags ''interface_metadata'' and ''class_metadata'' are supported on feature level like this is done on class level and allow to specify custom attributes for associated methods only in interface type or only in implementation type.
|
||||
* All versioned COM import interfaces now have versioned interface member names based on the trailing version number of the interface name, as this meta information is not available in any other way. This greatly improves the versioned names and makes implementing interfaces much easier.
|
||||
* Fixed various issues in the .NET consumer that would prevent the usage of certain .NET assemblies.
|
||||
* Added configurable (project to class-level) optimization for .NET project that will mark all classes frozen if they are not descended by another.
|
||||
|
||||
===Store/Retrieve issues===
|
||||
* Now the retrieval of objects is done with the GC (garbage collector) disabled.
|
||||
* Fixed issue when retrieving 64-bit storables on 32-bit machines. It requires a regeneration of the 64-bit storables if one wants to retrieve them on 32-bit machines. Fixed bug#11744.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
[[Property:title|Major changes between ISE Eiffel 6.0 and ISE Eiffel 6.1]]
|
||||
[[Property:link_title|6.1]]
|
||||
[[Property:weight|-8]]
|
||||
==What's new==
|
||||
|
||||
{{seealso|See also: [[Differences between standard ECMA-367 and Eiffel Software implementation|Differences between standard ECMA-367 and Eiffel Software implementation]] }}
|
||||
* Multiple errors are reported for each compilation degree.
|
||||
* Experimental support for Non-conforming Inheritance has been added (Classic only). Classes may now be inherited (using inherit {NONE} but no conformance of that class is implied.
|
||||
* Attachment marks are supported. Now it's possible to specify whether an entity is attached or detachable:
|
||||
<code>a: !A -- a cannot be used before it is attached
|
||||
b: ?A -- b can be used before it is attached</code>
|
||||
Default attachment status (for types without an attachment mark) is controlled by the option ''is_attached_by_default''.
|
||||
* Object test expression is a replacement for the reverse assignment construct with a new notion of scope:
|
||||
<code>if {o: !A} e then do_something_with (o) end</code>
|
||||
|
||||
* Attached variables are subject to the new check that they are properly set before use, in particular, attached attributes must be set by a creation procedure and all attached local variables must be set before they are used. The checks are performed when the option ''is_void_safe'' is turned on.
|
||||
* A feature call can be performed only on an attached target if the option ''is_void_safe'' is turned on.
|
||||
* Certified attachment patterns (CAP) are used to identify additional cases when an entity is attached (controlled by the option ''is_void_safe''). In particular, the following code is considered void-safe:
|
||||
<code>f (a: ?ANY)
|
||||
do
|
||||
if a /= void then
|
||||
x := a.out
|
||||
end
|
||||
end</code>
|
||||
|
||||
|
||||
==Improvements==
|
||||
* Improved speed of degree 3. Improvements are even more visible when the checking of inherited features in their descendants is enabled.
|
||||
|
||||
==Changes==
|
||||
* No major known changes.
|
||||
|
||||
==Bug fixes==
|
||||
* Fixed an issue where the version of <eiffel>default_create</eiffel> from <eiffel>ANY</eiffel> would not yield a dynamic binding if statically it had an empty body (See test#exec280).
|
||||
|
||||
===Compiler issues===
|
||||
* The options ''is_void_safe'' and ''is_attached_by_default'' are not tracked during recompilation, so in order to take any changes in their settings, the project has to be recompiled from scratch.
|
||||
* Object test is not permitted inside a precondition or a check instruction.
|
||||
* Object tests inside a feature should use different names for the corresponding locals.
|
||||
|
||||
===Runtime/code generation issues===
|
||||
* Non-conforming inheritance dynamic conformance only works with Classic compilations, for .Net non-conforming inheritance has no effect on code generation
|
||||
* Implemented time accounting on Windows.
|
||||
|
||||
===Store/Retrieve issues===
|
||||
* Fixed a potential dead lock when an exception occurs while retrieving an object in a multithreaded environment (See test#store012).
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
[[Property:title|Major changes between ISE Eiffel 6.1 and ISE Eiffel 6.2]]
|
||||
[[Property:link_title|6.2]]
|
||||
[[Property:weight|-9]]
|
||||
==What's new==
|
||||
|
||||
{{seealso|See also: [[Differences between standard ECMA-367 and Eiffel Software implementation|Differences between standard ECMA-367 and Eiffel Software implementation]] }}
|
||||
* Exceptions as objects are now implemented.
|
||||
* Added support for new ~ operator which can compare 2 objects safely regardless of their type.
|
||||
* Added detection of harmful catcall at runtime (harmless ones are currently ignored).
|
||||
* Added support for `note' keyword with a migration path in case `note' is being used as an identifier in your code.
|
||||
* Added `-gc_stats' option to get some information on how much CPU time is spent in GC during an Eiffel compilation.
|
||||
* Introduced several new much more powerful CAPs that now can be applied not only to read-only entities, but also to local variables (including <code>Result</code>), and can take into account execution paths as well as some obvious void-safe patterns.
|
||||
|
||||
==Improvements==
|
||||
* Improved speed of compiler by a significant factor for large system.
|
||||
* Generated code is about 3-4% faster with a size reduction of about 2-3%.
|
||||
* Improved number of dynamic to static bindings in finalized code. Improved quality of inlined code for reducing even more of the dynamic calls.
|
||||
* Reduced the size of the AST stored in memory during a compilation by 20/25% which results in a memory usage reduction for EiffelStudio of about 15%. For example when compiling EiffelStudio on Windows 64-bit, it was taking 920MB with the previous version, and now it would be 800MB.
|
||||
* Fixed performance issue with {<eiffel>SPECIAL</eiffel>}.<eiffel>clear_all</eiffel> when handling a special of reference.
|
||||
* Removed <code>VUOT(2)</code> that required that the type of an object test local is attached.
|
||||
|
||||
==Changes==
|
||||
* Protected several calls to `eif_wean' on the same EIF_OBJECT. This will prevent a memory corruption for people using it incorrectly with a minor slow down since in a typical application there should not be too many protected objects.
|
||||
* Removed <code>VFAV(4)</code> validity error that is no longer specified in the standard.
|
||||
* Due to new meaning of ~, the old syntax for agents is not being supported anymore. If you still have some code using the old agent syntax, compile it with 6.1 with syntax warning enabled to fix your code before upgrading to 6.2.
|
||||
|
||||
==Bug fixes==
|
||||
|
||||
===Language issues===
|
||||
* Fixed various limitations with support of attached types in 6.1, including support for
|
||||
** attachment marks for tuple types and formal generics
|
||||
** object tests in class invariants
|
||||
|
||||
|
||||
===Compiler issues===
|
||||
* Fixed eweasel test#final046 by avoiding useless creation of temporary objects during dynamic dispatch. It can also dramatically speed up certain kinds of code; on the compiler itself, the speed up is about 8-10%. In the worst case scenario it is 400% or more. Note this bug was introduced in version 6.0. Compared to 5.7, in 6.2 the worst case scenario is still about 10% slower.
|
||||
* Fixed an incorrect code generation for `is_equal' in ANY when exception trace is off which could cause a memory corruption.
|
||||
* Fixed various issues with compiler when inlining is enabled.
|
||||
* Fixed compiler crash when compiling a class where a type used in a signature of a feature has the wrong number of generic parameters. Fixed eweasel test#incr285.
|
||||
* Fixed an incorrect code generation for the dynamic binding of routines defined in generic classes and attribute access in general. Fixed eweasel test#exec272 and test#final039.
|
||||
* Fixed eweasel test#melt081 where having a redefined routine involving an anchor to a non-existing feature would crash the compiler instead of reporting a VEEN error.
|
||||
* Various bug fixes with respect of handling of expanded generic classes used in generic classes.
|
||||
|
||||
===Runtime/code generation issues===
|
||||
* Changed the usage of `eif_adopt', `eif_protect', `eif_wean', `eif_freeze' and `eif_unfreeze' so that they can be used in concurrent thread, meaning that it is safe to use them as long as the argument is different in various threads.
|
||||
|
||||
===Store/Retrieve issues===
|
||||
* Fixed some issues with the storing or retrieving of generic expanded types.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
[[Property:title|Compiler History]]
|
||||
[[Property:weight|-8]]
|
||||
* [[Major changes between ISE Eiffel 6.0 and ISE Eiffel 6.1|Major changes between ISE Eiffel 6.0 and ISE Eiffel 6.1]]
|
||||
* [[Major changes between ISE Eiffel 5.7 and ISE Eiffel 6.0|Major changes between ISE Eiffel 5.7 and ISE Eiffel 6.0]]
|
||||
* [[Major changes between ISE Eiffel 5.6 and ISE Eiffel 5.7|Major changes between ISE Eiffel 5.6 and ISE Eiffel 5.7]]
|
||||
* [[Major changes between ISE Eiffel 5.5 and ISE Eiffel 5.6|Major changes between ISE Eiffel 5.5 and ISE Eiffel 5.6]]
|
||||
* [[Major changes between ISE Eiffel 5.4 and ISE Eiffel 5.5|Major changes between ISE Eiffel 5.4 and ISE Eiffel 5.5]]
|
||||
* [[Major changes between ISE Eiffel 5.3 and ISE Eiffel 5.4|Major changes between ISE Eiffel 5.3 and ISE Eiffel 5.4]]
|
||||
* [[Major changes between ISE Eiffel 5.2 and ISE Eiffel 5.3|Major changes between ISE Eiffel 5.2 and ISE Eiffel 5.3]]
|
||||
* [[Major changes between ISE Eiffel 5.1 and ISE Eiffel 5.2|Major changes between ISE Eiffel 5.1 and ISE Eiffel 5.2]]
|
||||
* [[Major changes between ISE Eiffel 5.0 and ISE Eiffel 5.1|Major changes between ISE Eiffel 5.0 and ISE Eiffel 5.1]]
|
||||
* [[Major changes between ISE Eiffel 4.5 and ISE Eiffel 5.0|Major changes between ISE Eiffel 4.5 and ISE Eiffel 5.0]]
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user