todo = """
+-- Correct enums handling
+-- alias byte uchar ;
+-- Beware the callbacks in the properties. Improvement needed.
+-- Methods/functions returning callback functions :
    void (* func )( int , int , int , int , Fl_Color ) Fl_get_boxtype ( Fl_Boxtype arg0 ) {
        return Fl::get_boxtype ( arg0  );
    }
    The above code is incorrect, it has to be replaced by the following :

    void (* Fl_get_boxtype ( Fl_Boxtype arg0 ))( int , int , int , int , Fl_Color ) {
        return Fl::get_boxtype ( arg0  );
    }

+-- callbacks (FunctionType):
    o--In the c_str methods : fix the code generation in the functions ( doing something like the Method class ).
    +-- In the d_str and d_import functions : remove the pointer star after : return function ( args ) __*__.
""'

done = """
+-- Why is there a trailing comma after the last parameter of some Constructors ?

+-- Functions : Avoid the & ( adress of ) for return types that are not references.

+-- Make a symbol table. No more use findNode (). Add a __getitem__ function in 
    self.root ( 'GCC_XML' ).
    Keep handleClasses. It allows to avoid inclusion of not implemented nodes. 
    > Use it to add each attribute of a class -> 'members'.
    > Will be much more efficient and less complicated than handleClasses.

+-- D Wrapper classes : dereference the D wrapper parameters {Class, Struct, Union } with the
    .ptr () method in the constructor, functions et check if it's not needed for methods.

+-- Extends the use of dereferencing method .ptr () for structures and unions.

+-- Passing parameters by reference : simulate it giving C++ pointer that can be manipulated in D.
    This method/functions uses dereferencing for its argument :
        void Classname_method ( Classname * self, OtherClass * ref ) {
            self->method ( *ref );
        }

+-- D references and C++ pointers : Structures, Unions.
    If a function returns a pointer on a class instance, that instance  must be transformed into a D reference.

+-- Use isinstance () instead of __class__.

+-- Make a command line incerface for the analyse.py script to use it on some C++ samples.

+-- Take into account the static fields (Field class). -> They are 'Variable'.

+-- Don't generate a "by pointer" constructor with a default '= null' argument if it 
    already exists a constructor without argument.

+-- Why the 'char *' is transformed into a 'char' ?  -> PointerType.d_import (). Fixed.

+-- There is a segmentation fault when we use a subclass destructor
    prior to the base class one. Even if we test the value of the self pointer in the base class,
    the seg fault remains. The solution is no to define the destructor in subclass
    to use only the base class one. As everything is made by pointer, the C++ part
    knows wich destructor to call.

+-- Don't redefine the 'self' pointer ( to the C++ instance ) if there is a base class.

+-- Public members and other than  methods and {cons,des}structors must be generated as
    D properties:
    Field.c_str () -> <field.type> <field.name>_get ();
                   -> void <field.name>_get ( <field.type> );

    Field.d_str () -> <field.type> <field.name> ();
                   -> void <field.name> ( <field.type> );

+-- In the d_import () constructors : fix the generation of arguments and return type Class.
    Do it in the destructors too.

+-- Typedef management in d_import () functions: generate the name, not the definition.

+-- D references and C++ pointers :
    If a function returns a pointer to a class, it has to be transformed into a D reference.
    Add a constructor by pointer in the D classes.

+-- Static methods management in c_str () function : there must not be a self pointer.

+-- C++ functions export : give them a different name in C ( starting with a '_' )
    to avoid a double definition and allow the exportation to D.
    Redefine the original name in the import D file with an alias.

+-- Callbacks code generation problem fixed.

+-- Respect the '__const__ char *' attributes.

+-- D classes code generation:
    Make a symbol table.
    Classes are added method if there 'incomplete' attribute is set to 1.
    Avoid double definition of classes.
    |
    +-- Generalize it to other class members.
"""