remove old remnants of CINT

config/rootrc.in

@@ -352,7 +352,7 @@ Rint.History:            $(HOME)/.root_hist
 # Rint.WelcomeLite:      no
 # When the interactive ROOT starts, it can automatically load some frequently
 # used includes. However, this introduces several overheads
-#  - A long list of CINT and system files will be kept open during the session
+#  - A long list of CLING and system files will be kept open during the session
 #  - The initialisation takes more time (noticeable when using gdb or valgrind)
 #  - Memory overhead of about 5 Mbytes (1/3 of the base ROOT executable) when
 #    including <vector>

core/base/inc/GLConstants.h

@@ -12,7 +12,7 @@
 #define ROOT_GLConstants
 
 //*-*   This contains the map for those OpenGL package constant the ROOT uses
-//*-*   We need the second table since CINT doesn't understand the "define" pre-processor command
+//*-*   We need the second table since CINT was not able to understand the "define" pre-processor command
 
 
 #ifndef GLConstants

core/base/inc/MessageTypes.h

@@ -33,7 +33,7 @@ enum EMessageTypes {
    kMESS_NOTOK           = 2,            //things are NOT OK
    kMESS_STRING          = 3,            //string follows
    kMESS_OBJECT          = 4,            //object follows
-   kMESS_CINT            = 5,            //cint command follows
+   kMESS_CINT            = 5,            //CLING command follows
    kMESS_STREAMERINFO    = 6,            //TStreamerInfo object follows
    kMESS_PROCESSID       = 7,            //TProcessID object follows
 

core/base/inc/RtypesImp.h

@@ -44,7 +44,7 @@ inline void operator delete(void*, ROOT::Internal::TOperatorNewHelper*) { }
 
 // The STL GenerateInitInstance are not unique and hence are declared static
 // (not accessible outside the dictionary and not linker error for duplicate)
-#if defined(__CINT__)
+#if defined(__CINT__) || defined(__CLING__)
 #define RootStlStreamer(name,STREAMER)
 #else
 #define RootStlStreamer(name,STREAMER)                               \

core/base/inc/TPluginManager.h

@@ -61,7 +61,7 @@
 // should be the constructor or a static method that generates an       //
 // instance of the specified class. Global methods should start with    //
 // "::" in their name, like "::CreateFitter()".                         //
-// Instead of being a shared library a plugin can also be a CINT        //
+// Instead of being a shared library a plugin can also be a CLING       //
 // script, so instead of libDialog.so one can have Dialog.C.            //
 // The * is a placeholder in case there is no need for a URI to         //
 // differentiate between different plugins for the same base class.     //

core/base/inc/TQObject.h

@@ -259,7 +259,7 @@ class TQObjSender : public TQObject {
 // Global function which simplifies making connections in interpreted
 // ROOT session
 //
-//  ConnectCINT      - connects to interpreter(CINT) command
+//  ConnectCINT      - connects to interpreter(CLING) command
 
 extern Bool_t ConnectCINT(TQObject *sender, const char *signal,
                           const char *slot);

core/base/inc/TRootIOCtor.h

@@ -18,13 +18,13 @@
 //                                                                      //
 // Helper class used to mark a constructor to be used by ROOT instead   //
 // of the default constructor.                                          //
-// If rootcint sees in a class declaration of the class MyClass:        //
+// If rootcling sees in a class declaration of the class MyClass:       //
 //    MyClass(TRootIOCtor*);                                            //
 // This constructor will be used instead of the default constructor.    //
 //                                                                      //
 // Also the pragma:                                                     //
 //   #pragma link C++ ioctortype MyMarker;                              //
-// can be used to tell rootcint that a constuctor taking a MyMarker*    //
+// can be used to tell rootcling that a constuctor taking a MyMarker*   //
 // should be used whenever available.                                   //
 //                                                                      //
 //////////////////////////////////////////////////////////////////////////

core/base/inc/TSystem.h

@@ -531,7 +531,7 @@ class TSystem : public TNamed {
    virtual int             GetMemInfo(MemInfo_t *info) const;
    virtual int             GetProcInfo(ProcInfo_t *info) const;
 
-   //---- ACLiC (Automatic Compiler of Shared Library for CINT)
+   //---- ACLiC (Automatic Compiler of Shared Library for CLING)
    virtual void            AddIncludePath(const char *includePath);
    virtual void            AddLinkedLibs(const char *linkedLib);
    virtual int             CompileMacro(const char *filename, Option_t *opt = "", const char *library_name = "", const char *build_dir = "", UInt_t dirmode = 0);

core/base/src/TApplication.cxx

@@ -1724,7 +1724,7 @@ Longptr_t TApplication::ProcessLine(const char *line, Bool_t sync, Int_t *err)
       return 0;
 
 #if 0
-      // delete the ROOT dictionary since CINT will destroy all objects
+      // delete the ROOT dictionary since CLING will destroy all objects
       // referenced by the dictionary classes (TClass et. al.)
       gROOT->GetListOfClasses()->Delete();
       // fall through
@@ -1810,12 +1810,12 @@ Longptr_t TApplication::ExecuteFile(const char *file, Int_t *error, Bool_t keep)
       while (s && (*s == ' ' || *s == '\t')) s++;   // strip-off leading blanks
 
       // very simple minded pre-processor parsing, only works in case macro file
-      // starts with "#ifndef __CINT__". In that case everything till next
+      // starts with "#ifndef __CINT__" or "#ifndef __CLING__". In that case everything till next
       // "#else" or "#endif" will be skipped.
       if (*s == '#') {
          char *cs = Compress(currentline);
-         if (strstr(cs, "#ifndef__CINT__") ||
-             strstr(cs, "#if!defined(__CINT__)"))
+         if (strstr(cs, "#ifndef__CINT__") || strstr(cs, "#ifndef__CLING__") ||
+             strstr(cs, "#if!defined(__CINT__)") || strstr(cs, "#if!defined(__CLING__)"))
             ifndefc = 1;
          else if (ifndefc && (strstr(cs, "#ifdef") || strstr(cs, "#ifndef") ||
                   strstr(cs, "#ifdefined") || strstr(cs, "#if!defined")))

core/base/src/TDirectory.cxx

@@ -385,7 +385,7 @@ TObject *TDirectory::CloneObject(const TObject *obj, Bool_t autoadd /* = kTRUE *
 
    //create a buffer where the object will be streamed
    //We are forced to go via the I/O package (ie TBufferFile).
-   //Invoking TBufferFile via CINT will automatically load the I/O library
+   //Invoking TBufferFile via CLING will automatically load the I/O library
    TBuffer *buffer = R__CreateBuffer();
    if (!buffer) {
       Fatal("CloneObject","Not able to create a TBuffer!");

core/base/src/TExec.cxx

@@ -93,7 +93,7 @@ projection along X of the bin corresponding to the Y position
 of the mouse. The resulting histogram is fitted with a gaussian.
 A "dynamic" line shows the current bin position in Y.
 This more elaborated example can be used as a starting point
-to develop more powerful interactive applications exploiting CINT
+to develop more powerful interactive applications exploiting CLING
 as a development engine.
 
 The 3 options above can be combined.

core/base/src/TMemberInspector.cxx

@@ -107,7 +107,7 @@ void TMemberInspector::GenericShowMembers(const char *topClassName, const void *
    // Call ShowMember() on obj.
 
    // This could be faster if we implemented this either as a templated
-   // function or by rootcint-generated code using the typeid (i.e. the
+   // function or by rootcling-generated code using the typeid (i.e. the
    // difference is a lookup in a TList instead of in a map).
 
    // To avoid a spurious error message in case the data member is

core/base/src/TObject.cxx

@@ -268,8 +268,8 @@ Int_t TObject::Compare(const TObject *) const
 void TObject::Delete(Option_t *)
 {
    if (IsOnHeap()) {
-      // Delete object from CINT symbol table so it can not be used anymore.
-      // CINT object are always on the heap.
+      // Delete object from CLING symbol table so it can not be used anymore.
+      // CLING object are always on the heap.
       gInterpreter->DeleteGlobal(this);
 
       delete this;
@@ -695,7 +695,7 @@ void TObject::RecursiveRemove(TObject *)
 ///   Specific code should be implemented in each object to handle this
 ///   option. Like in TF1::SavePrimitive().
 ///
-/// - otherwise the object is written to filename as a CINT/C++ script. The
+/// - otherwise the object is written to filename as a CLING/C++ script. The
 ///   C++ code to rebuild this object is generated via SavePrimitive(). The
 ///   "option" parameter is passed to SavePrimitive. By default it is an empty
 ///   string. It can be used to specify the Draw option in the code generated
@@ -743,7 +743,7 @@ void TObject::SaveAs(const char *filename, Option_t *option) const
       return;
    }
 
-   //==============Save as a C++ CINT file======================================
+   //==============Save as a C++ CLING file======================================
    TString fname;
    if (filename && strlen(filename) > 0) {
       fname = filename;

core/base/src/TPluginManager.cxx

@@ -55,7 +55,7 @@ one plugin that can extend the same base class. The "<constructor>"
 should be the constructor or a static method that generates an
 instance of the specified class. Global methods should start with
 "::" in their name, like "::CreateFitter()".
-Instead of being a shared library a plugin can also be a CINT
+Instead of being a shared library a plugin can also be a CLING
 script, so instead of libDialog.so one can have Dialog.C.
 The * is a placeholder in case there is no need for a URI to
 differentiate between different plugins for the same base class.

core/base/src/TQConnection.cxx

@@ -45,8 +45,8 @@ Slightly modified TMethodCall class used in the object communication mechanism.
 class TQSlot : public TObject, public TRefCnt {
 
 protected:
-   CallFunc_t    *fFunc;      // CINT method invocation environment
-   ClassInfo_t   *fClass;     // CINT class for fFunc
+   CallFunc_t    *fFunc;      // CLING method invocation environment
+   ClassInfo_t   *fClass;     // CLING class for fFunc
    TFunction     *fMethod;    // slot method or global function
    Longptr_t      fOffset;    // offset added to object pointer
    TString        fName;      // full name of method

core/base/src/TQObject.cxx

@@ -1064,7 +1064,7 @@ Bool_t TQObject::BlockAllSignals(Bool_t b)
 ////////////////////////////////////////////////////////////////////////////////
 /// Global function which simplifies making connection in interpreted ROOT session
 ///
-///  ConnectCINT      - connects to interpreter(CINT) command
+///  ConnectCINT      - connects to interpreter(CLING) command
 
 Bool_t ConnectCINT(TQObject *sender, const char *signal, const char *slot)
 {

core/base/src/TROOT.cxx

@@ -621,7 +621,7 @@ namespace Internal {
 TROOT *ROOT::Internal::gROOTLocal = ROOT::GetROOT();
 
 // Global debug flag (set to > 0 to get debug output).
-// Can be set either via the interpreter (gDebug is exported to CINT),
+// Can be set either via the interpreter (gDebug is exported to CLING),
 // via the rootrc resource "Root.Debug", via the shell environment variable
 // ROOTDEBUG, or via the debugger.
 Int_t gDebug;
@@ -695,7 +695,7 @@ TROOT::TROOT(const char *name, const char *title, VoidFuncPtr_t *initfunc) : TDi
 
    TDirectory::BuildDirectory(nullptr, nullptr);
 
-   // Initialize interface to CINT C++ interpreter
+   // Initialize interface to CLING C++ interpreter
    fVersionInt      = 0;  // check in TROOT dtor in case TCling fails
    fClasses         = nullptr;  // might be checked via TCling ctor
    fEnums           = nullptr;
@@ -1029,7 +1029,7 @@ void TROOT::AddClass(TClass *cl)
 
 ////////////////////////////////////////////////////////////////////////////////
 /// Add a class generator.  This generator will be called by TClass::GetClass
-/// in case its does not find a loaded rootcint dictionary to request the
+/// in case its does not find a loaded rootcling dictionary to request the
 /// creation of a TClass object.
 
 void TROOT::AddClassGenerator(TClassGenerator *generator)
@@ -1448,7 +1448,7 @@ TObject *TROOT::FindObjectAnyFile(const char *name) const
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-/// Returns class name of a ROOT object including CINT globals.
+/// Returns class name of a ROOT object including CLING globals.
 
 const char *TROOT::FindObjectClassName(const char *name) const
 {
@@ -1626,7 +1626,7 @@ TFunctionTemplate *TROOT::GetFunctionTemplate(const char *name)
 
 ////////////////////////////////////////////////////////////////////////////////
 /// Return pointer to global variable by name. If load is true force
-/// reading of all currently defined globals from CINT (more expensive).
+/// reading of all currently defined globals from CLING (more expensive).
 
 TGlobal *TROOT::GetGlobal(const char *name, Bool_t load) const
 {
@@ -1712,7 +1712,7 @@ TFunction *TROOT::GetGlobalFunction(const char *function, const char *params,
 ////////////////////////////////////////////////////////////////////////////////
 /// Return pointer to global function by name. If proto != 0
 /// it will also resolve overloading. If load is true force reading
-/// of all currently defined global functions from CINT (more expensive).
+/// of all currently defined global functions from CLING (more expensive).
 /// The proto string must be of the form: "int, char*, float".
 
 TFunction *TROOT::GetGlobalFunctionWithPrototype(const char *function,
@@ -2360,12 +2360,12 @@ void  TROOT::Message(Int_t id, const TObject *obj)
 ////////////////////////////////////////////////////////////////////////////////
 /// Process interpreter command via TApplication::ProcessLine().
 /// On Win32 the line will be processed asynchronously by sending
-/// it to the CINT interpreter thread. For explicit synchronous processing
+/// it to the CLING interpreter thread. For explicit synchronous processing
 /// use ProcessLineSync(). On non-Win32 platforms there is no difference
 /// between ProcessLine() and ProcessLineSync().
 /// The possible error codes are defined by TInterpreter::EErrorCode. In
 /// particular, error will equal to TInterpreter::kProcessing until the
-/// CINT interpreted thread has finished executing the line.
+/// CLING interpreted thread has finished executing the line.
 /// Returns the result of the command, cast to a Longptr_t.
 
 Longptr_t TROOT::ProcessLine(const char *line, Int_t *error)
@@ -2382,7 +2382,7 @@ Longptr_t TROOT::ProcessLine(const char *line, Int_t *error)
 ////////////////////////////////////////////////////////////////////////////////
 /// Process interpreter command via TApplication::ProcessLine().
 /// On Win32 the line will be processed synchronously (i.e. it will
-/// only return when the CINT interpreter thread has finished executing
+/// only return when the CLING interpreter thread has finished executing
 /// the line). On non-Win32 platforms there is no difference between
 /// ProcessLine() and ProcessLineSync().
 /// The possible error codes are defined by TInterpreter::EErrorCode.
@@ -2400,7 +2400,7 @@ Longptr_t TROOT::ProcessLineSync(const char *line, Int_t *error)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-/// Process interpreter command directly via CINT interpreter.
+/// Process interpreter command directly via CLING interpreter.
 /// Only executable statements are allowed (no variable declarations),
 /// In all other cases use TROOT::ProcessLine().
 /// The possible error codes are defined by TInterpreter::EErrorCode.

core/base/src/TSystem.cxx

@@ -2160,7 +2160,7 @@ const char *TSystem::GetLibraries(const char *regexp, const char *options,
    if (opt.IsNull() || opt.First('D') != kNPOS)
       libs += gInterpreter->GetSharedLibs();
 
-   // Cint currently register all libraries that
+   // CLING currently register all libraries that
    // are loaded and have a dictionary in them, this
    // includes all the libraries that are included
    // in the list of (hard) linked libraries.
@@ -3457,7 +3457,7 @@ int TSystem::CompileMacro(const char *filename, Option_t *opt,
    linkdefFile << "// File Automatically generated by the ROOT Script Compiler "
                << std::endl;
    linkdefFile << std::endl;
-   linkdefFile << "#ifdef __CINT__" << std::endl;
+   linkdefFile << "#ifdef __ROOTCLING__" << std::endl;
    linkdefFile << std::endl;
    linkdefFile << "#pragma link C++ nestedclasses;" << std::endl;
    linkdefFile << "#pragma link C++ nestedtypedefs;" << std::endl;

core/base/src/TTimeStamp.cxx

@@ -25,7 +25,7 @@ This extends (and isolates) struct timespec
 ~~~
 No accounting of leap seconds is made.
 
-Due to ROOT/CINT limitations TTimeStamp does not explicitly
+Due to ROOT and/or historical CINT limitations TTimeStamp was implemented to not explicitly
 hold a timespec struct; attempting to do so means the Streamer
 must be hand written.  Instead we have chosen to simply contain
 similar fields within the private area of this class.

core/clingutils/CMakeLists.txt

@@ -51,7 +51,7 @@ set_target_properties(ClingUtils PROPERTIES
 
 ROOT_INSTALL_HEADERS()
 
-#### STL dictionary (replacement for cintdlls)##############################
+#### STL dictionaries ##############################
 
 set(stldicts
     vector
@@ -77,7 +77,7 @@ foreach(dict ${stldicts})
                                 LINKDEF src/${dict}Linkdef.h
                                 DICTIONARY_OPTIONS --noIncludePaths
                                 DEPENDENCIES Core)
-  target_include_directories(${dict}Dict PRIVATE ${CMAKE_SOURCE_DIR}/interpreter/cling/include/cling/cint)
+  target_include_directories(${dict}Dict PRIVATE ${CMAKE_SOURCE_DIR}/interpreter/cling/include/cling/icling)
 endforeach()
 
 set(CLANG_RESOURCE_DIR_STEM)
@@ -186,9 +186,9 @@ foreach(file ${custom_modulemaps}
 endforeach()
 
 foreach(file  multimap  multiset)
-  list(APPEND copy_commands COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/interpreter/cling/include/cling/cint/${file} ${CMAKE_BINARY_DIR}/etc/cling/cint/${file})
-  list(APPEND files_to_copy ${CMAKE_SOURCE_DIR}/interpreter/cling/include/cling/cint/${file})
-  install(FILES ${CMAKE_SOURCE_DIR}/interpreter/cling/include/cling/cint/${file} DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/cling/cint)
+  list(APPEND copy_commands COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/interpreter/cling/include/cling/icling/${file} ${CMAKE_BINARY_DIR}/etc/cling/icling/${file})
+  list(APPEND files_to_copy ${CMAKE_SOURCE_DIR}/interpreter/cling/include/cling/icling/${file})
+  install(FILES ${CMAKE_SOURCE_DIR}/interpreter/cling/include/cling/icling/${file} DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/cling/icling)
 endforeach()
 
 set(stamp_file ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/LLVMRES.stamp)

core/clingutils/res/RStl.h

@@ -17,7 +17,7 @@
 // RStl                                                                 //
 //                                                                      //
 // Use to manage the code that needs to be generated for the STL        //
-// by rootcint.  This class is reserved for rootcint and is a           //
+// by rootcling.  This class is reserved for rootcling and is a         //
 // singleton.                                                           //
 //                                                                      //
 //////////////////////////////////////////////////////////////////////////

core/clingutils/res/TClingUtils.h

@@ -283,7 +283,7 @@ class AnnotatedRecordDecl {
    const std::string &GetDemangledTypeInfo() const { return fDemangledTypeInfo; }
    bool HasClassVersion() const { return fRequestedVersionNumber >=0 ; }
    bool RequestStreamerInfo() const {
-      // Equivalent to CINT's cl.RootFlag() & G__USEBYTECOUNT
+      // Equivalent to historical CINT's cl.RootFlag() & G__USEBYTECOUNT
       return fRequestStreamerInfo;
    }
    // clang-format off

core/clingutils/src/RStl.cxx

@@ -32,7 +32,7 @@ using namespace TClassEdit;
 #include "Varargs.h"
 
 //
-// ROOT::Internal::RStl is the rootcint STL handling class.
+// ROOT::Internal::RStl is the rootcling STL handling class.
 //
 
 static int fgCount = 0;

core/dictgen/res/ClassSelectionRule.h

@@ -86,7 +86,7 @@ class ClassSelectionRule final : public BaseSelectionRule
 
    bool RequestOnlyTClass() const;      // True if the user want the TClass intiliazer but *not* the interpreter meta data
    bool RequestNoStreamer() const;      // Request no Streamer function in the dictionary
-   bool RequestNoInputOperator() const; // Request no generation on a default input operator by rootcint or the compiler.
+   bool RequestNoInputOperator() const; // Request no generation on a default input operator by rootcling or the compiler.
    bool RequestStreamerInfo() const;    // Request the ROOT 4+ I/O streamer
    bool RequestProtected() const;
    bool RequestPrivate() const;