Major changes between ISE Eiffel 5.3 and ISE Eiffel 5.4

    1. What's new
    2. Improvements
    3. Changes
    4. Bug fixes
      1. Language issues
      2. Compiler issues
      3. Runtime/code generation issues
      4. .NET issues
      5. Store/Retrieve issues

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 convert keyword (only on argument passing and assignments. Not supported when used with infix routines).


  • 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 TUPLE creation and TUPLE 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)


  • 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:

sleep (m: INTEGER) is external "C blocking" endNot 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:

td: TUPLE [DOUBLE] ti: TUPLE [INTEGER] td := tiThe 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 programming language specification.

  • Now we do not generate by default the .NET attribute ComVisibleAttribute 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 MY_CLASS, the following agent creation agent target. call is valid if and only if call is exported to MY_CLASS.
  • Allowed type specification for open operands in agent creation, i.e. one can now write: agent f ({ A}).
  • Fixed bug which allowed compiler to accept the following incorrect code: char: CHARACTER is "rdsf"
  • Fixed bug in error reporting for incompatible BIT types involving bit manifest constants. It would always report BIT 0, instead of the actual number of bits in the bit manifest constant.

Compiler issues

  • Fixed non-detection of changes when changing code from agent call to agent Current . call. Which should check for the validity of export of call 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 internal_correct_mismatch from ANY 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:

l_time: TIME_SPAN print (l_time.total_milliseconds.out)

  • 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 TUPLE objects where it would crash if storable did not include a reference to ANY.
cached: 02/26/2017 5:48:38.000 AM