Added dependencies to onepcm target to protect from running to early in build system.
ROOT_LIBRARY_TARGETS records all targets that is used for generation of allDict.cxx.pch.

This was updated in commit fe4ffa75,
but that commit only changed this on UNIX and missed Windows.

Issue: ROOT-9532

This reverts commit 316f5535.

This reverts commit dc825fc4.

* Centralise the generation of help for root command

Add argparse2help.py, add root-argparse.py, delete the old help of root, add the cmake commands needed to generate the header containing the command line options help and to generate manual page for the root command.

The python file argparse2help.py can be called with the root-argparse.py and the output name as arguments. This call will generate the header file if the output has an extension ".h" and will generate the manual page if the extension is ".1"

* Centralise the generation of help for the rest of the commands

Add cmake changes to generate headers and manual pages for rootcling hadd and hist2workspace
Delete old man pages of hadd and hist2workspace
Add commented out generation of man pages for python commands, we need to add a dependency before uncommenting them out
Add hadd rootcling hist2workspace argparse modules

* make the path compatible with windows

* review modifications

* add dependency on the input and the generation script of man pages

* remove installation of headers

* Update CMakeLists.txt

It makes no sense to generates man pages on Windows. Windows does not have the `man` command.

* Update argparse2help.py

* Update argparse2help.py

* Update argparse2help.py

* Update hadd.cxx

haddCommandLineOptionsHelp.h was not included for windows

* Update root-argparse.py

add the option --version

* Update argparse2help.py

simplified version (Thanks Bertrand !)

This reverts commit 5993be60, reversing
changes made to f6b75592.

* Revert "[cmake] Narrow the list of included directories."

This reverts commit 88c16588.

* Revert "[cxxmodules] Build cling runtime into module."

This reverts commit 76a9ce75.

This reverts commit e56b4a96.

After removing globbing in core module, if to fetch a fresh master
some headers were not able to get a valid relative path causing next error:
-- /home/oksana/CERN_sources/root/builds/include/TArrayF.h
CMake Error at cmake/modules/RootNewMacros.cmake:292 (message):
  Header path '/home/oksana/CERN_sources/root/builds/include/TArrayF.h'
  TArrayF.h is not relative!
Call Stack (most recent call first):
  core/base/CMakeLists.txt:232 (ROOT_GENERATE_DICTIONARY)
Adding extra replacement pattern, matching - $CMAKE_BUILD_DIR/include, fixes issue.

The improvement is by 20% from (260MB to 210MB) and within the reach of the PCH.

We are fixing a correct invocation accidentally removed in ROOT_GENERATE_DICTIONARY() macro
in '[cxxmodules] Move away from environment variable' commit.

When using builtin_openssl=ON, CMake erroneously exports the builtin
static libraries in ROOTConfig-targets.cmake, which causes problems with
dependent projects. In order to avoid this, we need Net and RHTTP to use
SSL as a private dependency. Since CMake requires target_link_libraries()
to either be all-plain (as before) or all-keyword (required to allow
PRIVATE linking), we need to move the build system to use all-keyword
linking only.

Fixes: ROOT-9532

We currently have two checks (that are supposed to have the same
result) in the changed if-stmt and a few lines above where we
set cpp_module_file. Obviously if we generate a module, we should
also set cpp_module_file, however (due to the duplicated code) in
the case of multidicts we generate a module without specifying the
file. This probably causes CMake to behave incorrectly when rebuilding
PCM files.

We generate C++ modules, but we currently don't install them where
they belong.

Our CMake code for making path to headers relative is broken
for the v7 headers (as they don't have the 'CURRENT_SOURCE/inc'
prefix we check for). This caused that we have absolute paths for
those headers in the modulemap we ship with ROOT. As the paths
are only valid on the same system in the specific build folder,
they prevent anyone from successfully building any ROOT module
with this modulemap.

This patch adds the additional check for v7 headers and also
adds a fallback where we always remove the current source dir
from the paths (which is necessary for all the tests which
don't follow any directory structure).

Also adds a sanity check that should prevent this error in the
future by checking that paths are not absolute before we write
them to the modulemap.

We insert module use clauses to point to our special modules responsible
for supplying the relevant headers.

RootNewMacros.cmake gets included by dependent projects, which
causes problems related to the IN_LIST operator used in the new
find_package() macro. Moving it to SearchInstalledSoftware.cmake
makes it private to ROOT and solves these problems.

From now on, if a package Foo is built by ROOT itself, its name should
be added to the 'ROOT_BUILTINS' list, which turns find_package(Foo) into
a no-op. This prevents find_package(Foo) from wrongly finding a version
of the package already installed in the system, which would lead to
inconsistencies in the build. Packages moving to this new system must
make sure to setup all variables that would normally be set up by the
call to find_package(), including the creation of imported targets with
the appropriate properties (i.e., include directories, etc).

There are three different kinds of header files in Core:
  * C headers - they can be included in C contexts
  * Config headers - they are supposed to be textually included in each
    TU.
  * No RTTI C++ headers - they can be built in non-rtti context which is
    needed for stage1 builds.

The rest of the headers in Core require rtti in order to be built, either
because they use typeinfo or exceptions.

This patch structures the ROOT's special modules in that way allowing
implicit module builds to be trigger from the right complation. For
example, we cannot (and should not) trigger build of C++ module when
compiling C code.

rootcling performs an integrity check on the headers that are passed
via the command line and the ones we have in the modulemap. As this
check currently fails because we had to split up the Core and Thread,
we signal with a `use` directive that these other modules belong to
the current module.

The `use` directive is usually only for signalling that we intend
to use this other module from our module, but as we anyway don't
use `-fmodules-decluse` in ROOT we can just reuse this for telling
rootcling that it should also check the split out submodules when
doing the integrity check for the headers.

To give a concrete example: `ThreadLocalStorage` had to split
out of `Thread` to fix a cycle between `Core` and `Thread`.
However, rootcling now doesn't see the ThreadLocalStorage headers
in the `Thread` module but we pass them to the rootcling invocation
for `Thread`. This adds a `use ThreadLocalStorage` to Thread and
lets rootcling also iterate all `use`'d other modules when doing
this check, so we again have the full set of modules here.

These C++ modules serve no purpose as we
1. already have an STL dict.
2. they contain just interpreter clutter therefore.
3. care only about the generated IO information.

Let's disable them to get rid of all the build warning
when rootcling can't find the specific STL header that doesn't
exist inside ROOT:

```
Warning in <GenerateModule>: warning: Couldn't find the following specified headers in the module listDict:
  list
Warning in <GenerateModule>: warning: Couldn't find the following specified headers in the module multisetDict:
  set
```

Beside the general aversion against using an environment variable
for this setting, it also turns out that we can't easily set an
environment variable for a rootcling invocation in roottest.

This patch adds the -cxxmodule flag to rootcling to allow activating
this feature without the old environment variable. For backwards
compability, we keep the ROOT_MODULES support alive (for now).

This header is supported in the C++ module, so we can remove it from
the blacklist.

Fixes ROOT-9047.

When we build with -Dcxxmodules=On we should set the cpp_module otherwise
we get an incomplete modulemap.

 - Add missing includes (gdk/glib) for TGWin32 dictionary generation
 - Replace use of bindexplib by CMake's built-in WINDOWS_EXPORT_ALL_SYMBOLS property
 - Replace old nmake based build by the CMake based one for builtin_freetype and builtin_pcre
 - Add support for Visual Studio for LZ4
 - Fix compilation of builtin_afterimage
 - Add a few missing compilation flags
 - Filter out the multiproc sub-directory

Right now we only generate modulemaps for the ROOT libraries which
are exposed to the user. But we also have generate dictionary
calls for dictionaries that are not exposed to the user and should
only be private (such as TBench, TMathCoreUnitDict etc.).

Right now we fail when compiling root on those dictionaries as we
don't have a modulemap for those dictionaries and we don't generate
one. This will also break tests that use the generate dictionary
call as those also don't have a modulemap now.

This patch reuses the existing CMake code for generating modulemaps
and also uses it in those cases to provide a dictionary that
rootcling can use to generate a C++ module.

Currently CMake has the wrong path to check for this file, which
means it always regenerates the modules with runtime_cxxmodules
enabled as it never sees the generated file (which is in another
path).

This reverts commit 0651fcf3.

This reverts commit 33806336.

This reverts commit a9643370.