Develop and test enum

build/unix/gminimalHeaders.list

@@ -334,6 +334,8 @@ include/TEntryList.h
 include/TEntryListArray.h
 include/TEntryListBlock.h
 include/TEntryListFromFile.h
+include/TEnum.h
+include/TEnumConstant.h
 include/TEnv.h
 include/TError.h
 include/TEventIter.h

core/base/inc/TROOT.h

@@ -130,6 +130,7 @@ friend TROOT *ROOT::GetROOT2();
    TSeqCollection  *fProofs;              //List of proof sessions
    TSeqCollection  *fClipboard;           //List of clipbard objects
    TSeqCollection  *fDataSets;            //List of data sets (TDSet or TChain)
+   TCollection     *fEnums;               //List of enum types
    TProcessUUID    *fUUIDs;               //Pointer to TProcessID managing TUUIDs
    TFolder         *fRootFolder;          //top level folder //root
    TList           *fBrowsables;          //List of browsables
@@ -212,6 +213,7 @@ friend TROOT *ROOT::GetROOT2();
    TSeqCollection   *GetListOfProofs() const { return fProofs; }
    TSeqCollection   *GetClipboard() const { return fClipboard; }
    TSeqCollection   *GetListOfDataSets() const { return fDataSets; }
+   TCollection      *GetListOfEnums() const { return fEnums; }
    TList            *GetListOfBrowsables() const { return fBrowsables; }
    TDataType        *GetType(const char *name, Bool_t load = kFALSE) const;
    TFile            *GetFile() const { if (gDirectory != this) return gDirectory->GetFile(); else return 0;}

core/base/src/TContextMenu.cxx

@@ -159,7 +159,7 @@ void TContextMenu::Action(TClassMenuItem *menuitem)
 #else
                // It is a workaround of the "Dead lock under Windows
                char *cmd = Form("((TContextMenu *)0x%lx)->Execute((TObject *)0x%lx,"
-                                "(TMethod *)0x%lx,(TObjArray *)0);",
+                                "(TMethod *)0x%lx,\"\");",
                                 (Long_t)this,(Long_t)object,(Long_t)method);
                //Printf("%s", cmd);
                gROOT->ProcessLine(cmd);
@@ -171,8 +171,9 @@ void TContextMenu::Action(TClassMenuItem *menuitem)
 #else
                // It is a workaround of the "Dead lock under Windows
                char *cmd = Form("((TContextMenu *)0x%lx)->Execute((TObject *)0x%lx,"
-                                "(TMethod *)0x%lx,(TObjArray *)0);",
-                                (Long_t)this,(Long_t)object,(Long_t)method);
+                                "(TMethod *)0x%lx,(TObject*)0x%lx);",
+                                (Long_t)this,(Long_t)object,(Long_t)method,
+                                (Long_t)fSelectedObject);
                //Printf("%s", cmd);
                gROOT->ProcessLine(cmd);
                //Execute( object, method, (TObjArray *)NULL );

core/base/src/TROOT.cxx

@@ -399,6 +399,7 @@ TROOT::TROOT(const char *name, const char *title, VoidFuncPtr_t *initfunc)
    // Initialize interface to CINT C++ interpreter
    fVersionInt      = 0;  // check in TROOT dtor in case TCling fails
    fClasses         = 0;  // might be checked via TCling ctor
+   fEnums           = 0;
 
    fConfigOptions   = R__CONFIGUREOPTIONS;
    fConfigFeatures  = R__CONFIGUREFEATURES;
@@ -416,6 +417,7 @@ TROOT::TROOT(const char *name, const char *title, VoidFuncPtr_t *initfunc)
    //fIdMap           = new IdMap_t;
    fStreamerInfo    = new TObjArray(100);
    fClassGenerators = new TList;
+   fEnums           = new THashTable(200, 3); // FIXME: should be 1.2 * number of ROOT global enums at startup
 
    // initialize plugin manager early
    fPluginManager->LoadHandlersFromEnv(gEnv);
@@ -630,6 +632,7 @@ TROOT::~TROOT()
       SafeDelete(fGlobals);
       if (fGlobalFunctions) fGlobalFunctions->Delete();
       SafeDelete(fGlobalFunctions);
+      fEnums->Delete();
       fClasses->Delete();    SafeDelete(fClasses);     // TClass'es must be deleted last
 #endif
 

core/meta/inc/LinkDef.h

@@ -27,6 +27,8 @@
 #pragma link C++ class TDataMember;
 #pragma link C++ class TDataType;
 #pragma link C++ class TDictionary;
+#pragma link C++ class TEnumConstant+;
+#pragma link C++ class TEnum+;
 #pragma link C++ class TFunction;
 #pragma link C++ class ROOT::TSchemaMatch+;
 #pragma link C++ class ROOT::TSchemaRule+;

core/meta/inc/TClass.h

@@ -92,6 +92,7 @@ friend class ROOT::TGenericClassInfo;
    TList             *fRealData;        //linked list for persistent members including base classes
    TList             *fBase;            //linked list for base classes
    TList             *fData;            //linked list for data members
+   TList             *fEnums;           //linked list for the enums
    TList             *fMethod;          //linked list for methods
    TList             *fAllPubData;      //all public data members (including from base classes)
    TList             *fAllPubMethod;    //all public methods (including from base classes)
@@ -267,6 +268,7 @@ friend class ROOT::TGenericClassInfo;
       else return (fCurrentInfo=(TVirtualStreamerInfo*)(fStreamerInfo->At(fClassVersion)));
    }
    TList             *GetListOfDataMembers();
+   TList             *GetListOfEnums();
    TList             *GetListOfBases();
    TList             *GetListOfMethods();
    TList             *GetListOfRealData() const { return fRealData; }

core/meta/inc/TEnum.h

@@ -0,0 +1,56 @@
+// @(#)root/meta:$Id$
+// Author: Bianca-Cristina Cristescu   09/07/13
+
+/*************************************************************************
+ * Copyright (C) 1995-2013, Rene Brun and Fons Rademakers.               *
+ * All rights reserved.                                                  *
+ *                                                                       *
+ * For the licensing terms see $ROOTSYS/LICENSE.                         *
+ * For the list of contributors see $ROOTSYS/README/CREDITS.             *
+ *************************************************************************/
+
+#ifndef ROOT_TEnum
+#define ROOT_TEnum
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// TEnum                                                                //
+//                                                                      //
+// TEnum class defines enum type.                                       //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef ROOT_TNamed
+#include "TNamed.h"
+#endif
+#ifndef ROOT_THashList
+#include "THashList.h"
+#endif
+#ifndef ROOT_TString
+#include "TString.h"
+#endif
+
+class TEnumConstant;
+
+class TEnum : public TNamed {
+
+private:
+   THashList fConstantList;     //list of constants the enum type
+   void*     fInfo;             //interpreter implementation provided declaration
+
+public:
+
+   TEnum(): fInfo(0) {}
+   TEnum(const char* name, bool isGlobal, void* info);
+   virtual ~TEnum();
+
+   void AddConstant(TEnumConstant* constant);
+   const TSeqCollection* GetConstants() const { return &fConstantList; }
+   const TEnumConstant* GetConstant(const char* name) const {
+      return (TEnumConstant*) fConstantList.FindObject(name);
+   }
+
+   ClassDef(TEnum,1)  //Enum type class
+};
+
+#endif

core/meta/inc/TEnumConstant.h

@@ -0,0 +1,46 @@
+// @(#)root/meta:$Id$
+// Author: Bianca-Cristina Cristescu   09/07/13
+
+/*************************************************************************
+ * Copyright (C) 1995-2013, Rene Brun and Fons Rademakers.               *
+ * All rights reserved.                                                  *
+ *                                                                       *
+ * For the licensing terms see $ROOTSYS/LICENSE.                         *
+ * For the list of contributors see $ROOTSYS/README/CREDITS.             *
+ *************************************************************************/
+
+#ifndef ROOT_TEnumConstant
+#define ROOT_TEnumConstant
+
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// TEnumConstant                                                        //
+//                                                                      //
+// TEnumConstant class defines a constant in the TEnum type.            //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef ROOT_TGlobal
+#include "TGlobal.h"
+#endif
+
+class TEnum;
+
+class TEnumConstant : public TGlobal {
+private:
+   const TEnum       *fEnum;  //the enum type
+   Long64_t           fValue; //the value for the constant
+
+public:
+   TEnumConstant(): fEnum(0), fValue(-1) {}
+   TEnumConstant(DataMemberInfo_t *info, const char* name, Long64_t value, TEnum* type);
+   virtual ~TEnumConstant();
+
+   Long64_t     GetValue() const { return fValue; }
+   const TEnum *GetType() const { return fEnum; }
+
+   ClassDef(TEnumConstant,1)  //Enum type constant
+};
+
+#endif

core/meta/inc/TInterpreter.h

@@ -113,6 +113,7 @@ class TInterpreter : public TNamed {
    virtual Bool_t   CheckClassTemplate(const char *name) = 0;
    virtual Long_t   Calc(const char *line, EErrorCode* error = 0) = 0;
    virtual void     CreateListOfBaseClasses(TClass *cl) const = 0;
+   virtual void     CreateListOfEnums(TClass *cl) const = 0;
    virtual void     CreateListOfDataMembers(TClass *cl) const = 0;
    virtual void     CreateListOfMethods(TClass *cl) const = 0;
    virtual void     CreateListOfMethodArgs(TFunction *m) const = 0;

core/meta/src/TClass.cxx

@@ -771,7 +771,7 @@ ClassImp(TClass)
 TClass::TClass() :
    TDictionary(),
    fStreamerInfo(0), fConversionStreamerInfo(0), fRealData(0),
-   fBase(0), fData(0), fMethod(0), fAllPubData(0), fAllPubMethod(0),
+   fBase(0), fData(0), fEnums(0), fMethod(0), fAllPubData(0), fAllPubMethod(0),
    fClassMenuList(0),
    fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
    fInstanceCount(0), fOnHeap(0),
@@ -797,7 +797,7 @@ TClass::TClass() :
 TClass::TClass(const char *name, Bool_t silent) :
    TDictionary(name),
    fStreamerInfo(0), fConversionStreamerInfo(0), fRealData(0),
-   fBase(0), fData(0), fMethod(0), fAllPubData(0), fAllPubMethod(0),
+   fBase(0), fData(0), fEnums(0), fMethod(0), fAllPubData(0), fAllPubMethod(0),
    fClassMenuList(0),
    fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
    fInstanceCount(0), fOnHeap(0),
@@ -846,7 +846,7 @@ TClass::TClass(const char *name, Version_t cversion,
                const char *dfil, const char *ifil, Int_t dl, Int_t il, Bool_t silent) :
    TDictionary(name),
    fStreamerInfo(0), fConversionStreamerInfo(0), fRealData(0),
-   fBase(0), fData(0), fMethod(0), fAllPubData(0), fAllPubMethod(0),
+   fBase(0), fData(0), fEnums(0), fMethod(0), fAllPubData(0), fAllPubMethod(0),
    fClassMenuList(0),
    fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
    fInstanceCount(0), fOnHeap(0),
@@ -875,7 +875,7 @@ TClass::TClass(const char *name, Version_t cversion,
                Bool_t silent) :
    TDictionary(name),
    fStreamerInfo(0), fConversionStreamerInfo(0), fRealData(0),
-   fBase(0), fData(0), fMethod(0), fAllPubData(0), fAllPubMethod(0),
+   fBase(0), fData(0), fEnums(0), fMethod(0), fAllPubData(0), fAllPubMethod(0),
    fClassMenuList(0),
    fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
    fInstanceCount(0), fOnHeap(0),
@@ -1129,6 +1129,7 @@ TClass::TClass(const TClass& cl) :
   fRealData(cl.fRealData),
   fBase(cl.fBase),
   fData(cl.fData),
+  fEnums(cl.fEnums),
   fMethod(cl.fMethod),
   fAllPubData(cl.fAllPubData),
   fAllPubMethod(cl.fAllPubMethod),
@@ -1231,6 +1232,10 @@ TClass::~TClass()
       fData->Delete();
    delete fData;   fData = 0;
 
+   if (fEnums)
+      fEnums->Delete();
+   delete fEnums; fEnums = 0;
+
    if (fMethod)
       fMethod->Delete();
    delete fMethod;   fMethod=0;
@@ -2983,6 +2988,26 @@ TList *TClass::GetListOfBases()
    return fBase;
 }
 
+//______________________________________________________________________________
+TList *TClass::GetListOfEnums()
+{
+   // Return list containing the TEnums of a class.
+
+   R__LOCKGUARD(gClingMutex);
+   if (!fClassInfo) {
+      if (!fEnums) fEnums = new TList;
+      return fEnums;
+   }
+
+   if (!fEnums) {
+      if (!gInterpreter)
+         Fatal("GetListOfEnums", "gInterpreter not initialized");
+
+      gInterpreter->CreateListOfEnums(this);
+   }
+   return fEnums;
+}
+
 //______________________________________________________________________________
 TList *TClass::GetListOfDataMembers()
 {
@@ -3241,6 +3266,10 @@ void TClass::ResetCaches()
       fData->Delete();
    delete fData;   fData = 0;
 
+   if (fEnums)
+      fEnums->Delete();
+   delete fEnums;   fEnums = 0;
+
    if (fMethod)
       fMethod->Delete();
    delete fMethod;   fMethod=0;