root-project · guitargeek · Dec 18, 2025 · Dec 11, 2025 · Dec 11, 2025 · Dec 11, 2025
@@ -469,7 +469,7 @@ class TGCocoa : public TVirtualX {
    static Atom_t fgDeleteWindowAtom;
 
 private:
-   //I'd prefer to use = delete syntax from C++0x11, but this file is processed by CINT.
+   //TODO: use instead = delete syntax from C++0x11
    TGCocoa(const TGCocoa &rhs);
    TGCocoa &operator = (const TGCocoa &rhs);
 

@@ -96,7 +96,7 @@ class TGQuartz : public TGCocoa {
    void AlignTTFString();
    Bool_t IsTTFStringVisible(Int_t x, Int_t y, UInt_t w, UInt_t h);
    void RenderTTFString(Int_t x, Int_t y, ETextMode mode);
-   //I have to use void * instead of QuartzPixmap * because of CINT :(
+   //TODO: move internal headers like TGQuartz.h out of the public ROOT user interface. Then we can also use XQuartz types like QuartzPixmap* instead of void * in functions like these
    void DrawFTGlyphIntoPixmap(void *pixmap, FT_Bitmap *source, ULong_t fore, ULong_t back, Int_t bx, Int_t by);
 
    void SetAA();

@@ -42,7 +42,7 @@
 ///
 /// Please have a look to the tutorials ($ROOTSYS/tutorials/fitsio/) to see
 /// some examples. IMPORTANT: to run tutorials it is required that
-/// you change the current working directory of ROOT (CINT) shell to the
+/// you change the current working directory of the ROOT shell to the
 /// tutorials directory. Example:
 /// ~~~ {.cpp}
 /// root [1] gSystem->ChangeDirectory("tutorials/fitsio")

@@ -13,7 +13,7 @@
 #ifndef ROOT_TGWin32ProxyDefs
 #define ROOT_TGWin32ProxyDefs
 
-#include "Rtypes.h"  // CINT headers
+#include "Rtypes.h"
 
 
 #define _NAME4_(name1,name2,name3,name4) _NAME3_(name1,name2,name3)name4

@@ -49,8 +49,6 @@ class TGLParametricEquation : public TNamed {
    Bool_t               fModified;
 
    typedef std::unique_ptr<TGLHistPainter> Painter_t;
-   //C++ compiler do not need TGLhistPainter definition here, but I'm not sure about CINT,
-   //so I've included TGLHistPainter definition.
    Painter_t            fPainter;
 
 public:

@@ -75,10 +75,10 @@ Delete a style:
 The selected style can be deleted from the list when you use the
 Style menu/Delete or the corresponding tool bar button. The selected
 style is removed from the list of all available styles for the
-current ROOT session. WARRNING: it will be lost if you didn't saved
+current ROOT session. WARNING: it will be lost if you didn't saved
 it in a C++ macro file before its deletion. Also, you cannot delete
 the selected style if it is set to gStyle. A message 'Can not delete
-gStyle' will be displayed on the CINT prompt.
+gStyle' will be displayed on the ROOT prompt.
 
 Editor's buttons:
 Open / close the style editor:

@@ -402,9 +402,9 @@ command line.\n\n\
 You can interrupt a running macro by selecting the Tools menu / \n\
 Interrupt; by clicking on the corresponding toolbar button, or by \n\
 using Shift+F5 accelerator keys.\n\n\
-      Interface to CINT Interpreter\n\n\
+      Interface to Cling Interpreter\n\n\
 Any command entered in the 'Command' combo box will be passed to the\n\
-CINT interpreter. This combo box will keep the commands history and \n\
+Cling interpreter. This combo box will keep the commands history and \n\
 will allow you to re-execute the same commands during an editor session.\n\n"
 "      Keyboard Bindings\n\n\
 The following table lists the keyboard shortcuts and accelerator keys.\n\n\

@@ -107,10 +107,10 @@
  Interrupt; by clicking on the corresponding toolbar button, or by
  using Shift+F5 accelerator keys.
 
-#### Interface to CINT Interpreter
+#### Interface to Cling Interpreter
 
  Any command entered in the Command combo box will be passed to
- the CINT interpreter. This combo box will keep the commands history
+ the Cling interpreter. This combo box will keep the commands history
  and will allow you to re-execute the same commands during an editor
  session.
 

@@ -11,8 +11,6 @@
 // Header file for class HFitInterface
 // set of free functions used to couple the ROOT data object with the fitting classes
 
-// avoid including this file when running CINT since free functions cannot be re-defined
-
 #ifndef ROOT_HFitInterface
 #define ROOT_HFitInterface
 

@@ -336,14 +336,14 @@ class TF1 : public TNamed, public TAttLine, public TAttFill, public TAttMarker {
    // Constructors using functors (compiled mode only)
    TF1(const char *name, ROOT::Math::ParamFunctor f, Double_t xmin = 0, Double_t xmax = 1, Int_t npar = 0, Int_t ndim = 1, EAddToList addToGlobList = EAddToList::kDefault);
 
-   // Template constructors from any  C++ callable object,  defining  the operator() (double * , double *)
-   // and returning a double.
-   // The class name is not needed when using compile code, while it is required when using
-   // interpreted code via the specialized constructor with void *.
-   // An instance of the C++ function class or its pointer can both be used. The former is reccomended when using
-   // C++ compiled code, but if CINT compatibility is needed, then a pointer to the function class must be used.
-   // xmin and xmax specify the plotting range,  npar is the number of parameters.
-   // See the tutorial math/exampleFunctor.C for an example of using this constructor
+   /// Template constructors from any  C++ callable object,  defining  the operator() (double * , double *)
+   /// and returning a double.
+   /// The class name is not needed when using compile code, while it is required when using
+   /// interpreted code via the specialized constructor with void *.
+   /// An instance of the C++ function class or its pointer can both be used. The former is recommended when using
+   /// C++ compiled code, but if CINT-compatibility is needed, then a pointer to the function class must be used.
+   /// xmin and xmax specify the plotting range,  npar is the number of parameters.
+   /// See the tutorial math/exampleFunctor.C for an example of using this constructor
    template <typename Func>
    TF1(const char *name, Func f, Double_t xmin, Double_t xmax, Int_t npar, Int_t ndim = 1, EAddToList addToGlobList = EAddToList::kDefault) :
       TF1(EFType::kTemplScalar, name, xmin, xmax, npar, ndim, addToGlobList)
@@ -352,7 +352,7 @@ class TF1 : public TNamed, public TAttLine, public TAttFill, public TAttMarker {
       ROOT::Internal::TF1Builder<Func>::Build(this, f);
    }
 
-   // backward compatible interface
+   /// backward compatible interface
    template <typename Func>
    TF1(const char *name, Func f, Double_t xmin, Double_t xmax, Int_t npar, const char *, EAddToList addToGlobList = EAddToList::kDefault) :
       TF1(EFType::kTemplScalar, name, xmin, xmax, npar, 1, addToGlobList, new TF1Parameters(npar))
@@ -361,20 +361,20 @@ class TF1 : public TNamed, public TAttLine, public TAttFill, public TAttMarker {
    }
 
 
-   // Template constructors from a pointer to any C++ class of type PtrObj with a specific member function of type
-   // MemFn.
-   // The member function must have the signature of  (double * , double *) and returning a double.
-   // The class name and the method name are not needed when using compile code
-   // (the member function pointer is used in this case), while they are required when using interpreted
-   // code via the specialized constructor with void *.
-   // xmin and xmax specify the plotting range,  npar is the number of parameters.
-   // See the tutorial math/exampleFunctor.C for an example of using this constructor
+   /// Template constructors from a pointer to any C++ class of type PtrObj with a specific member function of type
+   /// MemFn.
+   /// The member function must have the signature of  (double * , double *) and returning a double.
+   /// The class name and the method name are not needed when using compile code
+   /// (the member function pointer is used in this case), while they are required when using interpreted
+   /// code via the specialized constructor with void *.
+   /// xmin and xmax specify the plotting range,  npar is the number of parameters.
+   /// See the tutorial math/exampleFunctor.C for an example of using this constructor
    template <class PtrObj, typename MemFn>
    TF1(const char *name, const  PtrObj &p, MemFn memFn, Double_t xmin, Double_t xmax, Int_t npar, Int_t ndim = 1, EAddToList addToGlobList = EAddToList::kDefault) :
       TF1(EFType::kTemplScalar, name, xmin, xmax, npar, ndim, addToGlobList, new TF1Parameters(npar), new TF1FunctorPointerImpl<double>(ROOT::Math::ParamFunctor(p, memFn)))
    {}
 
-   // backward compatible interface
+   /// backward compatible interface
    template <class PtrObj, typename MemFn>
    TF1(const char *name, const  PtrObj &p, MemFn memFn, Double_t xmin, Double_t xmax, Int_t npar, const char *, const char *, EAddToList addToGlobList = EAddToList::kDefault) :
       TF1(EFType::kTemplScalar, name, xmin, xmax, npar, 1, addToGlobList, new TF1Parameters(npar), new TF1FunctorPointerImpl<double>(ROOT::Math::ParamFunctor(p, memFn)))

@@ -282,7 +282,7 @@ Begin_Macro(source)
 }
 End_Macro
 
-#### Case 3: inline expression using a user defined CLING function by name
+#### Case 3: inline expression using a user defined Cling function by name
 
 ~~~~{.cpp}
 Double_t myFunc(double x) { return x+sin(x); }

@@ -3619,8 +3619,8 @@ void TFormula::ReInitializeEvalMethod() {
 /// Return the expression formula.
 ///
 ///  - If option = "P" replace the parameter names with their values
-///  - If option = "CLING" return the actual expression used to build the function  passed to cling
-///  - If option = "CLINGP" replace in the CLING expression the parameter with their values
+///  - If option = "CLING" return the actual expression used to build the function passed to Cling
+///  - If option = "CLINGP" replace in the Cling expression the parameter with their values
 
 TString TFormula::GetExpFormula(Option_t *option) const
 {

@@ -212,7 +212,7 @@ void TVirtualFitter::SetFitter(TVirtualFitter *fitter, Int_t maxpar)
 
 ////////////////////////////////////////////////////////////////////////////////
 /// To set the address of the minimization objective function
-/// called by the native compiler (see function below when called by CINT)
+/// called by the native compiler (see function below when called by Cling)
 
 void TVirtualFitter::SetFCN(void (*fcn)(Int_t &, Double_t *, Double_t &f, Double_t *, Int_t))
 {

@@ -47,7 +47,7 @@ namespace ROOT {
       {
          // constructor from a TF1 function pointer.
 
-         // init the pointers for CINT
+         // init the pointers for Cling
          //if (fFunc->GetMethodCall() )  fFunc->InitArgs(fX, &fParams.front() );
          if (fFunc->GetMethodCall())  fFunc->InitArgs(fX, nullptr);
          // distinguish case of polynomial functions and linear functions

@@ -42,7 +42,7 @@ class TGenCollectionProxy
 #endif
 
    enum {
-      // Those 'bits' are used in conjunction with CINT's bit to store the 'type'
+      // Those 'bits' are used in conjunction with Cling's bit to store the 'type'
       // info into one int
       kBIT_ISSTRING   = 0x20000000,  // We can optimized a value operation when the content are strings
       kBIT_ISTSTRING  = 0x40000000

@@ -76,7 +76,7 @@ friend class TMapRec;
 public:
    enum { kDefaultMapSize = 0x80000 }; // default size of mapped heap is 500 KB
 
-   // Should both be protected (waiting for cint)
+   // TODO: Should both be protected
    ~TMapFile() override;
    void *operator new(size_t sz) { return TObject::operator new(sz); }
    void *operator new[](size_t sz) { return TObject::operator new[](sz); }

@@ -3433,7 +3433,7 @@ Int_t TBufferFile::ReadClassEmulated(const TClass *cl, void *object, const TClas
 /// Deserialize information from a buffer into an object.
 ///
 /// Note: This function is called by the xxx::Streamer() functions in
-/// rootcint-generated dictionaries.
+/// rootcling-generated dictionaries.
 /// This function assumes that the class version and the byte count
 /// information have been read.
 ///
@@ -3535,7 +3535,7 @@ Int_t TBufferFile::ReadClassBuffer(const TClass *cl, void *pointer, Int_t versio
 /// Deserialize information from a buffer into an object.
 ///
 /// Note: This function is called by the xxx::Streamer()
-/// functions in rootcint-generated dictionaries.
+/// functions in rootcling-generated dictionaries.
 ///
 
 Int_t TBufferFile::ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onFileClass)

@@ -224,7 +224,7 @@ Int_t TBufferText::WriteClassBuffer(const TClass *cl, void *pointer)
 /// Deserialize information from a buffer into an object.
 ///
 /// Note: This function is called by the xxx::Streamer() functions in
-/// rootcint-generated dictionaries.
+/// rootcling-generated dictionaries.
 /// This function assumes that the class version and the byte count
 /// information have been read.
 ///
@@ -321,7 +321,7 @@ Int_t TBufferText::ReadClassBuffer(const TClass *cl, void *pointer, Int_t versio
 /// Deserialize information from a buffer into an object.
 ///
 /// Note: This function is called by the xxx::Streamer()
-/// functions in rootcint-generated dictionaries.
+/// functions in rootcling-generated dictionaries.
 ///
 
 Int_t TBufferText::ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onFileClass)

@@ -596,8 +596,8 @@ TFile::~TFile()
    }
 
    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 objects are always on the heap.
       gInterpreter->ResetGlobalVar(this);
    }
 
@@ -2716,14 +2716,14 @@ void TFile::WriteHeader()
 /// new (default) | A new directory dirname is created. If dirname already exist, an error message is printed and the function returns.
 /// recreate      | If dirname does not exist, it is created (like in "new"). If dirname already exist, all existing files in dirname are deleted before creating the new files.
 /// update        | New classes are added to the existing directory. Existing classes with the same name are replaced by the new definition. If the directory dirname doest not exist, same effect as "new".
-/// genreflex     | Use genreflex rather than rootcint to generate the dictionary.
+/// genreflex     | Use genreflex rather than rootcling to generate the dictionary.
 /// par           | Create a PAR file with the minimal set of code needed to read the content of the ROOT file. The name of the PAR file is basename(dirname), with extension '.par' enforced; the PAR file will be created at dirname(dirname).
 ///
 /// If, in addition to one of the 3 above options, the option "+" is specified,
 /// the function will generate:
 ///   - a script called MAKEP to build the shared lib
 ///   - a dirnameLinkDef.h file
-///   - rootcint will be run to generate a dirnameProjectDict.cxx file
+///   - rootcling will be run to generate a dirnameProjectDict.cxx file
 ///   - dirnameProjectDict.cxx will be compiled with the current options in compiledata.h
 ///   - a shared lib dirname.so will be created.
 /// If the option "++" is specified, the generated shared lib is dynamically
@@ -2735,10 +2735,10 @@ void TFile::WriteHeader()
 ///   - creates a new directory demo unless it already exist
 ///   - clear the previous directory content
 ///   - generate the xxx.h files for all classes xxx found in this file
-///    and not yet known to the CINT dictionary.
+///    and not yet known to the Cling dictionary.
 ///   - creates the build script MAKEP
 ///   - creates a LinkDef.h file
-///   - runs rootcint generating demoProjectDict.cxx
+///   - runs rootcling generating demoProjectDict.cxx
 ///   - compiles demoProjectDict.cxx into demoProjectDict.o
 ///   - generates a shared lib demo.so
 ///   - dynamically links the shared lib demo.so to the executable
@@ -3005,7 +3005,7 @@ void TFile::MakeProject(const char *dirname, const char * /*classes*/,
       return;
    }
 
-   // Add rootcint/genreflex statement generating ProjectDict.cxx
+   // Add rootcling/genreflex statement generating ProjectDict.cxx
    FILE *ifp = nullptr;
    path.Form("%s/%sProjectInstances.h",clean_dirname.Data(),subdirname.Data());
 #ifdef R__WINGCC
@@ -3026,7 +3026,7 @@ void TFile::MakeProject(const char *dirname, const char * /*classes*/,
       fprintf(fpMAKE,"genreflex %sProjectHeaders.h -o %sProjectDict.cxx --comments --iocomments %s ",subdirname.Data(),subdirname.Data(),gSystem->GetIncludePath());
       path.Form("%s/%sSelection.xml",clean_dirname.Data(),subdirname.Data());
    } else {
-      fprintf(fpMAKE,"rootcint -v1 -f %sProjectDict.cxx %s ", subdirname.Data(), gSystem->GetIncludePath());
+      fprintf(fpMAKE,"rootcling -v1 -f %sProjectDict.cxx %s ", subdirname.Data(), gSystem->GetIncludePath());
       path.Form("%s/%sLinkDef.h",clean_dirname.Data(),subdirname.Data());
    }
 

@@ -58,10 +58,10 @@ TClassRef R__TTree_Class("TTree");
 TClassRef R__RNTuple_Class("ROOT::RNTuple");
 
 static const Int_t kCpProgress = BIT(14);
-static const Int_t kCintFileNumber = 100;
+static const Int_t kClingFileNumber = 100;
 ////////////////////////////////////////////////////////////////////////////////
 /// Return the maximum number of allowed opened files minus some wiggle room
-/// for CINT or at least of the standard library (stdio).
+/// for Cling or at least of the standard library (stdio).
 
 static Int_t R__GetSystemMaxOpenedFiles()
 {
@@ -77,8 +77,8 @@ static Int_t R__GetSystemMaxOpenedFiles()
       maxfiles = 512;
    }
 #endif
-   if (maxfiles > kCintFileNumber) {
-      return maxfiles - kCintFileNumber;
+   if (maxfiles > kClingFileNumber) {
+      return maxfiles - kClingFileNumber;
    } else if (maxfiles > 5) {
       return maxfiles - 5;
    } else {

@@ -360,7 +360,7 @@ TGenCollectionProxy::Value::Value(const std::string& inside_type, Bool_t silent,
       // In the case where we have an emulated class,
       // if the class is nested (in a class or a namespace),
       // calling G__TypeInfo ti(inside.c_str());
-      // might fail because CINT does not known the nesting
+      // might fail because Cling does not know the nesting
       // scope, so let's first look for an emulated class:
 
       fType = TClass::GetClass(intype.c_str(),kTRUE,silent, hint_pair_offset, hint_pair_size);

@@ -1108,7 +1108,7 @@ void TStreamerInfo::BuildCheck(TFile *file /* = 0 */, Bool_t load /* = kTRUE */)
                // match in the 'current' in memory TStreamerInfo for
                // a non foreign class (we can not get here if this is
                // a foreign class so we do not need to test it),
-               // we need to add this one more test since the CINT behaviour
+               // we need to add this one more test since the interpreter behaviour
                // with enums changed over time, so verify the checksum ignoring
                // members of type enum. We also used to not count the //[xyz] comment
                // in the checksum, so test for that too.
@@ -1158,7 +1158,7 @@ void TStreamerInfo::BuildCheck(TFile *file /* = 0 */, Bool_t load /* = kTRUE */)
                // match in the 'current' in memory TStreamerInfo for
                // a non foreign class (we can not get here if this is
                // a foreign class so we do not need to test it),
-               // we need to add this one more test since the CINT behaviour
+               // we need to add this one more test since the interpreter behaviour
                // with enums changed over time, so verify the checksum ignoring
                // members of type enum. We also used to not count the //[xyz] comment
                // in the checksum, so test for that too.

@@ -24,7 +24,7 @@
 // The XML file is built in memory before being dumped to disk.
 //
 // Like for normal ROOT files, XML files use the same I/O mechanism
-// exploiting the ROOT/CINT dictionary. Any class having a dictionary
+// exploiting the I/O dictionary. Any class having a dictionary
 // can be saved in XML format.
 //
 // This first implementation does not support subdirectories

@@ -70,7 +70,7 @@ namespace TMVA {
       MethodCuts( DataSetInfo& theData,
                   const TString& theWeightFile);
 
-      // this is a workaround which is necessary since CINT is not capable of handling dynamic casts
+      // TODO: remove this is a workaround which was necessary when CINT was not capable of handling dynamic casts
       static MethodCuts* DynamicCast( IMethod* method ) { return dynamic_cast<MethodCuts*>(method); }
 
       virtual ~MethodCuts( void );