Difference between revisions of "ECMA Implementation"

Revision as of 03:05, 5 April 2006

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].
• Chapter 3 Check that root class is not deferred (Update validity error)
• Chapter 3 Support generic derivation as a root type.
• Chapter 4 Replace "indexing" with "note".
• Chapter 5 Support new syntax for constant attributes: ... = Manifest_constant
• Chapter 5 Remove keyword "is" from feature declaration.
• 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.
• 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.
• Chapter 28 Make sure we have the right operator precedence.
• Chapter 29 Introduce notion of constant manifest type, constant type.
• Chapter 31 Support new registered languages "Eiffel", "Java", "Fortran95", "IL", "dll".
• Chapter 31 Support syntax for external signature using a keyword "signature".
• Chapter 31 Support syntax for external file use.
• Chapter 31 Support C external syntax and associated validity rules
• Chapter 31 Support C++ external syntax
• Chapter 31 Support DLL external syntax.
• 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 '%/.../'.
• Chapter 32 Add binary and octal notation for integers.

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
• Chapter 13 Support tuple types with labels.
• Chapter 27 Implementation of inline agents.
• Chapter 23 Support lazy locals and attributes (attached or expanded entities).
• Chapter 12 Support Rename and Constraint_creators in generic constraint with new VTGC.
• Chapter 15 Support conversion with associated validity rules.
• 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.
• 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.
• 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.
• 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).