From b06603d87e32393d54c8b730a231028df8f457f5 Mon Sep 17 00:00:00 2001
From: Axel Naumann <Axel.Naumann@cern.ch>
Date: Wed, 28 May 2014 17:49:10 +0200
Subject: [PATCH] Replace CINT by Cling.
---
documentation/users-guide/ALittleC++.md | 10 ++---
documentation/users-guide/AddingaClass.md | 22 +++++-----
documentation/users-guide/FoldersTasks.md | 2 +-
documentation/users-guide/GettingStarted.md | 18 ++++----
documentation/users-guide/Graphics.md | 6 +--
documentation/users-guide/Introduction.md | 33 ++++++---------
documentation/users-guide/MathLibraries.md | 8 ++--
documentation/users-guide/Preface.md | 2 +-
documentation/users-guide/PythonRuby.md | 42 +++++++++----------
documentation/users-guide/ROOTandQt.md | 10 ++---
documentation/users-guide/Threads.md | 2 +-
documentation/users-guide/Trees.md | 6 +--
.../users-guide/TutorialsandTests.md | 8 ++--
documentation/users-guide/WritingGUI.md | 10 ++---
14 files changed, 86 insertions(+), 93 deletions(-)
diff --git a/documentation/users-guide/ALittleC++.md b/documentation/users-guide/ALittleC++.md
index 06e0b31cb5f..1d641714da9 100644
--- a/documentation/users-guide/ALittleC++.md
+++ b/documentation/users-guide/ALittleC++.md
@@ -337,7 +337,7 @@ something like:
root[] my_objptr.Solve();
```
-Although this is a permitted by the CINT shortcuts, it is one that you
+Although this is a permitted by the Cling shortcuts, it is one that you
are *strongly* advised not to follow! As we have seen, heap objects
have to be accessed via pointers, whereas stack objects can be
accessed directly. They can also be accessed via pointers:
@@ -381,7 +381,7 @@ root[] my_objptr = 0;
```
You should see the print out from its destructor. Setting the pointer
-to zero afterwards is not strictly necessary (and CINT does it
+to zero afterwards is not strictly necessary (and Cling does it
automatically), but the object is no more accessible, and any attempt
to use the pointer again will, as has already been stated, cause
grief. So much for heap objects, but how are stack objects deleted? In
@@ -393,7 +393,7 @@ futile to do something like:
root[] { Quad my_object(1.,2.,-3.); }
```
-CINT does not follow this rule; if you type in the above line, you
+Cling does not follow this rule; if you type in the above line, you
will not see the destructor message. As explained in the Script
lesson, you can load in compound statements, which would be a bit
pointless if everything disappeared as soon as it was loaded! Instead,
@@ -422,10 +422,10 @@ the stack. This command will fail.
root[] my_objptr->Solve();
```
-CINT no longer knows what `my_objptr` is. This is a great example of a
+Cling no longer knows what `my_objptr` is. This is a great example of a
memory leak; the heap object exists but we have lost our way to access
it. In general, this is not a problem. If any object will outlive the
compound statement in which it was created then a more permanent
pointer will point to it, which frequently is part of another heap
object. See Resetting the Interpreter Environment in the chapter
-"CINT the C++ Interpreter".
+"Cling the C++ Interpreter".
diff --git a/documentation/users-guide/AddingaClass.md b/documentation/users-guide/AddingaClass.md
index 0042b14cd6c..2e887fa9b5f 100644
--- a/documentation/users-guide/AddingaClass.md
+++ b/documentation/users-guide/AddingaClass.md
@@ -42,7 +42,7 @@ Bool_t b = obj->InheritsFrom("TLine");
Bool_t b = obj->InheritsFrom(TLine::Class());
```
-ROOT and `CINT` rely on reflection and the class dictionary to identify
+ROOT and `Cling` rely on reflection and the class dictionary to identify
the type of a variable at run time. With **`TObject`** inheritance come
some methods that use Introspection to help you see the data in the
object or class. For instance:
@@ -385,7 +385,7 @@ MyClass(TRootIoCtor*);
MyClass(); // Or a constructor with all its arguments defaulted.
```
-## rootcint: The CINT Dictionary Generator
+## rootcint: The Cling Dictionary Generator
In the following example, we walk through the steps necessary to
@@ -611,7 +611,7 @@ void SClass::Print() const {
You can add a class without using the `ClassDef` and `ClassImp` macros;
however, you will be limited. Specifically the object I/O features of
-ROOT will not be available to you for these classes. See "CINT the C++
+ROOT will not be available to you for these classes. See "Cling the C++
Interpreter". The `ShowMembers` and `Streamer` method, as well as the
`>>` operator overloads, are implemented only if you use `ClassDef` and
`ClassImp`. See `$ROOTSYS/include/Rtypes.h` for the definition of
@@ -723,7 +723,7 @@ it is needed (and thus never instantiated by the compiler).
#### Other Useful Pragma Statements
-The complete list of pragma statements currently supported by CINT is:
+The complete list of pragma statements currently supported by Cling is:
``` {.cpp}
#pragma link [C|C++|off] all [class|function|global|typedef];
@@ -751,7 +751,7 @@ example:
```
This will request the dictionary for all the class whose name start with
-`'MyClass'` and are already known to CINT (class templates need to have
+`'MyClass'` and are already known to Cling (class templates need to have
already been instantiated to be considered).
``` {.cpp}
@@ -760,7 +760,7 @@ already been instantiated to be considered).
This pragma statement turns on or off the dictionary generation for all
classes, structures, namespaces, global variables, global functions and
-typedefs seen so far by CINT. Example:
+typedefs seen so far by Cling. Example:
``` {.cpp}
// some C++ header definition
@@ -902,12 +902,12 @@ The pragma statements are:
#endif
```
-Until CINT version 5.15.60, in order to generate dictionary for a member
+Until Cling version 5.15.60, in order to generate dictionary for a member
function, not only the member function but also the class itself has to
be turned on for the linkage. There was an inconvenience when generating
dictionary for template member function afterwards.
-From CINT v.5.15.61, a new behavior is introduced. If link for a member
+From Cling v.5.15.61, a new behavior is introduced. If link for a member
function is specified, dictionary is generated even if link to the
belonging class is off. For example, if you originally have A.h as
follows:
@@ -1055,7 +1055,7 @@ This statements controls default link mode for
```
By turning default 'on', all language constructs in given header files
-will be included in generated CINT dictionary (interface method source
+will be included in generated Cling dictionary (interface method source
file). If default is set to 'off', nothing will be included in the
generated dictionary. The next statement explicitly set linkage to each
item:
@@ -1065,9 +1065,9 @@ item:
```
This pragma statement must be given before `cint/rootcint` reads any
-C/C++ definitions from header files. For pure CINT, default is on. For
+C/C++ definitions from header files. For pure Cling, default is on. For
ROOT, including `$ROOTSYSDIR/bin/cint`, default is off. This feature was
-added from CINT v.5.15.57. Before this version, you had to use
+added from Cling v.5.15.57. Before this version, you had to use
explicitly in the ROOT `LinkDef.h` file the next statement:
``` {.cpp}
diff --git a/documentation/users-guide/FoldersTasks.md b/documentation/users-guide/FoldersTasks.md
index 151ee5db553..8012cb62052 100644
--- a/documentation/users-guide/FoldersTasks.md
+++ b/documentation/users-guide/FoldersTasks.md
@@ -282,7 +282,7 @@ void tasks() {
Note that the first line loads the class definitions in `MyTasks.cxx`
with ACLiC. ACLiC builds a shared library and adds the classes to the
-CINT dictionary. See "Adding a Class with ACLiC".
+Cling dictionary. See "Adding a Class with ACLiC".
To execute a **`TTask`**, you call the `ExecuteTask` method.
`ExecuteTask` will recursively call:
diff --git a/documentation/users-guide/GettingStarted.md b/documentation/users-guide/GettingStarted.md
index 3fefd066439..041761a191c 100644
--- a/documentation/users-guide/GettingStarted.md
+++ b/documentation/users-guide/GettingStarted.md
@@ -98,14 +98,14 @@ and the `MANPATH`. To run the program just type: `root`.
ROOT 5.34/07 (v5-34-07@c1f030b, May 13 2013, 16:42:38 on macosx64)
-CINT/ROOT C/C++ Interpreter version 5.18.00, July 2, 2010
+Cling/ROOT C/C++ Interpreter version 5.18.00, July 2, 2010
Type ? for help. Commands must be C++ statements.
Enclose multiple statements between { }.
root [0]
```
To start ROOT you can type `root` at the system prompt. This starts up
-CINT, the ROOT command line C/C++ interpreter, and it gives you the
+Cling, the ROOT command line C/C++ interpreter, and it gives you the
ROOT prompt (`root[0]`).
It is possible to launch ROOT with some command line options, as shown
@@ -168,7 +168,7 @@ root -b -q 'myMacro.C("text")' > myMacro.log
You can build a shared library with ACLiC and then use this shared
library on the command line for a quicker execution (i.e. the compiled
-speed rather than the interpreted speed). See also "CINT the C++
+speed rather than the interpreted speed). See also "Cling the C++
Interpreter".
```
@@ -707,7 +707,7 @@ root[] MyC_3->cd()
- Third pad will be selected since you called `TPad::cd()` for the
object `MyC_3`. ROOT will find the pad that was named` MyC_3 `when
- you typed it on the command line (see ROOT/CINT Extensions to
+ you typed it on the command line (see ROOT/Cling Extensions to
C++).
### Saving the Canvas
@@ -757,10 +757,10 @@ is available in the canvas toolbar (activated via View menu/Toolbar).
We have briefly touched on how to use the command line. There are
different types of commands.
-1. CINT commands start with "`.`"
+1. Cling commands start with "`.`"
``` {.cpp}
-root[] .? //this command will list all the CINT commands
+root[] .? //this command will list all the Cling commands
root[] .L <filename> //load [filename]
root[] .x <filename> //load and execute [filename]
```
@@ -803,11 +803,11 @@ It is more convenient to edit a script than the command line, and if
your multi line commands are getting unmanageable, you may want to
start with a script instead.
-### CINT Extensions
+### Cling Extensions
-We should say that some things are not standard C++. The CINT
-interpreter has several extensions. See "ROOT/CINT Extensions to C++".
+We should say that some things are not standard C++. The Cling
+interpreter has several extensions. See "ROOT/Cling Extensions to C++".
### Helpful Hints for Command Line Typing
diff --git a/documentation/users-guide/Graphics.md b/documentation/users-guide/Graphics.md
index 71b17f67bbb..243d295f67a 100644
--- a/documentation/users-guide/Graphics.md
+++ b/documentation/users-guide/Graphics.md
@@ -176,7 +176,7 @@ menu.
virtual void SetLineAttributes(); // *MENU*
```
-Nothing else is needed, since CINT knows the classes and their methods.
+Nothing else is needed, since Cling knows the classes and their methods.
It takes advantage of that to create the context menu on the fly when
the object is clicking on. If you click on an axis, ROOT will ask the
interpreter what are the methods of the **`TAxis`** and which ones are
@@ -187,7 +187,7 @@ class that you want to use in the ROOT environment, you use `rootcint`
that builds the so-called stub functions and the dictionary. These
functions and the dictionary contain the knowledge of the used classes.
To do this, `rootcint` parses all the header files. ROOT has defined
-some special syntax to inform CINT of certain things, this is done in
+some special syntax to inform Cling of certain things, this is done in
the comments so that the code still compiles with a C++ compiler.
For example, you have a class with a `Draw()` method, which will display
@@ -643,7 +643,7 @@ root[] pad1->Divide(3,2)
If `pad1` is a pad then, it will divide the pad into 3 columns of 2
sub-pads. The generated sub-pads get names `pad1_i` where the index
`i=1` to `nxm` (in our case `pad1_1`, `pad1_2`...`pad1_6)`. The names
-`pad1_1 `etc... correspond to new variables in CINT, so you may use them
+`pad1_1 `etc... correspond to new variables in Cling, so you may use them
as soon as the executed method was `pad->Divide()`. However, in a
compiled program, one has to access these objects. Remember that a pad
contains other objects and that these objects may themselves be pads. So
diff --git a/documentation/users-guide/Introduction.md b/documentation/users-guide/Introduction.md
index 96924b6f44d..c3cd022784c 100644
--- a/documentation/users-guide/Introduction.md
+++ b/documentation/users-guide/Introduction.md
@@ -17,8 +17,8 @@ has generated an impressive amount of data, around 10 Terabytes per
run. This rate provided the ideal environment to develop and test the
next generation data analysis.
-One cannot mention ROOT without mentioning CINT, its C++ interpreter.
-CINT was created by Masa Goto in Japan. It is an independent product,
+One cannot mention ROOT without mentioning Cling, its C++ interpreter.
+Cling was created by Masa Goto in Japan. It is an independent product,
which ROOT is using for the command line and script processor.
ROOT was, and still is, developed in the "Bazaar style", a term from
@@ -313,7 +313,7 @@ The `bin` directory contains several executables.
| | CINTdebugger |
+---------------+------------------------------------------------------------+
| `rootcint` | is the utility ROOT uses to create a class dictionary for |
-| | CINT |
+| | Cling |
+---------------+------------------------------------------------------------+
| `rmkdepend` | a modified version of `makedepend` that is used by the |
| | ROOT build system |
@@ -321,12 +321,6 @@ The `bin` directory contains several executables.
| `root-config` | a script returning the needed compile flags and libraries |
| | for projects that compile and link with ROOT |
+---------------+------------------------------------------------------------+
-| `cint` | the C++ interpreter executable that is independent of ROOT |
-+---------------+------------------------------------------------------------+
-| `makecint` | the pure CINT version of `rootcint`, used to generate a |
-| | dictionary; It is used by some of CINT install scripts to |
-| | generate dictionaries for external system libraries |
-+---------------+------------------------------------------------------------+
| `proofd` | a small daemon used to authenticate a user of ROOT |
| | parallel processing capability (PROOF) |
+---------------+------------------------------------------------------------+
@@ -349,7 +343,7 @@ marked with a \* are only installed when the options specified them.
- `libAsImage` is the image manipulation library
-- `libCint` is the C++ interpreter (CINT)
+- `libCling` is the C++ interpreter (Cling)
- `libCore` is the Base classes
@@ -420,7 +414,7 @@ marked with a \* are only installed when the options specified them.
- \*`libRGL` is the interface to OpenGL.
-- `libReflex` is the runtime type database library used by CINT
+- `libReflex` is the runtime type database library used by Cling
- `libRint` is the interactive interface to ROOT (provides command
prompt)
@@ -457,13 +451,12 @@ up of base classes, container classes, meta information classes,
operating system specific classes, and the ZIP algorithm used for
compression of the ROOT files.
-The CINT library (`libCint.so`) is also needed in all ROOT
-applications, and even by `libCore`. It can be used independently of
-`libCore`, in case you only need the C++ interpreter and not ROOT. A
-program referencing only **`TObject`** only needs `libCore` and
-`libCint`. To add the ability to read and write ROOT objects one also
-has to load libRIO. As one would expect, none of that depends on
-graphics or the GUI.
+The Cling library (`libCling.so`) is also needed in all ROOT
+applications, and even by `libCore`. A
+program referencing only **`TObject`** only needs `libCore`;
+`libCling` will be opened automatically. To add the ability to read and write
+ROOT objects one also has to load `libRIO`. As one would expect, none of that
+depends on graphics or the GUI.
Library dependencies have different consequences; depending on whether
you try to build a binary, or you just try to access a class that is
@@ -483,7 +476,7 @@ library names change you will not need to change your Makefile.
A batch program that does not have a graphic display, which creates,
fills, and saves histograms and trees, only needs to link the core
-libraries (`libCore`, `libCint`, `libRIO`), `libHist` and `libTree`.
+libraries (`libCore`, `libRIO`), `libHist` and `libTree`.
If ROOT needs access to other libraries, it loads them dynamically.
For example, if the **`TreeViewer`** is used, `libTreePlayer` and all
libraries `libTreePlayer` depends on are loaded also. The dependent
@@ -519,7 +512,7 @@ contains many plugin definitions, or by calls to
#### Library Autoloading
-When using a class in CINT, e.g. in an interpreted source file, ROOT
+When using a class in Cling, e.g. in an interpreted source file, ROOT
will automatically load the library that defines this class. On
start-up, ROOT parses all files ending on `.rootmap` rootmap that are
in one of the `$LD_LIBRARY_PATH` (or `$DYLD_LIBRARY_PATH` for `MacOS`,
diff --git a/documentation/users-guide/MathLibraries.md b/documentation/users-guide/MathLibraries.md
index 11e1c6a3bd2..fc94d6471c4 100644
--- a/documentation/users-guide/MathLibraries.md
+++ b/documentation/users-guide/MathLibraries.md
@@ -395,7 +395,7 @@ are:
A detailed description for all `MathCore` classes is available in the
[online reference documentation](online reference documentation). The
-`MathCore` library presented in the ROOT distribution contains the CINT
+`MathCore` library presented in the ROOT distribution contains the Cling
dictionary for I/O and interactive usage. For the template classes, the
dictionary is provided for some of the possible types, such as those
based on double and Double32\_t. For the I/O or interactive use of other
@@ -1390,7 +1390,7 @@ Building `MathMore` requires a version of GSL larger or equal 1.8. The
source code of `MathMore` is distributed under the GNU General Public
License.
-`MathMore` (and its ROOT CINT dictionary) can be built within ROOT
+`MathMore` (and its ROOT Cling dictionary) can be built within ROOT
whenever a GSL library is found in the system. The GSL library and
header file location can be specified in the ROOT configure script, by
doing:
@@ -1718,7 +1718,7 @@ vectors for objects of arbitrary type. This class has 2 template
parameters, which define at compile time, its properties: 1) type of the
contained elements (for example *float* or *double*); 2) size of the
vector. The use of this dictionary is mandatory if one want to use
-`Smatrix` in CINT and with I/O.
+`Smatrix` in Cling and with I/O.
#### Creating a Vector
@@ -2130,7 +2130,7 @@ the `Print` method or the `<<` operator:
std::cout << m << std::endl;
```
-In the ROOT distribution, the CINT dictionary is generated for `SMatrix`
+In the ROOT distribution, the Cling dictionary is generated for `SMatrix`
and `SVector` for for **`Double_t`**, **`Float_t`** and **`Double32_t`**
up to dimension 7. This allows the possibility to store them in a ROOT
file.
diff --git a/documentation/users-guide/Preface.md b/documentation/users-guide/Preface.md
index 64f414cd9f8..55cf7d4eb34 100644
--- a/documentation/users-guide/Preface.md
+++ b/documentation/users-guide/Preface.md
@@ -29,7 +29,7 @@ developed. Over the last five years, many of our "customers" became
co-developers. Here we would like to thank our main co-developers and
contributors:
-**Masaharu Goto** wrote the CINT C++ interpreter that became an
+**Masaharu Goto** wrote the Cling C++ interpreter that became an
essential part of ROOT. Despite being 8 time zones ahead of us, we
have the feeling he has been sitting in the room next door since 1995.
diff --git a/documentation/users-guide/PythonRuby.md b/documentation/users-guide/PythonRuby.md
index 35de4a2c827..a8423b67820 100644
--- a/documentation/users-guide/PythonRuby.md
+++ b/documentation/users-guide/PythonRuby.md
@@ -7,7 +7,7 @@ interactive interpreter. Its interoperability with other programming
languages, both for extending Python as well as embedding it, is
excellent and many existing third-party applications and libraries have
therefore so-called "Python bindings." PyROOT provides Python bindings
-for ROOT: it enables cross-calls from ROOT/CINT into Python and vice
+for ROOT: it enables cross-calls from ROOT/Cling into Python and vice
versa, the intermingling of the two interpreters, and the transport of
user-level objects from one interpreter to the other. PyROOT enables
access from ROOT to any application or library that itself has Python
@@ -24,11 +24,11 @@ practically every library and application these days comes with Python
bindings (and if not, they can be easily written or generated).
`PyROOT`, a Python extension module, provides the bindings for the ROOT
-class library in a generic way using the CINT dictionary. This way, it
+class library in a generic way using the Cling dictionary. This way, it
allows the use of any ROOT classes from the Python interpreter, and thus
the "glue-ing" of ROOT libraries with any non-ROOT library or
applications that provide Python bindings. Further, `PyROOT` can be
-loaded into the CINT interpreter to allow (as of now still rudimentary)
+loaded into the Cling interpreter to allow (as of now still rudimentary)
access to Python classes. The best way to understand the benefits of
`PyROOT` is through a few examples.
@@ -103,11 +103,11 @@ c1.Update()
### Access to Python from ROOT
-Access to Python objects from CINT is not completely fleshed out.
+Access to Python objects from Cling is not completely fleshed out.
Currently, ROOT objects and built-in types can cross the boundary
between the two interpreters, but other objects are much more
restricted. For example, for a Python object to cross, it has to be a
-class instance, and its class has to be known to CINT first (i.e. the
+class instance, and its class has to be known to Cling first (i.e. the
class has to cross first, before the instance can). All other
cross-coding is based on strings that are run on the Python interpreter
and vise-versa.
@@ -289,7 +289,7 @@ section contains a description on working with your own classes (see
#### Access to STL Classes
-Before STL classes can be used, you have to make sure that the CINT
+Before STL classes can be used, you have to make sure that the Cling
extension dlls are build (the "`cintdlls`" make target). Note that they
do not compile on as many platforms as ROOT itself. Further, if you want
to use template instantiations of STL classes with any of your own
@@ -324,7 +324,7 @@ The parameters to the template instantiation can either be an actual
type or value (as is used here, "int"), or a string representation of
the parameters (e.g. "'double'"), or a mixture of both (e.g. "'TCanvas,
0'" or "'double', 0" ). The "std::vector\<int\>" class is one of the
-classes builtin by default into the CINT extension dlls. You will get a
+classes builtin by default into the Cling extension dlls. You will get a
non-functional class (instances of which can still be passed around to
C++) if the corresponding dictionary doesn't exist.
@@ -357,7 +357,7 @@ True
```
It is also possible to create globals interactively, either by executing
-a CINT macro, or by a call to `gROOT.ProcessLine()`. These globals are
+a Cling macro, or by a call to `gROOT.ProcessLine()`. These globals are
made available in the same way: either use them directly after creation
in 'from ROOT import \*' more, or get them from the ROOT namespace after
an 'import ROOT'.
@@ -393,7 +393,7 @@ import \*'.
#### Access to Python
-The access to Python from CINT goes through the **`TPython`** class, or
+The access to Python from Cling goes through the **`TPython`** class, or
directly if a Python object or class has crossed the border. The
**`TPython`** class, which looks approximately like this:
@@ -420,7 +420,7 @@ public:
`LoadMacro(const char* name)` - the argument is a name of a Python file
that is to be executed (`'execfile'`), after which any new classes are
-automatically made available to CINT. Since it is non-selective, use
+automatically made available to Cling. Since it is non-selective, use
with care.
`ExecScript(const char* name,int argc=0,const char** argv=0)` - the
@@ -443,7 +443,7 @@ different type), whereas builtin types will be cast implicitly, if
possible, to the type of the local variable to which they are assigned.
`Bind(TObject* obj,const char* label)` - transfer a ROOT object from the
-CINT to the Python interpreter, where it will be referenced with a
+Cling to the Python interpreter, where it will be referenced with a
variable called "`label`".
`Prompt()` - Transfer the interactive prompt to Python.
@@ -467,7 +467,7 @@ class MyPyClass:
return what
```
-This module can now be loaded into a CINT session, the class used to
+This module can now be loaded into a Cling session, the class used to
instantiate objects, and their member functions called for showing how
different types can cross:
@@ -487,7 +487,7 @@ available, such that it can be used directly. Otherwise, a
#### Callbacks
-The simplest way of setting a callback to Python from CINT, e.g. for a
+The simplest way of setting a callback to Python from Cling, e.g. for a
button, is by providing the execution string. See for example
`tutorials/pyroot/demo.py` that comes with the ROOT installation:
@@ -499,19 +499,19 @@ bar.AddButton('browser',r'TPython::Exec("b = Tbrowser()");','Start the ROOT brow
# [..]
```
-Here, the callback is a string that will be interpreted by CINT to call
+Here, the callback is a string that will be interpreted by Cling to call
`TPython::Exec()`, which will, in turn, interpret and execute the string
given to it. Note the use of raw strings (the '`r`' in front of the
second argument string), in order to remove the need of escaping the
backslashes.
-#### CINT Commands
+#### Cling Commands
In interactive mode, the Python exception hook is used to mimic some of
-the CINT commands available. These are: `.q`, **`.!`**, **`.x`**,
+the Cling commands available. These are: `.q`, **`.!`**, **`.x`**,
**`.L`**, **`.cd`**, **`.ls`**, **`.pwd`**, **`.?`** and **`.help`**.
Note that **`.x`** translates to Python '`execfile()`' and thus accepts
-only Python files, not CINT macros.
+only Python files, not Cling macros.
### Memory Handling
@@ -587,7 +587,7 @@ the memory.
### Performance
The performance of `PyROOT` when programming with ROOT in Python is
-similar to that of CINT. Differences occur mainly because of differences
+similar to that of Cling. Differences occur mainly because of differences
in the respective languages: C++ is much harder to parse, but once
parsed, it is much easier to optimize. Consequently, individual calls to
ROOT are typically faster from `PyROOT`, whereas loops are typically
@@ -946,10 +946,10 @@ print(m.GetValue())
Ruby ROOT is a Ruby extension module that allows the user to interact
with any ROOT class from the Ruby scripting language. The Ruby module
-resolves ROOT Classes and Methods at run-time using the CINT API, so
+resolves ROOT Classes and Methods at run-time using the Cling API, so
there is no need for wrapping specific Classes to be used in Ruby. The
Ruby module, also, contains a **`TRuby`** class to execute Ruby
-statements via CINT and export C++ Objects to Ruby objects,
+statements via Cling and export C++ Objects to Ruby objects,
interactively.
### Building and Installing the Ruby Module
@@ -1023,7 +1023,7 @@ run them you need to execute the command:
`ruby demo.rb`
-#### Invoking the Ruby Module from CINT Interpreter
+#### Invoking the Ruby Module from Cling Interpreter
A ROOT user can run any Ruby command and eventually to run` IRB`, the
Interactive Ruby Shell. The commands to execute are:
diff --git a/documentation/users-guide/ROOTandQt.md b/documentation/users-guide/ROOTandQt.md
index bcde14ef7a4..12064e0df97 100644
--- a/documentation/users-guide/ROOTandQt.md
+++ b/documentation/users-guide/ROOTandQt.md
@@ -69,9 +69,9 @@ May sure you are not going to pick the obsolete version.
% gmake install
```
-#### Qt Main C++ Classes CINT Dictionary
+#### Qt Main C++ Classes Cling Dictionary
-The ROOT CINT dictionary allows to call the Qt main classes directly
+The ROOT Cling dictionary allows to call the Qt main classes directly
from the ROOT command prompt is an optional component and it is not
created during the "Qt-layer installation". To build / re-build the Qt
main classes ROOT dictionary one can invoke the make
@@ -266,7 +266,7 @@ qmake include file, namely, `$ROOTSYS/include/rootcint.pri `with one
extra line in the project file (as the example above has revealed). The
include file defines all necessary components one needs to compile and
link the healthy Qt application against of the ROOT shared libraries. It
-contains the qmake rules to create the ROOT/CINT dictionary from the
+contains the qmake rules to create the ROOT/Cling dictionary from the
list of the provided header files.
For example, we may convert the stand-alone Qt-based ROOT application
@@ -366,7 +366,7 @@ include("$(ROOTSYS)/include/rootcint.pri")
```
At this point, you are ready to produce the class-shared library with
-the ROOT/CINT dictionary by invoking two shell commands (as above):
+the ROOT/Cling dictionary by invoking two shell commands (as above):
``` {.cpp}
qmake MyQButton.pro
@@ -452,7 +452,7 @@ root[] pnt.drawPixmap(0,0,*pix);
is to display the Qt "Setup Printer" dialog and use QPrinter object to
print the current **`TPad`** image to the selected printer. To use the
more complex Qt-related code one is advised to apply "ACLiC - Automatic
-Compiler of Libraries for CINT" (see CINT the C++ Interpreter). For
+Compiler of Libraries for Cling" (see Cling the C++ Interpreter). For
example:
``` {.cpp}
diff --git a/documentation/users-guide/Threads.md b/documentation/users-guide/Threads.md
index 03afad640d9..514d2c54b3e 100644
--- a/documentation/users-guide/Threads.md
+++ b/documentation/users-guide/Threads.md
@@ -211,7 +211,7 @@ precision.
### TThread in More Details
-CINT is not thread safe yet, and it will block the execution of the
+Cling is not thread safe yet, and it will block the execution of the
threads until it has finished executing.
#### Asynchronous Actions
diff --git a/documentation/users-guide/Trees.md b/documentation/users-guide/Trees.md
index 479d2578d43..2cb50b93e22 100644
--- a/documentation/users-guide/Trees.md
+++ b/documentation/users-guide/Trees.md
@@ -1999,9 +1999,9 @@ experiment with the **`TTree::Draw`** method, so let's create a pointer to it:
root[] TTree *MyTree = T
```
-CINT allows us to get simply the object by using it. Here we define a
+Cling allows us to get simply the object by using it. Here we define a
pointer to a **`TTree`** object and assign it the value of "`T`", the
-**`TTree`** in the file. CINT looks for an object named "`T`" in the
+**`TTree`** in the file. Cling looks for an object named "`T`" in the
current ROOT file and returns it (this assumes that "T" has not
previously been used to declare a variable or function).
@@ -3586,7 +3586,7 @@ root[] T->MakeClass("MyClass")
Files: MyClass.h and MyClass.C generated from Tree: T
```
-CINT informs us that it has created two files. `MyClass.`h contains the
+Cling informs us that it has created two files. `MyClass.`h contains the
class definition and `MyClass.C` contains the `MyClass::Loop()` method.
`MyClass` has more methods than just `Loop()`. The other methods are a
constructor, a destructor, `GetEntry()`, `LoadTree()`, `Notify()`,
diff --git a/documentation/users-guide/TutorialsandTests.md b/documentation/users-guide/TutorialsandTests.md
index 1b5a45754bf..4879db112c5 100644
--- a/documentation/users-guide/TutorialsandTests.md
+++ b/documentation/users-guide/TutorialsandTests.md
@@ -35,7 +35,7 @@ To execute it type:
FreeType Engine v2.1.9 used to render TrueType fonts.
Compiled on 28 June 2007 for linux with thread support.
-CINT/ROOT C/C++ Interpreter version 5.16.21, June 22, 2007
+Cling/ROOT C/C++ Interpreter version 5.16.21, June 22, 2007
Type ? for help. Commands must be C++ statements.
Enclose multiple statements between { }.
root[0] .x hsimple.C
@@ -74,7 +74,7 @@ We see these source files:
| | `Event.cxx`, `EventCint.cxx` and `Event.h`. An example |
| | of a procedure to link this program is in |
| | `bind_Event`. Note that the `Makefile` invokes the |
-| | `rootcint` utility to generate the CINT interface |
+| | `rootcint` utility to generate the Cling interface |
| | `EventCint.cxx` |
+-------------------+--------------------------------------------------------+
| `Event.cxx` | Implementation for classes Event and Track |
@@ -356,7 +356,7 @@ sixteen tests covering the following capabilities of the ROOT framework.
- Divert Tree branches to separate files
-- CINT test (3 nested loops) with `LHCb` trigger
+- Cling test (3 nested loops) with `LHCb` trigger
The program stress takes one argument, the number of events to process.
The default is 1000 events. Be aware that executing stress with 1000
@@ -414,7 +414,7 @@ Test 12 : Compare histograms of test 9 and 11................... OK
Test 13 : Test merging files of a chain......................... OK
Test 14 : Check correct rebuilt of Event.root in test 13........ OK
Test 15 : Divert Tree branches to separate files................ OK
-Test 16 : CINT test (3 nested loops) with LHCb trigger.......... OK
+Test 16 : Cling test (3 nested loops) with LHCb trigger.......... OK
******************************************************************
* IRIX64 fnpat1 6.5 01221553 IP27
******************************************************************
diff --git a/documentation/users-guide/WritingGUI.md b/documentation/users-guide/WritingGUI.md
index c6cc7267352..7bda60f7b00 100644
--- a/documentation/users-guide/WritingGUI.md
+++ b/documentation/users-guide/WritingGUI.md
@@ -95,7 +95,7 @@ of the function `sin(x)/x` will be drawn in randomly chosen interval in
the canvas window, if you click on Exit - you close the application.
This example shows the basic concepts for almost any GUI-application in
ROOT and it is important to understand how it is constructed. The
-example program is written as a named script. See "CINT the C++
+example program is written as a named script. See "Cling the C++
Interpreter". Remember that the named script can be executed via
``` {.cpp}
@@ -363,7 +363,7 @@ fMain->MapWindow();
The line in between has an important mission - to execute all layout
specifications for the widgets before the top-level window itself is
-shown on the screen. We can run the named script via the CINT
+shown on the screen. We can run the named script via the Cling
interpreter with the command:
``` {.cpp}
@@ -1171,7 +1171,7 @@ To use signals and slot you need something that brings them together.
The class **`TQObject`** has several methods creating sender-receiver
connections. Some of them are static and can be called without having an
instance of the class. The ROOT implementation of signals and slots
-allows connections to any known CINT object. The class name parameter in
+allows connections to any known Cling object. The class name parameter in
the `Connect()` methods must be a class with a dictionary (interpreted
classes have an implicit dictionary).
@@ -1266,7 +1266,7 @@ The rules for using signals/slots mechanism in a standalone executable
program do not differ from what was described previously. Let's remind
that
-- a slot can be any class method with a generated CINT dictionary
+- a slot can be any class method with a generated Cling dictionary
- a slot can be a function with a dictionary
@@ -2561,7 +2561,7 @@ for an application environment with common ‘look and feel'. The
object-oriented, event-driven programming model supports the modern
signals/slots communication mechanism. It handles user interface actions
and allows total independence of interacting objects and classes. This
-mechanism uses the ROOT dictionary information and the CINT the C++
+mechanism uses the ROOT dictionary information and the Cling the C++
Interpreter to connect signals to slots methods.
Therefore, all necessary elements for an object-oriented editor design
--
GitLab