A little listing of language features and their definition/implementation states.

[David Pineau]

Hello folks !

Since we're soon going to start a re-write of the whole compiler into python, I
thought it would be useful (and amongst other things, nice for our followers) to
have a nice list of features and their current states of definition and/or
implementation within the current version of the language/compiler.

So here goes nothing, you're welcome to fix and improve my lil' listing :)

I'll try to go from top to bottom, in order to start by the big picture,
while classifying the features in two or three big categories.

Here are the three possible states that I use in this list:

 - Implemented: The solution is defined, and implemented within the compiler

 - Defined: The solution is defined but not implemented

 - Undefined: No solution has been defined (or only partially)

Well, here we go:

Code/Template Selection System:
  - Selection by config against a selection constraint
     * Front-End Configuration (assign values to variables)   -> Implemented
     * Constraints in templates through with block            -> Implemented

  - Cache of templates and interfaces:

     * Registration of Interfaces/Templates

        > Saves and indexes Interfaces                        -> Implemented
        > Saves and indexes Templates                         -> Implemented
        > Saves and indexes Source files associated           -> Defined

     * Load Interfaces/Templates trees on demand              -> Implemented

     * Caching of loaded Interfaces/Templates                 -> Defined

     * Selection of a template depending on a configuration   -> Implemented

     * Query the Cache by template to interrogate the support

       of a feature/OS/Version                                -> Undefined

Code Features/Structuration:

  - Interfaces (Middle End)

     * Lists available Config variables, types and templates  -> Implemented

     * Describes How each template interacts with the others
       (through provided chunks/pointcuts/attributes/methods) -> Implemented

     * Can be extended depending on the configuration

       variables' values                                      -> Undefined(partly)

  - Configuration Block (Middle/Front End)

     * Assigns values to variables defined by the interfaces  -> Implemented

  - Sequences (Language-wide)

     * Takes parameters (typed) from the caller               -> Implemented

     * Contains multiple chunks, one of which is the code

       matching a sequence call                               -> Implemented

     * Contains Instrumented C, resolved by the resolver      -> Implemented

  - Types (Middle/Back End)

     * Described as a list of fields, wrapper by the compiler -> Implemented

     * Declaration associated explicitly to a pointcut        -> Implemented

     * Contains rathaxes attributes, matched by an single

       expression in the instrumented C                       -> Implemented

     * Contains a list of 'methods' manipulating itself       -> Implemented(buggy)

  - Builtin Types (Middle/Back End)

     * Described in interfaces                                -> Implemented(badly)

     * Easily added to the compiler through a plugin-like

       interface                                              -> Implemented(badly)

     * Same feature coverage as a Back-End type               -> Implemented

  - Callbacks (Front End)

     * Receives parameters (typed) from the back-end          -> Implemented

     * Allows to describe an algorithm using the parameters   -> Implemented

     * Allows to declare temporary rathaxes variables         -> Defined

  - Error Management (Back-End)

     * Block associated to a chunk that manages error
       recovery (on the model of transactional C Code)        -> Defined

     * Builtin feature associated to automatically generate

       labels and jumps to avoid name conflicts               -> Undefined

  - Descriptors (Front End, similar to types)

     * Describe a user-defined type                           -> Undefined(partly)

  - Atomic Blocks (Front-End)

     * Creates an atomic behavior around multiple operations  -> Undefined

     * Generated a locked block or uses some specific chunks

       to create the atomic behavior                          -> Undefined

  - Identifier Magic (Back-End, Compiler internal)

     * Rename variables in a block in order to prevent name
       identifier conflict when weaving multiple chunks       -> Undefined

Code Weaving (Code Generation System):

  - Placeholders: Concatenated identifier                     -> Implemented

  - Placeholders: Value                                       -> Implemented

  - Placeholders: Type Declaration                            -> Implemented

  - Placeholders: Pointcut                                    -> Implemented

     * Includes any number of associated chunks, as long as

       they are registered in the cache's session             -> Implemented

     * Provides a default behavior in case no chunk was found -> Implemented

  - Placeholders: Type method call

     * Used like an Object Oriented language object's method  -> Implemented(buggy)

     * Defined as a chunk with no pointcut associated         -> Implemented

  - Placeholders: Sequence Call

     * Used seamlessly in Back-End/Front-End                  -> Implemented

     * Used like a function call in any language              -> Implemented

  - Rathaxes variable Scalar/Ref transcription

     * Provides an abstract notion of pointer                 -> Implemented

        > Types attribute are scalar/ref typed                -> Implemented

     * The use of a rathaxes variable transcribes to
       scalar/ref as needed, depending on the context         -> Implemented

        > Scalar to ref transcription                         -> Implemented

        > Ref to Scalar transcription                         -> Implemented

        > No transcription (ref/ref, scalar/scalar, */copy)   -> Implemented

Compiler features:

  - Logging:

     * Uniform logging format                                 -> Undefined

     * Defines a logging level per module                     -> Defined

  - Debugging:

     * Provides a step-by-step way to debug the generation    -> Undefined

     * Leveled log                                            -> Defined

If I missed some features, please help us completing this list, since it will
be really useful for us developers, in order to estimate the feature coverage

of the soon-to-be-started python rewrite, and what features we are missing
compared to the current state of the compiler.

By the way, I also plan to use this list to discuss some currently implemented

features, and some undefined or not-implemented features for a re-design before

we start writing the new compiler.

Cheers,

--
David Pineau,
Developer R&D at Scality