First iteration of updating CMake build for ROOT6. It builds on MacOSX but not yet run.

Assert only when in debug mode *and* llvmdev mode

Avoid assert in rootcling/genreflex just because there is a user error

Disable tests on SLC6 32 bit.

Add getter and silence a warning.

80 Cols.

DGRs can have a decl to be emitted, another not to be emitted.

When this oce comes from a #include through ParseForModules():
class A{} g;
A should be emitted, but not g.
This is now tested in roottest/root/meta/templateAutoload.

Compile RuntimeException with exceptions enabled.

Synthesizing if(DeclRefExpr) throw requires cling to be run with rtti.

Fix that problem by introducing an indirection - a compiled function that throws.

Add trampoline that will help avoid running without -no-rtti.

White space change (to force recompilation)

Compile RuntimeException.o with -fexception

Silence a warning.

Register result of .L

Use better name.

Remove unused files.

Extend the AST null deref checher and disable the IR checker.

This resulted in one change of warning kind, which is expected. I disabled the
test MetdhoCalls, Baozeng will look at it once he gets the code.

Visit the possible dereferences in-depth.

Typo

Improve exception reporting.

Add more rationale as to how this exception is different from others.

Use the correct routine.

Merge the two routines.

Reuse code.

Silence warnings for unused fields.

Comment out that unused variable until the new llvm import.

Spell out that we want only one wrapper per transaction.

Remove unused code.

Spaces.

Use best argument match constructor.

Add support for int *p = 0; *p; at AST level.

Add tmp prefix.

File renamed

Make CompilationException public, (also) use new cling runtime exception as base.

Install fatal error handler throwing an exception. Yes that is dangerous.

File was renamed.

Update the Module.mk. (Sorry for the mess).

Adapt the test suite to the new warnings produced.

Disable the indirect calls. We don't support them yet on AST level.

Reduce the dependence from the IR. It will be soon replaced by the AST one.

RuntimeExceptions got renamed.

Rename filename. We don't use plural in the names...

Pass in the Expr* instead of the SourceLocation.

Spell it syntactically correct.

Try silence an warning.

Fix doxygen warning.

Propagate the new callback to our InterpreterCallbacks interface.

Don't use local type as template argument.

Handle better the exceptions.

Improve the look&feel of the exception classes.

Remove the unused code.

Commit of storeState/compareState that now print lookup table and included files

Implementation of .files moved in the Interpreter.cpp

storeState now calls three functions: dumpAST(), dumpLookup(), printIncludedFiles().
compareState now calls three functions: compareAST(), compareLookup(), compareIncludedFiles().
It's working for the included files and the AST, and it needs a new patch for
being able to dump the lookup tables (we cannot use dumpLookups() for the moment).

Commit Interpreter.cpp with dumpLookupTable() function not working yet.

This will be fully operational after the LLVM/Clang update.

Handle the default interpreter's runtime exception.

Add base class for the interpreter's runtime exceptions.

Use default cling style for naming classes.

Add missing header method declarations.

Add forgotten to commit file.

Synthesize throwing of exception to handle the null deref.

Remove dead code (coverity 52208)

Copy the RuntimeExceptions.h over. Should fix the build.

Adapt to _Bool -> bool Use reg expr, because when building cling standalone we should still get _Bool.

If we know at compile time that something is wrong - throw without checks.

Add proper handling of the runtime exception.

Add special exception type for the null deref exceptions.

Implement the null deref checker on AST level.

We need to throw an exception if null deref is done. If we continued to do that
generating IR it would be too difficult to get the exception semantics and
cleanups right. Thus we decided to do it on AST level and delegate to codegen
generate the concrete IR that we need.

Update doxygen doc

In ParseProto register the addresses after the array is completely resized

Add missing transaction (fix .class)

Fix constness.

Add getter for dylib handle (against unused warning); remove unused kBitcode

adapt to new interface

Do not desugar typedef pointing to compiler 'details'.

Rather than skipping the desugaring of typedef pointing to anything in std, we
skip the desugaring of typedef pointing to a type starting with an underscore.

In GetPartiallyDesugaredType add ability to replace a type by a typedef.

Add struct cling::utils::Transform::Config to hold both the list of typedef to
avoid desugaring (m_toSkip) and the list of type to replace by a nicer typedef
(m_toReplace).

This is used to replace basic_string<...> by std::string.

Try without 'blocking' desugaring of typedef to std entities

Check if there were errors and only if there were not - run.

We must have a function implementation to take its address

In ReturnSynthesizer add better support for RecordType.

When we dectect that the last expression is a record type and is not
a temporary, we now return it by reference, hence avoiding an unnecessary
and sometimes impossible (cout) copy.   If it is a temporary we still
return a 'copy'.

Support function to function pointer decay in return value.

Add newline; (some?) fwd decls do not have one.

Remove unused variable.

Fix ROOT-5442, wrong normalization of std::vector<myNamespace::myClass1*>::const_iterator

GetPartiallyDesugaredType was 'forgetting' to add full qualification of the
template parameters in some case (where the template paramter in the
QualType was not yet an elaborated type).  Extend the internal interface to
distinguish when we need to add full qualification to the type itself or its
template parameters.

Add missing operators in ParseWithShortcuts.

Don't play smart* use proper empty str as default arg.

Finally fix that infinite const recursion.

Move codegenning of deserialized declarations in the IncrementalParser.

We had two different codepath for codegeneration. The first one was for
declarations that came from text and the second one for declarations that came
from 'ExternalSource' such as PCH. In the latter case we had to do some
extra equilibristics to emulate a PCM and ignore generating code for decls with
static storage, because it will clash with the loading of the library that already
contains them.

The advantage of the new implementation is that instead of communicating the
deserialized decls to ROOT via some fishy deserialization listeners we can use
the cling::Transaction as we use it for decls that came from code.

Print the decls coming from deserialization, too.

There is no need of checking the size of the transaction.

Fix getters, ending up in infinite recursion...

Implement pretty print of DelayCallInfo. Constify.

Order.

Add another sanity check. It will cry whenever we extend the enum.

Iterating over the AST might trigger deserialization.

Constify.

The ASTContext is a ref.

Use the ASTContext stored in the Transaction.

Forward to the const getter.

UserInterface must be compiled with -fexceptions.

Add support for TClingCallFunc function wrappers to transactions.

Support returning values of arbitrary class type.

This restriction prevents us from evaluating function argument
expressions of class type (by value), and prevents us from
returning values with a class type (by value), if that class
has a non-trivial constructor or copy constructor.

For now we will allow the StoredValue to do a bit copy, with
the expectation that in the future StoredValue will hold
values of class type by pointer or reference instead of making
a copy.

Add support for member data pointer type.

Given:

class A {
private:
   int fInt;
};

We need to support storing the return value of
a function like this:

int A::*
f()
{
   return &A::fInt;
}