Reformatting according to the coding conventions
Reformatting according to the coding conventions.
Fixed deepness for classes
Reformatting according to the coding conventions.
Reduce the memory necessary to find simple function.

In findFunction we now use a very simple parse step that dectect whether the
name search (which is already supposed to be an unqualified name) is a simple
identifier, a constructor name or a destructor name.  In those 3 cases, we can
easily create the UnqualifiedId object that would have resulted from the 'real'
parse.   By using this direct creation of the UnqualifiedId, we avoid the
'permanent' cost associated with creating a memory buffer and the associated
FileID.

If the name is a template or an operator, we revert to the regular parse (and
its associated permanent cost).

In the operator case, the additional work is in the case of a conversion
operator where we would need to 'quickly' parse the type itself (if want to
avoid the permanent cost).

In the case with the template the problem gets a bit worse as we need to handle
potentially arbitrary spaces and ordering ('const int' vs 'int  const', etc.)
Style.
Clarification comment. Still the reasoning ununderstood.
Clarification comment.
Half-implement the autoloading of classes within namespaces.

When there is a rootmap file describing: MyNamespace::MyClass and MyNamespace
is seen for the first time, we end up with a lookup failure for MyNamespace.
To avoid that we just need to store compiler's state declare the namespace as:
namespace MyNamespace{}

On a lookup failure of MyNamespace, ROOT has to signal cling that there is a
class in namespace with that name. We needed some extension of TCling's and
TClingCallbacks' interfaces.
Implement autoloading of entities in unknown namespaces.
Eg. MyNamespace::MyClass.
The implementation is far from ideal, but for the timeline we have it is good
enough. On a second iteration it could be improved a lot.
The namespace must be our second decl in the transaction.
Add support for mangling: How we can check regular C++ functions.

Indirect calls are still an issue.
Add support for null deref checks in indirect calls.
Fix lifetime. StringRef doesn't allocate storage.
Implement Jira #ROOT-5273 ACLiC through #include

Implement support of #include "myFile.C+" in Cling

- Add a new class TPPClingCallbacks in TClingCallbacks.cxx
- Add two new functions TCling__CompileMacro and TCling__SplitAclicMode TCling.cxx, both used by TPPClingCallbacks

The FileNotFound() method of TPPClingCallbacks is called via Callbacks->FileNotFound(Filename, RecoveryPath) in Preprocessor::HandleIncludeDirective(), allowing to compile code via ACLiC when specifying #include "myfile.C+", and hence suppressing preprocessor error message like:
input_line_23:1:10: fatal error: 'myfile.C+' file not found