### CINT

#### CINT7

After analyzing the results of our integration tests, we came to the conclusion that Cint 7 would not provide any immediate and visible gain in performance or memory use while also not helping us achieve any of the benefits we were aiming for to improve Cint for the LHC experiments; Cint 7 was also not yet to the point of being able to improve on any of the Cint 5 deficiencies or on the lack of support for the upcoming C++ standard. Hence we decided to no longer pursue this direction.

As an alternative we started investigating LLVM, a cutting edge popular open source compiler project that is already used in commercial environments. Apple is currently supporting the main developers and relying on LLVM for Mac OS 10.6 and above. Its strengths include binary platform compatibility, a C++ API, large number of optimizer, and a just-in-time compiler, amongst others; these strengths makes it an ideal candidate for building upon to develop a new interpreter. The LLVM team is currently implementing a promising C/C++ and Objective C/C++ front end (Clang) which can already parse more than 95% of the ROOT header files.

After working with the LLVM and Clang team for a while, we are confident that they will deliver a very good C++ compiler. We believe that we can re-use large parts of it to produce a production-grade interpreter with C++ API, leveraging the large LLVM developer community. Thanks to LLVM, this future interpreter would offer better and faster parsing and execution (for both the dictionary generation and the interpretation). We are currently exploring the implementation of the interpreter and reflection database based on LLVM with an early prototype, code named Cling. Amongst other things, it demonstrate the usability of LLVM's just-in-time compiler.

You can see more details on the Cint7 conclusion as well as LLVM and Cling in Axel's presentation.

#### Development

All other packages have seen bug fixes and performance improvements. They are all backward compatible with the v5.24/00 release.

- CINT
  - Improve the lookup time for type names. Improves start-up time (dictionary initialization) and parsing speed.
  - New link pragma to simply the generation of the dictionary for 'operators' in a rootcint dictionary.

        #pragma link [C++|off] operators classname;

    will turn on/off symbol table registration of the operators that are declared in the declaring scopes of 'classname' (and any of its enclosing scope) and take at least one argument that is a reference, pointer, or value argument of type classname.
  - Replace most of CINT's static buffers by a custom string class with very fast allocation. This costs <0.5% in runtime, <300kB in heap, and significantly increases CINT's robustness with large type names, source lines etc. It also reduces the stack use of CINT, a problem encountered mostly on Windows.
  - CINT now doesn't `exit()` anymore when encountering fatal errors but throws a `runtime_exception`.
  - Improve handling of `nan` (not a number).
- Reflex
  - Implement loading on demand of data and (most) function members for genreflex dictionaries, similar to what is available for rootcint dictionaries. This reduces the start-up time and especially the memory usage of dictionaries considerably.
- Cintex
  - Fix the implementation of ShowMembers in the case where the members are of type with a rootcint dictionary and no genreflex dictionary.
  - Don't add artificial `Streamer()` or `StreamerNVirtual()` methods to class passed through Cintex anymore. This speeds up the I/O of classes with Reflex dictionaries.
  - Only flag the artificial `ShowMembers()` as `virtual` if the class already has a virtual function table; otherwise ROOT will wrongly expect the class to have a virtual function table.