ECMA Implementation

See also

• For a release-by-release summary of the inclusion of language facilities: the roadmap to ISO/ECMA Eiffel.
• For a general plan of the development of EiffelStudio (the full environment, not just language and compiler aspects): the EiffelStudio roadmap.

Introduction

Below is the list of tasks required in order to implement the full ECMA 367 specification of the Eiffel language. The list is divided in two parts, easy and complex tasks. The complex tasks are ordered from what we feel the most important to implement to the less important. The tasks refer to a chapter number, if that number is X, it corresponds to chapter 8.X of the ECMA 367 standard.

Easy tasks

• Chapter 3 Remove a restriction that any creation procedure of a root class is either argumentless or has 1 argument of type ARRAY [STRING]. Done in 6.0
• Chapter 3 Check that root class is not deferred (Update validity error) Done in 6.0
• Chapter 3 Support generic derivation as a root type. Done in 6.0
• Chapter 4 Replace "indexing" with "note".
• Chapter 5 Support new syntax for constant attributes: ... = Manifest_constant Done in 5.7
• Chapter 5 Remove keyword "is" from feature declaration. Done in 5.7
• Chapter 5 Add Attachment_mark ("?"|"!") syntax for any type declarations.
• Chapter 6 Support for inherit {NONE} syntax
• Chapter 6 Implement VHPR(6): end keyword is present if the Feature_adaption clause is not empty.
• Chapter 7 Implement VLEL(3): which allow `f' to appear twice as long as it belongs to two different lists
• Chapter 9 Type of assertion violation exception which should be ASSERTION_VIOLATION.
• Chapter 11 Change VTAT to take into account the possibility of anchored types to be defined in terms of other anchored types.
• Chapter 17 Invert Variant and Invariant order for assertion checking in a loop?
• Chapter 20 Change our implementation as `create x.make (a)' is internally transformed into `x := create {like x}.make (a)' which are semantically identical when `x' is a reference, but not when `x' is expanded where there will be an additional copy. (test#exec273: as of 6.0.6.9201, only melted byte code does not work as expected)
• Chapter 22 Change VBAR to take conversion into account.
• Chapter 23 Use new syntax for Parenthesized_target ("(|" and "|)").
• Chapter 23 Add validity rule VUNO for non-object call.
• Chapter 23 Change VUAR(2) to allow conversion of feature arguments.
• Chapter 27 Implementation of PREDICATE. Done in 5.7
• Chapter 28 Make sure we have the right operator precedence.
• Chapter 29 Introduce notion of constant manifest type, constant type.
• Chapter 31 Support syntax for external signature using a keyword "signature". Done in 5.7
• Chapter 31 Support syntax for external file use. Done in 5.7
• Chapter 31 Support C external syntax and associated validity rules Done in 5.7
• Chapter 31 Support C++ external syntax Done in 5.7
• Chapter 31 Support DLL external syntax. Done in 5.7
• Chapter 32 Allow only blanks (and no other break characters) in "and then" and "or else".
• Chapter 32 Add hexadecimal notation for a character code '%/.../'. Done in 6.0
• Chapter 32 Add binary and octal notation for integers. Done in 6.0

Complex tasks

• Chapter 26 Implement exceptions as objects
• Chapter 24 Support void-safe calls.
• Other New expanded semantic
• Chapter 9 Support for `only' postcondition clauses -- will not be done (the ECMA standard will change here)
• Chapter 13 Support tuple types with labels. Done in 5.7
• Chapter 27 Implementation of inline agents. Done in 5.7
• Chapter 23 Support lazy locals and attributes (attached or expanded entities).
• Chapter 12 Support Rename and Constraint_creators in generic constraint with new VTGC.Done in 6.0
• Chapter 15 Support precondition rule for conversions.
• Chapter 32 Support 32-bit Unicode characters as encoding variant of source code.
• Other Full system validity checking
• Chapter 5 Support explicit "attribute" form of Feature_value that allows to attach subclauses: Obsolete, Header_comment, Pre- and Postconditions to attribute.
• Chapter 30 Implement CHARACTER, STRING, REAL, INTEGER and NATURAL as alias for a given sized variant of CHARACTER_XX, STRING_XX, REAL_XX, INTEGER_XX and NATURAL_XX. Done in 5.7
• Chapter 32 Make header comment a syntactical variant of a note subclause item "what".
• Chapter 23 Change order of a routine execution: initialization of local variables goes after evaluation of a precondition and class invariant.
• Chapter 30 Implement CHARACTER_GENERAL, INTEGER_GENERAL, REAL_GENERAL
• Chapter 17 Implement inspect where choices are of type STRING or TYPE [G].
• Chapter 21 Add new equality operators "~" and "/~".
• Chapter 25 Handle catcalls.
• Chapter 6 New order in the Feature_adaptation clause (main difference is rename clause at the end rather than at the beginning).
• Chapter 16 Proper implementation of replication semantics rule for `select' and `non-conforming inheritance'.
• Chapter 10 Ensures that `redefine' implies a redeclaration (no effecting as it allows it today)
• Chapter 12 Add multiple constraints and VTMC. Done in 6.0
• Chapter 6 Implement VHPR(5): no two ancestors types of D are different generic derivations of the same class
• Chapter 10 Ensures that `undefine' can have a redeclaration that is deferred with same signature.
• Chapter 10 Check Join Semantics rule implementation (especially assertions).
• Chapter 23 Add VUTA to disallow calls on void-unsafe targets.
• Chapter 23 Add exception and the corresponding class VOID_TARGET for calls on void target.
• Chapter 23 Add a feature ANY.onces and an associated class to refresh once features.
• Chapter 26 Checks that all possible path of execution that might raise an exception are properly handled (i.e. following the code path diagram that we used in the ECMA minutes).
• Chapter 28 Implement Object_test
• Chapter 9 Rules (which are not yet in the standard) talking about recursive checking of assertions with the various proposed levels.
• Chapter 3 Check that a root creation procedure meets VSRP.
• Chapter 8 Support of once with a key.
• Chapter 12 Full implementation (directly or indirectly) recursive formal generics. Done in 6.0
• Chapter 5 Support "convert" mark in Operator_alias.
• Chapter 14 Implement conformance of tuple type to ARRAY.
• Chapter 20 Ensures that preconditions of a creation routine are `creation-valid'.
• Chapter 28 Update semantic of Address
• Chapter 25 Ensure semantics of ARRAY.put and ARRAY.force as if they assign a formal argument to an attribute (is this really for ARRAY? Should be NATIVE_ARRAY/SPECIAL)
• Chapter 12 Add optional frozen mark to formal generics and handle frozen actual generics (defined by "frozen" mark in formal generics).
• Update EiffelBase (and other libraries) to follow compiler evolutions