ChangeLog

eddic 1.3.0 - in development
* Migrated from Boost Program Options to cxxopts
* Migrate from Spirit Qi to Spirit X3
* Replaced CMake by plain old makefiles
* Fix Loop Invariant Code Motion bugs
* Improve memory usage
* Better AST and grammar
* Faster optimizations
* Better C++11/C++14 code
* MIT license

eddic 1.2.3 - 2013.03.08

* Language: char and bool now take only 1 byte
* Language: Fix bug with use i++ in for loop
* Language: Automatic generation of copy constructors for structures with structure fields
* Optimizer: Improve the speed of the data-flow framework
* Optimizer: Loop Unswitching
* Optimizer: Iterate the call graph in postorder to inline functions
* Optimizer: Remove variables contributing only to themselves
* Optimizer: Improve induction variable to support division
* Compiler: Better timing system
* Compiler: Better error reporting
* Compiler: Parts of the compiler are compiled with RTTI disabled
* Compiler: Implement performance kernels to test the generated code

eddic 1.2.2 - 2013.01.26

* Language: When structures are passed by value, they are copy constructed
* Language: Inclusion of several times the same header is now handled correctly
* Standard Library: New functions into vector
* Standard Library: printI and printF have been rewritten in EDDI
* Optimizer: Loops with more than one basic block are now correctly discovered
* Optimizer: Analysis of functions to avoid creating new basic blocks when not necessary
* Optimizer: Management of a call graph, used to remove unused functions
* Optimizer: Aggressivity of the inliner has been reduced
* Optimizer: Loop Invariant Code Motion can now move read to memory (DOT)
* Optimizer: Common Subexpression Elimination can now group reads to memory (DOT)
* Options: New optimization level, O3, performs loop unrolling and complete loop peeling
* Compiler: All mtac::Statement merged into mtac::Quadruple and stored directly into a vector
* Compiler: Several memory leaks have been fixed
* Compiler: Performances of constant propagation have been improved

eddic 1.2.1 - 2012.12.31

* Language: string is renamed to str
* Language: concatenation is no more possible on str
* Language: delete can be applied on any left value now
* Language: Support for dynamic arrays of structures
* Language: printB is now an EDDI function
* Standard Library: Add a class string
* Standard Library: Add support for concatenation of string and int
* Standard Library: Add a vector
* Warnings: Better warnings for includes of standard library
* Bug: The hangman application no works correctly
* Optimizer: Propagate constant parameters into functions
* Optimizer: Improved performances of general optimization
* Tests: Add test case verifying that optimizations are done
* Compiler: Improved the error reporting to display several errors instead of only the first
* Compiler: Add statistics system to keep track of counters
* Compiler: Use less shared_ptr and manipulates references instead (eddic::Function, mtac::Function and mtac::Program)

eddic 1.2.0 - 2012.12.15

* Language: Support for single inheritance
* Language: Allow a function to return a structure by value
* Language: Structures can contains arrays
* Language: Switch can be used on strings
* Language: Function can be called on any valid left value
* Language: Allow members of structures in any order
* Language: Add & operator to get address of values
* Language: Add support for assignment to structures via copy constructor
* Optimizer: Basic loop unrolling
* Optimizer: Fix pointer propagation for structures
* Optimizer: Propagate conditionals into branches
* Loops: Store the list of induction variables in each Loop
* Loops: Store the estimated iterations in each Loop
* Registers: Save only necessary registers when calling a function
* Compiler: The template instantiation depth limit can be configured
* Compiler: Add options to keep track of time spent in each optimization
* Compiler: Great improvements in the AST and the grammar
* Compiler: Output warning if statement without effect is used

eddic 1.1.4 - 2012.11.07

* Language: Support for dynamically allocated arrays
* Language: Implicit this pointer in member functions
* Standard Library: Doubly-Linked List
* Template Engine: Recursive implementation
* Optimization: New graph coloring register allocation
* Optimization: Add pass manager
* Optimization: The CFG is computed only once
* Optimization: Add support for low-level data-flow
* Optimization: Loop Invariant Code Motion
* Optimization: Loop Strength Reduction
* Optimization: Complete Loop Peeling
* inlining: Call-site inlining
* inlining: Support for string parameters
* inlining: Take constants passed in passed into account
* Compiler: The whole compilation process is thread safe
* Compiler: Better separation of the middle end and back end
* Compiler: Add support for CLang
* Compiler: Add support for LTAC basic blocks
* Test Suite: The tests are run in parallel

eddic 1.1.3 - 2012.09.05

* Language: Support for template functions and structs
* Language: Support the ! operator for bool values
* Language: The this pointer is implicit to access member values
* Language: Support for foreach loop on strings
* Optimization: The Constant propagation take into account default values of arrays and structures
* Optimization: The modulus operation is compiled using AND when possible
* Optimization: The boolean operations are constant folded when possible
* Optimization: Propagate pointers
* inlining: Inline functions that takes char parameters
* Compiler: Use a powerful system for loggng

eddic 1.1.2 - 2012.08.25

* Language: Support char type
* Language: Support for cast between char and int
* Language: Support the [] operator for string
* Language: Add support to read the command line
* Standard Library: Add function to compare two strings
* inlining: Inline functions that takes arrays as parameters
* Compiler: The symbol table is now stored in the global context
* Compiler: Several improvements of the code
* Parser: Remove redundancy in the AST

eddic 1.1.1 - 2012.07.30

* Language: Support dynamic memory allocation (operators new and delete)
* Language: Support constructors and destructors
* Language: Support switch construct
* Optimization: Pass pointers in registers when possible
* Optimization: Separate escape-analysis and live-variable analysis
* Optimization: Remove some variables used only as temporary copies when possible
* Peephole optimizer: Use conditional move when possible
* Peephole optimizer: Local copy propagation of registers
* Assembly: Unify memory model

eddic 1.1.0 - 2012.07.22

* Language: Support member functions
* Language: Support ternary operator
* Optimizer: Enable parameter allocation only from O1
* Optimizer: Inline member functions
* Optimizer: Inline functions with pointers parameters
* Peephole optimizer: New optimizations for stack instructions
* Peephole optimizer: Avoid copies to parameter register
* Assembly: In O2 no generation of stack frames
* Compiler: Fix a problem with nasm and very small files

eddic 1.0.3 - 2012.07.13

* Language: Allow a const variable as the size of a global array
* Optimizer: Add inlining
* Optimizer: Allocate variables into registers
* Optimizer: Remove unused variable
* Optimizer: Remove unused functions (support for recursive functions)
* Optimizer: Improve overall performances of the optimization engine
* Intermediate Representation: Cleanup MTAC/LTAC operators
* Native Backend: Improve preamble and prologue generation
* Native Backend: When possible, stack frames are not printed
* Standard Library: Add a timer utility
* Compiler: Improve the configuration of the compiler

eddic 1.0.2 - 2012.07.04

* Language: Functions can now return pointers
* Language: Arrays can contains struct and pointers
* Language: Struct can have pointers members
* Optimizer: Global Dead-Code Elimination
* Optimizer: Global Live-Variable Analysis
* Optimizer: Empty functions are removed
* Peephole Optimizer: Support some local optimizations like dead-code elimination and simple constant propagation
* Native Backend: Output only the native methods that are used
* Native Backend: The standard functions are now in external files

eddic 1.0.1 - 2012.06.22

* Language: Support of pointers
* Language: Support for struct inside struct
* Compiler: Better error reporting for struct errors
* Peephole Optimizer: More optimizations for the LTAC Statements
* Optimizer: Do optimizations of functions in parralel
* Tests: New tests
* Tests: Test all optimization levels

eddic 1.0.0 - 2012.05.04

* Language: Support of structures
* Optimizer: First support for global optimizations (global constant propagation)
* Optimizer: Implemenation of Common Subexpression Elimination
* Optimizer: Use of a peephole optimizer for low-level optimizations
* Compiler: Use of a new low-level intermediate language
* Compiler: Review the use of constant floats in generated assembly
* Compiler: Much more complete unit test suite
* Compiler: Clear separation of front end and back end
* Miscellaneous: Boost chrono is no longer needed - Replaced by std::chrono

eddic 0.9.1 - 2012.03.21

* Pass params in registers
* Add suffix to integers to convert to float (5f for example)
* Fix bugs with the minus operator
* Implement optimizations for float
* Add casts to the language (cast from float to int and from int to float)

eddic 0.9.0 - 2012.03.07

* Add floating point support to the language
* Collect the position of the tokens and use them to display precise error or warning positions
* Add options to display AST and TAC representations to standard out
* Improved performance of the optimization engine
* Cleanup of the Compiler class
* Dispatch some code to different source files
* Remove some duplicated code

eddic 0.8.1 - 2012.02.19

* Add the do while loop to the language
* Implement constant and copy propagation for offset (e.g. (e)-8 = 4)
* Can now use the assignment as a value (e.g. a = b = 5)
* Optimize concat that are found to be constant after optimizations

eddic 0.8 - 2012.02.16

* Support for 64bit generation
* Support command line arguments
* Add builtin operators size() and length()
* Switch from AT&T Syntax to Intel Syntax in the generated assembly
* Implement copy propagation in the optimization engine
* Improvement on the generated assembly (use of string instructions for example)

eddic 0.7.1 - 2012.02.03

* Add logical operators (&& and ||) for boolean conditions
* Add the bool type to the language
* Add of increment and decrement operators (postfix and prefix versions)
* Add of compound operators to the language (*=, +=, /=, -=, %=)

eddic 0.7 - 2012.01.10

* Use Three-Address-Code as intermediate representations
* Use a better optimization engine on the TAC code
* Add minus and plus unary operators
* Implement const variables
* Allow a source file to include another file
* Use of Doxygen
* Use of more complete units tests

eddic 0.6.1 - 2011.11.21

* The functions can now return int or strings
* The pop instruction is now used to improve the generated assembly
* Performances of the AST have been improved a little
* The headers have been cleaned
* The readme has been improved
* The doxygen documentation can now be generated from CMake

eddic 0.6.0 - 2011.11.21

* Add arrays to the language
* New loop : foreach for arrays
* Fix print_integer to handle negative numbers
* Add default values for global and local variables
* Add warnings
* New optimizations for unused variables and functions
* Improved compilation speed

eddic 0.5.1 - 2011.11.10

* Use of Boost Spirit for lexer and parser
* Lot of improvements in the assembly
* Use of a simple intermediate representation : abstracted assembly
* Reduced time for compile
* Use of Boost Program Options

eddic 0.5.0 - 2011.10.10

* Function and functions calls
* New loop : foreach loop
* Global variables
* Improve error reporting
* Better code

eddic 0.4.1 - 2011.07.28

* Two loops : while and for
* Support parenthesis in mathematical expressions
* Variables are scoped
* Assembly improvements

eddic 0.4 - 2011.07.20

* Switch to a compiled language
* Swap operator <=>

eddic 0.3 - 2011.07.07

* Branches : if, else, else if
* Boolean operators : ==, !=, <, >, <=, >=
* Boolean litterals : true, false

eddic 0.2 - 2011.06.20

* New type : int
* New operators (+-*/%)
* String concatenations

eddic 0.1.1 - 2011.06.16

* Add string variables to the language

eddic 0.1 - 2011.06.13

* First version of EDDI.
* Contains only one instruction : Print
* Is an interpreted language