diff --git a/core/base/inc/GLConstants.h b/core/base/inc/GLConstants.h index adbb26558f6b9..258b69368a2c0 100644 --- a/core/base/inc/GLConstants.h +++ b/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 doesn't understand the "define" pre-processor command TODO: recheck with Cling #ifndef GLConstants diff --git a/core/base/inc/LinkDef3.h b/core/base/inc/LinkDef3.h index 5adf791bafbe7..285413ffb2199 100644 --- a/core/base/inc/LinkDef3.h +++ b/core/base/inc/LinkDef3.h @@ -184,7 +184,7 @@ #pragma link C++ class TBase64; // Insure the creation of the TClass object for pairs that might be -// inside the cintdlls. +// inside the cintdlls. TODO: recheck with Cling #pragma extra_include "string"; // insure using namespace std and declaration of std::pair #pragma extra_include "Rpair.h"; diff --git a/core/base/inc/MessageTypes.h b/core/base/inc/MessageTypes.h index b17e626660418..eeb3152e94841 100644 --- a/core/base/inc/MessageTypes.h +++ b/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 diff --git a/core/base/inc/TPluginManager.h b/core/base/inc/TPluginManager.h index 0e44c803ed85d..092c933bf3e2e 100644 --- a/core/base/inc/TPluginManager.h +++ b/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. // diff --git a/core/base/inc/TQObject.h b/core/base/inc/TQObject.h index 5976efa849c1d..7fd0b9fa57aef 100644 --- a/core/base/inc/TQObject.h +++ b/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); diff --git a/core/base/inc/TRootIOCtor.h b/core/base/inc/TRootIOCtor.h index 3c01330f2b0bb..bafc930f3524c 100644 --- a/core/base/inc/TRootIOCtor.h +++ b/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. // // // ////////////////////////////////////////////////////////////////////////// diff --git a/core/base/inc/TSystem.h b/core/base/inc/TSystem.h index 8ce174ee3f922..4ec51c0241267 100644 --- a/core/base/inc/TSystem.h +++ b/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); diff --git a/core/base/src/TApplication.cxx b/core/base/src/TApplication.cxx index f0d2124a8f6ab..653d8b0b2ec2b 100644 --- a/core/base/src/TApplication.cxx +++ b/core/base/src/TApplication.cxx @@ -1727,7 +1727,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 diff --git a/core/base/src/TDirectory.cxx b/core/base/src/TDirectory.cxx index 9bebee0e74a1d..7cbff2ff0c2d7 100644 --- a/core/base/src/TDirectory.cxx +++ b/core/base/src/TDirectory.cxx @@ -384,7 +384,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!"); diff --git a/core/base/src/TExec.cxx b/core/base/src/TExec.cxx index 84c6c1afc880e..9484ef6553ee2 100644 --- a/core/base/src/TExec.cxx +++ b/core/base/src/TExec.cxx @@ -92,7 +92,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. diff --git a/core/base/src/TMemberInspector.cxx b/core/base/src/TMemberInspector.cxx index 92783b4da2b31..4d8b58b210b43 100644 --- a/core/base/src/TMemberInspector.cxx +++ b/core/base/src/TMemberInspector.cxx @@ -106,7 +106,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 diff --git a/core/base/src/TObject.cxx b/core/base/src/TObject.cxx index f02db598949bb..65b6886cb60e5 100644 --- a/core/base/src/TObject.cxx +++ b/core/base/src/TObject.cxx @@ -267,8 +267,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; @@ -694,7 +694,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 @@ -742,7 +742,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; diff --git a/core/base/src/TPluginManager.cxx b/core/base/src/TPluginManager.cxx index 58a86fe47ce0f..ba3ed690eefc2 100644 --- a/core/base/src/TPluginManager.cxx +++ b/core/base/src/TPluginManager.cxx @@ -55,7 +55,7 @@ one plugin that can extend the same base class. The "" 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. diff --git a/core/base/src/TQConnection.cxx b/core/base/src/TQConnection.cxx index 19417e4d8830d..6c946f7e6b3eb 100644 --- a/core/base/src/TQConnection.cxx +++ b/core/base/src/TQConnection.cxx @@ -43,8 +43,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 diff --git a/core/base/src/TQObject.cxx b/core/base/src/TQObject.cxx index 4d108cbe926f9..fae46d693579c 100644 --- a/core/base/src/TQObject.cxx +++ b/core/base/src/TQObject.cxx @@ -1060,7 +1060,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) { diff --git a/core/base/src/TROOT.cxx b/core/base/src/TROOT.cxx index 59ab9bbbbec68..4ce60df69ef43 100644 --- a/core/base/src/TROOT.cxx +++ b/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; @@ -694,7 +694,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 fVersionInt = 0; // check in TROOT dtor in case TCling fails fClasses = nullptr; // might be checked via TCling ctor fEnums = nullptr; @@ -1030,7 +1030,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) @@ -1449,7 +1449,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 { @@ -1627,7 +1627,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 { @@ -1713,7 +1713,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, @@ -2361,12 +2361,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) @@ -2383,7 +2383,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. @@ -2401,7 +2401,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. diff --git a/core/base/src/TSystem.cxx b/core/base/src/TSystem.cxx index 7fcae5521f3c0..c452737bd9e56 100644 --- a/core/base/src/TSystem.cxx +++ b/core/base/src/TSystem.cxx @@ -2158,7 +2158,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. diff --git a/core/base/src/TTimeStamp.cxx b/core/base/src/TTimeStamp.cxx index 9350e55ae5ed1..5611cae764b6c 100644 --- a/core/base/src/TTimeStamp.cxx +++ b/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 historical ROOT/CINT limitations TTimeStamp does 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. diff --git a/core/clingutils/CMakeLists.txt b/core/clingutils/CMakeLists.txt index 6d2d893d5a8c1..b1ad27fb6ba71 100644 --- a/core/clingutils/CMakeLists.txt +++ b/core/clingutils/CMakeLists.txt @@ -51,7 +51,7 @@ set_target_properties(ClingUtils PROPERTIES ROOT_INSTALL_HEADERS() -#### STL dictionary (replacement for cintdlls)############################## +#### STL dictionary (replacement for historical cintdlls)############################## set(stldicts vector diff --git a/core/clingutils/inc/root_std_complex.h b/core/clingutils/inc/root_std_complex.h index 1d96c6a2f0ae2..86fbf2fc838b1 100644 --- a/core/clingutils/inc/root_std_complex.h +++ b/core/clingutils/inc/root_std_complex.h @@ -1,6 +1,6 @@ /************************************************************************* * This file defines a complex class which has an layout identical to the one - * of ROOT5. The file was located in cint/lib/prec_stl/complex + * of ROOT5. The file was historically located in cint/lib/prec_stl/complex * This class is used to provide to the ROOT6 typesystem a backward compatible * and platform independent information for the complex numbers. * diff --git a/core/clingutils/res/RStl.h b/core/clingutils/res/RStl.h index fa92a6e1eb45b..f0aa00d721518 100644 --- a/core/clingutils/res/RStl.h +++ b/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. // // // ////////////////////////////////////////////////////////////////////////// diff --git a/core/clingutils/res/TClingUtils.h b/core/clingutils/res/TClingUtils.h index 650146571c703..57430010cc7b8 100644 --- a/core/clingutils/res/TClingUtils.h +++ b/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 diff --git a/core/clingutils/src/RStl.cxx b/core/clingutils/src/RStl.cxx index b14fe3f0ac440..d91eda47a1933 100644 --- a/core/clingutils/src/RStl.cxx +++ b/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; diff --git a/core/clingutils/src/TClingUtils.cxx b/core/clingutils/src/TClingUtils.cxx index 3c49f56bdf5d0..a6eb7a3e7adbc 100644 --- a/core/clingutils/src/TClingUtils.cxx +++ b/core/clingutils/src/TClingUtils.cxx @@ -1500,7 +1500,7 @@ static void CreateNameTypeMap(const clang::CXXRecordDecl &cl, ROOT::MembersTypeM for(clang::RecordDecl::field_iterator field_iter = cl.field_begin(), end = cl.field_end(); field_iter != end; ++field_iter){ - // The CINT based code was filtering away static variables (they are not part of + // The historical CINT based code was filtering away static variables (they are not part of // the list starting with field_begin in clang), and const enums (which should // also not be part of this list). // It was also filtering out the 'G__virtualinfo' artificial member. @@ -3237,7 +3237,7 @@ clang::QualType ROOT::TMetaUtils::AddDefaultParameters(clang::QualType instanceT /// array data member. /// In case of error, or if the size is not specified, GrabIndex returns 0. /// If errnum is not null, *errnum updated with the error number: -/// Cint::G__DataMemberInfo::G__VALID : valid array index +/// Cint::G__DataMemberInfo::G__VALID : valid array index @todo: adapt docu for Cling /// Cint::G__DataMemberInfo::G__NOT_INT : array index is not an int /// Cint::G__DataMemberInfo::G__NOT_DEF : index not defined before array /// (this IS an error for streaming to disk) diff --git a/core/dictgen/res/ClassSelectionRule.h b/core/dictgen/res/ClassSelectionRule.h index b6c37b154bd15..3cbd2fa30ffc5 100644 --- a/core/dictgen/res/ClassSelectionRule.h +++ b/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; diff --git a/core/dictgen/res/DictSelectionReader.h b/core/dictgen/res/DictSelectionReader.h index b19135badd4f2..6322974bd64b2 100644 --- a/core/dictgen/res/DictSelectionReader.h +++ b/core/dictgen/res/DictSelectionReader.h @@ -6,7 +6,7 @@ * All rights reserved. * * * * For the licensing terms see $ROOTSYS/LICENSE. * - * For the list of contributors see $ROOTSYS/README/rootcint. * + * For the list of contributors see $ROOTSYS/README/CREDITS. * *************************************************************************/ #ifndef __DICTSELECTIONREADER__ diff --git a/core/dictgen/res/Scanner.h b/core/dictgen/res/Scanner.h index abd9568df5275..6696354a39288 100644 --- a/core/dictgen/res/Scanner.h +++ b/core/dictgen/res/Scanner.h @@ -9,7 +9,7 @@ * All rights reserved. * * * * For the licensing terms see $ROOTSYS/LICENSE. * - * For the list of contributors see $ROOTSYS/README/rootcint. * + * For the list of contributors see $ROOTSYS/README/CREDITS. * *************************************************************************/ #ifndef ROOT__RSCANNER_H__ diff --git a/core/dictgen/src/LinkdefReader.cxx b/core/dictgen/src/LinkdefReader.cxx index aeb047a9bd8fa..e5265e07686f7 100644 --- a/core/dictgen/src/LinkdefReader.cxx +++ b/core/dictgen/src/LinkdefReader.cxx @@ -14,13 +14,13 @@ // LinkdefReader // // // // // -// Note: some inconsistency in the way CINT parsed the #pragma: // +// Note: some inconsistency in the way historical CINT parsed the #pragma: // // "#pragma link C++ class" is terminated by either a ';' or a newline// // which ever come first and does NOT support line continuation. // // "#pragma read ..." is terminated by newline but support line // // continuation (i.e. '\' followed by newline means to also use the// // next line. // -// This was change in CINT to consistently ignore the continuation // +// This was changed in historical CINT to consistently ignore the continuation // // // // // ////////////////////////////////////////////////////////////////////////// @@ -123,7 +123,7 @@ bool LinkdefReader::AddInclude(const std::string& include) /* * The method that processes the pragma statement. - * Sometimes I had to do strange things to reflect the strange behavior of rootcint + * Sometimes I had to do strange things to reflect the strange behavior of historical rootcint */ bool LinkdefReader::AddRule(const std::string& ruletype, const std::string& identifier, @@ -294,7 +294,7 @@ bool LinkdefReader::AddRule(const std::string& ruletype, if (localIdentifier.at(localIdentifier.length() - 1) == '*') fsr.SetAttributeValue("pattern", localIdentifier); else if (name_or_proto) fsr.SetAttributeValue("name", localIdentifier); else { - int pos = localIdentifier.find("(*)"); //rootcint generates error here but I decided to implement that pattern + int pos = localIdentifier.find("(*)"); //historical rootcint generated error here but I decided to implement that pattern if (pos > -1) fsr.SetAttributeValue("proto_pattern", localIdentifier); else { // No multiline @@ -424,7 +424,7 @@ bool LinkdefReader::AddRule(const std::string& ruletype, if (linkOn) { csr.SetSelected(BaseSelectionRule::kYes); - if (localIdentifier == "*") { // rootcint generates error here, but I decided to implement it + if (localIdentifier == "*") { // historical rootcint generated error here, but I decided to implement it ClassSelectionRule csr2(fCount++, fInterp); csr2.SetSelected(BaseSelectionRule::kYes); csr2.SetAttributeValue("pattern", "*::*"); @@ -437,13 +437,13 @@ bool LinkdefReader::AddRule(const std::string& ruletype, } } else { csr.SetSelected(BaseSelectionRule::kNo); - if (localIdentifier == "*") { // rootcint generates error here, but I decided to implement it + if (localIdentifier == "*") { // historical rootcint generated error here, but I decided to implement it ClassSelectionRule csr2(fCount++, fInterp); csr2.SetSelected(BaseSelectionRule::kNo); csr2.SetAttributeValue("pattern", "*::*"); fSelectionRules->AddClassSelectionRule(csr2); - EnumSelectionRule esr(fCount++, fInterp); // we need this because of implicit/explicit rules - check my notes on rootcint + EnumSelectionRule esr(fCount++, fInterp); // we need this because of implicit/explicit rules - check my notes on historical rootcint esr.SetSelected(BaseSelectionRule::kNo); esr.SetAttributeValue("pattern", "*::*"); fSelectionRules->AddEnumSelectionRule(esr); @@ -453,13 +453,13 @@ bool LinkdefReader::AddRule(const std::string& ruletype, // should be off by default. Note that anyway, this is not yet relevant since the pcm actually ignore the on/off // request and contains everything (for now). // else { - // EnumSelectionRule esr(fCount++); // we need this because of implicit/explicit rules - check my notes on rootcint + // EnumSelectionRule esr(fCount++); // we need this because of implicit/explicit rules - check my notes on historical rootcint // esr.SetSelected(BaseSelectionRule::kNo); // esr.SetAttributeValue("pattern", localIdentifier+"::*"); // fSelectionRules->AddEnumSelectionRule(esr); // if (fSelectionRules->GetHasFileNameRule()) { - // FunctionSelectionRule fsr(fCount++); // we need this because of implicit/explicit rules - check my notes on rootcint + // FunctionSelectionRule fsr(fCount++); // we need this because of implicit/explicit rules - check my notes on historical rootcint // fsr.SetSelected(BaseSelectionRule::kNo); // std::string value = localIdentifier + "::*"; // fsr.SetAttributeValue("pattern", value); @@ -485,7 +485,7 @@ bool LinkdefReader::AddRule(const std::string& ruletype, fIOConstructorTypesPtr->push_back(ROOT::TMetaUtils::RConstructorType(identifier.c_str(), fInterp)); break; case kIgnore: - // All the pragma that were supported in CINT but are currently not relevant for CLING + // All the pragma that were supported in historical CINT but are currently not relevant for CLING // (mostly because we do not yet filter the dictionary/pcm). break; case kUnknown: @@ -544,7 +544,7 @@ bool LinkdefReader::ProcessFunctionPrototype(std::string &proto, bool &name) return false; } - // I don't have to escape the *-s because in rootcint there is no pattern recognition + // I don't have to escape the *-s because in historical rootcint there is no pattern recognition int pos3 = pos1; while (true) { pos3 = proto.find(" ", pos3); @@ -661,7 +661,7 @@ class LinkdefReaderPragmaHandler : public clang::PragmaHandler { * noinputoper: set G__NOINPUTOPERATOR flag * evolution: set G__USEBYTECOUNT flag * nomap: (ignored by roocling; prevents entry in ROOT's rootmap file) - * stub: (ignored by rootcling was a directly for CINT code generation) + * stub: (ignored by rootcling was a directly for historical CINT code generation) * version(x): sets the version number of the class to x * rntuple[un]split: enforce split/unsplit encoding in RNTuple */ @@ -724,7 +724,7 @@ class LinkdefReaderPragmaHandler : public clang::PragmaHandler { Error("Error: Malformed rntupleStreamerMode option (either 'true' or 'false').", boolval, PP); } } else if (tok.getIdentifierInfo()->getName() == "stub") { - // This was solely for CINT dictionary, ignore for now. + // This was solely for historical CINT dictionary, ignore for now. // options.fUseStubs = 1; } else if (tok.getIdentifierInfo()->getName() == "version") { clang::Token start = tok; diff --git a/core/dictgen/src/Scanner.cxx b/core/dictgen/src/Scanner.cxx index 36e0a75802b31..2b9a70ce6d4f0 100644 --- a/core/dictgen/src/Scanner.cxx +++ b/core/dictgen/src/Scanner.cxx @@ -6,7 +6,7 @@ * All rights reserved. * * * * For the licensing terms see $ROOTSYS/LICENSE. * - * For the list of contributors see $ROOTSYS/README/rootcint. * + * For the list of contributors see $ROOTSYS/README/CREDITS. * *************************************************************************/ #include "Scanner.h" @@ -651,7 +651,7 @@ bool RScanner::TreatRecordDeclOrTypedefNameDecl(clang::TypeDecl* typeDecl) if (fRecordDeclCallback) { // Pass on any declaration. This is usually used to record dependency. - // Since rootcint see C++ compliant header files, we can assume that + // Since historical rootcint saw C++ compliant header files, we can assume that // if a forward declaration or declaration has been inserted, the // classes for which we are creating a dictionary will be using // them either directly or indirectly. Any false positive can be diff --git a/core/dictgen/src/SelectionRules.cxx b/core/dictgen/src/SelectionRules.cxx index 7391c354470c1..89f6a96ca79b8 100644 --- a/core/dictgen/src/SelectionRules.cxx +++ b/core/dictgen/src/SelectionRules.cxx @@ -548,9 +548,9 @@ bool SelectionRules::GetParentName(const clang::Decl* D, std::string& parent_nam // isClassSelected checks if a class is selected or not. Thre is a difference between the -// behaviour of rootcint and genreflex especially with regard to class pattern processing. +// behaviour of historical rootcint and genreflex especially with regard to class pattern processing. // In genreflex if we have this will select all the classes -// (and structs) found in the header file. In rootcint if we have something similar, i.e. +// (and structs) found in the header file. In historical rootcint if we had something similar, i.e. // #pragma link C++ class *, we will select only the outer classes - for the nested // classes we have to specifie #pragma link C++ class *::*. And yet this is only valid // for one level of nesting - if you need it for many levels of nesting, you will @@ -593,7 +593,7 @@ const ClassSelectionRule *SelectionRules::IsNamespaceSelected(const clang::Decl* if (it->GetSelected() == BaseSelectionRule::kYes) { selector = &(*it); if (IsLinkdefFile()){ - // rootcint prefers explicit rules over pattern rules + // historical rootcint preferred explicit rules over pattern rules if (match == BaseSelectionRule::kName) { explicit_selector = &(*it); } else if (match == BaseSelectionRule::kPattern) { @@ -636,7 +636,7 @@ const ClassSelectionRule *SelectionRules::IsNamespaceSelected(const clang::Decl* } } if (IsLinkdefFile()) { - // for rootcint explicit (name) Yes is stronger than implicit (pattern) No which is stronger than implicit (pattern) Yes + // for historical rootcint explicit (name) Yes is stronger than implicit (pattern) No which is stronger than implicit (pattern) Yes #ifdef SELECTION_DEBUG std::cout<<"\n\tfYes = "<(D), qual_name, prototype, false); if (match != BaseSelectionRule::kNoMatch) { if (selRule.GetSelected() == BaseSelectionRule::kYes) { - // explicit rules are with stronger priority in rootcint + // explicit rules are with stronger priority in historical rootcint if (IsLinkdefFile()){ if (match == BaseSelectionRule::kName) { explicit_selector = &selRule; @@ -986,7 +986,7 @@ const BaseSelectionRule *SelectionRules::IsLinkdefEnumSelected(const clang::Enum it->Match(llvm::dyn_cast(D), qual_name, "", false); if (match != BaseSelectionRule::kNoMatch) { if (it->GetSelected() == BaseSelectionRule::kYes) { - // explicit rules are with stronger priority in rootcint + // explicit rules are with stronger priority in historical rootcint if (IsLinkdefFile()){ if (match == BaseSelectionRule::kName){ explicit_selector = &(*it); @@ -1027,7 +1027,7 @@ const BaseSelectionRule *SelectionRules::IsLinkdefEnumSelected(const clang::Enum } } -// In rootcint we could select and deselect methods independently of the class/struct/union rules +// In historical rootcint we could select and deselect methods independently of the class/struct/union rules // That's why we first have to check the explicit rules for the functions - to see if there // is rule corresponding to our method. // Which is more - if we have (and we can have) a pattern for the parent class, than a pattern for the diff --git a/core/dictgen/src/TModuleGenerator.cxx b/core/dictgen/src/TModuleGenerator.cxx index 8736aea69a804..72a8e8c3bbb79 100644 --- a/core/dictgen/src/TModuleGenerator.cxx +++ b/core/dictgen/src/TModuleGenerator.cxx @@ -208,7 +208,7 @@ void TModuleGenerator::ParseArgs(const std::vector &args) } break; case 'D': - if (args[iPcmArg] != "-DTRUE=1" && args[iPcmArg] != "-DFALSE=0" && args[iPcmArg] != "-DG__NOCINTDLL") { + if (args[iPcmArg] != "-DTRUE=1" && args[iPcmArg] != "-DFALSE=0" && args[iPcmArg] != "-DG__NOCINTDLL") { // TODO maybe remove CINT part fCompD.push_back(SplitPPDefine(args[iPcmArg].c_str() + 2)); } break; diff --git a/core/dictgen/src/rootcling-argparse.py b/core/dictgen/src/rootcling-argparse.py index e856bed6b8159..2e3828d79b884 100644 --- a/core/dictgen/src/rootcling-argparse.py +++ b/core/dictgen/src/rootcling-argparse.py @@ -2,7 +2,7 @@ import sys EPILOG = """ -The options -p, -c, -l, -cint and -gccxml are deprecated and currently ignored. +The options -p, -c, -l, -cint and -gccxml are deprecated and currently ignored, and might be removed in the future. diff --git a/core/dictgen/src/rootcling_impl.cxx b/core/dictgen/src/rootcling_impl.cxx index 36a34c956ec19..379d21e78dd77 100644 --- a/core/dictgen/src/rootcling_impl.cxx +++ b/core/dictgen/src/rootcling_impl.cxx @@ -600,7 +600,7 @@ void CheckClassNameForRootMap(const std::string &classname, map if (k) { string base = classname.substr(0, k); if (base == "std") { - // std is not declared but is also ignored by CINT! + // std is not declared but is also ignored by Cling (and historical CINT) break; } else { autoloads[base] = ""; // We never load namespaces on their own. @@ -2801,7 +2801,7 @@ void CreateDictHeader(std::ostream &dictStream, const std::string &main_dictname // We do not want deprecation warnings to fire in dictionaries << "#define R__NO_DEPRECATION" << std::endl - // Now that CINT is not longer there to write the header file, + // Now that historical CINT is not longer there to write the header file, // write one and include in there a few things for backward // compatibility. << "\n/*******************************************************************/\n" @@ -3699,7 +3699,7 @@ gOptVerboseLevel(llvm::cl::desc("Choose verbosity level:"), llvm::cl::cat(gRootclingOptions)); static llvm::cl::opt -gOptCint("cint", llvm::cl::desc("Deprecated, legacy flag which is ignored."), +gOptCint("cint", llvm::cl::desc("Deprecated, legacy flag which is ignored."), // TODO potentially remove llvm::cl::Hidden, llvm::cl::cat(gRootclingOptions)); static llvm::cl::opt @@ -4462,7 +4462,7 @@ int RootClingMain(int argc, } if (!isGenreflex) { // rootcling - // ROOTCINT uses to define a few header implicitly, we need to do it explicitly. + // historial rootcint used to define a few header implicitly, we need to do it explicitly in Cling. if (interp.declare("#include \n" "#include \"Rtypes.h\"\n" "#include \"TObject.h\"") != cling::Interpreter::kSuccess diff --git a/core/foundation/inc/TClassEdit.h b/core/foundation/inc/TClassEdit.h index ee69d729cf7fa..b83d5b76c2f79 100644 --- a/core/foundation/inc/TClassEdit.h +++ b/core/foundation/inc/TClassEdit.h @@ -69,7 +69,7 @@ namespace ROOT { // TClassEdit is used to manipulate class and type names. // // This class does not dependent on any other ROOT facility -// so that it can be used by rootcint. +// so that it can be used by rootcling. namespace TClassEdit { diff --git a/core/macosx/inc/TMacOSXSystem.h b/core/macosx/inc/TMacOSXSystem.h index 57293cdb9ca2c..053cf322ec573 100644 --- a/core/macosx/inc/TMacOSXSystem.h +++ b/core/macosx/inc/TMacOSXSystem.h @@ -29,7 +29,7 @@ namespace ROOT { namespace MacOSX { namespace Details { -//'Private' pimpl class to hide Apple's specific things from CINT. +//'Private' pimpl class to hide Apple's specific things from Cling class MacOSXSystem; } diff --git a/core/meta/doc/index.txt b/core/meta/doc/index.txt index 7b4cacad3b926..f9aad9ad35485 100644 --- a/core/meta/doc/index.txt +++ b/core/meta/doc/index.txt @@ -1,8 +1 @@ -This directory contains the Dictionary classes (interface to CINT) -BEGIN_HTML - See: - -END_HTML +This directory contains the Dictionary classes (interface to rootcling) diff --git a/core/meta/inc/TBaseClass.h b/core/meta/inc/TBaseClass.h index c70e5867b01ac..6fc60da0414d1 100644 --- a/core/meta/inc/TBaseClass.h +++ b/core/meta/inc/TBaseClass.h @@ -46,7 +46,7 @@ class TBaseClass : public TDictionary { TBaseClass&operator=(const TBaseClass &) = delete; private: - BaseClassInfo_t *fInfo; //!pointer to CINT base class info + BaseClassInfo_t *fInfo; //!pointer to Cling base class info TClassRef fClassPtr; // pointer to the base class TClass TClass *fClass; //!pointer to parent class AtomicInt_t fDelta; // BaseClassInfo_t offset (INT_MAX if unset) diff --git a/core/meta/inc/TClass.h b/core/meta/inc/TClass.h index 6d625cc21b588..3aaebad08238a 100644 --- a/core/meta/inc/TClass.h +++ b/core/meta/inc/TClass.h @@ -223,7 +223,7 @@ friend class TStreamerInfo; mutable std::atomic fCheckSum = 0; //checksum of data members and base classes TVirtualCollectionProxy *fCollectionProxy = nullptr; //Collection interface Version_t fClassVersion = 0; //Class version Identifier - ClassInfo_t *fClassInfo = nullptr; //pointer to CINT class info class + ClassInfo_t *fClassInfo = nullptr; //pointer to Cling class info class TString fContextMenuTitle; //context menu title const std::type_info *fTypeInfo = nullptr; //pointer to the C++ type information. ShowMembersFunc_t fShowMembers = nullptr; //pointer to the class's ShowMembers function diff --git a/core/meta/inc/TDataMember.h b/core/meta/inc/TDataMember.h index 9a6f4f59e9051..01f5c3ed7666e 100644 --- a/core/meta/inc/TDataMember.h +++ b/core/meta/inc/TDataMember.h @@ -35,7 +35,7 @@ class TDataMember : public TDictionary { kObjIsPersistent = BIT(2) }; - DataMemberInfo_t *fInfo; //!pointer to CINT data member info + DataMemberInfo_t *fInfo; //!pointer to Cling data member info TClass *fClass; //!pointer to the class TDataType *fDataType; //!pointer to data basic type descriptor diff --git a/core/meta/inc/TDataType.h b/core/meta/inc/TDataType.h index d0be3694efecc..8ea0a7067a238 100644 --- a/core/meta/inc/TDataType.h +++ b/core/meta/inc/TDataType.h @@ -18,7 +18,7 @@ // TDataType // // // // Basic data type descriptor (datatype information is obtained from // -// CINT). // +// Cling). // // // ////////////////////////////////////////////////////////////////////////// @@ -44,7 +44,7 @@ enum EDataType { class TDataType : public TDictionary { private: - TypedefInfo_t *fInfo; //!pointer to CINT typedef info + TypedefInfo_t *fInfo; //!pointer to Cling typedef info Int_t fSize; //size of type EDataType fType; //type id Long_t fProperty; //The property information for the (potential) underlying class diff --git a/core/meta/inc/TDictionary.h b/core/meta/inc/TDictionary.h index 5abff1011a5c7..6494d87b7ce7f 100644 --- a/core/meta/inc/TDictionary.h +++ b/core/meta/inc/TDictionary.h @@ -35,7 +35,7 @@ // The ROOT dictionary system provides a very extensive RTTI // // environment that facilitates a.o. object inspectors, object I/O, // // ROOT Trees, etc. Most of the type information is provided by the // -// CINT C++ interpreter. // +// Cling C++ interpreter. // // // // TMethodCall (method call environment) // // // diff --git a/core/meta/inc/TFunction.h b/core/meta/inc/TFunction.h index 727aeb87ae49e..374125a788aad 100644 --- a/core/meta/inc/TFunction.h +++ b/core/meta/inc/TFunction.h @@ -34,7 +34,7 @@ friend class TMethodCall; protected: MethodInfo_t *fInfo; //pointer to Interpreter function info - TString fMangledName; //Mangled name as determined by CINT. + TString fMangledName; //Mangled name as determined by Cling. TString fSignature; //string containing function signature TList *fMethodArgs; //list of function arguments diff --git a/core/meta/inc/TGlobal.h b/core/meta/inc/TGlobal.h index 86c4870c27e38..ede8978500512 100644 --- a/core/meta/inc/TGlobal.h +++ b/core/meta/inc/TGlobal.h @@ -17,7 +17,7 @@ // // // TGlobal // // // -// Global variables class (global variables are obtained from CINT). // +// Global variables class (global variables are obtained from Cling). // // // ////////////////////////////////////////////////////////////////////////// @@ -28,7 +28,7 @@ class TGlobal : public TDictionary { private: - DataMemberInfo_t *fInfo; //!pointer to CINT data member info + DataMemberInfo_t *fInfo; //!pointer to Cling data member info public: TGlobal(DataMemberInfo_t *info = nullptr); diff --git a/core/meta/inc/TMethodArg.h b/core/meta/inc/TMethodArg.h index 20ad4e80ae9cd..9e35342622b52 100644 --- a/core/meta/inc/TMethodArg.h +++ b/core/meta/inc/TMethodArg.h @@ -41,7 +41,7 @@ friend class TMethod; TMethodArg(const TMethodArg&) = delete; TMethodArg& operator=(const TMethodArg&) = delete; - MethodArgInfo_t *fInfo; //pointer to CINT method argument info + MethodArgInfo_t *fInfo; //pointer to Cling method argument info TFunction *fMethod; //pointer to the method or global function TDataMember *fDataMember; //TDataMember pointed by this arg,to get values and options from. diff --git a/core/meta/inc/TMethodCall.h b/core/meta/inc/TMethodCall.h index 76eeacfed5c19..934bdfe971675 100644 --- a/core/meta/inc/TMethodCall.h +++ b/core/meta/inc/TMethodCall.h @@ -18,7 +18,7 @@ // TMethodCall // // // // Method or function calling interface. Objects of this class contain // -// the (CINT) environment to call a global function or a method for an // +// the (Cling) environment to call a global function or a method for an // // object of a specific class with the desired arguments. This class is // // espicially useful when a method has to be called more times for // // different objects and/or with different arguments. If a function or // @@ -51,7 +51,7 @@ class TMethodCall : public TObject { // enum EReturnType { kLong, kDouble, kString, kOther, kNone }; private: - CallFunc_t *fFunc; //CINT method invocation environment + CallFunc_t *fFunc; //Cling method invocation environment Longptr_t fOffset; //offset added to object pointer before method invocation TClass *fClass; //pointer to the class info TFunction *fMetPtr; //pointer to the method or function info diff --git a/core/meta/inc/TVirtualArray.h b/core/meta/inc/TVirtualArray.h index b800f543bfee2..f4a0107a8be29 100644 --- a/core/meta/inc/TVirtualArray.h +++ b/core/meta/inc/TVirtualArray.h @@ -18,7 +18,7 @@ \class TVirtualArray \ingroup IO Wrapper around an object and giving indirect access to its content -even if the object is not of a class in the Cint/Reflex dictionary. +even if the object is not of a class in the rootcling/Reflex dictionary. */ #include "TClass.h" diff --git a/core/meta/inc/TVirtualObject.h b/core/meta/inc/TVirtualObject.h index ffae64dd7ab7c..bffa996289dc6 100644 --- a/core/meta/inc/TVirtualObject.h +++ b/core/meta/inc/TVirtualObject.h @@ -17,7 +17,7 @@ \ingroup IO Wrapper around an object and giving indirect access to its content -even if the object is not of a class in the Cint/Reflex dictionary. +even if the object is not of a class in the rootcling/Reflex dictionary. */ #include "TClassRef.h" diff --git a/core/meta/src/TBaseClass.cxx b/core/meta/src/TBaseClass.cxx index 2d38fa9abe950..27e8bd48556b1 100644 --- a/core/meta/src/TBaseClass.cxx +++ b/core/meta/src/TBaseClass.cxx @@ -20,7 +20,7 @@ /** \class TBaseClass Each class (see TClass) has a linked list of its base class(es). This class describes one single base class. -The base class info is obtained via the CINT api. +The base class info is obtained via the Interpreter api. see class TCling. The base class information is used a.o. in to find all inherited methods. @@ -40,7 +40,7 @@ TBaseClass::TBaseClass(BaseClassInfo_t *info, TClass *cl) : } //////////////////////////////////////////////////////////////////////////////// -/// TBaseClass dtor deletes adopted CINT BaseClassInfo object. +/// TBaseClass dtor deletes adopted Cling BaseClassInfo object. TBaseClass::~TBaseClass() { diff --git a/core/meta/src/TClass.cxx b/core/meta/src/TClass.cxx index 82e0df3f0b103..e353a4083a76a 100644 --- a/core/meta/src/TClass.cxx +++ b/core/meta/src/TClass.cxx @@ -126,7 +126,7 @@ In order to access the name of a class within the ROOT type system, the method T using std::multimap, std::make_pair, std::string; -// Mutex to protect CINT and META operations +// Mutex to protect Cling and META operations // (exported to be used for similar cases in related classes) TVirtualMutex* gInterpreterMutex = nullptr; @@ -1020,7 +1020,7 @@ void TAutoInspector::Inspect(TClass *cl, const char *tit, const char *name, assert(found); // we skip: non static members and non objects - // - the member G__virtualinfo inserted by the CINT RTTI system + // - the member G__virtualinfo inserted by the historical CINT RTTI system //Long_t prop = m.Property() | m.Type()->Property(); Long_t prop = gCling->DataMemberInfo_Property(m) | gCling->DataMemberInfo_TypeProperty(m); @@ -1464,10 +1464,10 @@ void TClass::Init(const char *name, Version_t cversion, if (fState == kHasTClassInit) { // If the TClass is being generated from a ROOT dictionary, - // even though we do not seem to have a CINT dictionary for + // even though we do not seem to have a historical CINT dictionary for // the class, we will will try to load it anyway UNLESS // the class is an STL container (or string). - // This is because we do not expect the CINT dictionary + // This is because we do not expect the historical CINT dictionary // to be present for all STL classes (and we can handle // the lack of CINT dictionary in that cases). // However, the cling the dictionary no longer carries @@ -3213,7 +3213,7 @@ TClass *TClass::GetClass(const char *name, Bool_t load, Bool_t silent, size_t hi } } - //last attempt. Look in CINT list of all (compiled+interpreted) classes + //last attempt. Look in Cling list of all (compiled+interpreted) classes if (gDebug>0){ printf("TClass::GetClass: Header Parsing - The representation of %s was not found in the type system. A lookup in the interpreter is about to be tried: this can cause parsing. This can be avoided selecting %s in the linkdef/selection file.\n",normalizedName.c_str(), normalizedName.c_str()); } @@ -3448,7 +3448,7 @@ Bool_t TClass::GetClass(DeclId_t id, std::vector &classes) //////////////////////////////////////////////////////////////////////////////// /// Return a pointer to the dictionary loading function generated by -/// rootcint +/// rootcling DictFuncPtr_t TClass::GetDict (const char *cname) { @@ -3457,7 +3457,7 @@ DictFuncPtr_t TClass::GetDict (const char *cname) //////////////////////////////////////////////////////////////////////////////// /// Return a pointer to the dictionary loading function generated by -/// rootcint +/// rootcling DictFuncPtr_t TClass::GetDict (const std::type_info& info) { @@ -5035,7 +5035,7 @@ TClass::ObjectPtr TClass::NewObject(ENewType defConstructor, Bool_t quiet) const if (fNew) { // We have the new operator wrapper function, // so there is a dictionary and it was generated - // by rootcint, so there should be a default + // by rootcling, so there should be a default // constructor we can call through the wrapper. { TClass__GetCallingNewRAII callingNew(defConstructor); @@ -5048,7 +5048,7 @@ TClass::ObjectPtr TClass::NewObject(ENewType defConstructor, Bool_t quiet) const } else if (HasInterpreterInfo()) { // We have the dictionary but do not have the // constructor wrapper, so the dictionary was - // not generated by rootcint. Let's try to + // not generated by rootcling. Let's try to // create the object by having the interpreter // call the new operator, hopefully the class // library is loaded and there will be a default @@ -5149,7 +5149,7 @@ TClass::ObjectPtr TClass::NewObject(void *arena, ENewType defConstructor) const if (fNew) { // We have the new operator wrapper function, // so there is a dictionary and it was generated - // by rootcint, so there should be a default + // by rootcling, so there should be a default // constructor we can call through the wrapper. { TClass__GetCallingNewRAII callingNew(defConstructor); @@ -5161,7 +5161,7 @@ TClass::ObjectPtr TClass::NewObject(void *arena, ENewType defConstructor) const } else if (HasInterpreterInfo()) { // We have the dictionary but do not have the // constructor wrapper, so the dictionary was - // not generated by rootcint. Let's try to + // not generated by rootcling. Let's try to // create the object by having the interpreter // call the new operator, hopefully the class // library is loaded and there will be a default @@ -5252,7 +5252,7 @@ TClass::ObjectPtr TClass::NewObjectArray(Long_t nElements, ENewType defConstruct if (fNewArray) { // We have the new operator wrapper function, // so there is a dictionary and it was generated - // by rootcint, so there should be a default + // by rootcling, so there should be a default // constructor we can call through the wrapper. { TClass__GetCallingNewRAII callingNew(defConstructor); @@ -5264,7 +5264,7 @@ TClass::ObjectPtr TClass::NewObjectArray(Long_t nElements, ENewType defConstruct } else if (HasInterpreterInfo()) { // We have the dictionary but do not have the // constructor wrapper, so the dictionary was - // not generated by rootcint. Let's try to + // not generated by rootcling. Let's try to // create the object by having the interpreter // call the new operator, hopefully the class // library is loaded and there will be a default @@ -5353,7 +5353,7 @@ TClass::ObjectPtr TClass::NewObjectArray(Long_t nElements, void *arena, ENewType if (fNewArray) { // We have the new operator wrapper function, // so there is a dictionary and it was generated - // by rootcint, so there should be a default + // by rootcling, so there should be a default // constructor we can call through the wrapper. { TClass__GetCallingNewRAII callingNew(defConstructor); @@ -5364,8 +5364,8 @@ TClass::ObjectPtr TClass::NewObjectArray(Long_t nElements, void *arena, ENewType } } else if (HasInterpreterInfo()) { // We have the dictionary but do not have the constructor wrapper, - // so the dictionary was not generated by rootcint (it was made either - // by cint or by some external mechanism). Let's try to create the + // so the dictionary was not generated by rootcling (it was made either + // by historical CINT or by some external mechanism). Let's try to create the // object by having the interpreter call the new operator, either the // class library is loaded and there is a default constructor we can // call, or the class is interpreted and we will call the default @@ -5452,8 +5452,8 @@ void TClass::Destructor(void *obj, Bool_t dtorOnly) } else if (HasInterpreterInfo()) { // We have the dictionary but do not have the // destruct/delete wrapper, so the dictionary was - // not generated by rootcint (it could have been - // created by cint or by some external mechanism). + // not generated by rootcling (it could have been + // created by historical CINT or by some external mechanism). // Let's have the interpreter call the destructor, // either the code will be in a loaded library, // or it will be interpreted, otherwise we fail @@ -5583,7 +5583,7 @@ void TClass::DeleteArray(void *ary, Bool_t dtorOnly) } else if (HasInterpreterInfo()) { // We have the dictionary but do not have the // array delete wrapper, so the dictionary was - // not generated by rootcint. Let's try to + // not generated by rootcling. Let's try to // delete the array by having the interpreter // call the array delete operator, hopefully // the class library is loaded and there will be @@ -5995,7 +5995,7 @@ Bool_t TClass::IsForeign() const } //////////////////////////////////////////////////////////////////////////////// -/// Do the initialization that can only be done after the CINT dictionary has +/// Do the initialization that can only be done after the ROOT dictionary has /// been fully populated and can not be delayed efficiently. void TClass::PostLoadCheck() diff --git a/core/meta/src/TDataMember.cxx b/core/meta/src/TDataMember.cxx index 63d3801a40ff7..528dca61428d0 100644 --- a/core/meta/src/TDataMember.cxx +++ b/core/meta/src/TDataMember.cxx @@ -333,7 +333,7 @@ TDataMember& TDataMember::operator=(const TDataMember& dm) } //////////////////////////////////////////////////////////////////////////////// -/// TDataMember dtor deletes adopted CINT DataMemberInfo object. +/// TDataMember dtor deletes adopted Cling DataMemberInfo object. TDataMember::~TDataMember() { @@ -491,7 +491,7 @@ Longptr_t TDataMember::GetOffset() const } //////////////////////////////////////////////////////////////////////////////// -/// Get offset from "this" using the information in CINT only. +/// Get offset from "this" using the information in Cling only. Longptr_t TDataMember::GetOffsetCint() const { diff --git a/core/meta/src/TDataType.cxx b/core/meta/src/TDataType.cxx index 6215649b262f6..d8fcbd12cbdee 100644 --- a/core/meta/src/TDataType.cxx +++ b/core/meta/src/TDataType.cxx @@ -11,7 +11,7 @@ /** \class TDataType Basic data type descriptor (datatype information is obtained from -CINT). This class describes the attributes of type definitions +Cling). This class describes the attributes of type definitions (typedef's). The TROOT class contains a list of all currently defined types (accessible via TROOT::GetListOfTypes()). */ @@ -99,7 +99,7 @@ TDataType& TDataType::operator=(const TDataType& dt) } //////////////////////////////////////////////////////////////////////////////// -/// TDataType dtor deletes adopted CINT TypedefInfo object. +/// TDataType dtor deletes adopted Cling TypedefInfo object. TDataType::~TDataType() { @@ -384,7 +384,7 @@ void TDataType::CheckInfo() { // This can be needed if the library defining this typedef was loaded after // another library and that this other library is unloaded (in which case - // things can get renumbered inside CINT). + // things can get renumbered inside Cling). if (!fInfo) return; diff --git a/core/meta/src/TFunction.cxx b/core/meta/src/TFunction.cxx index bcf6a98a32d0c..b9b1d4dd169a8 100644 --- a/core/meta/src/TFunction.cxx +++ b/core/meta/src/TFunction.cxx @@ -10,7 +10,7 @@ *************************************************************************/ /** \class TFunction -Global functions class (global functions are obtained from CINT). +Global functions class (global functions are obtained from Cling). This class describes one single global function. The TROOT class contains a list of all currently defined global functions (accessible via TROOT::GetListOfGlobalFunctions()). @@ -84,7 +84,7 @@ TFunction& TFunction::operator=(const TFunction &rhs) } //////////////////////////////////////////////////////////////////////////////// -/// TFunction dtor deletes adopted CINT MethodInfo. +/// TFunction dtor deletes adopted Cling MethodInfo. TFunction::~TFunction() { @@ -106,7 +106,7 @@ TObject *TFunction::Clone(const char *newname) const } //////////////////////////////////////////////////////////////////////////////// -/// Using the CINT method arg information to create a complete signature string. +/// Using the Cling method arg information to create a complete signature string. void TFunction::CreateSignature() { @@ -214,7 +214,7 @@ TDictionary::DeclId_t TFunction::GetDeclId() const //////////////////////////////////////////////////////////////////////////////// /// Return pointer to the interface method. Using this pointer we -/// can find which TFunction belongs to a CINT MethodInfo object. +/// can find which TFunction belongs to a Cling MethodInfo object. /// Both need to have the same InterfaceMethod pointer. void *TFunction::InterfaceMethod() const @@ -246,7 +246,7 @@ Bool_t TFunction::IsValid() } //////////////////////////////////////////////////////////////////////////////// -/// Returns the mangled name as defined by CINT, or 0 in case of error. +/// Returns the mangled name as defined by Cling, or 0 in case of error. const char *TFunction::GetMangledName() const { @@ -254,7 +254,7 @@ const char *TFunction::GetMangledName() const } //////////////////////////////////////////////////////////////////////////////// -/// Returns the prototype of a function as defined by CINT, or 0 in +/// Returns the prototype of a function as defined by Cling, or 0 in /// case of error. const char *TFunction::GetPrototype() const diff --git a/core/meta/src/TFunctionTemplate.cxx b/core/meta/src/TFunctionTemplate.cxx index 0d75db9218674..1715e2d393fde 100644 --- a/core/meta/src/TFunctionTemplate.cxx +++ b/core/meta/src/TFunctionTemplate.cxx @@ -63,7 +63,7 @@ TFunctionTemplate& TFunctionTemplate::operator=(const TFunctionTemplate &rhs) } //////////////////////////////////////////////////////////////////////////////// -/// TFunctionTemplate dtor deletes adopted CINT FuncTempInfo. +/// TFunctionTemplate dtor deletes adopted Cling FuncTempInfo. TFunctionTemplate::~TFunctionTemplate() { diff --git a/core/meta/src/TGlobal.cxx b/core/meta/src/TGlobal.cxx index 0ce1fca7a30f3..cb23befaf9eec 100644 --- a/core/meta/src/TGlobal.cxx +++ b/core/meta/src/TGlobal.cxx @@ -10,7 +10,7 @@ *************************************************************************/ /** \class TGlobal -Global variables class (global variables are obtained from CINT). +Global variables class (global variables are obtained from Cling). This class describes the attributes of a global variable. The TROOT class contains a list of all currently defined global variables (accessible via TROOT::GetListOfGlobals()). @@ -67,7 +67,7 @@ TGlobal &TGlobal::operator=(const TGlobal &rhs) } //////////////////////////////////////////////////////////////////////////////// -/// TGlobal dtor deletes adopted CINT DataMemberInfo object. +/// TGlobal dtor deletes adopted Cling DataMemberInfo object. TGlobal::~TGlobal() { diff --git a/core/meta/src/TMethod.cxx b/core/meta/src/TMethod.cxx index e57d69ed28db4..dc4530da4e9c9 100644 --- a/core/meta/src/TMethod.cxx +++ b/core/meta/src/TMethod.cxx @@ -12,7 +12,7 @@ /** \class TMethod Each ROOT class (see TClass) has a linked list of methods. This class describes one single method (member function). - The method info is obtained via the CINT api. See class TCling. + The method info is obtained via the Interpreter api. See class TCling. The method information is used a.o. by the THml class and by the TTree class. @@ -110,7 +110,7 @@ const char *TMethod::GetCommentString() //////////////////////////////////////////////////////////////////////////////// -/// Using the CINT method arg information create a complete signature string. +/// Using the Cling method arg information create a complete signature string. void TMethod::CreateSignature() { diff --git a/core/meta/src/TMethodArg.cxx b/core/meta/src/TMethodArg.cxx index 1b75367408c87..0b535436227f7 100644 --- a/core/meta/src/TMethodArg.cxx +++ b/core/meta/src/TMethodArg.cxx @@ -19,7 +19,7 @@ /** \class TMethodArg Each ROOT method (see TMethod) has a linked list of its arguments. This class describes one single method argument. -The method argument info is obtained via the CINT api. +The method argument info is obtained via the Interpreter api. See class TCling. The method argument information is used a.o. in the TContextMenu @@ -43,7 +43,7 @@ TMethodArg::TMethodArg(MethodArgInfo_t *info, TFunction *method) : TDictionary() } //////////////////////////////////////////////////////////////////////////////// -/// TMethodArg dtor deletes adopted CINT MethodArgInfo object. +/// TMethodArg dtor deletes adopted Cling MethodArgInfo object. TMethodArg::~TMethodArg() { diff --git a/core/meta/src/TMethodCall.cxx b/core/meta/src/TMethodCall.cxx index e7188d1d34e88..46377c55b0a6c 100644 --- a/core/meta/src/TMethodCall.cxx +++ b/core/meta/src/TMethodCall.cxx @@ -11,7 +11,7 @@ /** \class TMethodCall Method or function calling interface. Objects of this class contain -the (CINT) environment to call a global function or a method for an +the (Cling) environment to call a global function or a method for an object of a specific class with the desired arguments. This class is especially useful when a method has to be called more times for different objects and/or with different arguments. If a function or @@ -290,7 +290,7 @@ void TMethodCall::Init(const char *function, const char *params) /// This function implements Init and InitWithPrototype. /// /// 'methodname' should NOT have any scope information in it. The scope -/// information should be passed via the TClass or CINT ClassInfo. +/// information should be passed via the TClass or Cling ClassInfo. void TMethodCall::InitImplementation(const char *methodname, const char *params, const char *proto, diff --git a/core/meta/src/TStreamerElement.cxx b/core/meta/src/TStreamerElement.cxx index 561fca629178d..5b1a95fc23920 100644 --- a/core/meta/src/TStreamerElement.cxx +++ b/core/meta/src/TStreamerElement.cxx @@ -390,7 +390,7 @@ TMemberStreamer *TStreamerElement::GetStreamer() const //////////////////////////////////////////////////////////////////////////////// /// Return type name of this element /// in case the type name is not a standard basic type, return -/// the basic type name known to CINT. +/// the basic type name known to Cling. const char *TStreamerElement::GetTypeNameBasic() const { @@ -1912,7 +1912,7 @@ Int_t TStreamerSTL::GetSize() const if (cl==nullptr) { if (!TestBit(kWarned)) { Error("GetSize","Could not find the TClass for %s.\n" - "This is likely to have been a typedef, if possible please declare it in CINT to work around the issue\n",fTypeName.Data()); + "This is likely to have been a typedef, if possible please declare it in Cling to work around the issue\n",fTypeName.Data()); const_cast(this)->SetBit(kWarned); } } else { diff --git a/core/metacling/src/TCling.cxx b/core/metacling/src/TCling.cxx index 30ca417874c32..58f4627f9c99d 100644 --- a/core/metacling/src/TCling.cxx +++ b/core/metacling/src/TCling.cxx @@ -2567,7 +2567,7 @@ Longptr_t TCling::ProcessLine(const char* line, EErrorCode* error/*=0*/) cling::Interpreter::CompilationResult compRes = cling::Interpreter::kSuccess; if (!strncmp(sLine.Data(), ".L", 2) || !strncmp(sLine.Data(), ".x", 2) || !strncmp(sLine.Data(), ".X", 2)) { - // If there was a trailing "+", then CINT compiled the code above, + // If there was a trailing "+", then historical CINT compiled the code above, // and we will need to strip the "+" before passing the line to cling. TString mod_line(sLine); TString aclicMode; @@ -3221,7 +3221,7 @@ Bool_t TCling::HasPCMForLibrary(const char *libname) const } //////////////////////////////////////////////////////////////////////////////// -/// Return true if the file has already been loaded by cint. +/// Return true if the file has already been loaded by Cling. /// We will try in this order: /// actual filename /// filename as a path relative to @@ -4180,7 +4180,7 @@ void TCling::SetClassInfo(TClass* cl, Bool_t reload, Bool_t silent) } if (!info->IsLoaded()) { if (info->Property() & (kIsNamespace)) { - // Namespaces can have info but no corresponding CINT dictionary + // Namespaces can have info but no corresponding ROOT dictionary // because they are auto-created if one of their contained // classes has a dictionary. zombieCandidate = kTRUE; @@ -5276,7 +5276,7 @@ void TCling::GetInterpreterTypeName(const char* name, std::string &output, Bool_ return; } // Well well well, for backward compatibility we need to act a bit too - // much like CINT. + // much like historical CINT. TClassEdit::TSplitType splitname( cl.Name(), TClassEdit::kDropStd ); splitname.ShortType(output, TClassEdit::kDropStd ); @@ -5286,7 +5286,7 @@ void TCling::GetInterpreterTypeName(const char* name, std::string &output, Bool_ //////////////////////////////////////////////////////////////////////////////// /// Execute a global function with arguments params. /// -/// FIXME: The cint-based version of this code does not check if the +/// FIXME: The CINT-based version of this code does not check if the /// SetFunc() call works, and does not do any real checking /// for errors from the Exec() call. It did fetch the most /// recent cint security error and return that in error, but @@ -5310,7 +5310,7 @@ void TCling::Execute(const char* function, const char* params, int* error) //////////////////////////////////////////////////////////////////////////////// /// Execute a method from class cl with arguments params. /// -/// FIXME: The cint-based version of this code does not check if the +/// FIXME: The CINT-based version of this code does not check if the /// SetFunc() call works, and does not do any real checking /// for errors from the Exec() call. It did fetch the most /// recent cint security error and return that in error, but @@ -7470,7 +7470,7 @@ const char* TCling::GetIncludePath() } //////////////////////////////////////////////////////////////////////////////// -/// Return the directory containing CINT's stl cintdlls. +/// \deprecated Returned the directory containing historical CINT's stl cintdlls. \return "" const char* TCling::GetSTLIncludePath() const { diff --git a/core/metacling/src/TCling.h b/core/metacling/src/TCling.h index 1f0aa189fd89c..a00d1d0cb384a 100644 --- a/core/metacling/src/TCling.h +++ b/core/metacling/src/TCling.h @@ -102,7 +102,7 @@ extern "C" { class TCling final : public TInterpreter { private: // Static Data Members - static void* fgSetOfSpecials; // set of TObjects used in CINT variables + static void* fgSetOfSpecials; // set of TObjects used in Cling variables private: // Data Members diff --git a/core/metacling/src/TClingBaseClassInfo.cxx b/core/metacling/src/TClingBaseClassInfo.cxx index 39c6484aaa58e..d48dd06847cdc 100644 --- a/core/metacling/src/TClingBaseClassInfo.cxx +++ b/core/metacling/src/TClingBaseClassInfo.cxx @@ -11,13 +11,13 @@ /** \class TClingBaseClassInfo -Emulation of the CINT BaseClassInfo class. +Emulation of the historical CINT BaseClassInfo class. -The CINT C++ interpreter provides an interface to metadata about +The CINT C++ interpreter provided an interface to metadata about the base classes of a class through the BaseClassInfo class. This class provides the same functionality, using an interface as close as possible to BaseClassInfo but the base class metadata comes from -the Clang C++ compiler, not CINT. +the Clang C++ compiler, not historical CINT. */ #include "TClingBaseClassInfo.h" @@ -266,7 +266,7 @@ int TClingBaseClassInfo::InternalNext(int onlyDirect) while (1) { // Advance the iterator. if (fFirstTime) { - // The cint semantics are strange. + // The CINT Next() semantics were strange. fFirstTime = false; } else if (!onlyDirect && fDescend) { diff --git a/core/metacling/src/TClingBaseClassInfo.h b/core/metacling/src/TClingBaseClassInfo.h index f374102b54e3a..5eb9ec43cd8a5 100644 --- a/core/metacling/src/TClingBaseClassInfo.h +++ b/core/metacling/src/TClingBaseClassInfo.h @@ -16,13 +16,13 @@ // // // TClingBaseClassInfo // // // -// Emulation of the CINT BaseClassInfo class. // +// Emulation of the historical CINT BaseClassInfo class. // // // -// The CINT C++ interpreter provides an interface to metadata about // +// The CINT C++ interpreter provided an interface to metadata about // // the base classes of a class through the BaseClassInfo class. This // // class provides the same functionality, using an interface as close // // as possible to BaseClassInfo but the base class metadata comes from // -// the Clang C++ compiler, not CINT. // +// the Clang C++ compiler, not historical CINT. // // // ////////////////////////////////////////////////////////////////////////// @@ -46,7 +46,7 @@ class TClingBaseClassInfo { cling::Interpreter *fInterp; // Cling interpreter, we do *not* own. TClingClassInfo *fClassInfo; // Class we were intialized with, we own. - bool fFirstTime; // Flag to provide Cint semantics for iterator advancement (not first time) + bool fFirstTime; // Flag to provide historical Next() CINT semantics for iterator advancement (not first time) bool fDescend; // Flag for signaling the need to descend on this advancement. const clang::Decl *fDecl; // Current class whose bases we are iterating through, we do *not* own. clang::CXXRecordDecl::base_class_const_iterator fIter; // Current iterator. diff --git a/core/metacling/src/TClingCallFunc.cxx b/core/metacling/src/TClingCallFunc.cxx index 7ac8f8b879c55..ddb20e2042af9 100644 --- a/core/metacling/src/TClingCallFunc.cxx +++ b/core/metacling/src/TClingCallFunc.cxx @@ -12,14 +12,14 @@ *************************************************************************/ /** \class TClingCallFunc -Emulation of the CINT CallFunc class. +Emulation of the historical CINT CallFunc class. -The CINT C++ interpreter provides an interface for calling +The CINT C++ interpreter provided an interface for calling functions through the generated wrappers in dictionaries with the CallFunc class. This class provides the same functionality, using an interface as close as possible to CallFunc but the function metadata and calling service comes from the Cling -C++ interpreter and the Clang C++ compiler, not CINT. +C++ interpreter and the Clang C++ compiler, not historical CINT. */ #include "TClingCallFunc.h" @@ -1377,7 +1377,7 @@ void TClingCallFunc::SetFunc(const TClingClassInfo *info, const char *method, co return; } if (!strcmp(arglist, ")")) { - // CINT accepted a single right paren as meaning no arguments. + // Historical CINT accepted a single right paren as meaning no arguments. arglist = ""; } *fMethod = info->GetMethodWithArgs(method, arglist, objectIsConst, poffset); diff --git a/core/metacling/src/TClingCallFunc.h b/core/metacling/src/TClingCallFunc.h index a590c6b11425e..8ecbc5ad55a8b 100644 --- a/core/metacling/src/TClingCallFunc.h +++ b/core/metacling/src/TClingCallFunc.h @@ -17,14 +17,14 @@ // // // TClingCallFunc // // // -// Emulation of the CINT CallFunc class. // +// Emulation of the historical CINT CallFunc class. // // // -// The CINT C++ interpreter provides an interface for calling // +// The CINT C++ interpreter provided an interface for calling // // functions through the generated wrappers in dictionaries with // // the CallFunc class. This class provides the same functionality, // // using an interface as close as possible to CallFunc but the // // function metadata and calling service comes from the Cling // -// C++ interpreter and the Clang C++ compiler, not CINT. // +// C++ interpreter and the Clang C++ compiler, not historical CINT. // // // ////////////////////////////////////////////////////////////////////////// diff --git a/core/metacling/src/TClingCallbacks.cxx b/core/metacling/src/TClingCallbacks.cxx index bfe0f0607973e..0687752bb88ea 100644 --- a/core/metacling/src/TClingCallbacks.cxx +++ b/core/metacling/src/TClingCallbacks.cxx @@ -679,11 +679,10 @@ bool TClingCallbacks::tryFindROOTSpecialInternal(LookupResult &R, Scope *S) { if (obj) { #if defined(R__MUST_REVISIT) -#if R__MUST_REVISIT(6,2) +#if R__MUST_REVISIT(6,2) //TODO: recheck with Cling // Register the address in TCling::fgSetOfSpecials // to speed-up the execution of TCling::RecursiveRemove when // the object is not a special. - // See http://root.cern.ch/viewvc/trunk/core/meta/src/TCint.cxx?view=log#rev18109 if (!fgSetOfSpecials) { fgSetOfSpecials = new std::set; } diff --git a/core/metacling/src/TClingClassInfo.cxx b/core/metacling/src/TClingClassInfo.cxx index 005c17ffcaeaa..0bab5c3ffa69a 100644 --- a/core/metacling/src/TClingClassInfo.cxx +++ b/core/metacling/src/TClingClassInfo.cxx @@ -11,12 +11,12 @@ /** \class TClingClassInfo -Emulation of the CINT ClassInfo class. +Emulation of the historical CINT ClassInfo class. -The CINT C++ interpreter provides an interface to metadata about +The CINT C++ interpreter provided an interface to metadata about a class through the ClassInfo class. This class provides the same functionality, using an interface as close as possible to ClassInfo -but the class metadata comes from the Clang C++ compiler, not CINT. +but the class metadata comes from the Clang C++ compiler, not historical CINT. */ #include "TClingClassInfo.h" @@ -151,11 +151,11 @@ long TClingClassInfo::ClassProperty() const if (!RD) { // We are an enum or namespace. - // The cint interface always returns 0L for these guys. + // The historical CINT interface always returned 0L for these guys. return property; } if (RD->isUnion()) { - // The cint interface always returns 0L for these guys. + // The historical CINT interface always returns 0L for these guys. return property; } // We now have a class or a struct. @@ -539,7 +539,7 @@ TClingMethodInfo TClingClassInfo::GetMethodWithArgs(const char *fname, return tmi; } if (!strcmp(arglist, ")")) { - // CINT accepted a single right paren as meaning no arguments. + // Historical CINT accepted a single right paren as meaning no arguments. arglist = ""; } const cling::LookupHelper &lh = fInterp->getLookupHelper(); @@ -681,7 +681,7 @@ ROOT::TMetaUtils::EIOCtorCategory TClingClassInfo::HasDefaultConstructor(bool ch // compiler elides it. // // Note: This is could enhanced to also know about the ROOT ioctor - // but this was not the case in CINT. + // but this was not the case in historical CINT. // using namespace ROOT::TMetaUtils; @@ -886,10 +886,9 @@ EDataType TClingClassInfo::GetUnderlyingType() const bool TClingClassInfo::IsLoaded() const { - // IsLoaded in CINT was meaning is known to the interpreter + // IsLoaded in historical CINT was meaning is known to the interpreter // and has a complete definition. - // IsValid in Cling (as in CING) means 'just' is known to the - // interpreter. + // IsValid in Cling means 'just' is known to the interpreter. if (!IsValid()) { return false; } @@ -969,7 +968,7 @@ int TClingClassInfo::InternalNext() while (true) { // Advance to next usable decl, or return if there is no next usable decl. if (fFirstTime) { - // The cint semantics are strange. + // The historical CINT Next() semantics were strange. fFirstTime = false; if (!*fIter) { return 0; @@ -1331,11 +1330,11 @@ int TClingClassInfo::Size() const Decl::Kind DK = GetDecl()->getKind(); if (DK == Decl::Namespace) { - // Namespaces are special for cint. + // Namespaces are special for Cling. return 1; } else if (DK == Decl::Enum) { - // Enums are special for cint. + // Enums are special for Cling. return 0; } const RecordDecl *RD = llvm::dyn_cast(GetDecl()); diff --git a/core/metacling/src/TClingClassInfo.h b/core/metacling/src/TClingClassInfo.h index c08fa1bdae1c9..52b402000c4e8 100644 --- a/core/metacling/src/TClingClassInfo.h +++ b/core/metacling/src/TClingClassInfo.h @@ -16,12 +16,12 @@ // // // TClingClassInfo // // // -// Emulation of the CINT ClassInfo class. // +// Emulation of the historical CINT ClassInfo class. // // // -// The CINT C++ interpreter provides an interface to metadata about // +// The CINT C++ interpreter provided an interface to metadata about // // a class through the ClassInfo class. This class provides the same // // functionality, using an interface as close as possible to ClassInfo // -// but the class metadata comes from the Clang C++ compiler, not CINT. // +// but the class metadata comes from the Clang C++ compiler, not historical CINT. // // // ////////////////////////////////////////////////////////////////////////// diff --git a/core/metacling/src/TClingDataMemberInfo.cxx b/core/metacling/src/TClingDataMemberInfo.cxx index 9c8db5ef2c897..4215472faea3a 100644 --- a/core/metacling/src/TClingDataMemberInfo.cxx +++ b/core/metacling/src/TClingDataMemberInfo.cxx @@ -11,13 +11,13 @@ /** \class TClingDataMemberInfo -Emulation of the CINT DataMemberInfo class. +Emulation of the historical CINT DataMemberInfo class. -The CINT C++ interpreter provides an interface to metadata about +The CINT C++ interpreter provided an interface to metadata about the data members of a class through the DataMemberInfo class. This class provides the same functionality, using an interface as close as possible to DataMemberInfo but the data member metadata comes -from the Clang C++ compiler, not CINT. +from the Clang C++ compiler, not historical CINT. */ #include "TClingDataMemberInfo.h" @@ -319,7 +319,7 @@ int TClingDataMemberInfo::Next() } // Advance to the next decl. if (fFirstTime) { - // The cint semantics are weird. + // The CINT Next() semantics were weird. fFirstTime = false; } else { fIter.Next(); @@ -488,12 +488,12 @@ long TClingDataMemberInfo::Property() const property |= kIsStatic; } else if (nonTransparentDC->isNamespace()) { // Data members of a namespace are global variable which were - // considered to be 'static' in the CINT (and thus ROOT) scheme. + // considered to be 'static' in the historical CINT (and thus ROOT) scheme. property |= kIsStatic; } } else if (llvm::isa(vd)) { // Enumeration constant are considered to be 'static' data member in - // the CINT (and thus ROOT) scheme. + // the historical CINT (and thus ROOT) scheme. property |= kIsStatic; } clang::QualType qt = vd->getType(); @@ -573,7 +573,7 @@ const char *TClingDataMemberInfo::TypeName() const buf.clear(); const clang::ValueDecl *vd = GetTargetValueDecl(); clang::QualType vdType = vd->getType(); - // In CINT's version, the type name returns did *not* include any array + // In historical CINT's version, the type name returns did *not* include any array // information, ROOT's existing code depends on it. while (vdType->isArrayType()) { vdType = GetDecl()->getASTContext().getQualifiedType(vdType->getBaseElementTypeUnsafe(),vdType.getQualifiers()); @@ -605,7 +605,7 @@ const char *TClingDataMemberInfo::TypeTrueName(const ROOT::TMetaUtils::TNormaliz ROOT::TMetaUtils::GetNormalizedName(buf, vdType, *fInterp, normCtxt); - // In CINT's version, the type name returns did *not* include any array + // In historical CINT's version, the type name returns did *not* include any array // information, ROOT's existing code depends on it. // This might become part of the implementation of GetNormalizedName. while (buf.length() && buf[buf.length()-1] == ']') { diff --git a/core/metacling/src/TClingDataMemberInfo.h b/core/metacling/src/TClingDataMemberInfo.h index e07869005b016..83acad541ddf8 100644 --- a/core/metacling/src/TClingDataMemberInfo.h +++ b/core/metacling/src/TClingDataMemberInfo.h @@ -16,13 +16,13 @@ // // // TClingDataMemberInfo // // // -// Emulation of the CINT DataMemberInfo class. // +// Emulation of the historical CINT DataMemberInfo class. // // // -// The CINT C++ interpreter provides an interface to metadata about // +// The CINT C++ interpreter provided an interface to metadata about // // the data members of a class through the DataMemberInfo class. This // // class provides the same functionality, using an interface as close // // as possible to DataMemberInfo but the data member metadata comes // -// from the Clang C++ compiler, not CINT. // +// from the Clang C++ compiler, not historical CINT. // // // ////////////////////////////////////////////////////////////////////////// @@ -76,7 +76,7 @@ class TClingDataMemberInfo final : public TClingDeclInfo { TClingClassInfo fClassInfo; // ClassInfo for the decl context, for X vs X. TClingDataMemberIter fIter; // Current decl. std::string fTitle; // The meta info for the member. - bool fFirstTime = true; // We need to skip the first increment to support the cint Next() semantics. + bool fFirstTime = true; // We need to skip the first increment to support the historical CINT Next() semantics. int64_t fEnumValue; // Special case to handle enums mutable std::string fIoType; diff --git a/core/metacling/src/TClingMethodArgInfo.cxx b/core/metacling/src/TClingMethodArgInfo.cxx index 76762000770f1..7dd48119c9164 100644 --- a/core/metacling/src/TClingMethodArgInfo.cxx +++ b/core/metacling/src/TClingMethodArgInfo.cxx @@ -10,13 +10,13 @@ *************************************************************************/ /** \class TClingMethodArgInfo -Emulation of the CINT MethodInfo class. +Emulation of the historical CINT MethodInfo class. -The CINT C++ interpreter provides an interface to metadata about +The CINT C++ interpreter provided an interface to metadata about the arguments to a function through the MethodArgInfo class. This class provides the same functionality, using an interface as close as possible to MethodArgInfo but the typedef metadata comes from -the Clang C++ compiler, not CINT. +the Clang C++ compiler, not historical CINT. */ #include "TClingMethodArgInfo.h" @@ -105,7 +105,7 @@ const char *TClingMethodArgInfo::DefaultValue() const buf.clear(); llvm::raw_string_ostream out(buf); if (!expr) { - // CINT returned NULL for non-defaulted args. + // Historical CINT returned NULL for non-defaulted args. return nullptr; } bool implicitInit = false; diff --git a/core/metacling/src/TClingMethodArgInfo.h b/core/metacling/src/TClingMethodArgInfo.h index 05c494eb1b649..597bbfcd2e5fd 100644 --- a/core/metacling/src/TClingMethodArgInfo.h +++ b/core/metacling/src/TClingMethodArgInfo.h @@ -16,13 +16,13 @@ // // // TClingMethodArgInfo // // // -// Emulation of the CINT MethodInfo class. // +// Emulation of the historical CINT MethodInfo class. // // // -// The CINT C++ interpreter provides an interface to metadata about // +// The CINT C++ interpreter provided an interface to metadata about // // the arguments to a function through the MethodArgInfo class. This // // class provides the same functionality, using an interface as close // // as possible to MethodArgInfo but the typedef metadata comes from // -// the Clang C++ compiler, not CINT. // +// the Clang C++ compiler, not historical CINT. // // // ////////////////////////////////////////////////////////////////////////// diff --git a/core/metacling/src/TClingMethodInfo.cxx b/core/metacling/src/TClingMethodInfo.cxx index 0c1a62c8e846d..771cf55c2b93f 100644 --- a/core/metacling/src/TClingMethodInfo.cxx +++ b/core/metacling/src/TClingMethodInfo.cxx @@ -10,13 +10,13 @@ *************************************************************************/ /** \class TClingMethodInfo -Emulation of the CINT MethodInfo class. +Emulation of the historical CINT MethodInfo class. -The CINT C++ interpreter provides an interface to metadata about +The historical CINT C++ interpreter provided an interface to metadata about a function through the MethodInfo class. This class provides the same functionality, using an interface as close as possible to MethodInfo but the typedef metadata comes from the Clang C++ -compiler, not CINT. +compiler, not historical CINT. */ #include "TClingMethodInfo.h" @@ -381,7 +381,7 @@ int TClingMethodInfo::NArg() const // The next call locks the interpreter mutex. const clang::FunctionDecl *fd = GetTargetFunctionDecl(); unsigned num_params = fd->getNumParams(); - // Truncate cast to fit cint interface. + // Truncate cast to fit historical CINT interface. return static_cast(num_params); } @@ -395,7 +395,7 @@ int TClingMethodInfo::NDefaultArg() const unsigned num_params = fd->getNumParams(); unsigned min_args = fd->getMinRequiredArguments(); unsigned defaulted_params = num_params - min_args; - // Truncate cast to fit cint interface. + // Truncate cast to fit historical CINT interface. return static_cast(defaulted_params); } @@ -425,7 +425,7 @@ int TClingMethodInfo::Next() } // Advance to the next decl. if (fFirstTime) { - // The cint semantics are weird. + // The historical CINT Next() semantics were weird. fFirstTime = false; } else { fIter.Next(); @@ -573,7 +573,7 @@ TClingTypeInfo *TClingMethodInfo::Type() const // The next part interacts with clang, thus needs locking. R__LOCKGUARD(gInterpreterMutex); if (llvm::isa(GetTargetFunctionDecl())) { - // CINT claims that constructors return the class object. + // CINT claimed that constructors return the class object. TODO: check with Cling // For using-ctors of a base, claim that it "returns" the derived class. const clang::TypeDecl* ctorClass = llvm::dyn_cast_or_null (GetDecl()->getDeclContext()); @@ -681,7 +681,7 @@ const char *TClingMethodInfo::Name() const const char *TClingMethodInfo::TypeName() const { if (!IsValid()) { - // FIXME: Cint does not check! + // FIXME: Cint does not check! Recheck with Cling return nullptr; } // The next *two* calls lock the interpreter mutex. Lock here first instead diff --git a/core/metacling/src/TClingMethodInfo.h b/core/metacling/src/TClingMethodInfo.h index 46cbeedf86618..3a8b411d353dc 100644 --- a/core/metacling/src/TClingMethodInfo.h +++ b/core/metacling/src/TClingMethodInfo.h @@ -16,13 +16,13 @@ // // // TClingMethodInfo // // // -// Emulation of the CINT MethodInfo class. // +// Emulation of the historical CINT MethodInfo class. // // // -// The CINT C++ interpreter provides an interface to metadata about // +// The CINT C++ interpreter provided an interface to metadata about // // a function through the MethodInfo class. This class provides the // // same functionality, using an interface as close as possible to // // MethodInfo but the typedef metadata comes from the Clang C++ // -// compiler, not CINT. // +// compiler, not historical CINT. // // // ////////////////////////////////////////////////////////////////////////// @@ -124,7 +124,7 @@ class SpecFuncIter { class TClingMethodInfo final : public TClingDeclInfo { private: cling::Interpreter *fInterp; // Cling interpreter, we do *not* own. - bool fFirstTime; // Flag for first time incrementing iterator, cint semantics are weird. + bool fFirstTime; // Flag for first time incrementing iterator, CINT Next() semantics were weird. TClingCXXRecMethIter fIter; // Our iterator. std::string fTitle; // The meta info for the method. diff --git a/core/metacling/src/TClingTypeInfo.cxx b/core/metacling/src/TClingTypeInfo.cxx index 8a4b3639b108b..477d6d710e21f 100644 --- a/core/metacling/src/TClingTypeInfo.cxx +++ b/core/metacling/src/TClingTypeInfo.cxx @@ -10,12 +10,12 @@ *************************************************************************/ /** \class TClingTypeInfo -Emulation of the CINT TypeInfo class. +Emulation of the historical CINT TypeInfo class. -The CINT C++ interpreter provides an interface to metadata about +The CINT C++ interpreter provided an interface to metadata about a type through the TypeInfo class. This class provides the same functionality, using an interface as close as possible to TypeInfo -but the type metadata comes from the Clang C++ compiler, not CINT. +but the type metadata comes from the Clang C++ compiler, not historical CINT. */ #include "TClingTypeInfo.h" diff --git a/core/metacling/src/TClingTypeInfo.h b/core/metacling/src/TClingTypeInfo.h index c68a9ba7b2cf2..ce9ee46599e0b 100644 --- a/core/metacling/src/TClingTypeInfo.h +++ b/core/metacling/src/TClingTypeInfo.h @@ -16,12 +16,12 @@ // // // TClingTypeInfo // // // -// Emulation of the CINT TypeInfo class. // +// Emulation of the historical CINT TypeInfo class. // // // -// The CINT C++ interpreter provides an interface to metadata about // +// The CINT C++ interpreter provided an interface to metadata about // // a type through the TypeInfo class. This class provides the same // // functionality, using an interface as close as possible to TypeInfo // -// but the type metadata comes from the Clang C++ compiler, not CINT. // +// but the type metadata comes from the Clang C++ compiler, not historical CINT. // // // ////////////////////////////////////////////////////////////////////////// @@ -67,7 +67,7 @@ class TClingTypeInfo final : public TClingDeclInfo { bool IsValid() const override { return !fQualType.isNull(); } const char *Name() const override; // Get name of type. long Property() const; // Get properties of type. - int RefType() const; // Get CINT reftype of type. + int RefType() const; // Get Cling reftype of type. int Size() const; // Get size in bytes of type. const char *TrueName(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const; // Get name of type with no typedefs. std::string NormalizedName(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const; // Get name of type with no typedefs. diff --git a/core/metacling/src/TClingTypedefInfo.cxx b/core/metacling/src/TClingTypedefInfo.cxx index cfd88b63cef2f..bb0908414e164 100644 --- a/core/metacling/src/TClingTypedefInfo.cxx +++ b/core/metacling/src/TClingTypedefInfo.cxx @@ -10,13 +10,13 @@ *************************************************************************/ /** \class TClingTypedefInfo -Emulation of the CINT TypedefInfo class. +Emulation of the historical CINT TypedefInfo class. -The CINT C++ interpreter provides an interface to metadata about +The CINT C++ interpreter provided an interface to metadata about a typedef through the TypedefInfo class. This class provides the same functionality, using an interface as close as possible to TypedefInfo but the typedef metadata comes from the Clang C++ -compiler, not CINT. +compiler, not historical CINT. */ #include "TClingTypedefInfo.h" @@ -122,7 +122,7 @@ int TClingTypedefInfo::InternalNext() // Advance to next usable decl, or return if // there is no next usable decl. if (fFirstTime) { - // The cint semantics are strange. + // The historical CINT Next() semantics were strange. fFirstTime = false; } else { @@ -221,7 +221,7 @@ int TClingTypedefInfo::Size() const // Note: This is an int64_t. clang::CharUnits::QuantityType quantity = context.getTypeSizeInChars(qt).getQuantity(); - // Truncate cast to fit the CINT interface. + // Truncate cast to fit the CINT interface. TODO: check with Cling return static_cast(quantity); } diff --git a/core/metacling/src/TClingTypedefInfo.h b/core/metacling/src/TClingTypedefInfo.h index 6b6fceb4d3f7a..2804ca50b697a 100644 --- a/core/metacling/src/TClingTypedefInfo.h +++ b/core/metacling/src/TClingTypedefInfo.h @@ -16,13 +16,13 @@ // // // TClingTypedefInfo // // // -// Emulation of the CINT TypedefInfo class. // +// Emulation of the historical CINT TypedefInfo class. // // // // The CINT C++ interpreter provides an interface to metadata about // // a typedef through the TypedefInfo class. This class provides the // // same functionality, using an interface as close as possible to // // TypedefInfo but the typedef metadata comes from the Clang C++ // -// compiler, not CINT. // +// compiler, not historical CINT. // // // ////////////////////////////////////////////////////////////////////////// @@ -47,7 +47,7 @@ class TClingTypedefInfo final : public TClingDeclInfo { private: cling::Interpreter *fInterp; // Cling interpreter, we do *not* own. - bool fFirstTime; // We need to skip the first increment to support the cint Next() semantics. + bool fFirstTime; // We need to skip the first increment to support the historical CINT Next() semantics. bool fDescend; // Flag for signaling the need to descend on this advancement. clang::DeclContext::decl_iterator fIter; // Current decl in scope. std::vector fIterStack; // Recursion stack for traversing nested scopes. diff --git a/core/rint/inc/TTabCom.h b/core/rint/inc/TTabCom.h index b1aa1eba3d2a2..da7db5a15eccb 100644 --- a/core/rint/inc/TTabCom.h +++ b/core/rint/inc/TTabCom.h @@ -126,10 +126,9 @@ class TTabCom { kCINT_stderr, // stderr kCINT_stdin, // stdin - // CINT "." instructions + // Cling "." instructions // the position of these guys is irrelevant since each of // these commands will always be the only command on the line. - kCINT_Edit, // .E kCINT_Load, // .L kCINT_Exec, // .x kCINT_EXec, // .X diff --git a/core/rint/src/TTabCom.cxx b/core/rint/src/TTabCom.cxx index 7977a54775b80..f6c9163bcb840 100644 --- a/core/rint/src/TTabCom.cxx +++ b/core/rint/src/TTabCom.cxx @@ -47,7 +47,7 @@ // 2. nothing is guaranteed to work on windows // // (for one thing, /bin/env and /etc/passwd are hardcoded) // // // -// 3. CINT shortcut #2 is deliberately not supported. // +// 3. CINT shortcut #2 is deliberately not supported. TODO: check Cling // // (using "operator.()" instead of "operator->()") // // // // 4. most identifiers (including C++ identifiers, usernames, // @@ -63,7 +63,7 @@ // use whitespace (~ whatever[TAB]) if you want to complete a global // // identifier. // // // -// 6. CINT shortcut #3 is not supported when trying to complete // +// 6. CINT (TODO Cling) shortcut #3 is not supported when trying to complete // // the name of a global object. (it is supported when trying to // // complete a member of a global object) // // // @@ -84,7 +84,7 @@ // this won't work... looks for a file in pwd starting with TDict // // // // 11. the prototypes tend to omit the word "const" a lot. // -// this is a problem with ROOT or CINT. // +// this is a problem with ROOT or CINT. TODO: Cling recheck // // // // 12. when listing ambiguous matches, only one column is used, // // even if there are many completions. // @@ -775,7 +775,7 @@ void TTabCom::AppendListOfFilesInDirectory(const char dirName[], pList->Add(new TObjString(dirName + fileName.Prepend("/"))); } // NOTE: - // with a path like "/usr/include:/usr/include/CC:$ROOTDIR/include:$ROOTDIR/cint/include:..." + // with a path like "/usr/include:/usr/include/CC:$ROOTDIR/include:..." // the above loop could get traversed 700 times or more. // ==> keep it minimal or it could cost whole seconds on slower machines. // also: TClonesArray doesn't help. @@ -801,7 +801,7 @@ TString TTabCom::DetermineClass(const char varName[]) /////////////////////////////////// // // note that because of the strange way this function works, - // CINT will print + // Cling will print // // Error: No symbol asdf in current scope FILE:/var/tmp/gaaa001HR LINE:1 // @@ -924,7 +924,7 @@ Bool_t TTabCom::ExcludedByFignore(TString s) ///[static utility function]///////////////////////////// /// /// returns a colon-separated string of directories -/// that CINT will search when you call `#include<...>` +/// that Cling will search when you call `#include<...>` /// /// returns empty string on failure. /// @@ -941,20 +941,13 @@ TString TTabCom::GetSysIncludePath() // Right now, there is no easy command to tell you about it. Instead, I can // describe it here. // - // 1) CINT first searches current working directory for #include "xxx" + // 1) Cling first searches current working directory for #include "xxx" // (#include does not) // - // 2) CINT searches include path directories given by -I option + // 2) Cling searches include path directories given by -I option // - // 3) CINT searches following standard include directories. - // $CINTSYSDIR/include - // $CINTSYSDIR/stl - // $CINTSYSDIR/msdev/include if VC++4.0 - // $CINTSYSDIR/sc/include if Symantec C++ + // 3) Cling searches following standard include directories. // /usr/include - // /usr/include/g++ if gcc,g++ - // /usr/include/CC if HP-UX - // /usr/include/codelibs if HP-UX // // .include command only displays 2). // @@ -1006,19 +999,8 @@ TString TTabCom::GetSysIncludePath() // 3) standard directories // ---------------------------------------------- -#ifndef CINTINCDIR - TString sCINTSYSDIR("$ROOTSYS/cint"); -#else - TString sCINTSYSDIR(CINTINCDIR); -#endif - path.Append(":" + sCINTSYSDIR + "/include"); -// path.Append(":"+CINTSYSDIR+"/stl"); -// path.Append(":"+CINTSYSDIR+"/msdev/include"); -// path.Append(":"+CINTSYSDIR+"/sc/include"); + path.Append(":/usr/include"); -// path.Append(":/usr/include/g++"); -// path.Append(":/usr/include/CC"); -// path.Append(":/usr/include/codelibs"); return path; } @@ -1627,7 +1609,6 @@ Int_t TTabCom::Hook(char *buf, int *pLoc, std::ostream& out) } break; - case kCINT_Edit: case kCINT_Load: case kCINT_Exec: case kCINT_EXec: @@ -2165,7 +2146,6 @@ void TTabCom::InitPatterns() SetPattern(kCINT_stderr, "; *2>>?.*$"); // stderr SetPattern(kCINT_stdin, "; *<.*$"); // stdin - SetPattern(kCINT_Edit, "^ *\\.E .*$"); SetPattern(kCINT_Load, "^ *\\.L .*$"); SetPattern(kCINT_Exec, "^ *\\.x +[-0-9_a-zA-Z~$./]*$"); SetPattern(kCINT_EXec, "^ *\\.X +[-0-9_a-zA-Z~$./]*$"); diff --git a/core/thread/src/TThread.cxx b/core/thread/src/TThread.cxx index 0c67a37fa422d..4efa706dcc728 100644 --- a/core/thread/src/TThread.cxx +++ b/core/thread/src/TThread.cxx @@ -52,8 +52,8 @@ void **volatile TThread::fgXArr = nullptr; volatile Int_t TThread::fgXAnb = 0; volatile Int_t TThread::fgXArt = 0; -static void CINT_alloc_lock() { gGlobalMutex->Lock(); } -static void CINT_alloc_unlock() { gGlobalMutex->UnLock(); } +static void Cling_alloc_lock() { gGlobalMutex->Lock(); } +static void Cling_alloc_unlock() { gGlobalMutex->UnLock(); } static TMutex *gMainInternalMutex = nullptr; @@ -335,8 +335,8 @@ void TThread::Init() // Create the single global mutex gGlobalMutex = new TMutex(kTRUE); // We need to make sure that gCling is initialized. - TInterpreter::Instance()->SetAlloclockfunc(CINT_alloc_lock); - gCling->SetAllocunlockfunc(CINT_alloc_unlock); + TInterpreter::Instance()->SetAlloclockfunc(Cling_alloc_lock); + gCling->SetAllocunlockfunc(Cling_alloc_unlock); // To avoid deadlocks, gInterpreterMutex and gROOTMutex need // to point at the same instance. diff --git a/core/unix/src/TUnixSystem.cxx b/core/unix/src/TUnixSystem.cxx index 0d4c3dbe1a183..d6f09e4a402be 100644 --- a/core/unix/src/TUnixSystem.cxx +++ b/core/unix/src/TUnixSystem.cxx @@ -2187,7 +2187,7 @@ int TUnixSystem::GetPid() void TUnixSystem::Exit(int code, Bool_t mode) { // Insures that the files and sockets are closed before any library is unloaded - // and before emptying CINT. + // and before emptying Cling. TROOT::ShutDown(); if (mode) diff --git a/core/winnt/src/TWinNTSystem.cxx b/core/winnt/src/TWinNTSystem.cxx index 669a115ecb233..c6cc2b9616234 100644 --- a/core/winnt/src/TWinNTSystem.cxx +++ b/core/winnt/src/TWinNTSystem.cxx @@ -3920,7 +3920,7 @@ HANDLE TWinNTSystem::GetProcess() void TWinNTSystem::Exit(int code, Bool_t mode) { // Insures that the files and sockets are closed before any library is unloaded - // and before emptying CINT. + // and before emptying Cling. // FIXME: Unify with TROOT::ShutDown. if (gROOT) { gROOT->CloseFiles(); diff --git a/man/man1/root-config.1 b/man/man1/root-config.1 index 9c250f3e3fc41..46f868494150c 100644 --- a/man/man1/root-config.1 +++ b/man/man1/root-config.1 @@ -20,8 +20,8 @@ CPPFLAGS += $(shell root-config \-\-cflags) LDLIBS += $(shell root-config \-\-libs) LDFLAGS += $(shell root-config \-\-ldflags) -%Cint.cxx:Include.h LinkDef.h - rootcint \-f $@ \-c $^ +%Cling.cxx:Include.h LinkDef.h + rootcling \-f $@ \-c $^ .fi .RE @@ -38,19 +38,19 @@ the directories you use \fBROOT\fR libraries, have in your lib_LTLIBRARIES = libFoo.la pkginclude_HEADERS = Foo.h -noinst_HEADERS = FooCint.h -libFoo_la_SOURCES = Foo.cxx FooCint.cxx +noinst_HEADERS = FooCling.h +libFoo_la_SOURCES = Foo.cxx FooCling.cxx libFoo_la_LDFLAGS = \-version-info 1:0 \-R @ROOTLIBDIR@ -libFoo_la_LDADD = \-lCore \-lCint @ROOTAUXLIBS@ +libFoo_la_LDADD = \-lCore @ROOTAUXLIBS@ -BUILT_SOURCES = FooCint.cxx FooCint.h +BUILT_SOURCES = FooCling.cxx FooCling.h AM_CPPFLAGS = \-I@ROOTINCDIR@ AM_LDFLAGS = \-L@ROOTLIBDIR@ -CLEANFILES = *Cint.cxx *Cint.h *~ core +CLEANFILES = *Cling.cxx *Cling.h *~ core -%Cint.cxx %Cint.h:Include.h LinkDef.h - @ROOTCINT@ \-f $*Cint.cxx -c $(INCLUDES) $(AM_CPPFLAGS) $^ +%Cling.cxx %Cling.h:Include.h LinkDef.h + @ROOTCLING@ \-f $*Cling.cxx -c $(INCLUDES) $(AM_CPPFLAGS) $^ .fi .RE @@ -119,8 +119,8 @@ full path to \fIroot-config\fR .B ROOTEXEC full path to \fIroot\fR .TP -.B ROOTCINT -full path to \fIrootcint\fR +.B ROOTCLING +full path to \fIrootcling\fR .TP .B ROOTLIBDIR Where the \fBROOT\fR libraries are @@ -254,7 +254,7 @@ Print alternative Fortran compiler specified when ROOT was built .B \-\-ld Print alternative Linker specified when ROOT was built .SH "SEE ALSO" -\fIroot\fR(1), \fIroot-cint\fR(1) +\fIroot\fR(1), \fIroot-cling\fR(1) .PP See also the \fBROOT\fR webpages: .UR http://root.cern