do we really need to select stl generators at all?

This ensures that the LZ4 internal build is built with the same
compiler as the rest of ROOT.

Now unused

SelectColumns chooses between the optional user-provided set of
column names and the default set. Throws in case of error. Picks
an incremental number of column names from the default set until
the required number is reached, instead of requiring that the
number of default branches is strictly equal to the number of
required branches for the transformation/action.

* added a paragraph on "creating a TDataFrame", including a TDF from scratch
* added examples and short explanations for string expressions for Define and Filter
* added a minimal example of creation of a TDF from scratch, including snapshotting to a new data-set
* switched "branch" with "column" where we are not specifically talking about a TTree

Again, wrong file names. Found with the debug code in RootNewMacros.cmake.

We should enable rootcling warnings and just fix the issues
they point out. This patch enables those warnings and
fixes the warnings that have accumulated over the past years.

The specific actions to fix each warnings were:

* We remove TSchemaWarning as this class was removed in commit
  3803a998.

* We remove TMPInterruptHandler as this class was removed in commit
  780e16a5.

* We rename the ROOT::TPoolManager selection rule to the correct
  ROOT::Internal::TPoolManager.

* We added the VarTransformHandler.h to the headers passed to rootcling
  in TMVA.

* We remove the selection rule for TMVA::DataSetFactory::EventStats
  because the class is private/protected.

* Fixed missing "_t" in the TrackMathCoreLinkDef.h.

Again, this is because we don't have the matching naming between
module and filename. Long live the debug code that we added to
RootNewMacros.cmake.

CMake requires two backslashes here (one for escaping the backslash
in our string, and then the \. for regex to recognize it's a literal dot).

Reduce(Op, 0) is nicer than Reduce(Op, "", 0).

When looking for the end of a block comment, really don’t bother with nesting. Finding the first end is good enough, the real parser can warn about any balancing issues.

The shared_ptr-on-the-heap trick is only needed for jitted actions,
but we were using it for all of them -- forgetting to delete the
shared_ptr in the non-jitted case.

Now only the code path with jitting makes use of the heap-allocated
shared_ptr, removing the leak.

So far GENERATE_DICTIONARY depends on all the targets passed to its
DEPENDENCIES argument. However, this means for some targets not
only the generation of PCMs, rootmaps etc, but also the linking of
this target (as for example the target `Hist` generates Hist.pcm
and then also links libHist.so). We only care about the files
generated by rootcling when we specify the dependencies here,
so we can improve build performance here.

This patch creates a new target for each dictionary generation
command called ROOTCLING_{MODULE} which can be refernced by other
rootcling invocations to state that they depend on the
rootcling files (PCMs, rootmap, root-PCMs) of this module, but
not on a fully built module. We then start checking for each
dependency passed to GENERATE_DICTIONARY if there is a
ROOTCLING_MODULE target and depend on this if possible.

This should cause that all the rootcling invocations can be
started earlier and the linking of modules and rootcling
invocations of its dependencies now run in parallel.

Right now rootcling doesn't know if the headers depend on a
target that is provided by a BUILTIN. This patch adds a new
parameter that allows expressing if thie rootcling invocation
depends on a certain BUILTIN in a way that is identical to the
ROOT_LINKER_LIBRARY way of handling this.

The naming of the library in the two function calls ROOT_GENERATE_DICTIONARY
and ROOT_LINKER_LIBRARY was often not matching. This causes that
ROOT_LINKER_LIBRARY couldn't correctly set its dependencies to the output
file of ROOT_GENERATE_DICTIONARY and therefore causes race conditions in
the build system.

Note: We're attached all dependencies to a custom target, and
NOT to the output files generated by rootcling. This should mitigate
the race conditions we experience when multiple targets in different
Make jobs request the same output file as a dependency and then
suffer from this Make problem that is described here:
https://cmake.org/Bug/view.php?id=10082

This patch also adds a (commented out) piece of code that can print
warnings if we don't have a fitting G__*.cxx file for a
ROOT_LINKER_LIBRARY call. This is sometimes intended, so I didn't
enable this warning by default. We should enable this code
by default in the future once we have a way to express if we
intentionally don't provide the G__*.cxx file when calling
ROOT_LINKER_LIBRARY.

In case CMake spawns multiple instances of a rootcling invocation
(which can happen as CMake doesn't have a good mechanism for ensuring
that we only spawn one when using the make build system), we now
choose process-unique file names for the temporaries to prevent the
build errors when multiple rootcling invocations try to work
on the same temporary file.

This isn't a real fix, but as renaming files from temporary to the
real name is usually FS atomic, this will mitigate any future race
conditions we have in this problematic part of the building process
on obscure build systems. Those systems possible don't strictly follow the
order in which they are supposed to build those targets, so this hopefully
makes the consequences of any race conditions less intrusive  (e.g. Visual
Studio also seems to suffer from this problem according to the mailing
list).

ROOT_GENERATE_DICTIONARY allows to specify dependencies, but we currently
don't actually specify those. As we need this for getting the module
dependencies right (as we can't build missing modules on demand), we should
add those dependencies here. Then those dependencies propagate to the
rootcling invocation which will in the future also generate the C++ module
for the selected dictionary.

This is already the case in CMake builds, adding it to make
behavior between build types more uniform. The option is not
added for ICC since it does not have such option and will
generate warnings about ignored flags. Also remove some old
unused options.

This is already the case in the CMake build, enabling the same on
classic makes the behavior more uniform across build types.

This option is already set to OFF in interpreter/llvm/CMakeLists.txt.

The options are obsolete since the last LLVM upgrade.

Adding these unused options generates warnings in the classic build:
http://cdash.cern.ch/viewBuildError.php?type=1&buildid=372656

Also remove add_definitions(-pthread) from CMakeLists.txt.
This is not the right function to use to add the flag, and
it is already taken care of by cmake/modules/CheckCompiler.cmake
in any case.

Warning:
root/core/rootcling_stage1/src/rootcling_stage1.cxx(38):
	warning #69: integer conversion resulted in truncation

   auto dummyVal = (int)(long)&usedToIdentifyRootClingByDlSym;
                    ^^^

The method above uses a cast to long, followed by a cast to int,
which results in a truncation. That is harmless, since the value
is never used, but generates a compiler warning with ICC 17. This
commit avoids the warning by storing the address of the same symbol
in a static variable instead.