Comments normalized for all non deprecated variables.

They are now normalized pydoc """Comment""" with @type, @param, @rtype and @return implemented.
Recast of the Memory module.

This module has been refonded in order it to be compliant with the being developped new variable organisation.
Add a bunch of new classes called "Types"

These classes are used to define the very type of a variable (Word, Binary, HexWord...).
This commit add the directory which will contain these classes, an abstract class from which all types are supposed to inherit and an instance of type :
WordType that can represent a language word.
Add NumberType and DecimalWordType and correct some errors on WordType.

Two new types DecimalWordType and NumberType representing numbers in both string and number format are created.
Some bugs of import in WordType are resolved.
Add new types (IPv4 and MAC) and add generateRandomString function.

Add two new types : IPv4 and MAC.
Add a function "generateRandomString" in the AbstractType class used in almost all types class.
Factore the code of all types by implementing this new function.
Add HexType, BinaryType and type2bin()

Add two new type classes : HexType and BinaryType.
Add a function in AbstractType type2bin() which translates the local Type format in binary (bitarray) format.
Implement this function in every Type class.
Resolve some problems of import.
Start a new modelization of variables. Data variables are modelized.

Add an AbstractVariable class, an AbstractLeafVariable class which depends on the previous one and a DataVariable which represents every leaf variable that has data.
(Formerly WordVariable, BinaryVariable ...)
The type of these variable is now managed by the Type class stored in the Type directory.
The main functions of the variable class are also modified and corrected in order to better follow the theoretical model.
They are also factorized.
Modify the communication inter-function for all variable : New token system.

Variable processing (writing, and reading) functions now use a communication token to communicate critic objects.

Add three new classes:
 - AbstractVariableProcessingToken: the abstract mother class containing the main critic objects.
 - VariableReadingToken: a token dedicated to reading access.
 - VariableWritingToken: a token dedicated to writing access.

All the associated functions have been modified.
Add the node variables. Solve an error in DataVariable.

Add three new classes:
 - AbstractNodeVariable: an abstract class which inherits from AbstractVariable and describes a standard node variable.
 - AggregateVariable: new version of the aggregate variable (logical and of several variables)
 - AlternateVariable: new version of the alternate variable (logical or of several variables)
Solve a small error in DataVariable.
Corrects and extends the comment of all variable classes.

Adds contextual comment on each function of inheriting classes.
Adds a new version of the referenced variable.

This referenced variable subcontract all its function to the variable it pointed.
Management of element bit size between DataVariable and type changed.

The size is not anymore atomic size * number of characters.
That used to not work on Integer type.
A new class AbstractWordType has been created. It is an abstract type represented by a string and contains all string management function needed.
Change size management for fixed-size type (IPv4, MAC).

The size is now fixed for this type.
Add a static maker of Type and strengthen functions type2bin().

This maker can make a Type with a string designing it.
The type2bin() functions have been strengthen to resist to a 'None' parameter.
Change the NumberType into IntegerType, add a toString() function to each type.

NumberType used to define integer. So the name was quite unprecise.
The toString() function return the string definition of each type.
Adds the toXML() and loadFromXML() functions to every Variable module.

This functions were in the former version of the code and have conserved their global performance.
toXML() export a variable in an xml tree.
loadFromXML() is a static function which create a variable from an XML definition.
Both functions comply to the same XML format.

Warning: this XML format has been modified since the former version of the code. Changes are the following:
 - The replacement of every former leaf variable (WordVariable, BinaryVariable ...) by a unique DataVariable has been ported to the xml format.
 - Each leaf variable has the following leaf (plus the former ones) containing values of attribute introduced in this version:
   - type;
   - minBits;
   - maxBits.
Corrects details and grammar in Memory and AbstractionLayer modules.
Changes name of former variable modules.

They are now named _<Variable module name> so they can be seen as deprecated.
Adds the Repeat Variable.

The repeat variable is an aggregate variable which execute several times each elementary operation sequentially on its children.
Repeat variables inherit from aggregate variables.
The whole abstraction branch has been updated.
The function setIndex() has been added to the VariableReadinfToken module to fill in a need of repeat variables.
Modification of the RepeatVariable.

The repeat variable has now only one child and repeats its treatment.