From fa6654db0883984f369b6a8014a6be53c85ba525 Mon Sep 17 00:00:00 2001 From: Zhe Zhang Date: Tue, 3 Nov 2015 22:11:53 -0600 Subject: [PATCH 01/18] Added flag buffBigEndian into frombuf() tobuf() --- core/base/inc/Bytes.h | 367 +++++++++++++++++++++++++++++++++++++--- core/base/inc/TBuffer.h | 4 +- 2 files changed, 350 insertions(+), 21 deletions(-) diff --git a/core/base/inc/Bytes.h b/core/base/inc/Bytes.h index 8235e5cbb0e18..983ac3caa7563 100644 --- a/core/base/inc/Bytes.h +++ b/core/base/inc/Bytes.h @@ -67,9 +67,10 @@ inline void tobuf(char *&buf, UChar_t x) *buf++ = x; } -inline void tobuf(char *&buf, UShort_t x) +inline void tobuf(char *&buf, UShort_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP +if(buffBigEndian) { # if defined(R__USEASMSWAP) *((UShort_t *)buf) = Rbswap_16(x); # else @@ -79,15 +80,31 @@ inline void tobuf(char *&buf, UShort_t x) buf[0] = sw[1]; buf[1] = sw[0]; # endif +} else { + memcpy(buf, &x, sizeof(UShort_t)); +} #else +if(buffBigEndian) { memcpy(buf, &x, sizeof(UShort_t)); +} else { +# if defined(R__USEASMSWAP) + *((UShort_t *)buf) = Rbswap_16(x); +# else + // To work around a stupid optimization bug in MSVC++ 6.0 + const UShort_t *intermediary = &x; + char *sw = (char *) intermediary; + buf[0] = sw[1]; + buf[1] = sw[0]; +# endif +} #endif buf += sizeof(UShort_t); } -inline void tobuf(char *&buf, UInt_t x) +inline void tobuf(char *&buf, UInt_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP +if(buffBigEndian) { # if defined(R__USEASMSWAP) *((UInt_t *)buf) = Rbswap_32(x); # else @@ -99,15 +116,33 @@ inline void tobuf(char *&buf, UInt_t x) buf[2] = sw[1]; buf[3] = sw[0]; # endif +} else { + memcpy(buf, &x, sizeof(UInt_t)); +} #else +if(buffBigEndian) { memcpy(buf, &x, sizeof(UInt_t)); +} else { +# if defined(R__USEASMSWAP) + *((UInt_t *)buf) = Rbswap_32(x); +# else + // To work around a stupid optimization bug in MSVC++ 6.0 + const UInt_t *intermediary = &x; + char *sw = (char *)intermediary; + buf[0] = sw[3]; + buf[1] = sw[2]; + buf[2] = sw[1]; + buf[3] = sw[0]; +# endif +} #endif buf += sizeof(UInt_t); } -inline void tobuf(char *&buf, ULong_t x) +inline void tobuf(char *&buf, ULong_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP +if(buffBigEndian) { // To work around a stupid optimization bug in MSVC++ 6.0 const ULong_t *intermediary = &x; char *sw = (char *)intermediary; @@ -130,7 +165,19 @@ inline void tobuf(char *&buf, ULong_t x) buf[6] = sw[1]; buf[7] = sw[0]; } +} else { + if (sizeof(ULong_t) == 8) { + memcpy(buf, &x, 8); + } else { + buf[0] = 0; + buf[1] = 0; + buf[2] = 0; + buf[3] = 0; + memcpy(buf+4, &x, 4); + } +} #else +if(buffBigEndian) { if (sizeof(ULong_t) == 8) { memcpy(buf, &x, 8); } else { @@ -140,13 +187,37 @@ inline void tobuf(char *&buf, ULong_t x) buf[3] = 0; memcpy(buf+4, &x, 4); } +} else { + const ULong_t *intermediary = &x; + char *sw = (char *)intermediary; + if (sizeof(ULong_t) == 8) { + buf[0] = sw[7]; + buf[1] = sw[6]; + buf[2] = sw[5]; + buf[3] = sw[4]; + buf[4] = sw[3]; + buf[5] = sw[2]; + buf[6] = sw[1]; + buf[7] = sw[0]; + } else { + buf[0] = 0; + buf[1] = 0; + buf[2] = 0; + buf[3] = 0; + buf[4] = sw[3]; + buf[5] = sw[2]; + buf[6] = sw[1]; + buf[7] = sw[0]; + } +} #endif buf += 8; } -inline void tobuf(char *&buf, Long_t x) +inline void tobuf(char *&buf, Long_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP +if(buffBigEndian) { // To work around a stupid optimization bug in MSVC++ 6.0 const Long_t *intermediary = &x; char *sw = (char *)intermediary; @@ -176,7 +247,26 @@ inline void tobuf(char *&buf, Long_t x) buf[6] = sw[1]; buf[7] = sw[0]; } +} else { + if (sizeof(Long_t) == 8) { + memcpy(buf, &x, 8); + } else { + if (x < 0) { + buf[0] = (char) -1; + buf[1] = (char) -1; + buf[2] = (char) -1; + buf[3] = (char) -1; + } else { + buf[0] = 0; + buf[1] = 0; + buf[2] = 0; + buf[3] = 0; + } + memcpy(buf+4, &x, 4); + } +} #else +if(buffBigEndian) { if (sizeof(Long_t) == 8) { memcpy(buf, &x, 8); } else { @@ -193,13 +283,44 @@ inline void tobuf(char *&buf, Long_t x) } memcpy(buf+4, &x, 4); } +} else { + const Long_t *intermediary = &x; + char *sw = (char *)intermediary; + if (sizeof(Long_t) == 8) { + buf[0] = sw[7]; + buf[1] = sw[6]; + buf[2] = sw[5]; + buf[3] = sw[4]; + buf[4] = sw[3]; + buf[5] = sw[2]; + buf[6] = sw[1]; + buf[7] = sw[0]; + } else { + if (x < 0) { + buf[0] = (char) -1; + buf[1] = (char) -1; + buf[2] = (char) -1; + buf[3] = (char) -1; + } else { + buf[0] = 0; + buf[1] = 0; + buf[2] = 0; + buf[3] = 0; + } + buf[4] = sw[3]; + buf[5] = sw[2]; + buf[6] = sw[1]; + buf[7] = sw[0]; + } +} #endif buf += 8; } -inline void tobuf(char *&buf, ULong64_t x) +inline void tobuf(char *&buf, ULong64_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP +if(buffBigEndian) { # if defined(R__USEASMSWAP) *((ULong64_t *)buf) = Rbswap_64(x); # else @@ -215,15 +336,37 @@ inline void tobuf(char *&buf, ULong64_t x) buf[6] = sw[1]; buf[7] = sw[0]; # endif +} else { + memcpy(buf, &x, sizeof(ULong64_t)); +} #else +if(buffBigEndian) { memcpy(buf, &x, sizeof(ULong64_t)); +} else { +# if defined(R__USEASMSWAP) + *((ULong64_t *)buf) = Rbswap_64(x); +# else + // To work around a stupid optimization bug in MSVC++ 6.0 + const ULong64_t *intermediary = &x; + char *sw = (char *)intermediary; + buf[0] = sw[7]; + buf[1] = sw[6]; + buf[2] = sw[5]; + buf[3] = sw[4]; + buf[4] = sw[3]; + buf[5] = sw[2]; + buf[6] = sw[1]; + buf[7] = sw[0]; +# endif +} #endif buf += sizeof(ULong64_t); } -inline void tobuf(char *&buf, Float_t x) +inline void tobuf(char *&buf, Float_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP +if(buffBigEndian) { # if defined(R__USEASMSWAP) union { volatile UInt_t i; @@ -242,15 +385,40 @@ inline void tobuf(char *&buf, Float_t x) buf[2] = u.c[1]; buf[3] = u.c[0]; # endif +} else { + memcpy(buf, &x, sizeof(Float_t)); +} #else +if(buffBigEndian) { memcpy(buf, &x, sizeof(Float_t)); +} else { +# if defined(R__USEASMSWAP) + union { + volatile UInt_t i; + volatile Float_t f; + } u; + u.f = x; + *((UInt_t *)buf) = Rbswap_32(u.i); +# else + union { + volatile char c[4]; + volatile Float_t f; + } u; + u.f = x; + buf[0] = u.c[3]; + buf[1] = u.c[2]; + buf[2] = u.c[1]; + buf[3] = u.c[0]; +# endif +} #endif buf += sizeof(Float_t); } -inline void tobuf(char *&buf, Double_t x) +inline void tobuf(char *&buf, Double_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP +if(buffBigEndian) { # if defined(R__USEASMSWAP) union { volatile ULong64_t l; @@ -273,8 +441,36 @@ inline void tobuf(char *&buf, Double_t x) buf[6] = u.c[1]; buf[7] = u.c[0]; # endif +} else { + memcpy(buf, &x, sizeof(Double_t)); +} #else +if(buffBigEndian) { memcpy(buf, &x, sizeof(Double_t)); +} else { +# if defined(R__USEASMSWAP) + union { + volatile ULong64_t l; + volatile Double_t d; + } u; + u.d = x; + *((ULong64_t *)buf) = Rbswap_64(u.l); +# else + union { + volatile char c[8]; + volatile Double_t d; + } u; + u.d = x; + buf[0] = u.c[7]; + buf[1] = u.c[6]; + buf[2] = u.c[5]; + buf[3] = u.c[4]; + buf[4] = u.c[3]; + buf[5] = u.c[2]; + buf[6] = u.c[1]; + buf[7] = u.c[0]; +# endif +} #endif buf += sizeof(Double_t); } @@ -291,9 +487,10 @@ inline void frombuf(char *&buf, UChar_t *x) *x = *buf++; } -inline void frombuf(char *&buf, UShort_t *x) +inline void frombuf(char *&buf, UShort_t *x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP +if(buffBigEndian) { # if defined(R__USEASMSWAP) *x = Rbswap_16(*((UShort_t *)buf)); # else @@ -301,15 +498,29 @@ inline void frombuf(char *&buf, UShort_t *x) sw[0] = buf[1]; sw[1] = buf[0]; # endif +} else { + memcpy(x, buf, sizeof(UShort_t)); +} #else +if(buffBigEndian) { memcpy(x, buf, sizeof(UShort_t)); +} else { +# if defined(R__USEASMSWAP) + *x = Rbswap_16(*((UShort_t *)buf)); +# else + char *sw = (char *)x; + sw[0] = buf[1]; + sw[1] = buf[0]; +# endif +} #endif buf += sizeof(UShort_t); } -inline void frombuf(char *&buf, UInt_t *x) +inline void frombuf(char *&buf, UInt_t *x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP +if(buffBigEndian) { # if defined(R__USEASMSWAP) *x = Rbswap_32(*((UInt_t *)buf)); # else @@ -319,15 +530,31 @@ inline void frombuf(char *&buf, UInt_t *x) sw[2] = buf[1]; sw[3] = buf[0]; # endif +} else { + memcpy(x, buf, sizeof(UInt_t)); +} #else +if(buffBigEndian) { memcpy(x, buf, sizeof(UInt_t)); +} else { +# if defined(R__USEASMSWAP) + *x = Rbswap_32(*((UInt_t *)buf)); +# else + char *sw = (char *)x; + sw[0] = buf[3]; + sw[1] = buf[2]; + sw[2] = buf[1]; + sw[3] = buf[0]; +# endif +} #endif buf += sizeof(UInt_t); } -inline void frombuf(char *&buf, ULong_t *x) +inline void frombuf(char *&buf, ULong_t *x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP +if(buffBigEndian) { char *sw = (char *)x; if (sizeof(ULong_t) == 8) { sw[0] = buf[7]; @@ -344,19 +571,46 @@ inline void frombuf(char *&buf, ULong_t *x) sw[2] = buf[5]; sw[3] = buf[4]; } +} else { + if (sizeof(ULong_t) == 8) { + memcpy(x, buf, 8); + } else { + memcpy(x, buf+4, 4); + } +} #else +if(buffBigEndian) { if (sizeof(ULong_t) == 8) { memcpy(x, buf, 8); } else { memcpy(x, buf+4, 4); } +} else { + char *sw = (char *)x; + if (sizeof(ULong_t) == 8) { + sw[0] = buf[7]; + sw[1] = buf[6]; + sw[2] = buf[5]; + sw[3] = buf[4]; + sw[4] = buf[3]; + sw[5] = buf[2]; + sw[6] = buf[1]; + sw[7] = buf[0]; + } else { + sw[0] = buf[7]; + sw[1] = buf[6]; + sw[2] = buf[5]; + sw[3] = buf[4]; + } +} #endif buf += 8; } -inline void frombuf(char *&buf, ULong64_t *x) +inline void frombuf(char *&buf, ULong64_t *x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP +if(buffBigEndian) { # if defined(R__USEASMSWAP) *x = Rbswap_64(*((ULong64_t *)buf)); # else @@ -370,15 +624,35 @@ inline void frombuf(char *&buf, ULong64_t *x) sw[6] = buf[1]; sw[7] = buf[0]; # endif +} else { + memcpy(x, buf, sizeof(ULong64_t)); +} #else +if(buffBigEndian) { memcpy(x, buf, sizeof(ULong64_t)); +} else { +# if defined(R__USEASMSWAP) + *x = Rbswap_64(*((ULong64_t *)buf)); +# else + char *sw = (char *)x; + sw[0] = buf[7]; + sw[1] = buf[6]; + sw[2] = buf[5]; + sw[3] = buf[4]; + sw[4] = buf[3]; + sw[5] = buf[2]; + sw[6] = buf[1]; + sw[7] = buf[0]; +# endif +} #endif buf += sizeof(ULong64_t); } -inline void frombuf(char *&buf, Float_t *x) +inline void frombuf(char *&buf, Float_t *x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP +if(buffBigEndian) { # if defined(R__USEASMSWAP) // Use a union to allow strict-aliasing union { @@ -398,15 +672,40 @@ inline void frombuf(char *&buf, Float_t *x) u.c[3] = buf[0]; *x = u.f; # endif +} else { + memcpy(x, buf, sizeof(Float_t)); +} #else +if(buffBigEndian) { memcpy(x, buf, sizeof(Float_t)); +} else { +# if defined(R__USEASMSWAP) + union { + volatile UInt_t i; + volatile Float_t f; + } u; + u.i = Rbswap_32(*((UInt_t *)buf)); + *x = u.f; +# else + union { + volatile char c[4]; + volatile Float_t f; + } u; + u.c[0] = buf[3]; + u.c[1] = buf[2]; + u.c[2] = buf[1]; + u.c[3] = buf[0]; + *x = u.f; +# endif +} #endif buf += sizeof(Float_t); } -inline void frombuf(char *&buf, Double_t *x) +inline void frombuf(char *&buf, Double_t *x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP +if(buffBigEndian) { # if defined(R__USEASMSWAP) // Use a union to allow strict-aliasing union { @@ -430,22 +729,50 @@ inline void frombuf(char *&buf, Double_t *x) u.c[7] = buf[0]; *x = u.d; # endif +} else { + memcpy(x, buf, sizeof(Double_t)); +} #else +if(buffBigEndian) { memcpy(x, buf, sizeof(Double_t)); +} else { +# if defined(R__USEASMSWAP) + union { + volatile ULong64_t l; + volatile Double_t d; + } u; + u.l = Rbswap_64(*((ULong64_t *)buf)); + *x = u.d; +# else + union { + volatile char c[8]; + volatile Double_t d; + } u; + u.c[0] = buf[7]; + u.c[1] = buf[6]; + u.c[2] = buf[5]; + u.c[3] = buf[4]; + u.c[4] = buf[3]; + u.c[5] = buf[2]; + u.c[6] = buf[1]; + u.c[7] = buf[0]; + *x = u.d; +# endif +} #endif buf += sizeof(Double_t); } inline void tobuf(char *&buf, Char_t x) { tobuf(buf, (UChar_t) x); } -inline void tobuf(char *&buf, Short_t x) { tobuf(buf, (UShort_t) x); } -inline void tobuf(char *&buf, Int_t x) { tobuf(buf, (UInt_t) x); } -inline void tobuf(char *&buf, Long64_t x) { tobuf(buf, (ULong64_t) x); } +inline void tobuf(char *&buf, Short_t x, Bool_t buffBigEndian = kTRUE) { tobuf(buf, (UShort_t) x, buffBigEndian); } +inline void tobuf(char *&buf, Int_t x, Bool_t buffBigEndian = kTRUE) { tobuf(buf, (UInt_t) x, buffBigEndian); } +inline void tobuf(char *&buf, Long64_t x, Bool_t buffBigEndian = kTRUE) { tobuf(buf, (ULong64_t) x, buffBigEndian); } inline void frombuf(char *&buf, Char_t *x) { frombuf(buf, (UChar_t *) x); } -inline void frombuf(char *&buf, Short_t *x) { frombuf(buf, (UShort_t *) x); } -inline void frombuf(char *&buf, Int_t *x) { frombuf(buf, (UInt_t *) x); } -inline void frombuf(char *&buf, Long_t *x) { frombuf(buf, (ULong_t *) x); } -inline void frombuf(char *&buf, Long64_t *x) { frombuf(buf, (ULong64_t *) x); } +inline void frombuf(char *&buf, Short_t *x, Bool_t buffBigEndian = kTRUE) { frombuf(buf, (UShort_t *) x, buffBigEndian); } +inline void frombuf(char *&buf, Int_t *x, Bool_t buffBigEndian = kTRUE) { frombuf(buf, (UInt_t *) x, buffBigEndian); } +inline void frombuf(char *&buf, Long_t *x, Bool_t buffBigEndian = kTRUE) { frombuf(buf, (ULong_t *) x, buffBigEndian); } +inline void frombuf(char *&buf, Long64_t *x, Bool_t buffBigEndian = kTRUE) { frombuf(buf, (ULong64_t *) x, buffBigEndian); } //______________________________________________________________________________ diff --git a/core/base/inc/TBuffer.h b/core/base/inc/TBuffer.h index 1a1ec15dba6b4..1e255a8ef1e43 100644 --- a/core/base/inc/TBuffer.h +++ b/core/base/inc/TBuffer.h @@ -50,13 +50,14 @@ class TBuffer : public TObject { char *fBuffer; //Buffer used to store objects char *fBufCur; //Current position in buffer char *fBufMax; //End of buffer + Bool_t fBufEndian; //Big endian is default (0) TObject *fParent; //Pointer to parent object owning this buffer ReAllocCharFun_t fReAllocFunc; //! Realloc function to be used when extending the buffer. CacheList_t fCacheStack; //Stack of pointers to the cache where to temporarily store the value of 'missing' data members // Default ctor TBuffer() : TObject(), fMode(0), fVersion(0), fBufSize(0), fBuffer(0), - fBufCur(0), fBufMax(0), fParent(0), fReAllocFunc(0), fCacheStack(0,(TVirtualArray*)0) {} + fBufCur(0), fBufMax(0), fBufEndian(0), fParent(0), fReAllocFunc(0), fCacheStack(0,(TVirtualArray*)0) {} // TBuffer objects cannot be copied or assigned TBuffer(const TBuffer &); // not implemented @@ -70,6 +71,7 @@ class TBuffer : public TObject { public: enum EMode { kRead = 0, kWrite = 1 }; + enum EEndian { kBig = 0, kLittle = 1 }; enum { kIsOwner = BIT(16) }; //if set TBuffer owns fBuffer enum { kCannotHandleMemberWiseStreaming = BIT(17)}; //if set TClonesArray should not use member wise streaming enum { kInitialSize = 1024, kMinimalSize = 128 }; From 0704a6be2f8dcf7683af18422ea7f64848ccc41d Mon Sep 17 00:00:00 2001 From: Zhe Zhang Date: Fri, 13 Nov 2015 18:48:58 -0600 Subject: [PATCH 02/18] Change tobuf()/frombuf() functions --- core/base/inc/TBuffer.h | 6 +- core/base/inc/TROOT.h | 3 + core/base/inc/TUUID.h | 4 +- core/base/src/TNamed.cxx | 6 +- core/base/src/TROOT.cxx | 4 +- core/base/src/TUUID.cxx | 32 ++++---- io/io/inc/TBufferFile.h | 30 ++++---- io/io/inc/TFile.h | 2 +- io/io/inc/TFree.h | 2 +- io/io/src/TBufferFile.cxx | 140 ++++++++++++++++++++++++++--------- io/io/src/TDirectoryFile.cxx | 28 +++---- io/io/src/TFile.cxx | 18 ++--- io/io/src/TFree.cxx | 14 ++-- io/io/src/TKey.cxx | 32 ++++---- 14 files changed, 201 insertions(+), 120 deletions(-) diff --git a/core/base/inc/TBuffer.h b/core/base/inc/TBuffer.h index 1e255a8ef1e43..a5fc99db17d28 100644 --- a/core/base/inc/TBuffer.h +++ b/core/base/inc/TBuffer.h @@ -44,13 +44,13 @@ class TBuffer : public TObject { protected: typedef std::vector CacheList_t; + Bool_t fBufEndian; //Big endian is default (0) Bool_t fMode; //Read or write mode Int_t fVersion; //Buffer format version Int_t fBufSize; //Size of buffer char *fBuffer; //Buffer used to store objects char *fBufCur; //Current position in buffer char *fBufMax; //End of buffer - Bool_t fBufEndian; //Big endian is default (0) TObject *fParent; //Pointer to parent object owning this buffer ReAllocCharFun_t fReAllocFunc; //! Realloc function to be used when extending the buffer. CacheList_t fCacheStack; //Stack of pointers to the cache where to temporarily store the value of 'missing' data members @@ -86,6 +86,10 @@ class TBuffer : public TObject { Bool_t IsWriting() const { return (fMode & kWrite) != 0; } void SetReadMode(); void SetWriteMode(); + Bool_t IsBigEndian() const { return fBufEndian == 0; } + Bool_t IsLittleEndian() const { return fBufEndian == 1; } + void SetBigEndian() { fBufEndian = 0; } + void SetLittleEndian() { fBufEndian = 1; } void SetBuffer(void *buf, UInt_t bufsiz = 0, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0); ReAllocCharFun_t GetReAllocFunc() const; void SetReAllocFunc(ReAllocCharFun_t reallocfunc = 0); diff --git a/core/base/inc/TROOT.h b/core/base/inc/TROOT.h index 52779aaf1d914..206d94e574f36 100644 --- a/core/base/inc/TROOT.h +++ b/core/base/inc/TROOT.h @@ -123,6 +123,7 @@ friend TROOT *ROOT::Internal::GetROOT2(); Bool_t fInterrupt; //True if macro should be interrupted Bool_t fEscape; //True if ESC has been pressed Bool_t fExecutingMacro; //True while executing a TMacro + Bool_t fBigEndian; //True if user define the data format as Big Endian Int_t fEditorMode; //Current Editor mode const TObject *fPrimitive; //Currently selected primitive TVirtualPad *fSelectPad; //Currently selected pad @@ -264,6 +265,7 @@ friend TROOT *ROOT::Internal::GetROOT2(); void Idle(UInt_t idleTimeInSec, const char *command = 0); Int_t IgnoreInclude(const char *fname, const char *expandedfname); Bool_t IsBatch() const { return fBatch; } + Bool_t IsBigEndian() const { return fBigEndian; } Bool_t IsExecutingMacro() const { return fExecutingMacro; } Bool_t IsFolder() const { return kTRUE; } Bool_t IsInterrupted() const { return fInterrupt; } @@ -297,6 +299,7 @@ friend TROOT *ROOT::Internal::GetROOT2(); void SaveContext(); void SetApplication(TApplication *app) { fApplication = app; } void SetBatch(Bool_t batch = kTRUE) { fBatch = batch; } + void SetBigEndian(Bool_t bigendian = kTRUE) { fBigEndian = bigendian; } void SetCutClassName(const char *name = "TCutG"); void SetDefCanvasName(const char *name = "c1") { fDefCanvasName = name; } void SetEditHistograms(Bool_t flag = kTRUE) { fEditHistograms = flag; } diff --git a/core/base/inc/TUUID.h b/core/base/inc/TUUID.h index 6360ddb822096..5f17de11d1e40 100644 --- a/core/base/inc/TUUID.h +++ b/core/base/inc/TUUID.h @@ -82,8 +82,8 @@ class TUUID { void SetUUIDNumber(UInt_t index) { fUUIDIndex = index; } void StreamerV1(TBuffer &b); - void FillBuffer(char *&buffer); - void ReadBuffer(char *&buffer); + void FillBuffer(char *&buffer, Bool_t buffBigEndian=kTRUE); + void ReadBuffer(char *&buffer, Bool_t buffBigEndian=kTRUE); Int_t Sizeof() const { return 18; } ClassDef(TUUID,1) // Universally Unique IDentifier diff --git a/core/base/src/TNamed.cxx b/core/base/src/TNamed.cxx index c0df4b721fddb..3b2dbf36a8b3a 100644 --- a/core/base/src/TNamed.cxx +++ b/core/base/src/TNamed.cxx @@ -90,10 +90,10 @@ void TNamed::Copy(TObject &obj) const //////////////////////////////////////////////////////////////////////////////// /// Encode TNamed into output buffer. -void TNamed::FillBuffer(char *&buffer) +void TNamed::FillBuffer(char *&buffer, Bool_t buffBigEndian = kTRUE) { - fName.FillBuffer(buffer); - fTitle.FillBuffer(buffer); + fName.FillBuffer(buffer, buffBigEndian); + fTitle.FillBuffer(buffer, buffBigEndian); } //////////////////////////////////////////////////////////////////////////////// diff --git a/core/base/src/TROOT.cxx b/core/base/src/TROOT.cxx index af840154af10f..2f392826dbe2e 100644 --- a/core/base/src/TROOT.cxx +++ b/core/base/src/TROOT.cxx @@ -474,7 +474,7 @@ ClassImp(TROOT) TROOT::TROOT() : TDirectory(), fLineIsProcessing(0), fVersion(0), fVersionInt(0), fVersionCode(0), fVersionDate(0), fVersionTime(0), fBuiltDate(0), fBuiltTime(0), - fTimer(0), fApplication(0), fInterpreter(0), fBatch(kTRUE), fEditHistograms(kTRUE), + fTimer(0), fApplication(0), fInterpreter(0), fBatch(kTRUE), fBigEndian(kTRUE), fEditHistograms(kTRUE), fFromPopUp(kTRUE),fMustClean(kTRUE),fReadingObject(kFALSE),fForceStyle(kFALSE), fInterrupt(kFALSE),fEscape(kFALSE),fExecutingMacro(kFALSE),fEditorMode(0), fPrimitive(0),fSelectPad(0),fClasses(0),fTypes(0),fGlobals(0),fGlobalFunctions(0), @@ -507,7 +507,7 @@ TROOT::TROOT() : TDirectory(), TROOT::TROOT(const char *name, const char *title, VoidFuncPtr_t *initfunc) : TDirectory(), fLineIsProcessing(0), fVersion(0), fVersionInt(0), fVersionCode(0), fVersionDate(0), fVersionTime(0), fBuiltDate(0), fBuiltTime(0), - fTimer(0), fApplication(0), fInterpreter(0), fBatch(kTRUE), fEditHistograms(kTRUE), + fTimer(0), fApplication(0), fInterpreter(0), fBatch(kTRUE), fBigEndian(kTRUE), fEditHistograms(kTRUE), fFromPopUp(kTRUE),fMustClean(kTRUE),fReadingObject(kFALSE),fForceStyle(kFALSE), fInterrupt(kFALSE),fEscape(kFALSE),fExecutingMacro(kFALSE),fEditorMode(0), fPrimitive(0),fSelectPad(0),fClasses(0),fTypes(0),fGlobals(0),fGlobalFunctions(0), diff --git a/core/base/src/TUUID.cxx b/core/base/src/TUUID.cxx index 3ad6c9ae7ce80..9eb16dbc731c9 100644 --- a/core/base/src/TUUID.cxx +++ b/core/base/src/TUUID.cxx @@ -262,33 +262,33 @@ TUUID::TUUID(const char *uuid) //////////////////////////////////////////////////////////////////////////////// /// Stream UUID into output buffer. -void TUUID::FillBuffer(char *&buffer) +void TUUID::FillBuffer(char *&buffer, Bool_t buffBigEndian = kTRUE) { Version_t version = TUUID::Class_Version(); - tobuf(buffer, version); - tobuf(buffer, fTimeLow); - tobuf(buffer, fTimeMid); - tobuf(buffer, fTimeHiAndVersion); - tobuf(buffer, fClockSeqHiAndReserved); - tobuf(buffer, fClockSeqLow); + tobuf(buffer, version, buffBigEndian); + tobuf(buffer, fTimeLow, buffBigEndian); + tobuf(buffer, fTimeMid, buffBigEndian); + tobuf(buffer, fTimeHiAndVersion, buffBigEndian); + tobuf(buffer, fClockSeqHiAndReserved, buffBigEndian); + tobuf(buffer, fClockSeqLow, buffBigEndian); for (Int_t i = 0; i < 6; i++) - tobuf(buffer, fNode[i]); + tobuf(buffer, fNode[i], buffBigEndian); } //////////////////////////////////////////////////////////////////////////////// /// Stream UUID from input buffer. -void TUUID::ReadBuffer(char *&buffer) +void TUUID::ReadBuffer(char *&buffer, Bool_t buffBigEndian = kTRUE) { Version_t version; - frombuf(buffer, &version); - frombuf(buffer, &fTimeLow); - frombuf(buffer, &fTimeMid); - frombuf(buffer, &fTimeHiAndVersion); - frombuf(buffer, &fClockSeqHiAndReserved); - frombuf(buffer, &fClockSeqLow); + frombuf(buffer, &version, buffBigEndian); + frombuf(buffer, &fTimeLow, buffBigEndian); + frombuf(buffer, &fTimeMid, buffBigEndian); + frombuf(buffer, &fTimeHiAndVersion, buffBigEndian); + frombuf(buffer, &fClockSeqHiAndReserved, buffBigEndian); + frombuf(buffer, &fClockSeqLow, buffBigEndian); for (Int_t i = 0; i < 6; i++) - frombuf(buffer, &fNode[i]); + frombuf(buffer, &fNode[i], buffBigEndian); } //////////////////////////////////////////////////////////////////////////////// diff --git a/io/io/inc/TBufferFile.h b/io/io/inc/TBufferFile.h index c06bb42efc004..e5acd7b604ba5 100644 --- a/io/io/inc/TBufferFile.h +++ b/io/io/inc/TBufferFile.h @@ -350,70 +350,70 @@ inline void TBufferFile::WriteUChar(UChar_t c) inline void TBufferFile::WriteShort(Short_t h) { if (fBufCur + sizeof(Short_t) > fBufMax) AutoExpand(fBufSize+sizeof(Short_t)); - tobuf(fBufCur, h); + tobuf(fBufCur, h, IsBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteUShort(UShort_t h) { if (fBufCur + sizeof(UShort_t) > fBufMax) AutoExpand(fBufSize+sizeof(UShort_t)); - tobuf(fBufCur, (Short_t)h); + tobuf(fBufCur, (Short_t)h, IsBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteInt(Int_t i) { if (fBufCur + sizeof(Int_t) > fBufMax) AutoExpand(fBufSize+sizeof(Int_t)); - tobuf(fBufCur, i); + tobuf(fBufCur, i, IsBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteUInt(UInt_t i) { if (fBufCur + sizeof(UInt_t) > fBufMax) AutoExpand(fBufSize+sizeof(UInt_t)); - tobuf(fBufCur, (Int_t)i); + tobuf(fBufCur, (Int_t)i, IsBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteLong(Long_t l) { if (fBufCur + sizeof(Long_t) > fBufMax) AutoExpand(fBufSize+sizeof(Long_t)); - tobuf(fBufCur, l); + tobuf(fBufCur, l, IsBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteULong(ULong_t l) { if (fBufCur + sizeof(ULong_t) > fBufMax) AutoExpand(fBufSize+sizeof(ULong_t)); - tobuf(fBufCur, (Long_t)l); + tobuf(fBufCur, (Long_t)l, IsBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteLong64(Long64_t ll) { if (fBufCur + sizeof(Long64_t) > fBufMax) AutoExpand(fBufSize+sizeof(Long64_t)); - tobuf(fBufCur, ll); + tobuf(fBufCur, ll, IsBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteULong64(ULong64_t ll) { if (fBufCur + sizeof(ULong64_t) > fBufMax) AutoExpand(fBufSize+sizeof(ULong64_t)); - tobuf(fBufCur, (Long64_t)ll); + tobuf(fBufCur, (Long64_t)ll, IsBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteFloat(Float_t f) { if (fBufCur + sizeof(Float_t) > fBufMax) AutoExpand(fBufSize+sizeof(Float_t)); - tobuf(fBufCur, f); + tobuf(fBufCur, f, IsBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteDouble(Double_t d) { if (fBufCur + sizeof(Double_t) > fBufMax) AutoExpand(fBufSize+sizeof(Double_t)); - tobuf(fBufCur, d); + tobuf(fBufCur, d, IsBigEndian()); } //______________________________________________________________________________ @@ -443,7 +443,7 @@ inline void TBufferFile::ReadUChar(UChar_t &c) //______________________________________________________________________________ inline void TBufferFile::ReadShort(Short_t &h) { - frombuf(fBufCur, &h); + frombuf(fBufCur, &h, IsBigEndian()); } //______________________________________________________________________________ @@ -455,7 +455,7 @@ inline void TBufferFile::ReadUShort(UShort_t &h) //______________________________________________________________________________ inline void TBufferFile::ReadInt(Int_t &i) { - frombuf(fBufCur, &i); + frombuf(fBufCur, &i, IsBigEndian()); } //______________________________________________________________________________ @@ -482,7 +482,7 @@ inline void TBufferFile::ReadULong(ULong_t &ll) //______________________________________________________________________________ inline void TBufferFile::ReadLong64(Long64_t &ll) { - frombuf(fBufCur, &ll); + frombuf(fBufCur, &ll, IsBigEndian()); } //______________________________________________________________________________ @@ -494,13 +494,13 @@ inline void TBufferFile::ReadULong64(ULong64_t &ll) //______________________________________________________________________________ inline void TBufferFile::ReadFloat(Float_t &f) { - frombuf(fBufCur, &f); + frombuf(fBufCur, &f, IsBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::ReadDouble(Double_t &d) { - frombuf(fBufCur, &d); + frombuf(fBufCur, &d, IsBigEndian()); } //______________________________________________________________________________ diff --git a/io/io/inc/TFile.h b/io/io/inc/TFile.h index 1cee03558c9de..7316f4ac8e549 100644 --- a/io/io/inc/TFile.h +++ b/io/io/inc/TFile.h @@ -175,7 +175,7 @@ class TFile : public TDirectoryFile { virtual void Delete(const char *namecycle=""); virtual void Draw(Option_t *option=""); virtual void DrawMap(const char *keys="*",Option_t *option=""); // *MENU* - virtual void FillBuffer(char *&buffer); + virtual void FillBuffer(char *&buffer, Bool_t buffBigEndian=kTRUE); virtual void Flush(); TArchiveFile *GetArchive() const { return fArchive; } Long64_t GetArchiveOffset() const { return fArchiveOffset; } diff --git a/io/io/inc/TFree.h b/io/io/inc/TFree.h index dd1a3b3ce0a48..9133d16c33df5 100644 --- a/io/io/inc/TFree.h +++ b/io/io/inc/TFree.h @@ -37,7 +37,7 @@ class TFree : public TObject { TFree(TList *lfree, Long64_t first, Long64_t last); virtual ~TFree(); TFree *AddFree(TList *lfree, Long64_t first, Long64_t last); - virtual void FillBuffer(char *&buffer); + virtual void FillBuffer(char *&buffer, Bool_t buffBigEndian=kTRUE); TFree *GetBestFree(TList *lfree, Int_t nbytes); Long64_t GetFirst() const {return fFirst;} Long64_t GetLast() const {return fLast;} diff --git a/io/io/src/TBufferFile.cxx b/io/io/src/TBufferFile.cxx index 91cd148e8bc41..0a10ee0bbd02c 100644 --- a/io/io/src/TBufferFile.cxx +++ b/io/io/src/TBufferFile.cxx @@ -241,9 +241,9 @@ void TBufferFile::ReadLong(Long_t &l) { TFile *file = (TFile*)fParent; if (file && file->GetVersion() < 30006) { - frombufOld(fBufCur, &l); + frombufOld(fBufCur, &l, IsBigEndian()); } else { - frombuf(fBufCur, &l); + frombuf(fBufCur, &l, IsBigEndian()); } } @@ -357,14 +357,24 @@ void TBufferFile::SetByteCount(UInt_t cntpos, Bool_t packInVersion) } v; v.cnt = cnt; #ifdef R__BYTESWAP - tobuf(buf, Version_t(v.vers[1] | kByteCountVMask)); - tobuf(buf, v.vers[0]); + if(IsBigEndian()) { + tobuf(buf, Version_t(v.vers[1] | kByteCountVMask)); + tobuf(buf, v.vers[0]); + } else { + tobuf(buf, v.vers[0], 0); + tobuf(buf, Version_t(v.vers[1] | kByteCountVMask), 0); + } #else - tobuf(buf, Version_t(v.vers[0] | kByteCountVMask)); - tobuf(buf, v.vers[1]); + if(IsBigEndian()) { + tobuf(buf, Version_t(v.vers[0] | kByteCountVMask)); + tobuf(buf, v.vers[1]); + } else { + tobuf(buf, v.vers[1], 0); + tobuf(buf, Version_t(v.vers[0] | kByteCountVMask), 0); + } #endif } else - tobuf(buf, cnt | kByteCountMask); + tobuf(buf, cnt | kByteCountMask, IsBigEndian()); if (cnt >= kMaxMapCount) { Error("WriteByteCount", "bytecount too large (more than %d)", kMaxMapCount); @@ -1761,16 +1771,31 @@ void TBufferFile::WriteArray(const Short_t *h, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP + if(IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy16(fBufCur, h, n); - fBufCur += l; + bswapcpy16(fBufCur, h, n); + fBufCur += l; # else - for (int i = 0; i < n; i++) - tobuf(fBufCur, h[i]); + for (int i = 0; i < n; i++) + tobuf(fBufCur, h[i]); # endif + } else { + memcpy(fBufCur, h, l); + fBufCur += l; + } #else - memcpy(fBufCur, h, l); - fBufCur += l; + if(IsBigEndian()) { + memcpy(fBufCur, h, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy16(fBufCur, h, n); + fBufCur += l; +# else + for (int i = 0; i < n; i++) + tobuf(fBufCur, h[i], 0); +# endif + } #endif } @@ -1791,16 +1816,30 @@ void TBufferFile::WriteArray(const Int_t *ii, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP + if(IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy32(fBufCur, ii, n); - fBufCur += l; + bswapcpy32(fBufCur, ii, n); + fBufCur += l; # else - for (int i = 0; i < n; i++) - tobuf(fBufCur, ii[i]); + for (int i = 0; i < n; i++) + tobuf(fBufCur, ii[i]); # endif + } else { + memcpy(fBufCur, ii, l); + } + if(IsBigEndian()) { #else - memcpy(fBufCur, ii, l); - fBufCur += l; + memcpy(fBufCur, ii, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy32(fBufCur, ii, n); + fBufCur += l; +# else + for (int i = 0; i < n; i++) + tobuf(fBufCur, ii[i]); +# endif + } #endif } @@ -1859,11 +1898,21 @@ void TBufferFile::WriteArray(const Long64_t *ll, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - for (int i = 0; i < n; i++) - tobuf(fBufCur, ll[i]); + if(IsBigEndian()) { + for (int i = 0; i < n; i++) + tobuf(fBufCur, ll[i]); + } else { + memcpy(fBufCur, ll, l); + fBufCur += l; + } #else - memcpy(fBufCur, ll, l); - fBufCur += l; + if(IsBigEndian()) { + memcpy(fBufCur, ll, l); + fBufCur += l; + } else { + for (int i = 0; i < n; i++) + tobuf(fBufCur, ll[i]); + } #endif } @@ -1884,16 +1933,31 @@ void TBufferFile::WriteArray(const Float_t *f, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP + if(IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy32(fBufCur, f, n); - fBufCur += l; + bswapcpy32(fBufCur, f, n); + fBufCur += l; # else - for (int i = 0; i < n; i++) - tobuf(fBufCur, f[i]); + for (int i = 0; i < n; i++) + tobuf(fBufCur, f[i]); # endif + } else { + memcpy(fBufCur, f, l); + fBufCur += l; + } #else - memcpy(fBufCur, f, l); - fBufCur += l; + if(IsBigEndian()) { + memcpy(fBufCur, f, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy32(fBufCur, f, n); + fBufCur += l; +# else + for (int i = 0; i < n; i++) + tobuf(fBufCur, f[i], 0); +# endif + } #endif } @@ -1914,11 +1978,21 @@ void TBufferFile::WriteArray(const Double_t *d, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - for (int i = 0; i < n; i++) - tobuf(fBufCur, d[i]); + if(IsBigEndian()) { + for (int i = 0; i < n; i++) + tobuf(fBufCur, d[i]); + } else { + memcpy(fBufCur, d, l); + fBufCur += l; + } #else - memcpy(fBufCur, d, l); - fBufCur += l; + if(IsBigEndian()) { + memcpy(fBufCur, d, l); + fBufCur += l; + } else { + for (int i = 0; i < n; i++) + tobuf(fBufCur, d[i], 0); + } #endif } diff --git a/io/io/src/TDirectoryFile.cxx b/io/io/src/TDirectoryFile.cxx index d88a50eebec53..d7033ccb9794b 100644 --- a/io/io/src/TDirectoryFile.cxx +++ b/io/io/src/TDirectoryFile.cxx @@ -702,7 +702,7 @@ void TDirectoryFile::Delete(const char *namecycle) //////////////////////////////////////////////////////////////////////////////// /// Encode directory header into output buffer -void TDirectoryFile::FillBuffer(char *&buffer) +void TDirectoryFile::FillBuffer(char *&buffer, Bool_t buffBigEndian = kTRUE) { Version_t version = TDirectoryFile::Class_Version(); if (fSeekDir > TFile::kStartBigFile || @@ -715,23 +715,23 @@ void TDirectoryFile::FillBuffer(char *&buffer) // some object are 'removed' from the file and the holes are reused. version += 1000; } - tobuf(buffer, version); - fDatimeC.FillBuffer(buffer); - fDatimeM.FillBuffer(buffer); - tobuf(buffer, fNbytesKeys); - tobuf(buffer, fNbytesName); + tobuf(buffer, version, buffBigEndian); + fDatimeC.FillBuffer(buffer, buffBigEndian); + fDatimeM.FillBuffer(buffer, buffBigEndian); + tobuf(buffer, fNbytesKeys, buffBigEndian); + tobuf(buffer, fNbytesName, buffBigEndian); if (version > 1000) { - tobuf(buffer, fSeekDir); - tobuf(buffer, fSeekParent); - tobuf(buffer, fSeekKeys); + tobuf(buffer, fSeekDir, buffBigEndian); + tobuf(buffer, fSeekParent, buffBigEndian); + tobuf(buffer, fSeekKeys, buffBigEndian); } else { - tobuf(buffer, (Int_t)fSeekDir); - tobuf(buffer, (Int_t)fSeekParent); - tobuf(buffer, (Int_t)fSeekKeys); + tobuf(buffer, (Int_t)fSeekDir, buffBigEndian); + tobuf(buffer, (Int_t)fSeekParent, buffBigEndian); + tobuf(buffer, (Int_t)fSeekKeys, buffBigEndian); } - fUUID.FillBuffer(buffer); + fUUID.FillBuffer(buffer, buffBigEndian); if (fFile && fFile->GetVersion() < 40000) return; - if (version <=1000) for (Int_t i=0;i<3;i++) tobuf(buffer,Int_t(0)); + if (version <=1000) for (Int_t i=0;i<3;i++) tobuf(buffer,Int_t(0), buffBigEndian); } //////////////////////////////////////////////////////////////////////////////// diff --git a/io/io/src/TFile.cxx b/io/io/src/TFile.cxx index 1e63c07279533..630929b3a53ce 100644 --- a/io/io/src/TFile.cxx +++ b/io/io/src/TFile.cxx @@ -641,8 +641,8 @@ void TFile::Init(Bool_t create) fNbytesFree = 0; WriteHeader(); char *buffer = key->GetBuffer(); - TNamed::FillBuffer(buffer); - TDirectoryFile::FillBuffer(buffer); + TNamed::FillBuffer(buffer, key->IsBigEndian()); + TDirectoryFile::FillBuffer(buffer, key->IsBigEndian()); key->WriteFile(); delete key; } else { @@ -667,7 +667,7 @@ void TFile::Init(Bool_t create) } char *buffer = header + 4; // skip the "root" file identifier - frombuf(buffer, &fVersion); + frombuf(buffer, &fVersio); Int_t headerLength; frombuf(buffer, &headerLength); fBEGIN = (Long64_t)headerLength; @@ -678,7 +678,7 @@ void TFile::Init(Bool_t create) frombuf(buffer, &fNbytesFree); frombuf(buffer, &nfree); frombuf(buffer, &fNbytesName); - frombuf(buffer, &fUnits ); + frombuf(buffer, &fUnits); frombuf(buffer, &fCompress); frombuf(buffer, &sinfo); fSeekInfo = (Long64_t)sinfo; frombuf(buffer, &fNbytesInfo); @@ -688,7 +688,7 @@ void TFile::Init(Bool_t create) frombuf(buffer, &fNbytesFree); frombuf(buffer, &nfree); frombuf(buffer, &fNbytesName); - frombuf(buffer, &fUnits ); + frombuf(buffer, &fUnits); frombuf(buffer, &fCompress); frombuf(buffer, &fSeekInfo); frombuf(buffer, &fNbytesInfo); @@ -742,7 +742,7 @@ void TFile::Init(Bool_t create) frombuf(buffer,&version); versiondir = version%1000; fDatimeC.ReadBuffer(buffer); fDatimeM.ReadBuffer(buffer); - frombuf(buffer, &fNbytesKeys); + frombuf(buffer, &fNbytesKeys; frombuf(buffer, &fNbytesName); if (version > 1000) { frombuf(buffer, &fSeekDir); @@ -1105,10 +1105,10 @@ Bool_t TFile::FlushWriteCache() /// /// The file output buffer contains only the FREE data record. -void TFile::FillBuffer(char *&buffer) +void TFile::FillBuffer(char *&buffer, Bool_t buffBigEndian=kTRUE) { Version_t version = TFile::Class_Version(); - tobuf(buffer, version); + tobuf(buffer, version, buffBigEndian); } //////////////////////////////////////////////////////////////////////////////// @@ -2376,7 +2376,7 @@ void TFile::WriteFree() next.Reset(); while ((afree = (TFree*) next())) { - afree->FillBuffer(buffer); + afree->FillBuffer(buffer, key->IsBigEndian()); } if ( (buffer-start)!=nbytes ) { // Most likely one of the 'free' segment was used to store this diff --git a/io/io/src/TFree.cxx b/io/io/src/TFree.cxx index d33e4c564ed50..d024e1cd82afa 100644 --- a/io/io/src/TFree.cxx +++ b/io/io/src/TFree.cxx @@ -104,20 +104,20 @@ TFree::~TFree() } //////////////////////////////////////////////////////////////////////////////// -/// Encode fre structure into output buffer. +/// Encode free structure into output buffer. -void TFree::FillBuffer(char *&buffer) +void TFree::FillBuffer(char *&buffer, Bool_t buffBigEndian=kTRUE) { Version_t version = TFree::Class_Version(); if (fLast > TFile::kStartBigFile) version += 1000; - tobuf(buffer, version); + tobuf(buffer, version, buffBigEndian); //printf("TFree::fillBuffer, fFirst=%lld, fLast=%lld, version=%d\n",fFirst,fLast,version); if (version > 1000) { - tobuf(buffer, fFirst); - tobuf(buffer, fLast); + tobuf(buffer, fFirst, buffBigEndian); + tobuf(buffer, fLast, buffBigEndian); } else { - tobuf(buffer, (Int_t)fFirst); - tobuf(buffer, (Int_t)fLast); + tobuf(buffer, (Int_t)fFirst, buffBigEndian); + tobuf(buffer, (Int_t)fLast, buffBigEndian); } } diff --git a/io/io/src/TKey.cxx b/io/io/src/TKey.cxx index 32db83073dcfa..183720a0dd08c 100644 --- a/io/io/src/TKey.cxx +++ b/io/io/src/TKey.cxx @@ -582,18 +582,18 @@ Short_t TKey::GetKeep() const //////////////////////////////////////////////////////////////////////////////// /// Encode key header into output buffer. -void TKey::FillBuffer(char *&buffer) +void TKey::FillBuffer(char *&buffer, Bool_t buffBigEndian = kTRUE) { - tobuf(buffer, fNbytes); + tobuf(buffer, fNbytes, buffBigEndian); Version_t version = fVersion; - tobuf(buffer, version); + tobuf(buffer, version, buffBigEndian); - tobuf(buffer, fObjlen); - fDatime.FillBuffer(buffer); - tobuf(buffer, fKeylen); - tobuf(buffer, fCycle); + tobuf(buffer, fObjlen, buffBigEndian); + fDatime.FillBuffer(buffer, buffBigEndian); + tobuf(buffer, fKeylen, buffBigEndian); + tobuf(buffer, fCycle, buffBigEndian); if (fVersion > 1000) { - tobuf(buffer, fSeekKey); + tobuf(buffer, fSeekKey, buffBigEndian); // We currently store in the 16 highest bit of fSeekPdir the value of // fPidOffset. This offset is used when a key (or basket) is transfered from one @@ -603,19 +603,19 @@ void TKey::FillBuffer(char *&buffer) // TProcessID. This fPidOffset needs to be increment if the key/basket is copied // and need to be zero for new key/basket. Long64_t pdir = (((Long64_t)fPidOffset)< Date: Tue, 17 Nov 2015 23:46:30 -0600 Subject: [PATCH 03/18] Change the BigEndian representations --- core/base/inc/TBuffer.h | 14 ++++++-------- core/base/src/TBuffer.cxx | 19 +++++++++++-------- io/io/src/TFile.cxx | 4 ++-- 3 files changed, 19 insertions(+), 18 deletions(-) diff --git a/core/base/inc/TBuffer.h b/core/base/inc/TBuffer.h index a5fc99db17d28..9afac1e6dbf80 100644 --- a/core/base/inc/TBuffer.h +++ b/core/base/inc/TBuffer.h @@ -44,7 +44,7 @@ class TBuffer : public TObject { protected: typedef std::vector CacheList_t; - Bool_t fBufEndian; //Big endian is default (0) + Bool_t fBufBigEndian; //Big endian Bool_t fMode; //Read or write mode Int_t fVersion; //Buffer format version Int_t fBufSize; //Size of buffer @@ -56,8 +56,8 @@ class TBuffer : public TObject { CacheList_t fCacheStack; //Stack of pointers to the cache where to temporarily store the value of 'missing' data members // Default ctor - TBuffer() : TObject(), fMode(0), fVersion(0), fBufSize(0), fBuffer(0), - fBufCur(0), fBufMax(0), fBufEndian(0), fParent(0), fReAllocFunc(0), fCacheStack(0,(TVirtualArray*)0) {} + TBuffer() : TObject(), fBufBigEndian(1), fMode(0), fVersion(0), fBufSize(0), fBuffer(0), + fBufCur(0), fBufMax(0), fParent(0), fReAllocFunc(0), fCacheStack(0,(TVirtualArray*)0) {} // TBuffer objects cannot be copied or assigned TBuffer(const TBuffer &); // not implemented @@ -71,7 +71,6 @@ class TBuffer : public TObject { public: enum EMode { kRead = 0, kWrite = 1 }; - enum EEndian { kBig = 0, kLittle = 1 }; enum { kIsOwner = BIT(16) }; //if set TBuffer owns fBuffer enum { kCannotHandleMemberWiseStreaming = BIT(17)}; //if set TClonesArray should not use member wise streaming enum { kInitialSize = 1024, kMinimalSize = 128 }; @@ -86,10 +85,9 @@ class TBuffer : public TObject { Bool_t IsWriting() const { return (fMode & kWrite) != 0; } void SetReadMode(); void SetWriteMode(); - Bool_t IsBigEndian() const { return fBufEndian == 0; } - Bool_t IsLittleEndian() const { return fBufEndian == 1; } - void SetBigEndian() { fBufEndian = 0; } - void SetLittleEndian() { fBufEndian = 1; } + Bool_t IsBigEndian() const { return fBufBigEndian; } + void SetBigEndian() { fBufBigEndian = 1; } + void SetLittleEndian() { fBufBigEndian = 0; } void SetBuffer(void *buf, UInt_t bufsiz = 0, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0); ReAllocCharFun_t GetReAllocFunc() const; void SetReAllocFunc(ReAllocCharFun_t reallocfunc = 0); diff --git a/core/base/src/TBuffer.cxx b/core/base/src/TBuffer.cxx index 7a5abab91cb0e..d6b31145dc45d 100644 --- a/core/base/src/TBuffer.cxx +++ b/core/base/src/TBuffer.cxx @@ -41,6 +41,7 @@ TBuffer::TBuffer(EMode mode) fMode = mode; fVersion = 0; fParent = 0; + fBufBigEndian = gROOT->IsBigEndian(); SetBit(kIsOwner); @@ -59,10 +60,11 @@ TBuffer::TBuffer(EMode mode) TBuffer::TBuffer(EMode mode, Int_t bufsiz) { if (bufsiz < kMinimalSize) bufsiz = kMinimalSize; - fBufSize = bufsiz; - fMode = mode; - fVersion = 0; - fParent = 0; + fBufSize = bufsiz; + fMode = mode; + fVersion = 0; + fParent = 0; + fBufBigEndian = gROOT->IsBigEndian(); SetBit(kIsOwner); @@ -87,10 +89,11 @@ TBuffer::TBuffer(EMode mode, Int_t bufsiz) TBuffer::TBuffer(EMode mode, Int_t bufsiz, void *buf, Bool_t adopt, ReAllocCharFun_t reallocfunc) { - fBufSize = bufsiz; - fMode = mode; - fVersion = 0; - fParent = 0; + fBufSize = bufsiz; + fMode = mode; + fVersion = 0; + fParent = 0; + fBufBigEndian = gROOT->IsBigEndian(); SetBit(kIsOwner); diff --git a/io/io/src/TFile.cxx b/io/io/src/TFile.cxx index 630929b3a53ce..96babc90935a3 100644 --- a/io/io/src/TFile.cxx +++ b/io/io/src/TFile.cxx @@ -1105,10 +1105,10 @@ Bool_t TFile::FlushWriteCache() /// /// The file output buffer contains only the FREE data record. -void TFile::FillBuffer(char *&buffer, Bool_t buffBigEndian=kTRUE) +void TFile::FillBuffer(char *&buffer) { Version_t version = TFile::Class_Version(); - tobuf(buffer, version, buffBigEndian); + tobuf(buffer, version); } //////////////////////////////////////////////////////////////////////////////// From 202db5f78d3ece1f4fc4f614a810d70ac7ecc162 Mon Sep 17 00:00:00 2001 From: Zhe Zhang Date: Thu, 19 Nov 2015 23:49:46 -0600 Subject: [PATCH 04/18] Only change TBuffer functions and add fBufBigEndian --- core/base/inc/Bytes.h | 4 + core/base/inc/TROOT.h | 8 +- core/base/inc/TUUID.h | 4 +- core/base/src/TBuffer.cxx | 7 +- core/base/src/TNamed.cxx | 6 +- core/base/src/TROOT.cxx | 4 +- core/base/src/TUUID.cxx | 32 +- io/io/inc/TFile.h | 2 +- io/io/inc/TFree.h | 2 +- io/io/src/TBufferFile.cxx | 617 ++++++++++++++++++++++++++--------- io/io/src/TDirectoryFile.cxx | 18 +- io/io/src/TFile.cxx | 10 +- io/io/src/TFree.cxx | 12 +- io/io/src/TKey.cxx | 32 +- 14 files changed, 535 insertions(+), 223 deletions(-) diff --git a/core/base/inc/Bytes.h b/core/base/inc/Bytes.h index 983ac3caa7563..678aa822afbe2 100644 --- a/core/base/inc/Bytes.h +++ b/core/base/inc/Bytes.h @@ -385,7 +385,9 @@ if(buffBigEndian) { buf[2] = u.c[1]; buf[3] = u.c[0]; # endif + printf("tobuf:BigEndian:float=%f\n", x); } else { + printf("tobuf:LittleEndian:float=%f\n", x); memcpy(buf, &x, sizeof(Float_t)); } #else @@ -672,7 +674,9 @@ if(buffBigEndian) { u.c[3] = buf[0]; *x = u.f; # endif + printf("BigEndian:float=%f\n", *x); } else { + printf("LittleEndian:float=%f\n", *x); memcpy(x, buf, sizeof(Float_t)); } #else diff --git a/core/base/inc/TROOT.h b/core/base/inc/TROOT.h index 206d94e574f36..3bed889d7a1b6 100644 --- a/core/base/inc/TROOT.h +++ b/core/base/inc/TROOT.h @@ -115,6 +115,7 @@ friend TROOT *ROOT::Internal::GetROOT2(); std::atomic fApplication; //Pointer to current application TInterpreter *fInterpreter; //Command interpreter Bool_t fBatch; //True if session without graphics + Bool_t fBufBigEndian; //True if user define the data format as Big Endian Bool_t fEditHistograms; //True if histograms can be edited with the mouse Bool_t fFromPopUp; //True if command executed from a popup menu Bool_t fMustClean; //True if object destructor scans canvases @@ -123,7 +124,6 @@ friend TROOT *ROOT::Internal::GetROOT2(); Bool_t fInterrupt; //True if macro should be interrupted Bool_t fEscape; //True if ESC has been pressed Bool_t fExecutingMacro; //True while executing a TMacro - Bool_t fBigEndian; //True if user define the data format as Big Endian Int_t fEditorMode; //Current Editor mode const TObject *fPrimitive; //Currently selected primitive TVirtualPad *fSelectPad; //Currently selected pad @@ -265,7 +265,8 @@ friend TROOT *ROOT::Internal::GetROOT2(); void Idle(UInt_t idleTimeInSec, const char *command = 0); Int_t IgnoreInclude(const char *fname, const char *expandedfname); Bool_t IsBatch() const { return fBatch; } - Bool_t IsBigEndian() const { return fBigEndian; } + Bool_t IsBufBigEndian() const { return fBufBigEndian; } + Bool_t IsBufLittleEndian() const { return !fBufBigEndian; } Bool_t IsExecutingMacro() const { return fExecutingMacro; } Bool_t IsFolder() const { return kTRUE; } Bool_t IsInterrupted() const { return fInterrupt; } @@ -299,7 +300,8 @@ friend TROOT *ROOT::Internal::GetROOT2(); void SaveContext(); void SetApplication(TApplication *app) { fApplication = app; } void SetBatch(Bool_t batch = kTRUE) { fBatch = batch; } - void SetBigEndian(Bool_t bigendian = kTRUE) { fBigEndian = bigendian; } + void SetBufBigEndian() { fBufBigEndian = kTRUE; } + void SetBufLittleEndian() { fBufBigEndian = kFALSE; } void SetCutClassName(const char *name = "TCutG"); void SetDefCanvasName(const char *name = "c1") { fDefCanvasName = name; } void SetEditHistograms(Bool_t flag = kTRUE) { fEditHistograms = flag; } diff --git a/core/base/inc/TUUID.h b/core/base/inc/TUUID.h index 5f17de11d1e40..6360ddb822096 100644 --- a/core/base/inc/TUUID.h +++ b/core/base/inc/TUUID.h @@ -82,8 +82,8 @@ class TUUID { void SetUUIDNumber(UInt_t index) { fUUIDIndex = index; } void StreamerV1(TBuffer &b); - void FillBuffer(char *&buffer, Bool_t buffBigEndian=kTRUE); - void ReadBuffer(char *&buffer, Bool_t buffBigEndian=kTRUE); + void FillBuffer(char *&buffer); + void ReadBuffer(char *&buffer); Int_t Sizeof() const { return 18; } ClassDef(TUUID,1) // Universally Unique IDentifier diff --git a/core/base/src/TBuffer.cxx b/core/base/src/TBuffer.cxx index d6b31145dc45d..75f1dc2afb7b5 100644 --- a/core/base/src/TBuffer.cxx +++ b/core/base/src/TBuffer.cxx @@ -16,6 +16,7 @@ Buffer base class used for serializing objects. #include "TBuffer.h" #include "TClass.h" #include "TProcessID.h" +#include "TROOT.h" const Int_t kExtraSpace = 8; // extra space at end of buffer (used for free block count) @@ -41,7 +42,7 @@ TBuffer::TBuffer(EMode mode) fMode = mode; fVersion = 0; fParent = 0; - fBufBigEndian = gROOT->IsBigEndian(); + fBufBigEndian = gROOT->IsBufBigEndian(); SetBit(kIsOwner); @@ -64,7 +65,7 @@ TBuffer::TBuffer(EMode mode, Int_t bufsiz) fMode = mode; fVersion = 0; fParent = 0; - fBufBigEndian = gROOT->IsBigEndian(); + fBufBigEndian = gROOT->IsBufBigEndian(); SetBit(kIsOwner); @@ -93,7 +94,7 @@ TBuffer::TBuffer(EMode mode, Int_t bufsiz, void *buf, Bool_t adopt, ReAllocCharF fMode = mode; fVersion = 0; fParent = 0; - fBufBigEndian = gROOT->IsBigEndian(); + fBufBigEndian = gROOT->IsBufBigEndian(); SetBit(kIsOwner); diff --git a/core/base/src/TNamed.cxx b/core/base/src/TNamed.cxx index 3b2dbf36a8b3a..c0df4b721fddb 100644 --- a/core/base/src/TNamed.cxx +++ b/core/base/src/TNamed.cxx @@ -90,10 +90,10 @@ void TNamed::Copy(TObject &obj) const //////////////////////////////////////////////////////////////////////////////// /// Encode TNamed into output buffer. -void TNamed::FillBuffer(char *&buffer, Bool_t buffBigEndian = kTRUE) +void TNamed::FillBuffer(char *&buffer) { - fName.FillBuffer(buffer, buffBigEndian); - fTitle.FillBuffer(buffer, buffBigEndian); + fName.FillBuffer(buffer); + fTitle.FillBuffer(buffer); } //////////////////////////////////////////////////////////////////////////////// diff --git a/core/base/src/TROOT.cxx b/core/base/src/TROOT.cxx index 2f392826dbe2e..e3bd1b999817f 100644 --- a/core/base/src/TROOT.cxx +++ b/core/base/src/TROOT.cxx @@ -474,7 +474,7 @@ ClassImp(TROOT) TROOT::TROOT() : TDirectory(), fLineIsProcessing(0), fVersion(0), fVersionInt(0), fVersionCode(0), fVersionDate(0), fVersionTime(0), fBuiltDate(0), fBuiltTime(0), - fTimer(0), fApplication(0), fInterpreter(0), fBatch(kTRUE), fBigEndian(kTRUE), fEditHistograms(kTRUE), + fTimer(0), fApplication(0), fInterpreter(0), fBatch(kTRUE), fBufBigEndian(kTRUE), fEditHistograms(kTRUE), fFromPopUp(kTRUE),fMustClean(kTRUE),fReadingObject(kFALSE),fForceStyle(kFALSE), fInterrupt(kFALSE),fEscape(kFALSE),fExecutingMacro(kFALSE),fEditorMode(0), fPrimitive(0),fSelectPad(0),fClasses(0),fTypes(0),fGlobals(0),fGlobalFunctions(0), @@ -507,7 +507,7 @@ TROOT::TROOT() : TDirectory(), TROOT::TROOT(const char *name, const char *title, VoidFuncPtr_t *initfunc) : TDirectory(), fLineIsProcessing(0), fVersion(0), fVersionInt(0), fVersionCode(0), fVersionDate(0), fVersionTime(0), fBuiltDate(0), fBuiltTime(0), - fTimer(0), fApplication(0), fInterpreter(0), fBatch(kTRUE), fBigEndian(kTRUE), fEditHistograms(kTRUE), + fTimer(0), fApplication(0), fInterpreter(0), fBatch(kTRUE), fBufBigEndian(kTRUE), fEditHistograms(kTRUE), fFromPopUp(kTRUE),fMustClean(kTRUE),fReadingObject(kFALSE),fForceStyle(kFALSE), fInterrupt(kFALSE),fEscape(kFALSE),fExecutingMacro(kFALSE),fEditorMode(0), fPrimitive(0),fSelectPad(0),fClasses(0),fTypes(0),fGlobals(0),fGlobalFunctions(0), diff --git a/core/base/src/TUUID.cxx b/core/base/src/TUUID.cxx index 9eb16dbc731c9..3ad6c9ae7ce80 100644 --- a/core/base/src/TUUID.cxx +++ b/core/base/src/TUUID.cxx @@ -262,33 +262,33 @@ TUUID::TUUID(const char *uuid) //////////////////////////////////////////////////////////////////////////////// /// Stream UUID into output buffer. -void TUUID::FillBuffer(char *&buffer, Bool_t buffBigEndian = kTRUE) +void TUUID::FillBuffer(char *&buffer) { Version_t version = TUUID::Class_Version(); - tobuf(buffer, version, buffBigEndian); - tobuf(buffer, fTimeLow, buffBigEndian); - tobuf(buffer, fTimeMid, buffBigEndian); - tobuf(buffer, fTimeHiAndVersion, buffBigEndian); - tobuf(buffer, fClockSeqHiAndReserved, buffBigEndian); - tobuf(buffer, fClockSeqLow, buffBigEndian); + tobuf(buffer, version); + tobuf(buffer, fTimeLow); + tobuf(buffer, fTimeMid); + tobuf(buffer, fTimeHiAndVersion); + tobuf(buffer, fClockSeqHiAndReserved); + tobuf(buffer, fClockSeqLow); for (Int_t i = 0; i < 6; i++) - tobuf(buffer, fNode[i], buffBigEndian); + tobuf(buffer, fNode[i]); } //////////////////////////////////////////////////////////////////////////////// /// Stream UUID from input buffer. -void TUUID::ReadBuffer(char *&buffer, Bool_t buffBigEndian = kTRUE) +void TUUID::ReadBuffer(char *&buffer) { Version_t version; - frombuf(buffer, &version, buffBigEndian); - frombuf(buffer, &fTimeLow, buffBigEndian); - frombuf(buffer, &fTimeMid, buffBigEndian); - frombuf(buffer, &fTimeHiAndVersion, buffBigEndian); - frombuf(buffer, &fClockSeqHiAndReserved, buffBigEndian); - frombuf(buffer, &fClockSeqLow, buffBigEndian); + frombuf(buffer, &version); + frombuf(buffer, &fTimeLow); + frombuf(buffer, &fTimeMid); + frombuf(buffer, &fTimeHiAndVersion); + frombuf(buffer, &fClockSeqHiAndReserved); + frombuf(buffer, &fClockSeqLow); for (Int_t i = 0; i < 6; i++) - frombuf(buffer, &fNode[i], buffBigEndian); + frombuf(buffer, &fNode[i]); } //////////////////////////////////////////////////////////////////////////////// diff --git a/io/io/inc/TFile.h b/io/io/inc/TFile.h index 7316f4ac8e549..1cee03558c9de 100644 --- a/io/io/inc/TFile.h +++ b/io/io/inc/TFile.h @@ -175,7 +175,7 @@ class TFile : public TDirectoryFile { virtual void Delete(const char *namecycle=""); virtual void Draw(Option_t *option=""); virtual void DrawMap(const char *keys="*",Option_t *option=""); // *MENU* - virtual void FillBuffer(char *&buffer, Bool_t buffBigEndian=kTRUE); + virtual void FillBuffer(char *&buffer); virtual void Flush(); TArchiveFile *GetArchive() const { return fArchive; } Long64_t GetArchiveOffset() const { return fArchiveOffset; } diff --git a/io/io/inc/TFree.h b/io/io/inc/TFree.h index 9133d16c33df5..dd1a3b3ce0a48 100644 --- a/io/io/inc/TFree.h +++ b/io/io/inc/TFree.h @@ -37,7 +37,7 @@ class TFree : public TObject { TFree(TList *lfree, Long64_t first, Long64_t last); virtual ~TFree(); TFree *AddFree(TList *lfree, Long64_t first, Long64_t last); - virtual void FillBuffer(char *&buffer, Bool_t buffBigEndian=kTRUE); + virtual void FillBuffer(char *&buffer); TFree *GetBestFree(TList *lfree, Int_t nbytes); Long64_t GetFirst() const {return fFirst;} Long64_t GetLast() const {return fLast;} diff --git a/io/io/src/TBufferFile.cxx b/io/io/src/TBufferFile.cxx index 0a10ee0bbd02c..a0acebe0301bb 100644 --- a/io/io/src/TBufferFile.cxx +++ b/io/io/src/TBufferFile.cxx @@ -208,28 +208,52 @@ void TBufferFile::DecrementLevel(TVirtualStreamerInfo* /*info*/) /// files with these types we provide this dirty patch for "backward /// compatibility" -static void frombufOld(char *&buf, Long_t *x) +static void frombufOld(char *&buf, Long_t *x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP + if (buffBigEndian) { #ifdef R__B64 - char *sw = (char *)x; - sw[0] = buf[7]; - sw[1] = buf[6]; - sw[2] = buf[5]; - sw[3] = buf[4]; - sw[4] = buf[3]; - sw[5] = buf[2]; - sw[6] = buf[1]; - sw[7] = buf[0]; + char *sw = (char *)x; + sw[0] = buf[7]; + sw[1] = buf[6]; + sw[2] = buf[5]; + sw[3] = buf[4]; + sw[4] = buf[3]; + sw[5] = buf[2]; + sw[6] = buf[1]; + sw[7] = buf[0]; #else - char *sw = (char *)x; - sw[0] = buf[3]; - sw[1] = buf[2]; - sw[2] = buf[1]; - sw[3] = buf[0]; + char *sw = (char *)x; + sw[0] = buf[3]; + sw[1] = buf[2]; + sw[2] = buf[1]; + sw[3] = buf[0]; #endif + } else { + memcpy(x, buf, sizeof(Long_t)); + } +#else + if (buffBigEndian) { + memcpy(x, buf, sizeof(Long_t)); + } else { +#ifdef R__B64 + char *sw = (char *)x; + sw[0] = buf[7]; + sw[1] = buf[6]; + sw[2] = buf[5]; + sw[3] = buf[4]; + sw[4] = buf[3]; + sw[5] = buf[2]; + sw[6] = buf[1]; + sw[7] = buf[0]; #else - memcpy(x, buf, sizeof(Long_t)); + char *sw = (char *)x; + sw[0] = buf[3]; + sw[1] = buf[2]; + sw[2] = buf[1]; + sw[3] = buf[0]; +#endif + } #endif buf += sizeof(Long_t); } @@ -509,7 +533,7 @@ void TBufferFile::ReadWithFactor(Float_t *ptr, Double_t factor, Double_t minvalu { //a range was specified. We read an integer and convert it back to a double. UInt_t aint; - frombuf(this->fBufCur,&aint); + frombuf(this->fBufCur,&aint,IsBigEndian()); ptr[0] = (Float_t)(aint/factor + minvalue); } @@ -528,7 +552,7 @@ void TBufferFile::ReadWithNbits(Float_t *ptr, Int_t nbits) UChar_t theExp; UShort_t theMan; frombuf(this->fBufCur,&theExp); - frombuf(this->fBufCur,&theMan); + frombuf(this->fBufCur,&theMan,IsBigEndian()); temp.fIntValue = theExp; temp.fIntValue <<= 23; temp.fIntValue |= (theMan & ((1<<(nbits+1))-1)) <<(23-nbits); @@ -544,7 +568,7 @@ void TBufferFile::ReadWithFactor(Double_t *ptr, Double_t factor, Double_t minval { //a range was specified. We read an integer and convert it back to a double. UInt_t aint; - frombuf(this->fBufCur,&aint); + frombuf(this->fBufCur,&aint,IsBigEndian()); ptr[0] = (Double_t)(aint/factor + minvalue); } @@ -563,7 +587,7 @@ void TBufferFile::ReadWithNbits(Double_t *ptr, Int_t nbits) UChar_t theExp; UShort_t theMan; frombuf(this->fBufCur,&theExp); - frombuf(this->fBufCur,&theMan); + frombuf(this->fBufCur,&theMan,IsBigEndian()); temp.fIntValue = theExp; temp.fIntValue <<= 23; temp.fIntValue |= (theMan & ((1<<(nbits+1))-1)) <<(23-nbits); @@ -799,16 +823,31 @@ Int_t TBufferFile::ReadArray(Short_t *&h) if (!h) h = new Short_t[n]; #ifdef R__BYTESWAP + if (IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy16(h, fBufCur, n); - fBufCur += l; + bswapcpy16(h, fBufCur, n); + fBufCur += l; # else - for (int i = 0; i < n; i++) - frombuf(fBufCur, &h[i]); + for (int i = 0; i < n; i++) + frombuf(fBufCur, &h[i]); # endif + } else { + memcpy(h, fBufCur, l); + fBufCur += l; + } #else - memcpy(h, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(h, fBufCur, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy16(h, fBufCur, n); + fBufCur += l; +# else + for (int i = 0; i < n; i++) + frombuf(fBufCur, &h[i], 0); +# endif + } #endif return n; @@ -832,16 +871,31 @@ Int_t TBufferFile::ReadArray(Int_t *&ii) if (!ii) ii = new Int_t[n]; #ifdef R__BYTESWAP + if (IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy32(ii, fBufCur, n); - fBufCur += l; + bswapcpy32(ii, fBufCur, n); + fBufCur += l; # else - for (int i = 0; i < n; i++) - frombuf(fBufCur, &ii[i]); + for (int i = 0; i < n; i++) + frombuf(fBufCur, &ii[i]); # endif + } else { + memcpy(ii, fBufCur, l); + fBufCur += l; + } #else - memcpy(ii, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(ii, fBufCur, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy32(ii, fBufCur, n); + fBufCur += l; +# else + for (int i = 0; i < n; i++) + frombuf(fBufCur, &ii[i], 0); +# endif + } #endif return n; @@ -866,9 +920,9 @@ Int_t TBufferFile::ReadArray(Long_t *&ll) TFile *file = (TFile*)fParent; if (file && file->GetVersion() < 30006) { - for (int i = 0; i < n; i++) frombufOld(fBufCur, &ll[i]); + for (int i = 0; i < n; i++) frombufOld(fBufCur, &ll[i], IsBigEndian()); } else { - for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i]); + for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i], IsBigEndian()); } return n; } @@ -891,11 +945,21 @@ Int_t TBufferFile::ReadArray(Long64_t *&ll) if (!ll) ll = new Long64_t[n]; #ifdef R__BYTESWAP - for (int i = 0; i < n; i++) - frombuf(fBufCur, &ll[i]); + if (IsBigEndian()) { + for (int i = 0; i < n; i++) + frombuf(fBufCur, &ll[i]); + } else { + memcpy(ll, fBufCur, l); + fBufCur += l; + } #else - memcpy(ll, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(ll, fBufCur, l); + fBufCur += l; + } else { + for (int i = 0; i < n; i++) + frombuf(fBufCur, &ll[i], 0); + } #endif return n; @@ -919,16 +983,31 @@ Int_t TBufferFile::ReadArray(Float_t *&f) if (!f) f = new Float_t[n]; #ifdef R__BYTESWAP + if (IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy32(f, fBufCur, n); - fBufCur += l; + bswapcpy32(f, fBufCur, n); + fBufCur += l; # else - for (int i = 0; i < n; i++) - frombuf(fBufCur, &f[i]); + for (int i = 0; i < n; i++) + frombuf(fBufCur, &f[i]); # endif + } else { + memcpy(f, fBufCur, l); + fBufCur += l; + } #else - memcpy(f, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(f, fBufCur, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy32(f, fBufCur, n); + fBufCur += l; +# else + for (int i = 0; i < n; i++) + frombuf(fBufCur, &f[i], 0); +# endif + } #endif return n; @@ -952,11 +1031,21 @@ Int_t TBufferFile::ReadArray(Double_t *&d) if (!d) d = new Double_t[n]; #ifdef R__BYTESWAP - for (int i = 0; i < n; i++) - frombuf(fBufCur, &d[i]); + if (IsBigEndian()) { + for (int i = 0; i < n; i++) + frombuf(fBufCur, &d[i]); + } else { + memcpy(d, fBufCur, l); + fBufCur += l; + } #else - memcpy(d, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(d, fBufCur, l); + fBufCur += l; + } else { + for (int i = 0; i < n; i++) + frombuf(fBufCur, &d[i], 0); + } #endif return n; @@ -1072,16 +1161,31 @@ Int_t TBufferFile::ReadStaticArray(Short_t *h) if (!h) return 0; #ifdef R__BYTESWAP + if (IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy16(h, fBufCur, n); - fBufCur += l; + bswapcpy16(h, fBufCur, n); + fBufCur += l; # else - for (int i = 0; i < n; i++) - frombuf(fBufCur, &h[i]); + for (int i = 0; i < n; i++) + frombuf(fBufCur, &h[i]); # endif + } else { + memcpy(h, fBufCur, l); + fBufCur += l; + } #else - memcpy(h, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(h, fBufCur, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy16(h, fBufCur, n); + fBufCur += l; +# else + for (int i = 0; i < n; i++) + frombuf(fBufCur, &h[i], 0); +# endif + } #endif return n; @@ -1104,16 +1208,31 @@ Int_t TBufferFile::ReadStaticArray(Int_t *ii) if (!ii) return 0; #ifdef R__BYTESWAP + if (IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy32(ii, fBufCur, n); - fBufCur += sizeof(Int_t)*n; + bswapcpy32(ii, fBufCur, n); + fBufCur += sizeof(Int_t)*n; # else - for (int i = 0; i < n; i++) - frombuf(fBufCur, &ii[i]); + for (int i = 0; i < n; i++) + frombuf(fBufCur, &ii[i]); # endif + } else { + memcpy(ii, fBufCur, l); + fBufCur += l; + } #else - memcpy(ii, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(ii, fBufCur, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy32(ii, fBufCur, n); + fBufCur += sizeof(Int_t)*n; +# else + for (int i = 0; i < n; i++) + frombuf(fBufCur, &ii[i], 0); +# endif + } #endif return n; @@ -1137,9 +1256,9 @@ Int_t TBufferFile::ReadStaticArray(Long_t *ll) TFile *file = (TFile*)fParent; if (file && file->GetVersion() < 30006) { - for (int i = 0; i < n; i++) frombufOld(fBufCur, &ll[i]); + for (int i = 0; i < n; i++) frombufOld(fBufCur, &ll[i], IsBigEndian()); } else { - for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i]); + for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i], IsBigEndian()); } return n; } @@ -1161,11 +1280,21 @@ Int_t TBufferFile::ReadStaticArray(Long64_t *ll) if (!ll) return 0; #ifdef R__BYTESWAP - for (int i = 0; i < n; i++) - frombuf(fBufCur, &ll[i]); + if (IsBigEndian()) { + for (int i = 0; i < n; i++) + frombuf(fBufCur, &ll[i]); + } else { + memcpy(ll, fBufCur, l); + fBufCur += l; + } #else - memcpy(ll, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(ll, fBufCur, l); + fBufCur += l; + } else { + for (int i = 0; i < n; i++) + frombuf(fBufCur, &ll[i], 0); + } #endif return n; @@ -1188,16 +1317,31 @@ Int_t TBufferFile::ReadStaticArray(Float_t *f) if (!f) return 0; #ifdef R__BYTESWAP + if (IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy32(f, fBufCur, n); - fBufCur += sizeof(Float_t)*n; + bswapcpy32(f, fBufCur, n); + fBufCur += sizeof(Float_t)*n; # else - for (int i = 0; i < n; i++) - frombuf(fBufCur, &f[i]); + for (int i = 0; i < n; i++) + frombuf(fBufCur, &f[i]); # endif + } else { + memcpy(f, fBufCur, l); + fBufCur += l; + } #else - memcpy(f, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(f, fBufCur, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy32(f, fBufCur, n); + fBufCur += sizeof(Float_t)*n; +# else + for (int i = 0; i < n; i++) + frombuf(fBufCur, &f[i], 0); +# endif + } #endif return n; @@ -1220,11 +1364,21 @@ Int_t TBufferFile::ReadStaticArray(Double_t *d) if (!d) return 0; #ifdef R__BYTESWAP - for (int i = 0; i < n; i++) - frombuf(fBufCur, &d[i]); + if (IsBigEndian()) { + for (int i = 0; i < n; i++) + frombuf(fBufCur, &d[i]); + } else { + memcpy(d, fBufCur, l); + fBufCur += l; + } #else - memcpy(d, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(d, fBufCur, l); + fBufCur += l; + } else { + for (int i = 0; i < n; i++) + frombuf(fBufCur, &d[i], 0); + } #endif return n; @@ -1338,16 +1492,31 @@ void TBufferFile::ReadFastArray(Short_t *h, Int_t n) if (n <= 0 || l > fBufSize) return; #ifdef R__BYTESWAP + if (IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy16(h, fBufCur, n); - fBufCur += sizeof(Short_t)*n; + bswapcpy16(h, fBufCur, n); + fBufCur += sizeof(Short_t)*n; # else - for (int i = 0; i < n; i++) - frombuf(fBufCur, &h[i]); + for (int i = 0; i < n; i++) + frombuf(fBufCur, &h[i]); # endif + } else { + memcpy(h, fBufCur, l); + fBufCur += l; + } #else - memcpy(h, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(h, fBufCur, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy16(h, fBufCur, n); + fBufCur += sizeof(Short_t)*n; +# else + for (int i = 0; i < n; i++) + frombuf(fBufCur, &h[i], 0); +# endif + } #endif } @@ -1360,16 +1529,31 @@ void TBufferFile::ReadFastArray(Int_t *ii, Int_t n) if (l <= 0 || l > fBufSize) return; #ifdef R__BYTESWAP + if (IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy32(ii, fBufCur, n); - fBufCur += sizeof(Int_t)*n; + bswapcpy32(ii, fBufCur, n); + fBufCur += sizeof(Int_t)*n; # else - for (int i = 0; i < n; i++) - frombuf(fBufCur, &ii[i]); + for (int i = 0; i < n; i++) + frombuf(fBufCur, &ii[i]); # endif + } else { + memcpy(ii, fBufCur, l); + fBufCur += l; + } #else - memcpy(ii, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(ii, fBufCur, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy32(ii, fBufCur, n); + fBufCur += sizeof(Int_t)*n; +# else + for (int i = 0; i < n; i++) + frombuf(fBufCur, &ii[i], 0); +# endif + } #endif } @@ -1383,9 +1567,9 @@ void TBufferFile::ReadFastArray(Long_t *ll, Int_t n) TFile *file = (TFile*)fParent; if (file && file->GetVersion() < 30006) { - for (int i = 0; i < n; i++) frombufOld(fBufCur, &ll[i]); + for (int i = 0; i < n; i++) frombufOld(fBufCur, &ll[i], IsBigEndian()); } else { - for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i]); + for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i], IsBigEndian()); } } @@ -1398,11 +1582,21 @@ void TBufferFile::ReadFastArray(Long64_t *ll, Int_t n) if (l <= 0 || l > fBufSize) return; #ifdef R__BYTESWAP - for (int i = 0; i < n; i++) - frombuf(fBufCur, &ll[i]); + if (IsBigEndian()) { + for (int i = 0; i < n; i++) + frombuf(fBufCur, &ll[i]); + } else { + memcpy(ll, fBufCur, l); + fBufCur += l; + } #else - memcpy(ll, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(ll, fBufCur, l); + fBufCur += l; + } else { + for (int i = 0; i < n; i++) + frombuf(fBufCur, &ll[i], 0); + } #endif } @@ -1415,16 +1609,31 @@ void TBufferFile::ReadFastArray(Float_t *f, Int_t n) if (l <= 0 || l > fBufSize) return; #ifdef R__BYTESWAP + if (IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy32(f, fBufCur, n); - fBufCur += sizeof(Float_t)*n; + bswapcpy32(f, fBufCur, n); + fBufCur += sizeof(Float_t)*n; # else - for (int i = 0; i < n; i++) - frombuf(fBufCur, &f[i]); + for (int i = 0; i < n; i++) + frombuf(fBufCur, &f[i]); # endif + } else { + memcpy(f, fBufCur, l); + fBufCur += l; + } #else - memcpy(f, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(f, fBufCur, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy32(f, fBufCur, n); + fBufCur += sizeof(Float_t)*n; +# else + for (int i = 0; i < n; i++) + frombuf(fBufCur, &f[i], 0); +# endif + } #endif } @@ -1437,11 +1646,21 @@ void TBufferFile::ReadFastArray(Double_t *d, Int_t n) if (l <= 0 || l > fBufSize) return; #ifdef R__BYTESWAP - for (int i = 0; i < n; i++) - frombuf(fBufCur, &d[i]); + if (IsBigEndian()) { + for (int i = 0; i < n; i++) + frombuf(fBufCur, &d[i]); + } else { + memcpy(d, fBufCur, l); + fBufCur += l; + } #else - memcpy(d, fBufCur, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(d, fBufCur, l); + fBufCur += l; + } else { + for (int i = 0; i < n; i++) + frombuf(fBufCur, &d[i], 0); + } #endif } @@ -1826,9 +2045,10 @@ void TBufferFile::WriteArray(const Int_t *ii, Int_t n) # endif } else { memcpy(fBufCur, ii, l); + fBufCur += l; } - if(IsBigEndian()) { #else + if(IsBigEndian()) { memcpy(fBufCur, ii, l); fBufCur += l; } else { @@ -1837,7 +2057,7 @@ void TBufferFile::WriteArray(const Int_t *ii, Int_t n) fBufCur += l; # else for (int i = 0; i < n; i++) - tobuf(fBufCur, ii[i]); + tobuf(fBufCur, ii[i], 0); # endif } #endif @@ -1858,7 +2078,7 @@ void TBufferFile::WriteArray(const Long_t *ll, Int_t n) Int_t l = 8*n; if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); - for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i]); + for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i], IsBigEndian()); } //////////////////////////////////////////////////////////////////////////////// @@ -1878,7 +2098,7 @@ void TBufferFile::WriteArray(const ULong_t *ll, Int_t n) Int_t l = 8*n; if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); - for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i]); + for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i], IsBigEndian()); } //////////////////////////////////////////////////////////////////////////////// @@ -1911,7 +2131,7 @@ void TBufferFile::WriteArray(const Long64_t *ll, Int_t n) fBufCur += l; } else { for (int i = 0; i < n; i++) - tobuf(fBufCur, ll[i]); + tobuf(fBufCur, ll[i], 0); } #endif } @@ -2101,16 +2321,31 @@ void TBufferFile::WriteFastArray(const Short_t *h, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP + if(IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy16(fBufCur, h, n); - fBufCur += l; + bswapcpy16(fBufCur, h, n); + fBufCur += l; # else - for (int i = 0; i < n; i++) - tobuf(fBufCur, h[i]); + for (int i = 0; i < n; i++) + tobuf(fBufCur, h[i]); # endif + } else { + memcpy(fBufCur, h, l); + fBufCur += l; + } #else - memcpy(fBufCur, h, l); - fBufCur += l; + if(IsBigEndian()) { + memcpy(fBufCur, h, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy16(fBufCur, h, n); + fBufCur += l; +# else + for (int i = 0; i < n; i++) + tobuf(fBufCur, h[i], 0); +# endif + } #endif } @@ -2125,16 +2360,31 @@ void TBufferFile::WriteFastArray(const Int_t *ii, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP + if(IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy32(fBufCur, ii, n); - fBufCur += l; + bswapcpy32(fBufCur, ii, n); + fBufCur += l; # else - for (int i = 0; i < n; i++) - tobuf(fBufCur, ii[i]); + for (int i = 0; i < n; i++) + tobuf(fBufCur, ii[i]); # endif + } else { + memcpy(fBufCur, ii, l); + fBufCur += l; + } #else - memcpy(fBufCur, ii, l); - fBufCur += l; + if(IsBigEndian()) { + memcpy(fBufCur, ii, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy32(fBufCur, ii, n); + fBufCur += l; +# else + for (int i = 0; i < n; i++) + tobuf(fBufCur, ii[i], 0); +# endif + } #endif } @@ -2148,7 +2398,7 @@ void TBufferFile::WriteFastArray(const Long_t *ll, Int_t n) Int_t l = 8*n; if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); - for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i]); + for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i], IsBigEndian()); } //////////////////////////////////////////////////////////////////////////////// @@ -2163,7 +2413,7 @@ void TBufferFile::WriteFastArray(const ULong_t *ll, Int_t n) Int_t l = 8*n; if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); - for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i]); + for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i], IsBigEndian()); } //////////////////////////////////////////////////////////////////////////////// @@ -2177,11 +2427,21 @@ void TBufferFile::WriteFastArray(const Long64_t *ll, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - for (int i = 0; i < n; i++) - tobuf(fBufCur, ll[i]); + if(IsBigEndian()) { + for (int i = 0; i < n; i++) + tobuf(fBufCur, ll[i]); + } else { + memcpy(fBufCur, ll, l); + fBufCur += l; + } #else - memcpy(fBufCur, ll, l); - fBufCur += l; + if(IsBigEndian()) { + memcpy(fBufCur, ll, l); + fBufCur += l; + } else { + for (int i = 0; i < n; i++) + tobuf(fBufCur, ll[i], 0); + } #endif } @@ -2196,16 +2456,31 @@ void TBufferFile::WriteFastArray(const Float_t *f, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP + if(IsBigEndian()) { # ifdef USE_BSWAPCPY - bswapcpy32(fBufCur, f, n); - fBufCur += l; + bswapcpy32(fBufCur, f, n); + fBufCur += l; # else - for (int i = 0; i < n; i++) - tobuf(fBufCur, f[i]); + for (int i = 0; i < n; i++) + tobuf(fBufCur, f[i]); # endif + } else { + memcpy(fBufCur, f, l); + fBufCur += l; + } #else - memcpy(fBufCur, f, l); - fBufCur += l; + if(IsBigEndian()) { + memcpy(fBufCur, f, l); + fBufCur += l; + } else { +# ifdef USE_BSWAPCPY + bswapcpy32(fBufCur, f, n); + fBufCur += l; +# else + for (int i = 0; i < n; i++) + tobuf(fBufCur, f[i], 0); +# endif + } #endif } @@ -2220,11 +2495,21 @@ void TBufferFile::WriteFastArray(const Double_t *d, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - for (int i = 0; i < n; i++) - tobuf(fBufCur, d[i]); + if (IsBigEndian()) { + for (int i = 0; i < n; i++) + tobuf(fBufCur, d[i]); + } else { + memcpy(fBufCur, d, l); + fBufCur += l; + } #else - memcpy(fBufCur, d, l); - fBufCur += l; + if (IsBigEndian()) { + memcpy(fBufCur, d, l); + fBufCur += l; + } else { + for (int i = 0; i < n; i++) + tobuf(fBufCur, d[i], 0); + } #endif } @@ -2848,19 +3133,19 @@ void TBufferFile::SkipVersion(const TClass *cl) Version_t version; // not interested in byte count - frombuf(this->fBufCur,&version); + frombuf(this->fBufCur,&version, IsBigEndian()); // if this is a byte count, then skip next short and read version if (version & kByteCountVMask) { - frombuf(this->fBufCur,&version); - frombuf(this->fBufCur,&version); + frombuf(this->fBufCur,&version,IsBigEndian()); + frombuf(this->fBufCur,&version,IsBigEndian()); } if (cl && cl->GetClassVersion() != 0 && version<=1) { if (version <= 0) { UInt_t checksum = 0; //*this >> checksum; - frombuf(this->fBufCur,&checksum); + frombuf(this->fBufCur,&checksum, IsBigEndian()); TStreamerInfo *vinfo = (TStreamerInfo*)cl->FindStreamerInfo(checksum); if (vinfo) { return; @@ -2932,11 +3217,21 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass Version_t vers[2]; } v; #ifdef R__BYTESWAP - frombuf(this->fBufCur,&v.vers[1]); - frombuf(this->fBufCur,&v.vers[0]); + if (IsBigEndian()) { + frombuf(this->fBufCur,&v.vers[1]); + frombuf(this->fBufCur,&v.vers[0]); + } else { + frombuf(this->fBufCur,&v.vers[0], 0); + frombuf(this->fBufCur,&v.vers[1], 0); + } #else - frombuf(this->fBufCur,&v.vers[0]); - frombuf(this->fBufCur,&v.vers[1]); + if (IsBigEndian()) { + frombuf(this->fBufCur,&v.vers[0]); + frombuf(this->fBufCur,&v.vers[1]); + } else { + frombuf(this->fBufCur,&v.vers[1], 0); + frombuf(this->fBufCur,&v.vers[0], 0); + } #endif // no bytecount, backup and read version @@ -2945,7 +3240,7 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass v.cnt = 0; } if (bcnt) *bcnt = (v.cnt & ~kByteCountMask); - frombuf(this->fBufCur,&version); + frombuf(this->fBufCur,&version, IsBigEndian()); if (version<=1) { if (version <= 0) { @@ -2956,7 +3251,7 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass ) { UInt_t checksum = 0; //*this >> checksum; - frombuf(this->fBufCur,&checksum); + frombuf(this->fBufCur,&checksum, IsBigEndian()); TStreamerInfo *vinfo = (TStreamerInfo*)cl->FindStreamerInfo(checksum); if (vinfo) { return vinfo->TStreamerInfo::GetClassVersion(); // Try to get inlining. @@ -2984,7 +3279,7 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass //*this >> checksum; // If *bcnt < 6 then we have a class with 'just' version zero and no checksum if (v.cnt && v.cnt >= 6) - frombuf(this->fBufCur,&checksum); + frombuf(this->fBufCur,&checksum, IsBigEndian()); } } else if (version == 1 && fParent && ((TFile*)fParent)->GetVersion()<40000 && cl && cl->GetClassVersion() != 0) { // We could have a file created using a Foreign class before @@ -3038,11 +3333,21 @@ Version_t TBufferFile::ReadVersionNoCheckSum(UInt_t *startpos, UInt_t *bcnt) Version_t vers[2]; } v; #ifdef R__BYTESWAP - frombuf(this->fBufCur,&v.vers[1]); - frombuf(this->fBufCur,&v.vers[0]); + if (IsBigEndian()) { + frombuf(this->fBufCur,&v.vers[1]); + frombuf(this->fBufCur,&v.vers[0]); + } else { + frombuf(this->fBufCur,&v.vers[0], 0); + frombuf(this->fBufCur,&v.vers[1], 0); + } #else - frombuf(this->fBufCur,&v.vers[0]); - frombuf(this->fBufCur,&v.vers[1]); + if (IsBigEndian()) { + frombuf(this->fBufCur,&v.vers[0]); + frombuf(this->fBufCur,&v.vers[1]); + } else { + frombuf(this->fBufCur,&v.vers[1], 0); + frombuf(this->fBufCur,&v.vers[0], 0); + } #endif // no bytecount, backup and read version @@ -3051,7 +3356,7 @@ Version_t TBufferFile::ReadVersionNoCheckSum(UInt_t *startpos, UInt_t *bcnt) v.cnt = 0; } if (bcnt) *bcnt = (v.cnt & ~kByteCountMask); - frombuf(this->fBufCur,&version); + frombuf(this->fBufCur,&version,IsBigEndian()); return version; } @@ -3068,14 +3373,14 @@ Version_t TBufferFile::ReadVersionForMemberWise(const TClass *cl) Version_t version; // not interested in byte count - frombuf(this->fBufCur,&version); + frombuf(this->fBufCur,&version,IsBigEndian()); if (version<=1) { if (version <= 0) { if (cl) { if (cl->GetClassVersion() != 0) { UInt_t checksum = 0; - frombuf(this->fBufCur,&checksum); + frombuf(this->fBufCur,&checksum,IsBigEndian()); TStreamerInfo *vinfo = (TStreamerInfo*)cl->FindStreamerInfo(checksum); if (vinfo) { return vinfo->TStreamerInfo::GetClassVersion(); // Try to get inlining. @@ -3096,7 +3401,7 @@ Version_t TBufferFile::ReadVersionForMemberWise(const TClass *cl) } } else { // of if (cl) { UInt_t checksum = 0; - frombuf(this->fBufCur,&checksum); + frombuf(this->fBufCur,&checksum,IsBigEndian()); } } else if (version == 1 && fParent && ((TFile*)fParent)->GetVersion()<40000 && cl && cl->GetClassVersion() != 0) { // We could have a file created using a Foreign class before diff --git a/io/io/src/TDirectoryFile.cxx b/io/io/src/TDirectoryFile.cxx index d7033ccb9794b..45bd311d93235 100644 --- a/io/io/src/TDirectoryFile.cxx +++ b/io/io/src/TDirectoryFile.cxx @@ -702,7 +702,7 @@ void TDirectoryFile::Delete(const char *namecycle) //////////////////////////////////////////////////////////////////////////////// /// Encode directory header into output buffer -void TDirectoryFile::FillBuffer(char *&buffer, Bool_t buffBigEndian = kTRUE) +void TDirectoryFile::FillBuffer(char *&buffer) { Version_t version = TDirectoryFile::Class_Version(); if (fSeekDir > TFile::kStartBigFile || @@ -721,17 +721,17 @@ void TDirectoryFile::FillBuffer(char *&buffer, Bool_t buffBigEndian = kTRUE) tobuf(buffer, fNbytesKeys, buffBigEndian); tobuf(buffer, fNbytesName, buffBigEndian); if (version > 1000) { - tobuf(buffer, fSeekDir, buffBigEndian); - tobuf(buffer, fSeekParent, buffBigEndian); - tobuf(buffer, fSeekKeys, buffBigEndian); + tobuf(buffer, fSeekDir); + tobuf(buffer, fSeekParent); + tobuf(buffer, fSeekKeys); } else { - tobuf(buffer, (Int_t)fSeekDir, buffBigEndian); - tobuf(buffer, (Int_t)fSeekParent, buffBigEndian); - tobuf(buffer, (Int_t)fSeekKeys, buffBigEndian); + tobuf(buffer, (Int_t)fSeekDir); + tobuf(buffer, (Int_t)fSeekParent); + tobuf(buffer, (Int_t)fSeekKeys); } - fUUID.FillBuffer(buffer, buffBigEndian); + fUUID.FillBuffer(buffer); if (fFile && fFile->GetVersion() < 40000) return; - if (version <=1000) for (Int_t i=0;i<3;i++) tobuf(buffer,Int_t(0), buffBigEndian); + if (version <=1000) for (Int_t i=0;i<3;i++) tobuf(buffer,Int_t(0)); } //////////////////////////////////////////////////////////////////////////////// diff --git a/io/io/src/TFile.cxx b/io/io/src/TFile.cxx index 96babc90935a3..127451858c2c8 100644 --- a/io/io/src/TFile.cxx +++ b/io/io/src/TFile.cxx @@ -641,8 +641,8 @@ void TFile::Init(Bool_t create) fNbytesFree = 0; WriteHeader(); char *buffer = key->GetBuffer(); - TNamed::FillBuffer(buffer, key->IsBigEndian()); - TDirectoryFile::FillBuffer(buffer, key->IsBigEndian()); + TNamed::FillBuffer(buffer); + TDirectoryFile::FillBuffer(buffer); key->WriteFile(); delete key; } else { @@ -667,7 +667,7 @@ void TFile::Init(Bool_t create) } char *buffer = header + 4; // skip the "root" file identifier - frombuf(buffer, &fVersio); + frombuf(buffer, &fVersion); Int_t headerLength; frombuf(buffer, &headerLength); fBEGIN = (Long64_t)headerLength; @@ -742,7 +742,7 @@ void TFile::Init(Bool_t create) frombuf(buffer,&version); versiondir = version%1000; fDatimeC.ReadBuffer(buffer); fDatimeM.ReadBuffer(buffer); - frombuf(buffer, &fNbytesKeys; + frombuf(buffer, &fNbytesKeys); frombuf(buffer, &fNbytesName); if (version > 1000) { frombuf(buffer, &fSeekDir); @@ -2376,7 +2376,7 @@ void TFile::WriteFree() next.Reset(); while ((afree = (TFree*) next())) { - afree->FillBuffer(buffer, key->IsBigEndian()); + afree->FillBuffer(buffer); } if ( (buffer-start)!=nbytes ) { // Most likely one of the 'free' segment was used to store this diff --git a/io/io/src/TFree.cxx b/io/io/src/TFree.cxx index d024e1cd82afa..f3ad23ff06e5e 100644 --- a/io/io/src/TFree.cxx +++ b/io/io/src/TFree.cxx @@ -106,18 +106,18 @@ TFree::~TFree() //////////////////////////////////////////////////////////////////////////////// /// Encode free structure into output buffer. -void TFree::FillBuffer(char *&buffer, Bool_t buffBigEndian=kTRUE) +void TFree::FillBuffer(char *&buffer) { Version_t version = TFree::Class_Version(); if (fLast > TFile::kStartBigFile) version += 1000; - tobuf(buffer, version, buffBigEndian); + tobuf(buffer, version); //printf("TFree::fillBuffer, fFirst=%lld, fLast=%lld, version=%d\n",fFirst,fLast,version); if (version > 1000) { - tobuf(buffer, fFirst, buffBigEndian); - tobuf(buffer, fLast, buffBigEndian); + tobuf(buffer, fFirst); + tobuf(buffer, fLast); } else { - tobuf(buffer, (Int_t)fFirst, buffBigEndian); - tobuf(buffer, (Int_t)fLast, buffBigEndian); + tobuf(buffer, (Int_t)fFirst); + tobuf(buffer, (Int_t)fLast); } } diff --git a/io/io/src/TKey.cxx b/io/io/src/TKey.cxx index 183720a0dd08c..32db83073dcfa 100644 --- a/io/io/src/TKey.cxx +++ b/io/io/src/TKey.cxx @@ -582,18 +582,18 @@ Short_t TKey::GetKeep() const //////////////////////////////////////////////////////////////////////////////// /// Encode key header into output buffer. -void TKey::FillBuffer(char *&buffer, Bool_t buffBigEndian = kTRUE) +void TKey::FillBuffer(char *&buffer) { - tobuf(buffer, fNbytes, buffBigEndian); + tobuf(buffer, fNbytes); Version_t version = fVersion; - tobuf(buffer, version, buffBigEndian); + tobuf(buffer, version); - tobuf(buffer, fObjlen, buffBigEndian); - fDatime.FillBuffer(buffer, buffBigEndian); - tobuf(buffer, fKeylen, buffBigEndian); - tobuf(buffer, fCycle, buffBigEndian); + tobuf(buffer, fObjlen); + fDatime.FillBuffer(buffer); + tobuf(buffer, fKeylen); + tobuf(buffer, fCycle); if (fVersion > 1000) { - tobuf(buffer, fSeekKey, buffBigEndian); + tobuf(buffer, fSeekKey); // We currently store in the 16 highest bit of fSeekPdir the value of // fPidOffset. This offset is used when a key (or basket) is transfered from one @@ -603,19 +603,19 @@ void TKey::FillBuffer(char *&buffer, Bool_t buffBigEndian = kTRUE) // TProcessID. This fPidOffset needs to be increment if the key/basket is copied // and need to be zero for new key/basket. Long64_t pdir = (((Long64_t)fPidOffset)< Date: Tue, 12 Apr 2016 10:29:13 -0500 Subject: [PATCH 05/18] Change {Is,Set}{Endianess} to {Is,Set}Buf{Endianess} --- core/base/inc/TBuffer.h | 6 +- io/io/inc/TBufferFile.h | 30 +++---- io/io/src/TBufferFile.cxx | 168 +++++++++++++++++++------------------- 3 files changed, 102 insertions(+), 102 deletions(-) diff --git a/core/base/inc/TBuffer.h b/core/base/inc/TBuffer.h index 9afac1e6dbf80..61d35cb3b70c7 100644 --- a/core/base/inc/TBuffer.h +++ b/core/base/inc/TBuffer.h @@ -85,9 +85,9 @@ class TBuffer : public TObject { Bool_t IsWriting() const { return (fMode & kWrite) != 0; } void SetReadMode(); void SetWriteMode(); - Bool_t IsBigEndian() const { return fBufBigEndian; } - void SetBigEndian() { fBufBigEndian = 1; } - void SetLittleEndian() { fBufBigEndian = 0; } + Bool_t IsBufBigEndian() const { return fBufBigEndian; } + void SetBufBigEndian() { fBufBigEndian = 1; } + void SetBufLittleEndian() { fBufBigEndian = 0; } void SetBuffer(void *buf, UInt_t bufsiz = 0, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0); ReAllocCharFun_t GetReAllocFunc() const; void SetReAllocFunc(ReAllocCharFun_t reallocfunc = 0); diff --git a/io/io/inc/TBufferFile.h b/io/io/inc/TBufferFile.h index e5acd7b604ba5..024e89f13c119 100644 --- a/io/io/inc/TBufferFile.h +++ b/io/io/inc/TBufferFile.h @@ -350,70 +350,70 @@ inline void TBufferFile::WriteUChar(UChar_t c) inline void TBufferFile::WriteShort(Short_t h) { if (fBufCur + sizeof(Short_t) > fBufMax) AutoExpand(fBufSize+sizeof(Short_t)); - tobuf(fBufCur, h, IsBigEndian()); + tobuf(fBufCur, h, IsBufBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteUShort(UShort_t h) { if (fBufCur + sizeof(UShort_t) > fBufMax) AutoExpand(fBufSize+sizeof(UShort_t)); - tobuf(fBufCur, (Short_t)h, IsBigEndian()); + tobuf(fBufCur, (Short_t)h, IsBufBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteInt(Int_t i) { if (fBufCur + sizeof(Int_t) > fBufMax) AutoExpand(fBufSize+sizeof(Int_t)); - tobuf(fBufCur, i, IsBigEndian()); + tobuf(fBufCur, i, IsBufBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteUInt(UInt_t i) { if (fBufCur + sizeof(UInt_t) > fBufMax) AutoExpand(fBufSize+sizeof(UInt_t)); - tobuf(fBufCur, (Int_t)i, IsBigEndian()); + tobuf(fBufCur, (Int_t)i, IsBufBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteLong(Long_t l) { if (fBufCur + sizeof(Long_t) > fBufMax) AutoExpand(fBufSize+sizeof(Long_t)); - tobuf(fBufCur, l, IsBigEndian()); + tobuf(fBufCur, l, IsBufBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteULong(ULong_t l) { if (fBufCur + sizeof(ULong_t) > fBufMax) AutoExpand(fBufSize+sizeof(ULong_t)); - tobuf(fBufCur, (Long_t)l, IsBigEndian()); + tobuf(fBufCur, (Long_t)l, IsBufBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteLong64(Long64_t ll) { if (fBufCur + sizeof(Long64_t) > fBufMax) AutoExpand(fBufSize+sizeof(Long64_t)); - tobuf(fBufCur, ll, IsBigEndian()); + tobuf(fBufCur, ll, IsBufBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteULong64(ULong64_t ll) { if (fBufCur + sizeof(ULong64_t) > fBufMax) AutoExpand(fBufSize+sizeof(ULong64_t)); - tobuf(fBufCur, (Long64_t)ll, IsBigEndian()); + tobuf(fBufCur, (Long64_t)ll, IsBufBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteFloat(Float_t f) { if (fBufCur + sizeof(Float_t) > fBufMax) AutoExpand(fBufSize+sizeof(Float_t)); - tobuf(fBufCur, f, IsBigEndian()); + tobuf(fBufCur, f, IsBufBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::WriteDouble(Double_t d) { if (fBufCur + sizeof(Double_t) > fBufMax) AutoExpand(fBufSize+sizeof(Double_t)); - tobuf(fBufCur, d, IsBigEndian()); + tobuf(fBufCur, d, IsBufBigEndian()); } //______________________________________________________________________________ @@ -443,7 +443,7 @@ inline void TBufferFile::ReadUChar(UChar_t &c) //______________________________________________________________________________ inline void TBufferFile::ReadShort(Short_t &h) { - frombuf(fBufCur, &h, IsBigEndian()); + frombuf(fBufCur, &h, IsBufBigEndian()); } //______________________________________________________________________________ @@ -455,7 +455,7 @@ inline void TBufferFile::ReadUShort(UShort_t &h) //______________________________________________________________________________ inline void TBufferFile::ReadInt(Int_t &i) { - frombuf(fBufCur, &i, IsBigEndian()); + frombuf(fBufCur, &i, IsBufBigEndian()); } //______________________________________________________________________________ @@ -482,7 +482,7 @@ inline void TBufferFile::ReadULong(ULong_t &ll) //______________________________________________________________________________ inline void TBufferFile::ReadLong64(Long64_t &ll) { - frombuf(fBufCur, &ll, IsBigEndian()); + frombuf(fBufCur, &ll, IsBufBigEndian()); } //______________________________________________________________________________ @@ -494,13 +494,13 @@ inline void TBufferFile::ReadULong64(ULong64_t &ll) //______________________________________________________________________________ inline void TBufferFile::ReadFloat(Float_t &f) { - frombuf(fBufCur, &f, IsBigEndian()); + frombuf(fBufCur, &f, IsBufBigEndian()); } //______________________________________________________________________________ inline void TBufferFile::ReadDouble(Double_t &d) { - frombuf(fBufCur, &d, IsBigEndian()); + frombuf(fBufCur, &d, IsBufBigEndian()); } //______________________________________________________________________________ diff --git a/io/io/src/TBufferFile.cxx b/io/io/src/TBufferFile.cxx index a0acebe0301bb..e728a5c51e907 100644 --- a/io/io/src/TBufferFile.cxx +++ b/io/io/src/TBufferFile.cxx @@ -265,9 +265,9 @@ void TBufferFile::ReadLong(Long_t &l) { TFile *file = (TFile*)fParent; if (file && file->GetVersion() < 30006) { - frombufOld(fBufCur, &l, IsBigEndian()); + frombufOld(fBufCur, &l, IsBufBigEndian()); } else { - frombuf(fBufCur, &l, IsBigEndian()); + frombuf(fBufCur, &l, IsBufBigEndian()); } } @@ -381,7 +381,7 @@ void TBufferFile::SetByteCount(UInt_t cntpos, Bool_t packInVersion) } v; v.cnt = cnt; #ifdef R__BYTESWAP - if(IsBigEndian()) { + if(IsBufBigEndian()) { tobuf(buf, Version_t(v.vers[1] | kByteCountVMask)); tobuf(buf, v.vers[0]); } else { @@ -389,7 +389,7 @@ void TBufferFile::SetByteCount(UInt_t cntpos, Bool_t packInVersion) tobuf(buf, Version_t(v.vers[1] | kByteCountVMask), 0); } #else - if(IsBigEndian()) { + if(IsBufBigEndian()) { tobuf(buf, Version_t(v.vers[0] | kByteCountVMask)); tobuf(buf, v.vers[1]); } else { @@ -398,7 +398,7 @@ void TBufferFile::SetByteCount(UInt_t cntpos, Bool_t packInVersion) } #endif } else - tobuf(buf, cnt | kByteCountMask, IsBigEndian()); + tobuf(buf, cnt | kByteCountMask, IsBufBigEndian()); if (cnt >= kMaxMapCount) { Error("WriteByteCount", "bytecount too large (more than %d)", kMaxMapCount); @@ -533,7 +533,7 @@ void TBufferFile::ReadWithFactor(Float_t *ptr, Double_t factor, Double_t minvalu { //a range was specified. We read an integer and convert it back to a double. UInt_t aint; - frombuf(this->fBufCur,&aint,IsBigEndian()); + frombuf(this->fBufCur,&aint,IsBufBigEndian()); ptr[0] = (Float_t)(aint/factor + minvalue); } @@ -552,7 +552,7 @@ void TBufferFile::ReadWithNbits(Float_t *ptr, Int_t nbits) UChar_t theExp; UShort_t theMan; frombuf(this->fBufCur,&theExp); - frombuf(this->fBufCur,&theMan,IsBigEndian()); + frombuf(this->fBufCur,&theMan,IsBufBigEndian()); temp.fIntValue = theExp; temp.fIntValue <<= 23; temp.fIntValue |= (theMan & ((1<<(nbits+1))-1)) <<(23-nbits); @@ -568,7 +568,7 @@ void TBufferFile::ReadWithFactor(Double_t *ptr, Double_t factor, Double_t minval { //a range was specified. We read an integer and convert it back to a double. UInt_t aint; - frombuf(this->fBufCur,&aint,IsBigEndian()); + frombuf(this->fBufCur,&aint,IsBufBigEndian()); ptr[0] = (Double_t)(aint/factor + minvalue); } @@ -587,7 +587,7 @@ void TBufferFile::ReadWithNbits(Double_t *ptr, Int_t nbits) UChar_t theExp; UShort_t theMan; frombuf(this->fBufCur,&theExp); - frombuf(this->fBufCur,&theMan,IsBigEndian()); + frombuf(this->fBufCur,&theMan,IsBufBigEndian()); temp.fIntValue = theExp; temp.fIntValue <<= 23; temp.fIntValue |= (theMan & ((1<<(nbits+1))-1)) <<(23-nbits); @@ -823,7 +823,7 @@ Int_t TBufferFile::ReadArray(Short_t *&h) if (!h) h = new Short_t[n]; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy16(h, fBufCur, n); fBufCur += l; @@ -836,7 +836,7 @@ Int_t TBufferFile::ReadArray(Short_t *&h) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(h, fBufCur, l); fBufCur += l; } else { @@ -871,7 +871,7 @@ Int_t TBufferFile::ReadArray(Int_t *&ii) if (!ii) ii = new Int_t[n]; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy32(ii, fBufCur, n); fBufCur += l; @@ -884,7 +884,7 @@ Int_t TBufferFile::ReadArray(Int_t *&ii) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(ii, fBufCur, l); fBufCur += l; } else { @@ -920,9 +920,9 @@ Int_t TBufferFile::ReadArray(Long_t *&ll) TFile *file = (TFile*)fParent; if (file && file->GetVersion() < 30006) { - for (int i = 0; i < n; i++) frombufOld(fBufCur, &ll[i], IsBigEndian()); + for (int i = 0; i < n; i++) frombufOld(fBufCur, &ll[i], IsBufBigEndian()); } else { - for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i], IsBigEndian()); + for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i], IsBufBigEndian()); } return n; } @@ -945,7 +945,7 @@ Int_t TBufferFile::ReadArray(Long64_t *&ll) if (!ll) ll = new Long64_t[n]; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i]); } else { @@ -953,7 +953,7 @@ Int_t TBufferFile::ReadArray(Long64_t *&ll) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(ll, fBufCur, l); fBufCur += l; } else { @@ -983,7 +983,7 @@ Int_t TBufferFile::ReadArray(Float_t *&f) if (!f) f = new Float_t[n]; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy32(f, fBufCur, n); fBufCur += l; @@ -996,7 +996,7 @@ Int_t TBufferFile::ReadArray(Float_t *&f) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(f, fBufCur, l); fBufCur += l; } else { @@ -1031,7 +1031,7 @@ Int_t TBufferFile::ReadArray(Double_t *&d) if (!d) d = new Double_t[n]; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { for (int i = 0; i < n; i++) frombuf(fBufCur, &d[i]); } else { @@ -1039,7 +1039,7 @@ Int_t TBufferFile::ReadArray(Double_t *&d) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(d, fBufCur, l); fBufCur += l; } else { @@ -1161,7 +1161,7 @@ Int_t TBufferFile::ReadStaticArray(Short_t *h) if (!h) return 0; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy16(h, fBufCur, n); fBufCur += l; @@ -1174,7 +1174,7 @@ Int_t TBufferFile::ReadStaticArray(Short_t *h) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(h, fBufCur, l); fBufCur += l; } else { @@ -1208,7 +1208,7 @@ Int_t TBufferFile::ReadStaticArray(Int_t *ii) if (!ii) return 0; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy32(ii, fBufCur, n); fBufCur += sizeof(Int_t)*n; @@ -1221,7 +1221,7 @@ Int_t TBufferFile::ReadStaticArray(Int_t *ii) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(ii, fBufCur, l); fBufCur += l; } else { @@ -1256,9 +1256,9 @@ Int_t TBufferFile::ReadStaticArray(Long_t *ll) TFile *file = (TFile*)fParent; if (file && file->GetVersion() < 30006) { - for (int i = 0; i < n; i++) frombufOld(fBufCur, &ll[i], IsBigEndian()); + for (int i = 0; i < n; i++) frombufOld(fBufCur, &ll[i], IsBufBigEndian()); } else { - for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i], IsBigEndian()); + for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i], IsBufBigEndian()); } return n; } @@ -1280,7 +1280,7 @@ Int_t TBufferFile::ReadStaticArray(Long64_t *ll) if (!ll) return 0; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i]); } else { @@ -1288,7 +1288,7 @@ Int_t TBufferFile::ReadStaticArray(Long64_t *ll) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(ll, fBufCur, l); fBufCur += l; } else { @@ -1317,7 +1317,7 @@ Int_t TBufferFile::ReadStaticArray(Float_t *f) if (!f) return 0; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy32(f, fBufCur, n); fBufCur += sizeof(Float_t)*n; @@ -1330,7 +1330,7 @@ Int_t TBufferFile::ReadStaticArray(Float_t *f) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(f, fBufCur, l); fBufCur += l; } else { @@ -1364,7 +1364,7 @@ Int_t TBufferFile::ReadStaticArray(Double_t *d) if (!d) return 0; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { for (int i = 0; i < n; i++) frombuf(fBufCur, &d[i]); } else { @@ -1372,7 +1372,7 @@ Int_t TBufferFile::ReadStaticArray(Double_t *d) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(d, fBufCur, l); fBufCur += l; } else { @@ -1492,7 +1492,7 @@ void TBufferFile::ReadFastArray(Short_t *h, Int_t n) if (n <= 0 || l > fBufSize) return; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy16(h, fBufCur, n); fBufCur += sizeof(Short_t)*n; @@ -1505,7 +1505,7 @@ void TBufferFile::ReadFastArray(Short_t *h, Int_t n) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(h, fBufCur, l); fBufCur += l; } else { @@ -1529,7 +1529,7 @@ void TBufferFile::ReadFastArray(Int_t *ii, Int_t n) if (l <= 0 || l > fBufSize) return; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy32(ii, fBufCur, n); fBufCur += sizeof(Int_t)*n; @@ -1542,7 +1542,7 @@ void TBufferFile::ReadFastArray(Int_t *ii, Int_t n) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(ii, fBufCur, l); fBufCur += l; } else { @@ -1567,9 +1567,9 @@ void TBufferFile::ReadFastArray(Long_t *ll, Int_t n) TFile *file = (TFile*)fParent; if (file && file->GetVersion() < 30006) { - for (int i = 0; i < n; i++) frombufOld(fBufCur, &ll[i], IsBigEndian()); + for (int i = 0; i < n; i++) frombufOld(fBufCur, &ll[i], IsBufBigEndian()); } else { - for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i], IsBigEndian()); + for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i], IsBufBigEndian()); } } @@ -1582,7 +1582,7 @@ void TBufferFile::ReadFastArray(Long64_t *ll, Int_t n) if (l <= 0 || l > fBufSize) return; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { for (int i = 0; i < n; i++) frombuf(fBufCur, &ll[i]); } else { @@ -1590,7 +1590,7 @@ void TBufferFile::ReadFastArray(Long64_t *ll, Int_t n) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(ll, fBufCur, l); fBufCur += l; } else { @@ -1609,7 +1609,7 @@ void TBufferFile::ReadFastArray(Float_t *f, Int_t n) if (l <= 0 || l > fBufSize) return; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy32(f, fBufCur, n); fBufCur += sizeof(Float_t)*n; @@ -1622,7 +1622,7 @@ void TBufferFile::ReadFastArray(Float_t *f, Int_t n) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(f, fBufCur, l); fBufCur += l; } else { @@ -1646,7 +1646,7 @@ void TBufferFile::ReadFastArray(Double_t *d, Int_t n) if (l <= 0 || l > fBufSize) return; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { for (int i = 0; i < n; i++) frombuf(fBufCur, &d[i]); } else { @@ -1654,7 +1654,7 @@ void TBufferFile::ReadFastArray(Double_t *d, Int_t n) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(d, fBufCur, l); fBufCur += l; } else { @@ -1990,7 +1990,7 @@ void TBufferFile::WriteArray(const Short_t *h, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - if(IsBigEndian()) { + if(IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy16(fBufCur, h, n); fBufCur += l; @@ -2003,7 +2003,7 @@ void TBufferFile::WriteArray(const Short_t *h, Int_t n) fBufCur += l; } #else - if(IsBigEndian()) { + if(IsBufBigEndian()) { memcpy(fBufCur, h, l); fBufCur += l; } else { @@ -2035,7 +2035,7 @@ void TBufferFile::WriteArray(const Int_t *ii, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - if(IsBigEndian()) { + if(IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy32(fBufCur, ii, n); fBufCur += l; @@ -2048,7 +2048,7 @@ void TBufferFile::WriteArray(const Int_t *ii, Int_t n) fBufCur += l; } #else - if(IsBigEndian()) { + if(IsBufBigEndian()) { memcpy(fBufCur, ii, l); fBufCur += l; } else { @@ -2078,7 +2078,7 @@ void TBufferFile::WriteArray(const Long_t *ll, Int_t n) Int_t l = 8*n; if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); - for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i], IsBigEndian()); + for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i], IsBufBigEndian()); } //////////////////////////////////////////////////////////////////////////////// @@ -2098,7 +2098,7 @@ void TBufferFile::WriteArray(const ULong_t *ll, Int_t n) Int_t l = 8*n; if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); - for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i], IsBigEndian()); + for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i], IsBufBigEndian()); } //////////////////////////////////////////////////////////////////////////////// @@ -2118,7 +2118,7 @@ void TBufferFile::WriteArray(const Long64_t *ll, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - if(IsBigEndian()) { + if(IsBufBigEndian()) { for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i]); } else { @@ -2126,7 +2126,7 @@ void TBufferFile::WriteArray(const Long64_t *ll, Int_t n) fBufCur += l; } #else - if(IsBigEndian()) { + if(IsBufBigEndian()) { memcpy(fBufCur, ll, l); fBufCur += l; } else { @@ -2153,7 +2153,7 @@ void TBufferFile::WriteArray(const Float_t *f, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - if(IsBigEndian()) { + if(IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy32(fBufCur, f, n); fBufCur += l; @@ -2166,7 +2166,7 @@ void TBufferFile::WriteArray(const Float_t *f, Int_t n) fBufCur += l; } #else - if(IsBigEndian()) { + if(IsBufBigEndian()) { memcpy(fBufCur, f, l); fBufCur += l; } else { @@ -2198,7 +2198,7 @@ void TBufferFile::WriteArray(const Double_t *d, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - if(IsBigEndian()) { + if(IsBufBigEndian()) { for (int i = 0; i < n; i++) tobuf(fBufCur, d[i]); } else { @@ -2206,7 +2206,7 @@ void TBufferFile::WriteArray(const Double_t *d, Int_t n) fBufCur += l; } #else - if(IsBigEndian()) { + if(IsBufBigEndian()) { memcpy(fBufCur, d, l); fBufCur += l; } else { @@ -2321,7 +2321,7 @@ void TBufferFile::WriteFastArray(const Short_t *h, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - if(IsBigEndian()) { + if(IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy16(fBufCur, h, n); fBufCur += l; @@ -2334,7 +2334,7 @@ void TBufferFile::WriteFastArray(const Short_t *h, Int_t n) fBufCur += l; } #else - if(IsBigEndian()) { + if(IsBufBigEndian()) { memcpy(fBufCur, h, l); fBufCur += l; } else { @@ -2360,7 +2360,7 @@ void TBufferFile::WriteFastArray(const Int_t *ii, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - if(IsBigEndian()) { + if(IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy32(fBufCur, ii, n); fBufCur += l; @@ -2373,7 +2373,7 @@ void TBufferFile::WriteFastArray(const Int_t *ii, Int_t n) fBufCur += l; } #else - if(IsBigEndian()) { + if(IsBufBigEndian()) { memcpy(fBufCur, ii, l); fBufCur += l; } else { @@ -2398,7 +2398,7 @@ void TBufferFile::WriteFastArray(const Long_t *ll, Int_t n) Int_t l = 8*n; if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); - for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i], IsBigEndian()); + for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i], IsBufBigEndian()); } //////////////////////////////////////////////////////////////////////////////// @@ -2413,7 +2413,7 @@ void TBufferFile::WriteFastArray(const ULong_t *ll, Int_t n) Int_t l = 8*n; if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); - for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i], IsBigEndian()); + for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i], IsBufBigEndian()); } //////////////////////////////////////////////////////////////////////////////// @@ -2427,7 +2427,7 @@ void TBufferFile::WriteFastArray(const Long64_t *ll, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - if(IsBigEndian()) { + if(IsBufBigEndian()) { for (int i = 0; i < n; i++) tobuf(fBufCur, ll[i]); } else { @@ -2435,7 +2435,7 @@ void TBufferFile::WriteFastArray(const Long64_t *ll, Int_t n) fBufCur += l; } #else - if(IsBigEndian()) { + if(IsBufBigEndian()) { memcpy(fBufCur, ll, l); fBufCur += l; } else { @@ -2456,7 +2456,7 @@ void TBufferFile::WriteFastArray(const Float_t *f, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - if(IsBigEndian()) { + if(IsBufBigEndian()) { # ifdef USE_BSWAPCPY bswapcpy32(fBufCur, f, n); fBufCur += l; @@ -2469,7 +2469,7 @@ void TBufferFile::WriteFastArray(const Float_t *f, Int_t n) fBufCur += l; } #else - if(IsBigEndian()) { + if(IsBufBigEndian()) { memcpy(fBufCur, f, l); fBufCur += l; } else { @@ -2495,7 +2495,7 @@ void TBufferFile::WriteFastArray(const Double_t *d, Int_t n) if (fBufCur + l > fBufMax) AutoExpand(fBufSize+l); #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { for (int i = 0; i < n; i++) tobuf(fBufCur, d[i]); } else { @@ -2503,7 +2503,7 @@ void TBufferFile::WriteFastArray(const Double_t *d, Int_t n) fBufCur += l; } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { memcpy(fBufCur, d, l); fBufCur += l; } else { @@ -3133,19 +3133,19 @@ void TBufferFile::SkipVersion(const TClass *cl) Version_t version; // not interested in byte count - frombuf(this->fBufCur,&version, IsBigEndian()); + frombuf(this->fBufCur,&version, IsBufBigEndian()); // if this is a byte count, then skip next short and read version if (version & kByteCountVMask) { - frombuf(this->fBufCur,&version,IsBigEndian()); - frombuf(this->fBufCur,&version,IsBigEndian()); + frombuf(this->fBufCur,&version,IsBufBigEndian()); + frombuf(this->fBufCur,&version,IsBufBigEndian()); } if (cl && cl->GetClassVersion() != 0 && version<=1) { if (version <= 0) { UInt_t checksum = 0; //*this >> checksum; - frombuf(this->fBufCur,&checksum, IsBigEndian()); + frombuf(this->fBufCur,&checksum, IsBufBigEndian()); TStreamerInfo *vinfo = (TStreamerInfo*)cl->FindStreamerInfo(checksum); if (vinfo) { return; @@ -3217,7 +3217,7 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass Version_t vers[2]; } v; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { frombuf(this->fBufCur,&v.vers[1]); frombuf(this->fBufCur,&v.vers[0]); } else { @@ -3225,7 +3225,7 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass frombuf(this->fBufCur,&v.vers[1], 0); } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { frombuf(this->fBufCur,&v.vers[0]); frombuf(this->fBufCur,&v.vers[1]); } else { @@ -3240,7 +3240,7 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass v.cnt = 0; } if (bcnt) *bcnt = (v.cnt & ~kByteCountMask); - frombuf(this->fBufCur,&version, IsBigEndian()); + frombuf(this->fBufCur,&version, IsBufBigEndian()); if (version<=1) { if (version <= 0) { @@ -3251,7 +3251,7 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass ) { UInt_t checksum = 0; //*this >> checksum; - frombuf(this->fBufCur,&checksum, IsBigEndian()); + frombuf(this->fBufCur,&checksum, IsBufBigEndian()); TStreamerInfo *vinfo = (TStreamerInfo*)cl->FindStreamerInfo(checksum); if (vinfo) { return vinfo->TStreamerInfo::GetClassVersion(); // Try to get inlining. @@ -3279,7 +3279,7 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass //*this >> checksum; // If *bcnt < 6 then we have a class with 'just' version zero and no checksum if (v.cnt && v.cnt >= 6) - frombuf(this->fBufCur,&checksum, IsBigEndian()); + frombuf(this->fBufCur,&checksum, IsBufBigEndian()); } } else if (version == 1 && fParent && ((TFile*)fParent)->GetVersion()<40000 && cl && cl->GetClassVersion() != 0) { // We could have a file created using a Foreign class before @@ -3333,7 +3333,7 @@ Version_t TBufferFile::ReadVersionNoCheckSum(UInt_t *startpos, UInt_t *bcnt) Version_t vers[2]; } v; #ifdef R__BYTESWAP - if (IsBigEndian()) { + if (IsBufBigEndian()) { frombuf(this->fBufCur,&v.vers[1]); frombuf(this->fBufCur,&v.vers[0]); } else { @@ -3341,7 +3341,7 @@ Version_t TBufferFile::ReadVersionNoCheckSum(UInt_t *startpos, UInt_t *bcnt) frombuf(this->fBufCur,&v.vers[1], 0); } #else - if (IsBigEndian()) { + if (IsBufBigEndian()) { frombuf(this->fBufCur,&v.vers[0]); frombuf(this->fBufCur,&v.vers[1]); } else { @@ -3356,7 +3356,7 @@ Version_t TBufferFile::ReadVersionNoCheckSum(UInt_t *startpos, UInt_t *bcnt) v.cnt = 0; } if (bcnt) *bcnt = (v.cnt & ~kByteCountMask); - frombuf(this->fBufCur,&version,IsBigEndian()); + frombuf(this->fBufCur,&version,IsBufBigEndian()); return version; } @@ -3373,14 +3373,14 @@ Version_t TBufferFile::ReadVersionForMemberWise(const TClass *cl) Version_t version; // not interested in byte count - frombuf(this->fBufCur,&version,IsBigEndian()); + frombuf(this->fBufCur,&version,IsBufBigEndian()); if (version<=1) { if (version <= 0) { if (cl) { if (cl->GetClassVersion() != 0) { UInt_t checksum = 0; - frombuf(this->fBufCur,&checksum,IsBigEndian()); + frombuf(this->fBufCur,&checksum,IsBufBigEndian()); TStreamerInfo *vinfo = (TStreamerInfo*)cl->FindStreamerInfo(checksum); if (vinfo) { return vinfo->TStreamerInfo::GetClassVersion(); // Try to get inlining. @@ -3401,7 +3401,7 @@ Version_t TBufferFile::ReadVersionForMemberWise(const TClass *cl) } } else { // of if (cl) { UInt_t checksum = 0; - frombuf(this->fBufCur,&checksum,IsBigEndian()); + frombuf(this->fBufCur,&checksum,IsBufBigEndian()); } } else if (version == 1 && fParent && ((TFile*)fParent)->GetVersion()<40000 && cl && cl->GetClassVersion() != 0) { // We could have a file created using a Foreign class before From 37bae27f9932d1e78a5cb10e1f807fe4fefa3113 Mon Sep 17 00:00:00 2001 From: zzxuanyuan Date: Tue, 12 Apr 2016 11:12:07 -0500 Subject: [PATCH 06/18] Add debug info and set gROOT to little endian in MainEvent.cxx --- io/io/src/TFile.cxx | 7 +++++++ test/MainEvent.cxx | 1 + 2 files changed, 8 insertions(+) diff --git a/io/io/src/TFile.cxx b/io/io/src/TFile.cxx index 127451858c2c8..e9023132d3a8a 100644 --- a/io/io/src/TFile.cxx +++ b/io/io/src/TFile.cxx @@ -1332,6 +1332,13 @@ TList *TFile::GetStreamerInfoList() GetName()); return 0; } + //### + int cnt = 0; + for(cnt=0;cntReadKeyBuffer(buf); list = dynamic_cast(key->ReadObjWithBuffer(buffer)); if (list) list->SetOwner(); diff --git a/test/MainEvent.cxx b/test/MainEvent.cxx index b102e1098e774..c119b0d7e635a 100644 --- a/test/MainEvent.cxx +++ b/test/MainEvent.cxx @@ -100,6 +100,7 @@ using namespace std; int main(int argc, char **argv) { + gROOT->SetBufLittleEndian(); Int_t nevent = 400; // by default create 400 events Int_t comp = 1; // by default file is compressed Int_t split = 1; // by default, split Event in sub branches From 7e3ca53f06dfb3df8a623fe0b9b3847c4c5898b2 Mon Sep 17 00:00:00 2001 From: zzxuanyuan Date: Fri, 15 Apr 2016 22:19:04 -0500 Subject: [PATCH 07/18] Added debug messages --- core/base/inc/TBuffer.h | 6 +++--- core/base/src/TBuffer.cxx | 33 +++++++++++++++++++++++++------ io/io/inc/TBufferFile.h | 6 +++--- io/io/inc/TKey.h | 6 +++--- io/io/src/TBufferFile.cxx | 38 ++++++++++++++++-------------------- io/io/src/TDirectoryFile.cxx | 10 +++++----- io/io/src/TFile.cxx | 2 +- io/io/src/TKey.cxx | 12 ++++++------ net/net/src/TMessage.cxx | 2 +- test/MainEvent.cxx | 2 +- 10 files changed, 67 insertions(+), 50 deletions(-) diff --git a/core/base/inc/TBuffer.h b/core/base/inc/TBuffer.h index 61d35cb3b70c7..399c7ec168c86 100644 --- a/core/base/inc/TBuffer.h +++ b/core/base/inc/TBuffer.h @@ -75,9 +75,9 @@ class TBuffer : public TObject { enum { kCannotHandleMemberWiseStreaming = BIT(17)}; //if set TClonesArray should not use member wise streaming enum { kInitialSize = 1024, kMinimalSize = 128 }; - TBuffer(EMode mode); - TBuffer(EMode mode, Int_t bufsiz); - TBuffer(EMode mode, Int_t bufsiz, void *buf, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0); + TBuffer(EMode mode, Bool_t def = kTRUE, Bool_t buffBigEndian = kTRUE); + TBuffer(EMode mode, Int_t bufsiz, Bool_t def = kTRUE, Bool_t buffBigEndian = kTRUE); + TBuffer(EMode mode, Int_t bufsiz, void *buf, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0, Bool_t def = kTRUE, Bool_t buffBigEndian = kTRUE); virtual ~TBuffer(); Int_t GetBufferVersion() const { return fVersion; } diff --git a/core/base/src/TBuffer.cxx b/core/base/src/TBuffer.cxx index 75f1dc2afb7b5..f29e2e0926916 100644 --- a/core/base/src/TBuffer.cxx +++ b/core/base/src/TBuffer.cxx @@ -36,13 +36,20 @@ static char *R__NoReAllocChar(char *, size_t, size_t) /// TBuffer::kWrite. By default the I/O buffer has a size of /// TBuffer::kInitialSize (1024) bytes. -TBuffer::TBuffer(EMode mode) +TBuffer::TBuffer(EMode mode, Bool_t def, Bool_t buffBigEndian) { fBufSize = kInitialSize; fMode = mode; fVersion = 0; fParent = 0; - fBufBigEndian = gROOT->IsBufBigEndian(); + if (def) { + fBufBigEndian = gROOT->IsBufBigEndian(); + } else { + if (buffBigEndian) + fBufBigEndian = kTRUE; + else + fBufBigEndian = kFALSE; + } SetBit(kIsOwner); @@ -58,14 +65,21 @@ TBuffer::TBuffer(EMode mode) /// Create an I/O buffer object. Mode should be either TBuffer::kRead or /// TBuffer::kWrite. -TBuffer::TBuffer(EMode mode, Int_t bufsiz) +TBuffer::TBuffer(EMode mode, Int_t bufsiz, Bool_t def, Bool_t buffBigEndian) { if (bufsiz < kMinimalSize) bufsiz = kMinimalSize; fBufSize = bufsiz; fMode = mode; fVersion = 0; fParent = 0; - fBufBigEndian = gROOT->IsBufBigEndian(); + if (def) { + fBufBigEndian = gROOT->IsBufBigEndian(); + } else { + if (buffBigEndian) + fBufBigEndian = kTRUE; + else + fBufBigEndian = kFALSE; + } SetBit(kIsOwner); @@ -88,13 +102,20 @@ TBuffer::TBuffer(EMode mode, Int_t bufsiz) /// is provided, a Fatal error will be issued if the Buffer attempts to /// expand. -TBuffer::TBuffer(EMode mode, Int_t bufsiz, void *buf, Bool_t adopt, ReAllocCharFun_t reallocfunc) +TBuffer::TBuffer(EMode mode, Int_t bufsiz, void *buf, Bool_t adopt, ReAllocCharFun_t reallocfunc, Bool_t def, Bool_t buffBigEndian) { fBufSize = bufsiz; fMode = mode; fVersion = 0; fParent = 0; - fBufBigEndian = gROOT->IsBufBigEndian(); + if (def) { + fBufBigEndian = gROOT->IsBufBigEndian(); + } else { + if (buffBigEndian) + fBufBigEndian = kTRUE; + else + fBufBigEndian = kFALSE; + } SetBit(kIsOwner); diff --git a/io/io/inc/TBufferFile.h b/io/io/inc/TBufferFile.h index 024e89f13c119..9371e25b2ddc9 100644 --- a/io/io/inc/TBufferFile.h +++ b/io/io/inc/TBufferFile.h @@ -86,9 +86,9 @@ class TBufferFile : public TBuffer { enum { kTextBasedStreaming = BIT(18) }; //indicates if buffer used for XML/SQL object streaming enum { kUser1 = BIT(21), kUser2 = BIT(22), kUser3 = BIT(23)}; //free for user - TBufferFile(TBuffer::EMode mode); - TBufferFile(TBuffer::EMode mode, Int_t bufsiz); - TBufferFile(TBuffer::EMode mode, Int_t bufsiz, void *buf, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0); + TBufferFile(TBuffer::EMode mode, Bool_t def = kTRUE, Bool_t buffBigEndian = kTRUE); + TBufferFile(TBuffer::EMode mode, Int_t bufsiz, Bool_t def = kTRUE, Bool_t buffBigEndian = kTRUE); + TBufferFile(TBuffer::EMode mode, Int_t bufsiz, void *buf, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = 0, Bool_t def = kTRUE, Bool_t buffBigEndian = kTRUE); virtual ~TBufferFile(); Int_t GetMapCount() const { return fMapCount; } diff --git a/io/io/inc/TKey.h b/io/io/inc/TKey.h index f8f2378da59c8..39f14a985e961 100644 --- a/io/io/inc/TKey.h +++ b/io/io/inc/TKey.h @@ -62,11 +62,11 @@ class TKey : public TNamed { public: TKey(); TKey(TDirectory* motherDir); - TKey(TDirectory* motherDir, const TKey &orig, UShort_t pidOffset); + TKey(TDirectory* motherDir, const TKey &orig, UShort_t pidOffset, Bool_t def = kTRUE, Bool_t buffBigEndian = kTRUE); TKey(const char *name, const char *title, const TClass *cl, Int_t nbytes, TDirectory* motherDir); TKey(const TString &name, const TString &title, const TClass *cl, Int_t nbytes, TDirectory* motherDir); - TKey(const TObject *obj, const char *name, Int_t bufsize, TDirectory* motherDir); - TKey(const void *obj, const TClass *cl, const char *name, Int_t bufsize, TDirectory* motherDir); + TKey(const TObject *obj, const char *name, Int_t bufsize, TDirectory* motherDir, Bool_t def = kTRUE, Bool_t buffBigEndian = kTRUE); + TKey(const void *obj, const TClass *cl, const char *name, Int_t bufsize, TDirectory* motherDir, Bool_t def = kTRUE, Bool_t buffBigEndian = kTRUE); TKey(Long64_t pointer, Int_t nbytes, TDirectory* motherDir = 0); virtual ~TKey(); diff --git a/io/io/src/TBufferFile.cxx b/io/io/src/TBufferFile.cxx index e728a5c51e907..63d4184200ca0 100644 --- a/io/io/src/TBufferFile.cxx +++ b/io/io/src/TBufferFile.cxx @@ -88,8 +88,8 @@ static inline bool Class_Has_StreamerInfo(const TClass* cl) /// TBuffer::kWrite. By default the I/O buffer has a size of /// TBuffer::kInitialSize (1024) bytes. -TBufferFile::TBufferFile(TBuffer::EMode mode) - :TBuffer(mode), +TBufferFile::TBufferFile(TBuffer::EMode mode, Bool_t def, Bool_t buffBigEndian) + :TBuffer(mode,def,buffBigEndian), fDisplacement(0),fPidOffset(0), fMap(0), fClassMap(0), fInfo(0), fInfoStack() { @@ -105,8 +105,8 @@ TBufferFile::TBufferFile(TBuffer::EMode mode) /// Create an I/O buffer object. Mode should be either TBuffer::kRead or /// TBuffer::kWrite. -TBufferFile::TBufferFile(TBuffer::EMode mode, Int_t bufsiz) - :TBuffer(mode,bufsiz), +TBufferFile::TBufferFile(TBuffer::EMode mode, Int_t bufsiz, Bool_t def, Bool_t buffBigEndian) + :TBuffer(mode,bufsiz,def,buffBigEndian), fDisplacement(0),fPidOffset(0), fMap(0), fClassMap(0), fInfo(0), fInfoStack() { @@ -128,8 +128,8 @@ TBufferFile::TBufferFile(TBuffer::EMode mode, Int_t bufsiz) /// is provided, a Fatal error will be issued if the Buffer attempts to /// expand. -TBufferFile::TBufferFile(TBuffer::EMode mode, Int_t bufsiz, void *buf, Bool_t adopt, ReAllocCharFun_t reallocfunc) : - TBuffer(mode,bufsiz,buf,adopt,reallocfunc), +TBufferFile::TBufferFile(TBuffer::EMode mode, Int_t bufsiz, void *buf, Bool_t adopt, ReAllocCharFun_t reallocfunc, Bool_t def, Bool_t buffBigEndian) : + TBuffer(mode,bufsiz,buf,adopt,reallocfunc,def,buffBigEndian), fDisplacement(0),fPidOffset(0), fMap(0), fClassMap(0), fInfo(0), fInfoStack() { @@ -375,30 +375,23 @@ void TBufferFile::SetByteCount(UInt_t cntpos, Bool_t packInVersion) // if true, pack byte count in two consecutive shorts, so it can // be read by ReadVersion() if (packInVersion) { + printf("in packInVersion\n");//## union { UInt_t cnt; Version_t vers[2]; } v; v.cnt = cnt; #ifdef R__BYTESWAP - if(IsBufBigEndian()) { tobuf(buf, Version_t(v.vers[1] | kByteCountVMask)); tobuf(buf, v.vers[0]); - } else { - tobuf(buf, v.vers[0], 0); - tobuf(buf, Version_t(v.vers[1] | kByteCountVMask), 0); - } #else - if(IsBufBigEndian()) { tobuf(buf, Version_t(v.vers[0] | kByteCountVMask)); tobuf(buf, v.vers[1]); - } else { - tobuf(buf, v.vers[1], 0); - tobuf(buf, Version_t(v.vers[0] | kByteCountVMask), 0); - } #endif - } else - tobuf(buf, cnt | kByteCountMask, IsBufBigEndian()); + } else {//## + printf("else packInVersion\n");//## + tobuf(buf, cnt | kByteCountMask); + } if (cnt >= kMaxMapCount) { Error("WriteByteCount", "bytecount too large (more than %d)", kMaxMapCount); @@ -3019,14 +3012,16 @@ TClass *TBufferFile::ReadClass(const TClass *clReq, UInt_t *objTag) UInt_t bcnt, tag, startpos = 0; *this >> bcnt; if (!(bcnt & kByteCountMask) || bcnt == kNewClassTag) { + printf("in if, bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); tag = bcnt; bcnt = 0; } else { + printf("in else, bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); fVersion = 1; startpos = UInt_t(fBufCur-fBuffer); *this >> tag; } - + printf("bcnt=%u(0x%x),tag=%u(0x%x),startpos=%u(0x%x),kNewClassTag=%u(0x%x)\n",bcnt,bcnt,tag,tag,startpos,startpos,kNewClassTag,kNewClassTag);//## // in case tag is object tag return tag if (!(tag & kClassMask)) { if (objTag) *objTag = tag; @@ -3053,7 +3048,7 @@ TClass *TBufferFile::ReadClass(const TClass *clReq, UInt_t *objTag) // got a tag to an already seen class UInt_t clTag = (tag & ~kClassMask); - + printf("clTag=%u(0x%x)\n",clTag,clTag);//## if (fVersion > 0) { clTag += fDisplacement; clTag = CheckObject(clTag, clReq, kTRUE); @@ -4062,6 +4057,7 @@ Int_t TBufferFile::ReadClassEmulated(const TClass *cl, void *object, const TClas Int_t TBufferFile::ReadClassBuffer(const TClass *cl, void *pointer, Int_t version, UInt_t start, UInt_t count, const TClass *onFileClass) { + printf("!!!ReadBuffer, class: %s, attempting to access a wrong version: %d, object skipped at offset %d",cl->GetName(), version, Length() ); //## //--------------------------------------------------------------------------- // The ondisk class has been specified so get foreign streamer info @@ -4323,7 +4319,7 @@ Int_t TBufferFile::WriteClassBuffer(const TClass *cl, void *pointer) //write the byte count at the start of the buffer SetByteCount(R__c, kTRUE); - + printf(" WriteBuffer for class: %s version %d has written %d bytes\n",cl->GetName(),cl->GetClassVersion(),UInt_t(fBufCur - fBuffer) - R__c - (UInt_t)sizeof(UInt_t)); //## if (gDebug > 2) printf(" WriteBuffer for class: %s version %d has written %d bytes\n",cl->GetName(),cl->GetClassVersion(),UInt_t(fBufCur - fBuffer) - R__c - (UInt_t)sizeof(UInt_t)); return 0; } diff --git a/io/io/src/TDirectoryFile.cxx b/io/io/src/TDirectoryFile.cxx index 45bd311d93235..d88a50eebec53 100644 --- a/io/io/src/TDirectoryFile.cxx +++ b/io/io/src/TDirectoryFile.cxx @@ -715,11 +715,11 @@ void TDirectoryFile::FillBuffer(char *&buffer) // some object are 'removed' from the file and the holes are reused. version += 1000; } - tobuf(buffer, version, buffBigEndian); - fDatimeC.FillBuffer(buffer, buffBigEndian); - fDatimeM.FillBuffer(buffer, buffBigEndian); - tobuf(buffer, fNbytesKeys, buffBigEndian); - tobuf(buffer, fNbytesName, buffBigEndian); + tobuf(buffer, version); + fDatimeC.FillBuffer(buffer); + fDatimeM.FillBuffer(buffer); + tobuf(buffer, fNbytesKeys); + tobuf(buffer, fNbytesName); if (version > 1000) { tobuf(buffer, fSeekDir); tobuf(buffer, fSeekParent); diff --git a/io/io/src/TFile.cxx b/io/io/src/TFile.cxx index e9023132d3a8a..aeda2d0d85d06 100644 --- a/io/io/src/TFile.cxx +++ b/io/io/src/TFile.cxx @@ -3627,7 +3627,7 @@ void TFile::WriteStreamerInfo() //free previous StreamerInfo record if (fSeekInfo) MakeFree(fSeekInfo,fSeekInfo+fNbytesInfo-1); //Create new key - TKey key(&list,"StreamerInfo",GetBestBuffer(), this); + TKey key(&list,"StreamerInfo",GetBestBuffer(), this, 0, 1); fKeys->Remove(&key); fSeekInfo = key.GetSeekKey(); fNbytesInfo = key.GetNbytes(); diff --git a/io/io/src/TKey.cxx b/io/io/src/TKey.cxx index 32db83073dcfa..f9d3198f0c042 100644 --- a/io/io/src/TKey.cxx +++ b/io/io/src/TKey.cxx @@ -113,7 +113,7 @@ TKey::TKey(TDirectory* motherDir) : TNamed(), fDatime((UInt_t)0) //////////////////////////////////////////////////////////////////////////////// /// Copy a TKey from its original directory to the new 'motherDir' -TKey::TKey(TDirectory* motherDir, const TKey &orig, UShort_t pidOffset) : TNamed(), fDatime((UInt_t)0) +TKey::TKey(TDirectory* motherDir, const TKey &orig, UShort_t pidOffset, Bool_t def, Bool_t buffBigEndian) : TNamed(), fDatime((UInt_t)0) { fMotherDir = motherDir; @@ -147,7 +147,7 @@ TKey::TKey(TDirectory* motherDir, const TKey &orig, UShort_t pidOffset) : TNamed fNbytes += bufferIncOffset; } - fBufferRef = new TBufferFile(TBuffer::kWrite, alloc); + fBufferRef = new TBufferFile(TBuffer::kWrite, alloc, def, buffBigEndian); fBuffer = fBufferRef->Buffer(); // Steal the data from the old key. @@ -225,7 +225,7 @@ TKey::TKey(const TString &name, const TString &title, const TClass *cl, Int_t nb /// WARNING: in name avoid special characters like '^','$','.' that are used /// by the regular expression parser (see TRegexp). -TKey::TKey(const TObject *obj, const char *name, Int_t bufsize, TDirectory* motherDir) +TKey::TKey(const TObject *obj, const char *name, Int_t bufsize, TDirectory* motherDir, Bool_t def, Bool_t buffBigEndian) : TNamed(name, obj->GetTitle()) { R__ASSERT(obj); @@ -241,7 +241,7 @@ TKey::TKey(const TObject *obj, const char *name, Int_t bufsize, TDirectory* moth Build(motherDir, obj->ClassName(), -1); Int_t lbuf, nout, noutot, bufmax, nzip; - fBufferRef = new TBufferFile(TBuffer::kWrite, bufsize); + fBufferRef = new TBufferFile(TBuffer::kWrite, bufsize, def, buffBigEndian); fBufferRef->SetParent(GetFile()); fCycle = fMotherDir->AppendKey(this); @@ -298,7 +298,7 @@ TKey::TKey(const TObject *obj, const char *name, Int_t bufsize, TDirectory* moth /// WARNING: in name avoid special characters like '^','$','.' that are used /// by the regular expression parser (see TRegexp). -TKey::TKey(const void *obj, const TClass *cl, const char *name, Int_t bufsize, TDirectory* motherDir) +TKey::TKey(const void *obj, const TClass *cl, const char *name, Int_t bufsize, TDirectory* motherDir, Bool_t def, Bool_t buffBigEndian) : TNamed(name, "object title") { R__ASSERT(obj && cl); @@ -329,7 +329,7 @@ TKey::TKey(const void *obj, const TClass *cl, const char *name, Int_t bufsize, T Build(motherDir, clActual->GetName(), -1); - fBufferRef = new TBufferFile(TBuffer::kWrite, bufsize); + fBufferRef = new TBufferFile(TBuffer::kWrite, bufsize, def, buffBigEndian); fBufferRef->SetParent(GetFile()); fCycle = fMotherDir->AppendKey(this); diff --git a/net/net/src/TMessage.cxx b/net/net/src/TMessage.cxx index 38fd20fe86b52..04eb75c209459 100644 --- a/net/net/src/TMessage.cxx +++ b/net/net/src/TMessage.cxx @@ -44,7 +44,7 @@ ClassImp(TMessage) /// (only if message is > 256 bytes). TMessage::TMessage(UInt_t what, Int_t bufsiz) : - TBufferFile(TBuffer::kWrite, bufsiz + 2*sizeof(UInt_t)) + TBufferFile(TBuffer::kWrite, Int_t(bufsiz + 2*sizeof(UInt_t))) { // space at the beginning of the message reserved for the message length UInt_t reserved = 0; diff --git a/test/MainEvent.cxx b/test/MainEvent.cxx index c119b0d7e635a..b060d4ffb8b31 100644 --- a/test/MainEvent.cxx +++ b/test/MainEvent.cxx @@ -100,7 +100,7 @@ using namespace std; int main(int argc, char **argv) { - gROOT->SetBufLittleEndian(); +// gROOT->SetBufLittleEndian(); Int_t nevent = 400; // by default create 400 events Int_t comp = 1; // by default file is compressed Int_t split = 1; // by default, split Event in sub branches From 4028c7ec099598038a1d6d58b38d296bd34358d7 Mon Sep 17 00:00:00 2001 From: zzxuanyuan Date: Sun, 17 Apr 2016 16:13:25 -0500 Subject: [PATCH 08/18] Added fVersion debug --- io/io/src/TBufferFile.cxx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/io/io/src/TBufferFile.cxx b/io/io/src/TBufferFile.cxx index 63d4184200ca0..1998448f88e50 100644 --- a/io/io/src/TBufferFile.cxx +++ b/io/io/src/TBufferFile.cxx @@ -3012,14 +3012,14 @@ TClass *TBufferFile::ReadClass(const TClass *clReq, UInt_t *objTag) UInt_t bcnt, tag, startpos = 0; *this >> bcnt; if (!(bcnt & kByteCountMask) || bcnt == kNewClassTag) { - printf("in if, bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); + printf("in if, fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); tag = bcnt; bcnt = 0; } else { - printf("in else, bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); fVersion = 1; startpos = UInt_t(fBufCur-fBuffer); *this >> tag; + printf("in else, fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); } printf("bcnt=%u(0x%x),tag=%u(0x%x),startpos=%u(0x%x),kNewClassTag=%u(0x%x)\n",bcnt,bcnt,tag,tag,startpos,startpos,kNewClassTag,kNewClassTag);//## // in case tag is object tag return tag @@ -3048,7 +3048,7 @@ TClass *TBufferFile::ReadClass(const TClass *clReq, UInt_t *objTag) // got a tag to an already seen class UInt_t clTag = (tag & ~kClassMask); - printf("clTag=%u(0x%x)\n",clTag,clTag);//## + printf("clTag=%u(0x%x),fVersion=%d\n",clTag,clTag,fVersion);//## if (fVersion > 0) { clTag += fDisplacement; clTag = CheckObject(clTag, clReq, kTRUE); From ec110fd43d20b58815097575b58f273cd08b506d Mon Sep 17 00:00:00 2001 From: zzxuanyuan Date: Sun, 17 Apr 2016 16:59:57 -0500 Subject: [PATCH 09/18] Add debug message in TFile::GetStreamerInfo --- io/io/src/TFile.cxx | 5 +++-- test/MainEvent.cxx | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/io/io/src/TFile.cxx b/io/io/src/TFile.cxx index aeda2d0d85d06..5991cde9e45b3 100644 --- a/io/io/src/TFile.cxx +++ b/io/io/src/TFile.cxx @@ -1317,6 +1317,7 @@ const TList *TFile::GetStreamerInfoCache() TList *TFile::GetStreamerInfoList() { + printf("In TFile::GetStreamerInfoList\n");//## if (fIsPcmFile) return 0; // No schema evolution for ROOT PCM files. TList *list = 0; @@ -1332,13 +1333,13 @@ TList *TFile::GetStreamerInfoList() GetName()); return 0; } - //### + /* int cnt = 0; for(cnt=0;cntReadKeyBuffer(buf); list = dynamic_cast(key->ReadObjWithBuffer(buffer)); if (list) list->SetOwner(); diff --git a/test/MainEvent.cxx b/test/MainEvent.cxx index b060d4ffb8b31..c119b0d7e635a 100644 --- a/test/MainEvent.cxx +++ b/test/MainEvent.cxx @@ -100,7 +100,7 @@ using namespace std; int main(int argc, char **argv) { -// gROOT->SetBufLittleEndian(); + gROOT->SetBufLittleEndian(); Int_t nevent = 400; // by default create 400 events Int_t comp = 1; // by default file is compressed Int_t split = 1; // by default, split Event in sub branches From 015cf7b6e7823bc8a86176524a48eac4c8bb3f65 Mon Sep 17 00:00:00 2001 From: zzxuanyuan Date: Mon, 18 Apr 2016 19:57:35 -0500 Subject: [PATCH 10/18] Fix tag out of range issue and TTree ReadVersion error 1. Fix tag out of range issue, this is due to TKey calling ReadObjWithBuffer which does not set as Little Endian 2. Fix TTree ReadVersion error, this is because in TBufferFile::ReadVersion we changed the cnt format and it will cause the startoffset of reading version goes back to the cnt offset --- io/io/inc/TKey.h | 2 +- io/io/src/TBufferFile.cxx | 23 +++++++++++------------ io/io/src/TFile.cxx | 6 +++++- io/io/src/TKey.cxx | 13 +++++++++---- tree/tree/src/TTree.cxx | 2 ++ 5 files changed, 28 insertions(+), 18 deletions(-) diff --git a/io/io/inc/TKey.h b/io/io/inc/TKey.h index 39f14a985e961..37515d5af5471 100644 --- a/io/io/inc/TKey.h +++ b/io/io/inc/TKey.h @@ -98,7 +98,7 @@ class TKey : public TNamed { virtual void Print(Option_t *option="") const; virtual Int_t Read(TObject *obj); virtual TObject *ReadObj(); - virtual TObject *ReadObjWithBuffer(char *bufferRead); + virtual TObject *ReadObjWithBuffer(char *bufferRead, Bool_t def = kTRUE, Bool_t buffBigEndian = kTRUE); virtual void *ReadObjectAny(const TClass *expectedClass); virtual void ReadBuffer(char *&buffer); void ReadKeyBuffer(char *&buffer); diff --git a/io/io/src/TBufferFile.cxx b/io/io/src/TBufferFile.cxx index 1998448f88e50..0b9793c5aaccc 100644 --- a/io/io/src/TBufferFile.cxx +++ b/io/io/src/TBufferFile.cxx @@ -3202,6 +3202,7 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass // before reading object save start position *startpos = UInt_t(fBufCur-fBuffer); } + printf("In TBufferFile::ReadVersion, start pos=%u\n",UInt_t(fBufCur-fBuffer));//## // read byte count (older files don't have byte count) // byte count is packed in two individual shorts, this to be @@ -3212,31 +3213,22 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass Version_t vers[2]; } v; #ifdef R__BYTESWAP - if (IsBufBigEndian()) { frombuf(this->fBufCur,&v.vers[1]); frombuf(this->fBufCur,&v.vers[0]); - } else { - frombuf(this->fBufCur,&v.vers[0], 0); - frombuf(this->fBufCur,&v.vers[1], 0); - } #else - if (IsBufBigEndian()) { frombuf(this->fBufCur,&v.vers[0]); frombuf(this->fBufCur,&v.vers[1]); - } else { - frombuf(this->fBufCur,&v.vers[1], 0); - frombuf(this->fBufCur,&v.vers[0], 0); - } #endif - + printf("vers[0]=%hi(0x%hx),vers[1]=%hi(0x%hx)\n",v.vers[0],v.vers[0],v.vers[1],v.vers[1]);//## // no bytecount, backup and read version if (!(v.cnt & kByteCountMask)) { + printf("In TBufferFile::ReadVersion, v.cnt=%u, and no bytecount found!!!\n",v.cnt);//## fBufCur -= sizeof(UInt_t); v.cnt = 0; } if (bcnt) *bcnt = (v.cnt & ~kByteCountMask); frombuf(this->fBufCur,&version, IsBufBigEndian()); - + printf("version=%hi(0x%hx)\n",version,version);//## if (version<=1) { if (version <= 0) { if (cl) { @@ -3303,6 +3295,7 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass } } } + printf("before return, version=%hi(0x%hx)\n",version,version);//## return version; } @@ -3436,11 +3429,14 @@ UInt_t TBufferFile::WriteVersion(const TClass *cl, Bool_t useBcnt) UInt_t cntpos = 0; if (useBcnt) { // reserve space for leading byte count + printf("In TBufferFile::WriteVersion, we need to reserve space for bount count\n");//## cntpos = UInt_t(fBufCur-fBuffer); fBufCur += sizeof(UInt_t); + printf("In TBufferFile::WriteVersion, class:%s and start offset=%u\n",cl->GetName(),UInt_t(fBufCur-fBuffer));//## } Version_t version = cl->GetClassVersion(); + printf("In TBufferFile::WriteVersion, version=%hi(0x%hx)\n",version,version);//## if (version<=1 && cl->IsForeign()) { *this << Version_t(0); *this << cl->GetCheckSum(); @@ -4310,11 +4306,14 @@ Int_t TBufferFile::WriteClassBuffer(const TClass *cl, void *pointer) } //write the class version number and reserve space for the byte count + printf("TBufferFile::WriteClassBuffer, before WriteVersion,class:%s\n",cl->GetName());//## UInt_t R__c = WriteVersion(cl, kTRUE); + printf("TBufferFile::WriteClassBuffer, after WriteVersion,class:%s\n",cl->GetName());//## //NOTE: In the future Philippe wants this to happen via a custom action TagStreamerInfo(sinfo); ApplySequence(*(sinfo->GetWriteObjectWiseActions()), (char*)pointer); + printf("TBufferFile::WriteClassBuffer, after TagStreamerInfo and ApplySequence,class:%s\n",cl->GetName());//## //write the byte count at the start of the buffer diff --git a/io/io/src/TFile.cxx b/io/io/src/TFile.cxx index 5991cde9e45b3..759cef959db4a 100644 --- a/io/io/src/TFile.cxx +++ b/io/io/src/TFile.cxx @@ -1327,12 +1327,14 @@ TList *TFile::GetStreamerInfoList() char *buffer = new char[fNbytesInfo+1]; char *buf = buffer; Seek(fSeekInfo); + printf("In TFile::GetStreamerInfo, After Seek()\n"); //## if (ReadBuffer(buf,fNbytesInfo)) { // ReadBuffer returns kTRUE in case of failure. Warning("GetRecordHeader","%s: failed to read the StreamerInfo data from disk.", GetName()); return 0; } + printf("In TFile::GetStreamerInfo, After ReadBuffer()\n"); //## /* int cnt = 0; for(cnt=0;cntReadKeyBuffer(buf); - list = dynamic_cast(key->ReadObjWithBuffer(buffer)); + printf("In TFile::GetStreamerInfo, After ReadKeyBuffer()\n"); //## + list = dynamic_cast(key->ReadObjWithBuffer(buffer,0,1)); + printf("In TFile::GetStreamerInfo, After ReadObjWithBuffer()\n"); //## if (list) list->SetOwner(); delete [] buffer; delete key; diff --git a/io/io/src/TKey.cxx b/io/io/src/TKey.cxx index f9d3198f0c042..0fbf5614f78fd 100644 --- a/io/io/src/TKey.cxx +++ b/io/io/src/TKey.cxx @@ -242,6 +242,7 @@ TKey::TKey(const TObject *obj, const char *name, Int_t bufsize, TDirectory* moth Int_t lbuf, nout, noutot, bufmax, nzip; fBufferRef = new TBufferFile(TBuffer::kWrite, bufsize, def, buffBigEndian); + printf("In TKey::TKey and fBufferRef->IsBufBigEndian()=%d\n",fBufferRef->IsBufBigEndian());//## fBufferRef->SetParent(GetFile()); fCycle = fMotherDir->AppendKey(this); @@ -866,7 +867,7 @@ TObject *TKey::ReadObj() /// If used, you must make sure that the bufferRead is large enough to /// accomodate the object being read. -TObject *TKey::ReadObjWithBuffer(char *bufferRead) +TObject *TKey::ReadObjWithBuffer(char *bufferRead, Bool_t def, Bool_t buffBigEndian) { TClass *cl = TClass::GetClass(fClassName.Data()); @@ -879,7 +880,7 @@ TObject *TKey::ReadObjWithBuffer(char *bufferRead) return (TObject*)ReadObjectAny(0); } - fBufferRef = new TBufferFile(TBuffer::kRead, fObjlen+fKeylen); + fBufferRef = new TBufferFile(TBuffer::kRead, fObjlen+fKeylen, def, buffBigEndian); if (!fBufferRef) { Error("ReadObjWithBuffer", "Cannot allocate buffer: fObjlen = %d", fObjlen); return 0; @@ -899,7 +900,7 @@ TObject *TKey::ReadObjWithBuffer(char *bufferRead) // get version of key fBufferRef->SetBufferOffset(sizeof(fNbytes)); Version_t kvers = fBufferRef->ReadVersion(); - + printf("version of key: %d\n",kvers); //## fBufferRef->SetBufferOffset(fKeylen); TObject *tobj = 0; // Create an instance of this class @@ -923,6 +924,7 @@ TObject *TKey::ReadObjWithBuffer(char *bufferRead) fBufferRef->MapObject(pobj,cl); //register obj in map to handle self reference if (fObjlen > fNbytes-fKeylen) { + printf("if and Before everything\n");//## char *objbuf = fBufferRef->Buffer() + fKeylen; UChar_t *bufcur = (UChar_t *)&fBuffer[fKeylen]; Int_t nin, nout = 0, nbuf; @@ -938,7 +940,9 @@ TObject *TKey::ReadObjWithBuffer(char *bufferRead) objbuf += nout; } if (nout) { + printf("nout!=0, and before Streamer, fVersion=%d\n",fVersion);//## tobj->Streamer(*fBufferRef); //does not work with example 2 above + printf("nout!=0, and after Streamer, fVersion=%d\n",fVersion);//## } else { // Even-though we have a TObject, if the class is emulated the virtual // table may not be 'right', so let's go via the TClass. @@ -948,9 +952,10 @@ TObject *TKey::ReadObjWithBuffer(char *bufferRead) goto CLEAR; } } else { + printf("else and Before tobj->Streamer\n");//## tobj->Streamer(*fBufferRef); } - + printf("After Comparing\n");//## if (gROOT->GetForceStyle()) tobj->UseCurrentStyle(); if (cl->InheritsFrom(TDirectoryFile::Class())) { diff --git a/tree/tree/src/TTree.cxx b/tree/tree/src/TTree.cxx index 13f680e01724b..548289efe37c1 100644 --- a/tree/tree/src/TTree.cxx +++ b/tree/tree/src/TTree.cxx @@ -8770,6 +8770,7 @@ void TTree::Streamer(TBuffer& b) fCacheDoAutoInit = kTRUE; fCacheUserSet = kFALSE; Version_t R__v = b.ReadVersion(&R__s, &R__c); + printf("In TTree::Streamer,R__v = %d, b.IsBufBigEndian() = %d\n",R__v,b.IsBufBigEndian());//## if (R__v > 4) { b.ReadClassBuffer(TTree::Class(), this, R__v, R__s, R__c); @@ -8859,6 +8860,7 @@ void TTree::Streamer(TBuffer& b) TRefTable *table = TRefTable::GetRefTable(); if (table) TRefTable::SetRefTable(0); + printf("In TTree::Streamer,Write Tree,b.IsBufBigEndian() = %d\n",b.IsBufBigEndian());//## b.WriteClassBuffer(TTree::Class(), this); if (table) TRefTable::SetRefTable(table); From d5888ee074e9d8ff64e6702de662fe7bb11823b3 Mon Sep 17 00:00:00 2001 From: zzxuanyuan Date: Tue, 19 Apr 2016 10:09:52 -0500 Subject: [PATCH 11/18] Add some debug code and change back the version reading back to big endian --- io/io/src/TBufferFile.cxx | 16 ++++------------ io/io/src/TKey.cxx | 1 + 2 files changed, 5 insertions(+), 12 deletions(-) diff --git a/io/io/src/TBufferFile.cxx b/io/io/src/TBufferFile.cxx index 0b9793c5aaccc..ddee2122829b1 100644 --- a/io/io/src/TBufferFile.cxx +++ b/io/io/src/TBufferFile.cxx @@ -2737,7 +2737,9 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) // attempt to load next object as TClass clCast UInt_t tag; // either tag or byte count + printf("In TBufferFile::ReadObjectAny, before ReadClass()\n");//## TClass *clRef = ReadClass(clCast, &tag); + printf("In TBufferFile::ReadObjectAny, after ReadClass()\n");//## TClass *clOnfile = 0; Int_t baseOffset = 0; if (clRef && (clRef!=(TClass*)(-1)) && clCast) { @@ -3012,14 +3014,14 @@ TClass *TBufferFile::ReadClass(const TClass *clReq, UInt_t *objTag) UInt_t bcnt, tag, startpos = 0; *this >> bcnt; if (!(bcnt & kByteCountMask) || bcnt == kNewClassTag) { - printf("in if, fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); + printf("in if, requested class:%s,fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",clReq->GetName(),fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); tag = bcnt; bcnt = 0; } else { fVersion = 1; startpos = UInt_t(fBufCur-fBuffer); *this >> tag; - printf("in else, fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); + printf("in else, requested class:%s,fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",clReq->GetName(),fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); } printf("bcnt=%u(0x%x),tag=%u(0x%x),startpos=%u(0x%x),kNewClassTag=%u(0x%x)\n",bcnt,bcnt,tag,tag,startpos,startpos,kNewClassTag,kNewClassTag);//## // in case tag is object tag return tag @@ -3321,21 +3323,11 @@ Version_t TBufferFile::ReadVersionNoCheckSum(UInt_t *startpos, UInt_t *bcnt) Version_t vers[2]; } v; #ifdef R__BYTESWAP - if (IsBufBigEndian()) { frombuf(this->fBufCur,&v.vers[1]); frombuf(this->fBufCur,&v.vers[0]); - } else { - frombuf(this->fBufCur,&v.vers[0], 0); - frombuf(this->fBufCur,&v.vers[1], 0); - } #else - if (IsBufBigEndian()) { frombuf(this->fBufCur,&v.vers[0]); frombuf(this->fBufCur,&v.vers[1]); - } else { - frombuf(this->fBufCur,&v.vers[1], 0); - frombuf(this->fBufCur,&v.vers[0], 0); - } #endif // no bytecount, backup and read version diff --git a/io/io/src/TKey.cxx b/io/io/src/TKey.cxx index 0fbf5614f78fd..6b56e68d2ee2f 100644 --- a/io/io/src/TKey.cxx +++ b/io/io/src/TKey.cxx @@ -727,6 +727,7 @@ void TKey::Print(Option_t *) const TObject *TKey::ReadObj() { + printf("In TKey::ReadObj()\n");//## TClass *cl = TClass::GetClass(fClassName.Data()); if (!cl) { Error("ReadObj", "Unknown class %s", fClassName.Data()); From c664e27d5b850ead5f12b05a8f1b8dd691655a03 Mon Sep 17 00:00:00 2001 From: zzxuanyuan Date: Mon, 25 Apr 2016 16:00:24 -0500 Subject: [PATCH 12/18] Added IsBufBigEndian() to indicate the endianness in tobuf(buf, cnt | kByteCountMask, IsBufBigEndian()); --- core/base/inc/Bytes.h | 8 ++--- io/io/src/TBufferFile.cxx | 64 +++++++++++++++++++++++++-------------- test/MainEvent.cxx | 3 ++ 3 files changed, 49 insertions(+), 26 deletions(-) diff --git a/core/base/inc/Bytes.h b/core/base/inc/Bytes.h index 678aa822afbe2..a65aaf83469df 100644 --- a/core/base/inc/Bytes.h +++ b/core/base/inc/Bytes.h @@ -385,9 +385,9 @@ if(buffBigEndian) { buf[2] = u.c[1]; buf[3] = u.c[0]; # endif - printf("tobuf:BigEndian:float=%f\n", x); +// printf("tobuf:BigEndian:float=%f\n", x);//## } else { - printf("tobuf:LittleEndian:float=%f\n", x); +// printf("tobuf:LittleEndian:float=%f\n", x);//## memcpy(buf, &x, sizeof(Float_t)); } #else @@ -674,9 +674,9 @@ if(buffBigEndian) { u.c[3] = buf[0]; *x = u.f; # endif - printf("BigEndian:float=%f\n", *x); +// printf("BigEndian:float=%f\n", *x);//## } else { - printf("LittleEndian:float=%f\n", *x); +// printf("LittleEndian:float=%f\n", *x);//## memcpy(x, buf, sizeof(Float_t)); } #else diff --git a/io/io/src/TBufferFile.cxx b/io/io/src/TBufferFile.cxx index ddee2122829b1..7a8f864769588 100644 --- a/io/io/src/TBufferFile.cxx +++ b/io/io/src/TBufferFile.cxx @@ -375,22 +375,32 @@ void TBufferFile::SetByteCount(UInt_t cntpos, Bool_t packInVersion) // if true, pack byte count in two consecutive shorts, so it can // be read by ReadVersion() if (packInVersion) { - printf("in packInVersion\n");//## +// printf("in packInVersion,buffBigEndian=%d\n",IsBufBigEndian());//## union { UInt_t cnt; Version_t vers[2]; } v; v.cnt = cnt; #ifdef R__BYTESWAP + if (IsBufBigEndian()) { tobuf(buf, Version_t(v.vers[1] | kByteCountVMask)); tobuf(buf, v.vers[0]); + } else { + tobuf(buf, v.vers[0], 0); + tobuf(buf, Version_t(v.vers[1] | kByteCountVMask), 0); + } #else + if (IsBufBigEndian()) { tobuf(buf, Version_t(v.vers[0] | kByteCountVMask)); tobuf(buf, v.vers[1]); + } else { + tobuf(buf, v.vers[1], 0); + tobuf(buf, Version_t(v.vers[0] | kByteCountVMask), 0); + } #endif } else {//## - printf("else packInVersion\n");//## - tobuf(buf, cnt | kByteCountMask); + tobuf(buf, cnt | kByteCountMask, IsBufBigEndian()); +// printf("else packInVersion,buffBigEndian=%d, cnt|kByteCountMask and cnt=%u(0x%x)\n",IsBufBigEndian(),cnt|kByteCountMask,cnt|kByteCountMask);//## } if (cnt >= kMaxMapCount) { @@ -2737,9 +2747,9 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) // attempt to load next object as TClass clCast UInt_t tag; // either tag or byte count - printf("In TBufferFile::ReadObjectAny, before ReadClass()\n");//## +// printf("In TBufferFile::ReadObjectAny, before ReadClass()\n");//## TClass *clRef = ReadClass(clCast, &tag); - printf("In TBufferFile::ReadObjectAny, after ReadClass()\n");//## +// printf("In TBufferFile::ReadObjectAny, after ReadClass()\n");//## TClass *clOnfile = 0; Int_t baseOffset = 0; if (clRef && (clRef!=(TClass*)(-1)) && clCast) { @@ -3014,16 +3024,16 @@ TClass *TBufferFile::ReadClass(const TClass *clReq, UInt_t *objTag) UInt_t bcnt, tag, startpos = 0; *this >> bcnt; if (!(bcnt & kByteCountMask) || bcnt == kNewClassTag) { - printf("in if, requested class:%s,fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",clReq->GetName(),fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); +// printf("in if, buffBigEndian=%d,requested class:%s,fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",IsBufBigEndian(),clReq->GetName(),fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); tag = bcnt; bcnt = 0; } else { fVersion = 1; startpos = UInt_t(fBufCur-fBuffer); *this >> tag; - printf("in else, requested class:%s,fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",clReq->GetName(),fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); +// printf("in else, buffBigEndian=%d,requested class:%s,fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",IsBufBigEndian(),clReq->GetName(),fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); } - printf("bcnt=%u(0x%x),tag=%u(0x%x),startpos=%u(0x%x),kNewClassTag=%u(0x%x)\n",bcnt,bcnt,tag,tag,startpos,startpos,kNewClassTag,kNewClassTag);//## +// printf("bcnt=%u(0x%x),tag=%u(0x%x),startpos=%u(0x%x),kNewClassTag=%u(0x%x)\n",bcnt,bcnt,tag,tag,startpos,startpos,kNewClassTag,kNewClassTag);//## // in case tag is object tag return tag if (!(tag & kClassMask)) { if (objTag) *objTag = tag; @@ -3050,7 +3060,7 @@ TClass *TBufferFile::ReadClass(const TClass *clReq, UInt_t *objTag) // got a tag to an already seen class UInt_t clTag = (tag & ~kClassMask); - printf("clTag=%u(0x%x),fVersion=%d\n",clTag,clTag,fVersion);//## +// printf("clTag=%u(0x%x),fVersion=%d\n",clTag,clTag,fVersion);//## if (fVersion > 0) { clTag += fDisplacement; clTag = CheckObject(clTag, clReq, kTRUE); @@ -3204,7 +3214,7 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass // before reading object save start position *startpos = UInt_t(fBufCur-fBuffer); } - printf("In TBufferFile::ReadVersion, start pos=%u\n",UInt_t(fBufCur-fBuffer));//## +// printf("In TBufferFile::ReadVersion, buffBigEndian=%d, start pos=%u\n",IsBufBigEndian(),UInt_t(fBufCur-fBuffer));//## // read byte count (older files don't have byte count) // byte count is packed in two individual shorts, this to be @@ -3215,22 +3225,32 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass Version_t vers[2]; } v; #ifdef R__BYTESWAP + if (IsBufBigEndian()) { frombuf(this->fBufCur,&v.vers[1]); frombuf(this->fBufCur,&v.vers[0]); + } else { + frombuf(this->fBufCur,&v.vers[0],0); + frombuf(this->fBufCur,&v.vers[1],0); + } #else + if (IsBufBigEndian()) { frombuf(this->fBufCur,&v.vers[0]); frombuf(this->fBufCur,&v.vers[1]); + } else { + frombuf(this->fBufCur,&v.vers[1],0); + frombuf(this->fBufCur,&v.vers[0],0); + } #endif - printf("vers[0]=%hi(0x%hx),vers[1]=%hi(0x%hx)\n",v.vers[0],v.vers[0],v.vers[1],v.vers[1]);//## +// printf("vers[0]=%hi(0x%hx),vers[1]=%hi(0x%hx)\n",v.vers[0],v.vers[0],v.vers[1],v.vers[1]);//## // no bytecount, backup and read version if (!(v.cnt & kByteCountMask)) { - printf("In TBufferFile::ReadVersion, v.cnt=%u, and no bytecount found!!!\n",v.cnt);//## +// printf("In TBufferFile::ReadVersion, buffBigEndian=%d, v.cnt=%u, and no bytecount found!!!\n",IsBufBigEndian(),v.cnt);//## fBufCur -= sizeof(UInt_t); v.cnt = 0; } if (bcnt) *bcnt = (v.cnt & ~kByteCountMask); frombuf(this->fBufCur,&version, IsBufBigEndian()); - printf("version=%hi(0x%hx)\n",version,version);//## +// printf("version=%hi(0x%hx)\n",version,version);//## if (version<=1) { if (version <= 0) { if (cl) { @@ -3297,7 +3317,7 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass } } } - printf("before return, version=%hi(0x%hx)\n",version,version);//## +// printf("before return, version=%hi(0x%hx)\n",version,version);//## return version; } @@ -3421,14 +3441,14 @@ UInt_t TBufferFile::WriteVersion(const TClass *cl, Bool_t useBcnt) UInt_t cntpos = 0; if (useBcnt) { // reserve space for leading byte count - printf("In TBufferFile::WriteVersion, we need to reserve space for bount count\n");//## +// printf("In TBufferFile::WriteVersion, we need to reserve space for bount count\n");//## cntpos = UInt_t(fBufCur-fBuffer); fBufCur += sizeof(UInt_t); - printf("In TBufferFile::WriteVersion, class:%s and start offset=%u\n",cl->GetName(),UInt_t(fBufCur-fBuffer));//## +// printf("In TBufferFile::WriteVersion, class:%s and start offset=%u\n",cl->GetName(),UInt_t(fBufCur-fBuffer));//## } Version_t version = cl->GetClassVersion(); - printf("In TBufferFile::WriteVersion, version=%hi(0x%hx)\n",version,version);//## +// printf("In TBufferFile::WriteVersion, version=%hi(0x%hx)\n",version,version);//## if (version<=1 && cl->IsForeign()) { *this << Version_t(0); *this << cl->GetCheckSum(); @@ -4045,7 +4065,7 @@ Int_t TBufferFile::ReadClassEmulated(const TClass *cl, void *object, const TClas Int_t TBufferFile::ReadClassBuffer(const TClass *cl, void *pointer, Int_t version, UInt_t start, UInt_t count, const TClass *onFileClass) { - printf("!!!ReadBuffer, class: %s, attempting to access a wrong version: %d, object skipped at offset %d",cl->GetName(), version, Length() ); //## +// printf("!!!ReadBuffer, class: %s, attempting to access a wrong version: %d, object skipped at offset %d",cl->GetName(), version, Length() ); //## //--------------------------------------------------------------------------- // The ondisk class has been specified so get foreign streamer info @@ -4298,19 +4318,19 @@ Int_t TBufferFile::WriteClassBuffer(const TClass *cl, void *pointer) } //write the class version number and reserve space for the byte count - printf("TBufferFile::WriteClassBuffer, before WriteVersion,class:%s\n",cl->GetName());//## +// printf("TBufferFile::WriteClassBuffer, before WriteVersion,class:%s\n",cl->GetName());//## UInt_t R__c = WriteVersion(cl, kTRUE); - printf("TBufferFile::WriteClassBuffer, after WriteVersion,class:%s\n",cl->GetName());//## +// printf("TBufferFile::WriteClassBuffer, after WriteVersion,class:%s\n",cl->GetName());//## //NOTE: In the future Philippe wants this to happen via a custom action TagStreamerInfo(sinfo); ApplySequence(*(sinfo->GetWriteObjectWiseActions()), (char*)pointer); - printf("TBufferFile::WriteClassBuffer, after TagStreamerInfo and ApplySequence,class:%s\n",cl->GetName());//## +// printf("TBufferFile::WriteClassBuffer, after TagStreamerInfo and ApplySequence,class:%s\n",cl->GetName());//## //write the byte count at the start of the buffer SetByteCount(R__c, kTRUE); - printf(" WriteBuffer for class: %s version %d has written %d bytes\n",cl->GetName(),cl->GetClassVersion(),UInt_t(fBufCur - fBuffer) - R__c - (UInt_t)sizeof(UInt_t)); //## +// printf(" WriteBuffer for class: %s version %d has written %d bytes\n",cl->GetName(),cl->GetClassVersion(),UInt_t(fBufCur - fBuffer) - R__c - (UInt_t)sizeof(UInt_t)); //## if (gDebug > 2) printf(" WriteBuffer for class: %s version %d has written %d bytes\n",cl->GetName(),cl->GetClassVersion(),UInt_t(fBufCur - fBuffer) - R__c - (UInt_t)sizeof(UInt_t)); return 0; } diff --git a/test/MainEvent.cxx b/test/MainEvent.cxx index c119b0d7e635a..9b655244cd982 100644 --- a/test/MainEvent.cxx +++ b/test/MainEvent.cxx @@ -155,8 +155,11 @@ int main(int argc, char **argv) hfile = new TNetFile("root://localhost/root/test/EventNet.root"); } else hfile = new TFile("Event.root"); + printf("In MainEvent.cxx, before getting tree\n");//## tree = (TTree*)hfile->Get("T"); + printf("In MainEvent.cxx, before getting branch\n");//## TBranch *branch = tree->GetBranch("event"); + printf("In MainEvent.cxx, before setting address\n");//## branch->SetAddress(&event); Int_t nentries = (Int_t)tree->GetEntries(); nevent = TMath::Min(nevent,nentries); From 0378251578945447dea3b8b0bdcd6a6749545b67 Mon Sep 17 00:00:00 2001 From: zzxuanyuan Date: Wed, 27 Apr 2016 11:45:17 -0500 Subject: [PATCH 13/18] Fix some segmentation fault in roottest cases and CheckByteCount error 1. In roottest mathcore, some tests call cl->GetMethod which finds the interface of creator of TBufferFile. Since I changed the interface and add two Bool_t arguments, so as should we change the cl->GetMethod here. 2. If we change TBufferFile to LittleEndian, there is a situation could be inappropriately characterized as Having ByteCount and here is the situation happens: For example, if there is no byte count and the first two bytes stores version and the next four bytes store fBufferSize like following: UShort_t + UInt_t ( Version_t + fBufferSize) But in TBufferFile.cxx, it takes a look at (v.cnt & kByteCountMask)(v.cnt is the first four bytes). If it is 0, ROOT determine there is no byte count. Otherwise, the next four bytes should be byte count. If TBufferFile is BigEndian: 00 02 00 00 7d 00 and in this example, version = 2 and fBufferSize = 32000. So v.cnt is 00 00 02 00. However, if we change TBufferFile to LittleEndian, the memory layout becomes: 02 00 00 7d 00 00 and in this case, v.cnt is 7d 00 00 02 and (v.cnt & kByteCountMask != 0) so ROOT thinks the next four bytes are byte count. --- core/base/inc/Bytes.h | 4 ++ core/base/src/TDirectory.cxx | 2 +- io/io/src/TBufferFile.cxx | 95 +++++++++++++++++++-------- io/io/src/TKey.cxx | 9 +++ math/mathcore/test/fit/testRooFit.cxx | 3 +- tree/tree/src/TBasket.cxx | 5 ++ tree/tree/src/TTree.cxx | 2 + 7 files changed, 91 insertions(+), 29 deletions(-) diff --git a/core/base/inc/Bytes.h b/core/base/inc/Bytes.h index a65aaf83469df..6bfea59ff9cf6 100644 --- a/core/base/inc/Bytes.h +++ b/core/base/inc/Bytes.h @@ -80,8 +80,10 @@ if(buffBigEndian) { buf[0] = sw[1]; buf[1] = sw[0]; # endif + printf("to:BigEndian:ushort=%hu\n", x);//## } else { memcpy(buf, &x, sizeof(UShort_t)); + printf("to:LittleEndian:ushort=%hu\n", x);//## } #else if(buffBigEndian) { @@ -500,8 +502,10 @@ if(buffBigEndian) { sw[0] = buf[1]; sw[1] = buf[0]; # endif + printf("from:BigEndian:ushort=%hu\n", *x);//## } else { memcpy(x, buf, sizeof(UShort_t)); + printf("from:LittleEndian:ushort=x[0]=%hu\n", *x);//## } #else if(buffBigEndian) { diff --git a/core/base/src/TDirectory.cxx b/core/base/src/TDirectory.cxx index c781e93c5eb37..291f29b2d89c2 100644 --- a/core/base/src/TDirectory.cxx +++ b/core/base/src/TDirectory.cxx @@ -240,7 +240,7 @@ static TBuffer* R__CreateBuffer() if (creator == 0) { R__LOCKGUARD2(gROOTMutex); TClass *c = TClass::GetClass("TBufferFile"); - TMethod *m = c->GetMethodWithPrototype("TBufferFile","TBuffer::EMode,Int_t",kFALSE,ROOT::kExactMatch); + TMethod *m = c->GetMethodWithPrototype("TBufferFile","TBuffer::EMode,Int_t,Bool_t,Bool_t",kFALSE,ROOT::kExactMatch); creator = (tcling_callfunc_Wrapper_t)( m->InterfaceMethod() ); } TBuffer::EMode mode = TBuffer::kWrite; diff --git a/io/io/src/TBufferFile.cxx b/io/io/src/TBufferFile.cxx index 7a8f864769588..b5f709e5b8123 100644 --- a/io/io/src/TBufferFile.cxx +++ b/io/io/src/TBufferFile.cxx @@ -375,7 +375,7 @@ void TBufferFile::SetByteCount(UInt_t cntpos, Bool_t packInVersion) // if true, pack byte count in two consecutive shorts, so it can // be read by ReadVersion() if (packInVersion) { -// printf("in packInVersion,buffBigEndian=%d\n",IsBufBigEndian());//## + printf("in packInVersion,buffBigEndian=%d\n",IsBufBigEndian());//## union { UInt_t cnt; Version_t vers[2]; @@ -400,7 +400,7 @@ void TBufferFile::SetByteCount(UInt_t cntpos, Bool_t packInVersion) #endif } else {//## tobuf(buf, cnt | kByteCountMask, IsBufBigEndian()); -// printf("else packInVersion,buffBigEndian=%d, cnt|kByteCountMask and cnt=%u(0x%x)\n",IsBufBigEndian(),cnt|kByteCountMask,cnt|kByteCountMask);//## + printf("else packInVersion,buffBigEndian=%d, cnt|kByteCountMask and cnt=%u(0x%x)\n",IsBufBigEndian(),cnt|kByteCountMask,cnt|kByteCountMask);//## } if (cnt >= kMaxMapCount) { @@ -424,11 +424,12 @@ Int_t TBufferFile::CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *cl Int_t offset = 0; Long_t endpos = Long_t(fBuffer) + startpos + bcnt + sizeof(UInt_t); + printf("Outer: In TBufferFile::CheckByteCount(),fBuffer=%ld,startpos=%u,bcnt=%u,endpos=%ld,fBufCur=%ld,offset=%d\n",Long_t(fBuffer),startpos,bcnt,endpos,Long_t(fBufCur),offset);//## if (Long_t(fBufCur) != endpos) { offset = Int_t(Long_t(fBufCur) - endpos); - const char *name = clss ? clss->GetName() : classname ? classname : 0; + printf("In TBufferFile::CheckByteCount(),name=%s,fBuffer=%ld,startpos=%u,bcnt=%u,endpos=%ld,fBufCur=%ld,offset=%d\n",name,Long_t(fBuffer),startpos,bcnt,endpos,Long_t(fBufCur),offset);//## if (name) { if (offset < 0) { @@ -2747,9 +2748,9 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) // attempt to load next object as TClass clCast UInt_t tag; // either tag or byte count -// printf("In TBufferFile::ReadObjectAny, before ReadClass()\n");//## + printf("In TBufferFile::ReadObjectAny, before ReadClass()\n");//## TClass *clRef = ReadClass(clCast, &tag); -// printf("In TBufferFile::ReadObjectAny, after ReadClass()\n");//## + printf("In TBufferFile::ReadObjectAny, after ReadClass()\n");//## TClass *clOnfile = 0; Int_t baseOffset = 0; if (clRef && (clRef!=(TClass*)(-1)) && clCast) { @@ -2764,7 +2765,7 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) // There is no converter Error("ReadObject", "got object of wrong class! requested %s but got %s", clCast->GetName(), clRef->GetName()); - + printf("In TBufferFile::ReadObjectAny(), CheckByteCount 1\n");//## CheckByteCount(startpos, tag, (TClass*)0); // avoid mis-leading byte count error message return 0; // We better return at this point } @@ -2778,6 +2779,7 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) //we cannot mix a compiled class with an emulated class in the inheritance Error("ReadObject", "trying to read an emulated class (%s) to store in a compiled pointer (%s)", clRef->GetName(),clCast->GetName()); + printf("In TBufferFile::ReadObjectAny(), CheckByteCount 2\n");//## CheckByteCount(startpos, tag, (TClass*)0); // avoid mis-leading byte count error message return 0; } @@ -2790,6 +2792,7 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) obj = (char *) (Long_t)fMap->GetValue(startpos+kMapOffset); if (obj == (void*) -1) obj = 0; if (obj) { + printf("In TBufferFile::ReadObjectAny(), CheckByteCount 3\n");//## CheckByteCount(startpos, tag, (TClass*)0); return (obj+baseOffset); } @@ -2802,6 +2805,7 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) MapObject((TObject*) -1, startpos+kMapOffset); else MapObject((void*)0, 0, fMapCount); + printf("In TBufferFile::ReadObjectAny(), CheckByteCount 4\n");//## CheckByteCount(startpos, tag, (TClass*)0); return 0; } @@ -2859,8 +2863,11 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) MapObject(obj, clRef, fMapCount); // let the object read itself + printf("In ReadObjectAny(), before Streamer,name=%s,fBufCur=%ld\n",clRef->GetName(),Long_t(fBufCur));//## clRef->Streamer( obj, *this, clOnfile ); + printf("In ReadObjectAny(), after Streamer,name=%s,fBufCur=%ld\n",clRef->GetName(),Long_t(fBufCur));//## + printf("In TBufferFile::ReadObjectAny(), CheckByteCount 5\n");//## CheckByteCount(startpos, tag, clRef); } @@ -2942,7 +2949,7 @@ void TBufferFile::WriteObjectClass(const void *actualObjectStart, const TClass * fMapCount++; ((TClass*)actualClass)->Streamer((void*)actualObjectStart,*this); - + printf("In TBufferFile::WriteObjectClass, between Class->Streamer and SetByteCount()\n"); // write byte count SetByteCount(cntpos); } @@ -3024,16 +3031,16 @@ TClass *TBufferFile::ReadClass(const TClass *clReq, UInt_t *objTag) UInt_t bcnt, tag, startpos = 0; *this >> bcnt; if (!(bcnt & kByteCountMask) || bcnt == kNewClassTag) { -// printf("in if, buffBigEndian=%d,requested class:%s,fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",IsBufBigEndian(),clReq->GetName(),fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); + printf("in if, buffBigEndian=%d,requested class:%s,fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",IsBufBigEndian(),clReq->GetName(),fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag);//## tag = bcnt; bcnt = 0; } else { fVersion = 1; startpos = UInt_t(fBufCur-fBuffer); *this >> tag; -// printf("in else, buffBigEndian=%d,requested class:%s,fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",IsBufBigEndian(),clReq->GetName(),fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag); + printf("in else, buffBigEndian=%d,requested class:%s,fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",IsBufBigEndian(),clReq->GetName(),fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag);//## } -// printf("bcnt=%u(0x%x),tag=%u(0x%x),startpos=%u(0x%x),kNewClassTag=%u(0x%x)\n",bcnt,bcnt,tag,tag,startpos,startpos,kNewClassTag,kNewClassTag);//## + printf("bcnt=%u(0x%x),tag=%u(0x%x),startpos=%u(0x%x),kNewClassTag=%u(0x%x)\n",bcnt,bcnt,tag,tag,startpos,startpos,kNewClassTag,kNewClassTag);//## // in case tag is object tag return tag if (!(tag & kClassMask)) { if (objTag) *objTag = tag; @@ -3060,7 +3067,7 @@ TClass *TBufferFile::ReadClass(const TClass *clReq, UInt_t *objTag) // got a tag to an already seen class UInt_t clTag = (tag & ~kClassMask); -// printf("clTag=%u(0x%x),fVersion=%d\n",clTag,clTag,fVersion);//## + printf("clTag=%u(0x%x),fVersion=%d\n",clTag,clTag,fVersion);//## if (fVersion > 0) { clTag += fDisplacement; clTag = CheckObject(clTag, clReq, kTRUE); @@ -3214,7 +3221,20 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass // before reading object save start position *startpos = UInt_t(fBufCur-fBuffer); } -// printf("In TBufferFile::ReadVersion, buffBigEndian=%d, start pos=%u\n",IsBufBigEndian(),UInt_t(fBufCur-fBuffer));//## + printf("In TBufferFile::ReadVersion, buffBigEndian=%d, start pos=%u\n",IsBufBigEndian(),UInt_t(fBufCur-fBuffer));//## + UInt_t teststart = UInt_t(fBufCur-fBuffer);//## + printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart-4,fBuffer[teststart-4],teststart-3,fBuffer[teststart-3],teststart-2,fBuffer[teststart-2],teststart-1,fBuffer[teststart-1]);//## + printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart,fBuffer[teststart],teststart+1,fBuffer[teststart+1],teststart+2,fBuffer[teststart+2],teststart+3,fBuffer[teststart+3]);//## + teststart += 4; + printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart,fBuffer[teststart],teststart+1,fBuffer[teststart+1],teststart+2,fBuffer[teststart+2],teststart+3,fBuffer[teststart+3]);//## + teststart += 4; + printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart,fBuffer[teststart],teststart+1,fBuffer[teststart+1],teststart+2,fBuffer[teststart+2],teststart+3,fBuffer[teststart+3]);//## + teststart += 4; + printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart,fBuffer[teststart],teststart+1,fBuffer[teststart+1],teststart+2,fBuffer[teststart+2],teststart+3,fBuffer[teststart+3]);//## + teststart += 4; + printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart,fBuffer[teststart],teststart+1,fBuffer[teststart+1],teststart+2,fBuffer[teststart+2],teststart+3,fBuffer[teststart+3]);//## + teststart += 4; + printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart,fBuffer[teststart],teststart+1,fBuffer[teststart+1],teststart+2,fBuffer[teststart+2],teststart+3,fBuffer[teststart+3]);//## // read byte count (older files don't have byte count) // byte count is packed in two individual shorts, this to be @@ -3241,16 +3261,36 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass frombuf(this->fBufCur,&v.vers[0],0); } #endif -// printf("vers[0]=%hi(0x%hx),vers[1]=%hi(0x%hx)\n",v.vers[0],v.vers[0],v.vers[1],v.vers[1]);//## + printf("vers[0]=%hi(0x%hx),vers[1]=%hi(0x%hx)\n",v.vers[0],v.vers[0],v.vers[1],v.vers[1]);//## // no bytecount, backup and read version - if (!(v.cnt & kByteCountMask)) { -// printf("In TBufferFile::ReadVersion, buffBigEndian=%d, v.cnt=%u, and no bytecount found!!!\n",IsBufBigEndian(),v.cnt);//## - fBufCur -= sizeof(UInt_t); - v.cnt = 0; + printf("v.cnt=0x%x,kByteCountMask=%x\n",v.cnt,kByteCountMask);//## + UShort_t possibleVersion; //## + if (IsBufBigEndian()) { + if (!(v.cnt & kByteCountMask)) { + printf("In TBufferFile::ReadVersion, buffBigEndian=%d, v.cnt=%u, and no bytecount found!!!\n",IsBufBigEndian(),v.cnt);//## + fBufCur -= sizeof(UInt_t); + v.cnt = 0; + } + } else { + if (!(v.cnt & kByteCountMask)) { + printf("In TBufferFile::ReadVersion, buffBigEndian=%d, v.cnt=%u, and no bytecount found!!!\n",IsBufBigEndian(),v.cnt);//## + fBufCur -= sizeof(UInt_t); + v.cnt = 0; + } else { + frombuf(this->fBufCur,&possibleVersion,0); + printf("My Added Code:possibleVersion=%hu,v.vers[1]=%hu\n",possibleVersion,v.vers[1]);//## + if (!possibleVersion) { + if ((v.vers[1] >> 8) != 0x40) { + fBufCur -= sizeof(UInt_t); + v.cnt = 0; + } + } + fBufCur -= sizeof(UShort_t); + } } if (bcnt) *bcnt = (v.cnt & ~kByteCountMask); frombuf(this->fBufCur,&version, IsBufBigEndian()); -// printf("version=%hi(0x%hx)\n",version,version);//## + printf("version=%hi(0x%hx)\n",version,version);//## if (version<=1) { if (version <= 0) { if (cl) { @@ -3317,7 +3357,7 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass } } } -// printf("before return, version=%hi(0x%hx)\n",version,version);//## + printf("before return, version=%hi(0x%hx)\n",version,version);//## return version; } @@ -3439,16 +3479,17 @@ Version_t TBufferFile::ReadVersionForMemberWise(const TClass *cl) UInt_t TBufferFile::WriteVersion(const TClass *cl, Bool_t useBcnt) { UInt_t cntpos = 0; + printf("In TBufferFile::WriteVersion, useBcnt=%d\n",useBcnt);//## if (useBcnt) { // reserve space for leading byte count -// printf("In TBufferFile::WriteVersion, we need to reserve space for bount count\n");//## + printf("In TBufferFile::WriteVersion, we need to reserve space for bount count\n");//## cntpos = UInt_t(fBufCur-fBuffer); fBufCur += sizeof(UInt_t); -// printf("In TBufferFile::WriteVersion, class:%s and start offset=%u\n",cl->GetName(),UInt_t(fBufCur-fBuffer));//## + printf("In TBufferFile::WriteVersion, class:%s and start offset=%u\n",cl->GetName(),UInt_t(fBufCur-fBuffer));//## } Version_t version = cl->GetClassVersion(); -// printf("In TBufferFile::WriteVersion, version=%hi(0x%hx)\n",version,version);//## + printf("In TBufferFile::WriteVersion, version=%hi(0x%hx)\n",version,version);//## if (version<=1 && cl->IsForeign()) { *this << Version_t(0); *this << cl->GetCheckSum(); @@ -4065,7 +4106,7 @@ Int_t TBufferFile::ReadClassEmulated(const TClass *cl, void *object, const TClas Int_t TBufferFile::ReadClassBuffer(const TClass *cl, void *pointer, Int_t version, UInt_t start, UInt_t count, const TClass *onFileClass) { -// printf("!!!ReadBuffer, class: %s, attempting to access a wrong version: %d, object skipped at offset %d",cl->GetName(), version, Length() ); //## + printf("!!!ReadBuffer, class: %s, attempting to access a wrong version: %d, object skipped at offset %d",cl->GetName(), version, Length() ); //## //--------------------------------------------------------------------------- // The ondisk class has been specified so get foreign streamer info @@ -4318,19 +4359,19 @@ Int_t TBufferFile::WriteClassBuffer(const TClass *cl, void *pointer) } //write the class version number and reserve space for the byte count -// printf("TBufferFile::WriteClassBuffer, before WriteVersion,class:%s\n",cl->GetName());//## + printf("TBufferFile::WriteClassBuffer, before WriteVersion,class:%s\n",cl->GetName());//## UInt_t R__c = WriteVersion(cl, kTRUE); -// printf("TBufferFile::WriteClassBuffer, after WriteVersion,class:%s\n",cl->GetName());//## + printf("TBufferFile::WriteClassBuffer, after WriteVersion,class:%s\n",cl->GetName());//## //NOTE: In the future Philippe wants this to happen via a custom action TagStreamerInfo(sinfo); ApplySequence(*(sinfo->GetWriteObjectWiseActions()), (char*)pointer); -// printf("TBufferFile::WriteClassBuffer, after TagStreamerInfo and ApplySequence,class:%s\n",cl->GetName());//## + printf("TBufferFile::WriteClassBuffer, after TagStreamerInfo and ApplySequence,class:%s\n",cl->GetName());//## //write the byte count at the start of the buffer SetByteCount(R__c, kTRUE); -// printf(" WriteBuffer for class: %s version %d has written %d bytes\n",cl->GetName(),cl->GetClassVersion(),UInt_t(fBufCur - fBuffer) - R__c - (UInt_t)sizeof(UInt_t)); //## + printf(" WriteBuffer for class: %s version %d has written %d bytes\n",cl->GetName(),cl->GetClassVersion(),UInt_t(fBufCur - fBuffer) - R__c - (UInt_t)sizeof(UInt_t)); //## if (gDebug > 2) printf(" WriteBuffer for class: %s version %d has written %d bytes\n",cl->GetName(),cl->GetClassVersion(),UInt_t(fBufCur - fBuffer) - R__c - (UInt_t)sizeof(UInt_t)); return 0; } diff --git a/io/io/src/TKey.cxx b/io/io/src/TKey.cxx index 6b56e68d2ee2f..4a1f7382da9e4 100644 --- a/io/io/src/TKey.cxx +++ b/io/io/src/TKey.cxx @@ -247,9 +247,11 @@ TKey::TKey(const TObject *obj, const char *name, Int_t bufsize, TDirectory* moth fCycle = fMotherDir->AppendKey(this); Streamer(*fBufferRef); //write key itself + printf("In TKey::TKey and after Streamer\n");//## fKeylen = fBufferRef->Length(); fBufferRef->MapObject(obj); //register obj in map in case of self reference ((TObject*)obj)->Streamer(*fBufferRef); //write object + printf("In TKey::TKey and after obj Streamer\n");//## lbuf = fBufferRef->Length(); fObjlen = lbuf - fKeylen; @@ -1359,6 +1361,7 @@ void TKey::Streamer(TBuffer &b) fDatime.Streamer(b); b >> fKeylen; b >> fCycle; + printf("In TKey::Streamer, and fVersion=%d\n",fVersion);//## if (fVersion > 1000) { b >> fSeekKey; @@ -1379,13 +1382,16 @@ void TKey::Streamer(TBuffer &b) b >> seekdir; fSeekPdir= (Long64_t)seekdir; } fClassName.Streamer(b); + printf("In TKey::Streamer, and fClassName=%s\n",fClassName.Data());//## //the following test required for forward and backward compatibility if (fClassName == "TDirectory") { fClassName = "TDirectoryFile"; SetBit(kIsDirectoryFile); } fName.Streamer(b); + printf("In TKey::Streamer, and fName=%s\n",fName.Data());//## fTitle.Streamer(b); + printf("In TKey::Streamer, and fTitle=%s\n",fTitle.Data());//## if (fKeylen < 0) { Error("Streamer","The value of fKeylen is incorrect (%d) ; trying to recover by setting it to zero",fKeylen); MakeZombie(); @@ -1435,6 +1441,9 @@ void TKey::Streamer(TBuffer &b) } fName.Streamer(b); fTitle.Streamer(b); + printf("In TKey::Streamer, and fClassName=%s\n",fClassName.Data());//## + printf("In TKey::Streamer, and fName=%s\n",fName.Data());//## + printf("In TKey::Streamer, and fTitle=%s\n",fTitle.Data());//## } } diff --git a/math/mathcore/test/fit/testRooFit.cxx b/math/mathcore/test/fit/testRooFit.cxx index b9c1413ad79c7..b76c615433f53 100644 --- a/math/mathcore/test/fit/testRooFit.cxx +++ b/math/mathcore/test/fit/testRooFit.cxx @@ -4,6 +4,7 @@ #include #include +#include "TROOT.h" #include "RooDataSet.h" #include "RooRealVar.h" #include "RooGaussian.h" @@ -338,7 +339,7 @@ struct GausNorm<1> { int main() { - + gROOT->SetBufLittleEndian();//## TTree tree("t","a large Tree with many gaussian variables"); fillTree(tree); diff --git a/tree/tree/src/TBasket.cxx b/tree/tree/src/TBasket.cxx index 00450a1f2c8cc..29bc61d985cb3 100644 --- a/tree/tree/src/TBasket.cxx +++ b/tree/tree/src/TBasket.cxx @@ -781,6 +781,7 @@ void TBasket::Streamer(TBuffer &b) { char flag; if (b.IsReading()) { + printf("Begining of TBasket::Streamer()\n");//## TKey::Streamer(b); //this must be first Version_t v = b.ReadVersion(); b >> fBufferSize; @@ -793,8 +794,10 @@ void TBasket::Streamer(TBuffer &b) b >> fNevBuf; b >> fLast; b >> flag; + printf("v=%hu,fBufferSize=%d,fNevBufSize=%d,fNevBuf=%d,fLast=%d,flag=%d\n",v,fBufferSize,fNevBufSize,fNevBuf,fLast,flag);//## if (fLast > fBufferSize) fBufferSize = fLast; if (!flag) { + printf("In TBasket::Streamer() and before return\n");//## return; } if (flag%10 != 2) { @@ -822,6 +825,7 @@ void TBasket::Streamer(TBuffer &b) // yet be set correctly. // fBranch->GetTree()->IncrementTotalBuffers(fBufferSize); } + printf("End of TBasket::Streamer()\n");//## } else { TKey::Streamer(b); //this must be first b.WriteVersion(TBasket::IsA()); @@ -885,6 +889,7 @@ void TBasket::Streamer(TBuffer &b) b.WriteFastArray(buf, fLast); } } + printf("TBasket::IsA()=%s,fBufferSize=%d,fNevBufSize=%d,fNevBuf=%d,fLast=%d,flag=%d\n",TBasket::IsA()->GetName(),fBufferSize,fNevBufSize,fNevBuf,fLast,flag);//## } } diff --git a/tree/tree/src/TTree.cxx b/tree/tree/src/TTree.cxx index 548289efe37c1..f3fb18cd029fd 100644 --- a/tree/tree/src/TTree.cxx +++ b/tree/tree/src/TTree.cxx @@ -8818,6 +8818,7 @@ void TTree::Streamer(TBuffer& b) fCacheSize = 0; } ResetBit(kMustCleanup); + printf("In TTree::Streamer(), before return\n");//## return; } //====process old versions before automatic schema evolution @@ -8865,6 +8866,7 @@ void TTree::Streamer(TBuffer& b) if (table) TRefTable::SetRefTable(table); } + printf("End of TTree::Streamer()\n");//## } //////////////////////////////////////////////////////////////////////////////// From 8fd7774904ac939aaa01f9a8d49a1aabaeb70cf1 Mon Sep 17 00:00:00 2001 From: zzxuanyuan Date: Wed, 27 Apr 2016 21:54:29 -0500 Subject: [PATCH 14/18] Remove debug code --- core/base/inc/Bytes.h | 8 ------ io/io/src/TBufferFile.cxx | 57 +++++---------------------------------- io/io/src/TFile.cxx | 12 --------- io/io/src/TKey.cxx | 17 ------------ test/MainEvent.cxx | 3 --- tree/tree/src/TBasket.cxx | 5 ---- tree/tree/src/TTree.cxx | 4 --- 7 files changed, 6 insertions(+), 100 deletions(-) diff --git a/core/base/inc/Bytes.h b/core/base/inc/Bytes.h index 6bfea59ff9cf6..983ac3caa7563 100644 --- a/core/base/inc/Bytes.h +++ b/core/base/inc/Bytes.h @@ -80,10 +80,8 @@ if(buffBigEndian) { buf[0] = sw[1]; buf[1] = sw[0]; # endif - printf("to:BigEndian:ushort=%hu\n", x);//## } else { memcpy(buf, &x, sizeof(UShort_t)); - printf("to:LittleEndian:ushort=%hu\n", x);//## } #else if(buffBigEndian) { @@ -387,9 +385,7 @@ if(buffBigEndian) { buf[2] = u.c[1]; buf[3] = u.c[0]; # endif -// printf("tobuf:BigEndian:float=%f\n", x);//## } else { -// printf("tobuf:LittleEndian:float=%f\n", x);//## memcpy(buf, &x, sizeof(Float_t)); } #else @@ -502,10 +498,8 @@ if(buffBigEndian) { sw[0] = buf[1]; sw[1] = buf[0]; # endif - printf("from:BigEndian:ushort=%hu\n", *x);//## } else { memcpy(x, buf, sizeof(UShort_t)); - printf("from:LittleEndian:ushort=x[0]=%hu\n", *x);//## } #else if(buffBigEndian) { @@ -678,9 +672,7 @@ if(buffBigEndian) { u.c[3] = buf[0]; *x = u.f; # endif -// printf("BigEndian:float=%f\n", *x);//## } else { -// printf("LittleEndian:float=%f\n", *x);//## memcpy(x, buf, sizeof(Float_t)); } #else diff --git a/io/io/src/TBufferFile.cxx b/io/io/src/TBufferFile.cxx index b5f709e5b8123..41c240246205f 100644 --- a/io/io/src/TBufferFile.cxx +++ b/io/io/src/TBufferFile.cxx @@ -375,7 +375,6 @@ void TBufferFile::SetByteCount(UInt_t cntpos, Bool_t packInVersion) // if true, pack byte count in two consecutive shorts, so it can // be read by ReadVersion() if (packInVersion) { - printf("in packInVersion,buffBigEndian=%d\n",IsBufBigEndian());//## union { UInt_t cnt; Version_t vers[2]; @@ -398,9 +397,8 @@ void TBufferFile::SetByteCount(UInt_t cntpos, Bool_t packInVersion) tobuf(buf, Version_t(v.vers[0] | kByteCountVMask), 0); } #endif - } else {//## + } else { tobuf(buf, cnt | kByteCountMask, IsBufBigEndian()); - printf("else packInVersion,buffBigEndian=%d, cnt|kByteCountMask and cnt=%u(0x%x)\n",IsBufBigEndian(),cnt|kByteCountMask,cnt|kByteCountMask);//## } if (cnt >= kMaxMapCount) { @@ -424,12 +422,10 @@ Int_t TBufferFile::CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *cl Int_t offset = 0; Long_t endpos = Long_t(fBuffer) + startpos + bcnt + sizeof(UInt_t); - printf("Outer: In TBufferFile::CheckByteCount(),fBuffer=%ld,startpos=%u,bcnt=%u,endpos=%ld,fBufCur=%ld,offset=%d\n",Long_t(fBuffer),startpos,bcnt,endpos,Long_t(fBufCur),offset);//## if (Long_t(fBufCur) != endpos) { offset = Int_t(Long_t(fBufCur) - endpos); const char *name = clss ? clss->GetName() : classname ? classname : 0; - printf("In TBufferFile::CheckByteCount(),name=%s,fBuffer=%ld,startpos=%u,bcnt=%u,endpos=%ld,fBufCur=%ld,offset=%d\n",name,Long_t(fBuffer),startpos,bcnt,endpos,Long_t(fBufCur),offset);//## if (name) { if (offset < 0) { @@ -2748,9 +2744,7 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) // attempt to load next object as TClass clCast UInt_t tag; // either tag or byte count - printf("In TBufferFile::ReadObjectAny, before ReadClass()\n");//## TClass *clRef = ReadClass(clCast, &tag); - printf("In TBufferFile::ReadObjectAny, after ReadClass()\n");//## TClass *clOnfile = 0; Int_t baseOffset = 0; if (clRef && (clRef!=(TClass*)(-1)) && clCast) { @@ -2765,7 +2759,6 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) // There is no converter Error("ReadObject", "got object of wrong class! requested %s but got %s", clCast->GetName(), clRef->GetName()); - printf("In TBufferFile::ReadObjectAny(), CheckByteCount 1\n");//## CheckByteCount(startpos, tag, (TClass*)0); // avoid mis-leading byte count error message return 0; // We better return at this point } @@ -2779,7 +2772,6 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) //we cannot mix a compiled class with an emulated class in the inheritance Error("ReadObject", "trying to read an emulated class (%s) to store in a compiled pointer (%s)", clRef->GetName(),clCast->GetName()); - printf("In TBufferFile::ReadObjectAny(), CheckByteCount 2\n");//## CheckByteCount(startpos, tag, (TClass*)0); // avoid mis-leading byte count error message return 0; } @@ -2792,7 +2784,6 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) obj = (char *) (Long_t)fMap->GetValue(startpos+kMapOffset); if (obj == (void*) -1) obj = 0; if (obj) { - printf("In TBufferFile::ReadObjectAny(), CheckByteCount 3\n");//## CheckByteCount(startpos, tag, (TClass*)0); return (obj+baseOffset); } @@ -2805,7 +2796,6 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) MapObject((TObject*) -1, startpos+kMapOffset); else MapObject((void*)0, 0, fMapCount); - printf("In TBufferFile::ReadObjectAny(), CheckByteCount 4\n");//## CheckByteCount(startpos, tag, (TClass*)0); return 0; } @@ -2863,11 +2853,8 @@ void *TBufferFile::ReadObjectAny(const TClass *clCast) MapObject(obj, clRef, fMapCount); // let the object read itself - printf("In ReadObjectAny(), before Streamer,name=%s,fBufCur=%ld\n",clRef->GetName(),Long_t(fBufCur));//## clRef->Streamer( obj, *this, clOnfile ); - printf("In ReadObjectAny(), after Streamer,name=%s,fBufCur=%ld\n",clRef->GetName(),Long_t(fBufCur));//## - printf("In TBufferFile::ReadObjectAny(), CheckByteCount 5\n");//## CheckByteCount(startpos, tag, clRef); } @@ -2949,7 +2936,6 @@ void TBufferFile::WriteObjectClass(const void *actualObjectStart, const TClass * fMapCount++; ((TClass*)actualClass)->Streamer((void*)actualObjectStart,*this); - printf("In TBufferFile::WriteObjectClass, between Class->Streamer and SetByteCount()\n"); // write byte count SetByteCount(cntpos); } @@ -3031,16 +3017,13 @@ TClass *TBufferFile::ReadClass(const TClass *clReq, UInt_t *objTag) UInt_t bcnt, tag, startpos = 0; *this >> bcnt; if (!(bcnt & kByteCountMask) || bcnt == kNewClassTag) { - printf("in if, buffBigEndian=%d,requested class:%s,fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",IsBufBigEndian(),clReq->GetName(),fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag);//## tag = bcnt; bcnt = 0; } else { fVersion = 1; startpos = UInt_t(fBufCur-fBuffer); *this >> tag; - printf("in else, buffBigEndian=%d,requested class:%s,fVersion=%d,bcnt=%u(0x%x), kByteCountMask=%u(0x%x), kNewClassTag=%u(0x%x)\n",IsBufBigEndian(),clReq->GetName(),fVersion,bcnt,bcnt,kByteCountMask,kByteCountMask,kNewClassTag,kNewClassTag);//## } - printf("bcnt=%u(0x%x),tag=%u(0x%x),startpos=%u(0x%x),kNewClassTag=%u(0x%x)\n",bcnt,bcnt,tag,tag,startpos,startpos,kNewClassTag,kNewClassTag);//## // in case tag is object tag return tag if (!(tag & kClassMask)) { if (objTag) *objTag = tag; @@ -3067,7 +3050,6 @@ TClass *TBufferFile::ReadClass(const TClass *clReq, UInt_t *objTag) // got a tag to an already seen class UInt_t clTag = (tag & ~kClassMask); - printf("clTag=%u(0x%x),fVersion=%d\n",clTag,clTag,fVersion);//## if (fVersion > 0) { clTag += fDisplacement; clTag = CheckObject(clTag, clReq, kTRUE); @@ -3221,20 +3203,6 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass // before reading object save start position *startpos = UInt_t(fBufCur-fBuffer); } - printf("In TBufferFile::ReadVersion, buffBigEndian=%d, start pos=%u\n",IsBufBigEndian(),UInt_t(fBufCur-fBuffer));//## - UInt_t teststart = UInt_t(fBufCur-fBuffer);//## - printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart-4,fBuffer[teststart-4],teststart-3,fBuffer[teststart-3],teststart-2,fBuffer[teststart-2],teststart-1,fBuffer[teststart-1]);//## - printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart,fBuffer[teststart],teststart+1,fBuffer[teststart+1],teststart+2,fBuffer[teststart+2],teststart+3,fBuffer[teststart+3]);//## - teststart += 4; - printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart,fBuffer[teststart],teststart+1,fBuffer[teststart+1],teststart+2,fBuffer[teststart+2],teststart+3,fBuffer[teststart+3]);//## - teststart += 4; - printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart,fBuffer[teststart],teststart+1,fBuffer[teststart+1],teststart+2,fBuffer[teststart+2],teststart+3,fBuffer[teststart+3]);//## - teststart += 4; - printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart,fBuffer[teststart],teststart+1,fBuffer[teststart+1],teststart+2,fBuffer[teststart+2],teststart+3,fBuffer[teststart+3]);//## - teststart += 4; - printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart,fBuffer[teststart],teststart+1,fBuffer[teststart+1],teststart+2,fBuffer[teststart+2],teststart+3,fBuffer[teststart+3]);//## - teststart += 4; - printf("fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x,fBuffer[%u]=0x%x\n",teststart,fBuffer[teststart],teststart+1,fBuffer[teststart+1],teststart+2,fBuffer[teststart+2],teststart+3,fBuffer[teststart+3]);//## // read byte count (older files don't have byte count) // byte count is packed in two individual shorts, this to be @@ -3261,24 +3229,22 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass frombuf(this->fBufCur,&v.vers[0],0); } #endif - printf("vers[0]=%hi(0x%hx),vers[1]=%hi(0x%hx)\n",v.vers[0],v.vers[0],v.vers[1],v.vers[1]);//## - // no bytecount, backup and read version - printf("v.cnt=0x%x,kByteCountMask=%x\n",v.cnt,kByteCountMask);//## - UShort_t possibleVersion; //## + // no bytecount, backup and read version. + // read in next UShort_t and determine if it is zero or not. + // If it's not zero, it is 'highly possible' storing version + // and consequently the first four byte should be byte count. + UShort_t possibleVersion; if (IsBufBigEndian()) { if (!(v.cnt & kByteCountMask)) { - printf("In TBufferFile::ReadVersion, buffBigEndian=%d, v.cnt=%u, and no bytecount found!!!\n",IsBufBigEndian(),v.cnt);//## fBufCur -= sizeof(UInt_t); v.cnt = 0; } } else { if (!(v.cnt & kByteCountMask)) { - printf("In TBufferFile::ReadVersion, buffBigEndian=%d, v.cnt=%u, and no bytecount found!!!\n",IsBufBigEndian(),v.cnt);//## fBufCur -= sizeof(UInt_t); v.cnt = 0; } else { frombuf(this->fBufCur,&possibleVersion,0); - printf("My Added Code:possibleVersion=%hu,v.vers[1]=%hu\n",possibleVersion,v.vers[1]);//## if (!possibleVersion) { if ((v.vers[1] >> 8) != 0x40) { fBufCur -= sizeof(UInt_t); @@ -3290,7 +3256,6 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass } if (bcnt) *bcnt = (v.cnt & ~kByteCountMask); frombuf(this->fBufCur,&version, IsBufBigEndian()); - printf("version=%hi(0x%hx)\n",version,version);//## if (version<=1) { if (version <= 0) { if (cl) { @@ -3357,7 +3322,6 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass } } } - printf("before return, version=%hi(0x%hx)\n",version,version);//## return version; } @@ -3479,17 +3443,13 @@ Version_t TBufferFile::ReadVersionForMemberWise(const TClass *cl) UInt_t TBufferFile::WriteVersion(const TClass *cl, Bool_t useBcnt) { UInt_t cntpos = 0; - printf("In TBufferFile::WriteVersion, useBcnt=%d\n",useBcnt);//## if (useBcnt) { // reserve space for leading byte count - printf("In TBufferFile::WriteVersion, we need to reserve space for bount count\n");//## cntpos = UInt_t(fBufCur-fBuffer); fBufCur += sizeof(UInt_t); - printf("In TBufferFile::WriteVersion, class:%s and start offset=%u\n",cl->GetName(),UInt_t(fBufCur-fBuffer));//## } Version_t version = cl->GetClassVersion(); - printf("In TBufferFile::WriteVersion, version=%hi(0x%hx)\n",version,version);//## if (version<=1 && cl->IsForeign()) { *this << Version_t(0); *this << cl->GetCheckSum(); @@ -4106,7 +4066,6 @@ Int_t TBufferFile::ReadClassEmulated(const TClass *cl, void *object, const TClas Int_t TBufferFile::ReadClassBuffer(const TClass *cl, void *pointer, Int_t version, UInt_t start, UInt_t count, const TClass *onFileClass) { - printf("!!!ReadBuffer, class: %s, attempting to access a wrong version: %d, object skipped at offset %d",cl->GetName(), version, Length() ); //## //--------------------------------------------------------------------------- // The ondisk class has been specified so get foreign streamer info @@ -4359,19 +4318,15 @@ Int_t TBufferFile::WriteClassBuffer(const TClass *cl, void *pointer) } //write the class version number and reserve space for the byte count - printf("TBufferFile::WriteClassBuffer, before WriteVersion,class:%s\n",cl->GetName());//## UInt_t R__c = WriteVersion(cl, kTRUE); - printf("TBufferFile::WriteClassBuffer, after WriteVersion,class:%s\n",cl->GetName());//## //NOTE: In the future Philippe wants this to happen via a custom action TagStreamerInfo(sinfo); ApplySequence(*(sinfo->GetWriteObjectWiseActions()), (char*)pointer); - printf("TBufferFile::WriteClassBuffer, after TagStreamerInfo and ApplySequence,class:%s\n",cl->GetName());//## //write the byte count at the start of the buffer SetByteCount(R__c, kTRUE); - printf(" WriteBuffer for class: %s version %d has written %d bytes\n",cl->GetName(),cl->GetClassVersion(),UInt_t(fBufCur - fBuffer) - R__c - (UInt_t)sizeof(UInt_t)); //## if (gDebug > 2) printf(" WriteBuffer for class: %s version %d has written %d bytes\n",cl->GetName(),cl->GetClassVersion(),UInt_t(fBufCur - fBuffer) - R__c - (UInt_t)sizeof(UInt_t)); return 0; } diff --git a/io/io/src/TFile.cxx b/io/io/src/TFile.cxx index 759cef959db4a..3f942a3cdfa94 100644 --- a/io/io/src/TFile.cxx +++ b/io/io/src/TFile.cxx @@ -1317,7 +1317,6 @@ const TList *TFile::GetStreamerInfoCache() TList *TFile::GetStreamerInfoList() { - printf("In TFile::GetStreamerInfoList\n");//## if (fIsPcmFile) return 0; // No schema evolution for ROOT PCM files. TList *list = 0; @@ -1327,25 +1326,14 @@ TList *TFile::GetStreamerInfoList() char *buffer = new char[fNbytesInfo+1]; char *buf = buffer; Seek(fSeekInfo); - printf("In TFile::GetStreamerInfo, After Seek()\n"); //## if (ReadBuffer(buf,fNbytesInfo)) { // ReadBuffer returns kTRUE in case of failure. Warning("GetRecordHeader","%s: failed to read the StreamerInfo data from disk.", GetName()); return 0; } - printf("In TFile::GetStreamerInfo, After ReadBuffer()\n"); //## - /* - int cnt = 0; - for(cnt=0;cntReadKeyBuffer(buf); - printf("In TFile::GetStreamerInfo, After ReadKeyBuffer()\n"); //## list = dynamic_cast(key->ReadObjWithBuffer(buffer,0,1)); - printf("In TFile::GetStreamerInfo, After ReadObjWithBuffer()\n"); //## if (list) list->SetOwner(); delete [] buffer; delete key; diff --git a/io/io/src/TKey.cxx b/io/io/src/TKey.cxx index 4a1f7382da9e4..f0bade8098b84 100644 --- a/io/io/src/TKey.cxx +++ b/io/io/src/TKey.cxx @@ -242,16 +242,13 @@ TKey::TKey(const TObject *obj, const char *name, Int_t bufsize, TDirectory* moth Int_t lbuf, nout, noutot, bufmax, nzip; fBufferRef = new TBufferFile(TBuffer::kWrite, bufsize, def, buffBigEndian); - printf("In TKey::TKey and fBufferRef->IsBufBigEndian()=%d\n",fBufferRef->IsBufBigEndian());//## fBufferRef->SetParent(GetFile()); fCycle = fMotherDir->AppendKey(this); Streamer(*fBufferRef); //write key itself - printf("In TKey::TKey and after Streamer\n");//## fKeylen = fBufferRef->Length(); fBufferRef->MapObject(obj); //register obj in map in case of self reference ((TObject*)obj)->Streamer(*fBufferRef); //write object - printf("In TKey::TKey and after obj Streamer\n");//## lbuf = fBufferRef->Length(); fObjlen = lbuf - fKeylen; @@ -729,7 +726,6 @@ void TKey::Print(Option_t *) const TObject *TKey::ReadObj() { - printf("In TKey::ReadObj()\n");//## TClass *cl = TClass::GetClass(fClassName.Data()); if (!cl) { Error("ReadObj", "Unknown class %s", fClassName.Data()); @@ -903,7 +899,6 @@ TObject *TKey::ReadObjWithBuffer(char *bufferRead, Bool_t def, Bool_t buffBigEnd // get version of key fBufferRef->SetBufferOffset(sizeof(fNbytes)); Version_t kvers = fBufferRef->ReadVersion(); - printf("version of key: %d\n",kvers); //## fBufferRef->SetBufferOffset(fKeylen); TObject *tobj = 0; // Create an instance of this class @@ -927,7 +922,6 @@ TObject *TKey::ReadObjWithBuffer(char *bufferRead, Bool_t def, Bool_t buffBigEnd fBufferRef->MapObject(pobj,cl); //register obj in map to handle self reference if (fObjlen > fNbytes-fKeylen) { - printf("if and Before everything\n");//## char *objbuf = fBufferRef->Buffer() + fKeylen; UChar_t *bufcur = (UChar_t *)&fBuffer[fKeylen]; Int_t nin, nout = 0, nbuf; @@ -943,9 +937,7 @@ TObject *TKey::ReadObjWithBuffer(char *bufferRead, Bool_t def, Bool_t buffBigEnd objbuf += nout; } if (nout) { - printf("nout!=0, and before Streamer, fVersion=%d\n",fVersion);//## tobj->Streamer(*fBufferRef); //does not work with example 2 above - printf("nout!=0, and after Streamer, fVersion=%d\n",fVersion);//## } else { // Even-though we have a TObject, if the class is emulated the virtual // table may not be 'right', so let's go via the TClass. @@ -955,10 +947,8 @@ TObject *TKey::ReadObjWithBuffer(char *bufferRead, Bool_t def, Bool_t buffBigEnd goto CLEAR; } } else { - printf("else and Before tobj->Streamer\n");//## tobj->Streamer(*fBufferRef); } - printf("After Comparing\n");//## if (gROOT->GetForceStyle()) tobj->UseCurrentStyle(); if (cl->InheritsFrom(TDirectoryFile::Class())) { @@ -1361,7 +1351,6 @@ void TKey::Streamer(TBuffer &b) fDatime.Streamer(b); b >> fKeylen; b >> fCycle; - printf("In TKey::Streamer, and fVersion=%d\n",fVersion);//## if (fVersion > 1000) { b >> fSeekKey; @@ -1382,16 +1371,13 @@ void TKey::Streamer(TBuffer &b) b >> seekdir; fSeekPdir= (Long64_t)seekdir; } fClassName.Streamer(b); - printf("In TKey::Streamer, and fClassName=%s\n",fClassName.Data());//## //the following test required for forward and backward compatibility if (fClassName == "TDirectory") { fClassName = "TDirectoryFile"; SetBit(kIsDirectoryFile); } fName.Streamer(b); - printf("In TKey::Streamer, and fName=%s\n",fName.Data());//## fTitle.Streamer(b); - printf("In TKey::Streamer, and fTitle=%s\n",fTitle.Data());//## if (fKeylen < 0) { Error("Streamer","The value of fKeylen is incorrect (%d) ; trying to recover by setting it to zero",fKeylen); MakeZombie(); @@ -1441,9 +1427,6 @@ void TKey::Streamer(TBuffer &b) } fName.Streamer(b); fTitle.Streamer(b); - printf("In TKey::Streamer, and fClassName=%s\n",fClassName.Data());//## - printf("In TKey::Streamer, and fName=%s\n",fName.Data());//## - printf("In TKey::Streamer, and fTitle=%s\n",fTitle.Data());//## } } diff --git a/test/MainEvent.cxx b/test/MainEvent.cxx index 9b655244cd982..c119b0d7e635a 100644 --- a/test/MainEvent.cxx +++ b/test/MainEvent.cxx @@ -155,11 +155,8 @@ int main(int argc, char **argv) hfile = new TNetFile("root://localhost/root/test/EventNet.root"); } else hfile = new TFile("Event.root"); - printf("In MainEvent.cxx, before getting tree\n");//## tree = (TTree*)hfile->Get("T"); - printf("In MainEvent.cxx, before getting branch\n");//## TBranch *branch = tree->GetBranch("event"); - printf("In MainEvent.cxx, before setting address\n");//## branch->SetAddress(&event); Int_t nentries = (Int_t)tree->GetEntries(); nevent = TMath::Min(nevent,nentries); diff --git a/tree/tree/src/TBasket.cxx b/tree/tree/src/TBasket.cxx index 29bc61d985cb3..00450a1f2c8cc 100644 --- a/tree/tree/src/TBasket.cxx +++ b/tree/tree/src/TBasket.cxx @@ -781,7 +781,6 @@ void TBasket::Streamer(TBuffer &b) { char flag; if (b.IsReading()) { - printf("Begining of TBasket::Streamer()\n");//## TKey::Streamer(b); //this must be first Version_t v = b.ReadVersion(); b >> fBufferSize; @@ -794,10 +793,8 @@ void TBasket::Streamer(TBuffer &b) b >> fNevBuf; b >> fLast; b >> flag; - printf("v=%hu,fBufferSize=%d,fNevBufSize=%d,fNevBuf=%d,fLast=%d,flag=%d\n",v,fBufferSize,fNevBufSize,fNevBuf,fLast,flag);//## if (fLast > fBufferSize) fBufferSize = fLast; if (!flag) { - printf("In TBasket::Streamer() and before return\n");//## return; } if (flag%10 != 2) { @@ -825,7 +822,6 @@ void TBasket::Streamer(TBuffer &b) // yet be set correctly. // fBranch->GetTree()->IncrementTotalBuffers(fBufferSize); } - printf("End of TBasket::Streamer()\n");//## } else { TKey::Streamer(b); //this must be first b.WriteVersion(TBasket::IsA()); @@ -889,7 +885,6 @@ void TBasket::Streamer(TBuffer &b) b.WriteFastArray(buf, fLast); } } - printf("TBasket::IsA()=%s,fBufferSize=%d,fNevBufSize=%d,fNevBuf=%d,fLast=%d,flag=%d\n",TBasket::IsA()->GetName(),fBufferSize,fNevBufSize,fNevBuf,fLast,flag);//## } } diff --git a/tree/tree/src/TTree.cxx b/tree/tree/src/TTree.cxx index f3fb18cd029fd..13f680e01724b 100644 --- a/tree/tree/src/TTree.cxx +++ b/tree/tree/src/TTree.cxx @@ -8770,7 +8770,6 @@ void TTree::Streamer(TBuffer& b) fCacheDoAutoInit = kTRUE; fCacheUserSet = kFALSE; Version_t R__v = b.ReadVersion(&R__s, &R__c); - printf("In TTree::Streamer,R__v = %d, b.IsBufBigEndian() = %d\n",R__v,b.IsBufBigEndian());//## if (R__v > 4) { b.ReadClassBuffer(TTree::Class(), this, R__v, R__s, R__c); @@ -8818,7 +8817,6 @@ void TTree::Streamer(TBuffer& b) fCacheSize = 0; } ResetBit(kMustCleanup); - printf("In TTree::Streamer(), before return\n");//## return; } //====process old versions before automatic schema evolution @@ -8861,12 +8859,10 @@ void TTree::Streamer(TBuffer& b) TRefTable *table = TRefTable::GetRefTable(); if (table) TRefTable::SetRefTable(0); - printf("In TTree::Streamer,Write Tree,b.IsBufBigEndian() = %d\n",b.IsBufBigEndian());//## b.WriteClassBuffer(TTree::Class(), this); if (table) TRefTable::SetRefTable(table); } - printf("End of TTree::Streamer()\n");//## } //////////////////////////////////////////////////////////////////////////////// From 783a2311d3a922da8172c21a37d6983bc8413f22 Mon Sep 17 00:00:00 2001 From: zzxuanyuan Date: Sun, 22 May 2016 13:53:12 -0500 Subject: [PATCH 15/18] Fix format of if statement and fix compiling warning. 1. By convention, there must be a space between if and left parentheses. 2. TKeyXML and TKeySQL derive from TKey, therefore ReadObjWithBuffer() must add two more argument. Additionally, we only add argument type without variable name to avoid compiling error of "arguments are not used". --- core/base/inc/Bytes.h | 52 +++++++++++++++++++++--------------------- io/sql/inc/TKeySQL.h | 2 +- io/sql/src/TKeySQL.cxx | 2 +- io/xml/inc/TKeyXML.h | 2 +- io/xml/src/TKeyXML.cxx | 2 +- 5 files changed, 30 insertions(+), 30 deletions(-) diff --git a/core/base/inc/Bytes.h b/core/base/inc/Bytes.h index 983ac3caa7563..c2a84b7b6836d 100644 --- a/core/base/inc/Bytes.h +++ b/core/base/inc/Bytes.h @@ -70,7 +70,7 @@ inline void tobuf(char *&buf, UChar_t x) inline void tobuf(char *&buf, UShort_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP -if(buffBigEndian) { +if (buffBigEndian) { # if defined(R__USEASMSWAP) *((UShort_t *)buf) = Rbswap_16(x); # else @@ -84,7 +84,7 @@ if(buffBigEndian) { memcpy(buf, &x, sizeof(UShort_t)); } #else -if(buffBigEndian) { +if (buffBigEndian) { memcpy(buf, &x, sizeof(UShort_t)); } else { # if defined(R__USEASMSWAP) @@ -104,7 +104,7 @@ if(buffBigEndian) { inline void tobuf(char *&buf, UInt_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP -if(buffBigEndian) { +if (buffBigEndian) { # if defined(R__USEASMSWAP) *((UInt_t *)buf) = Rbswap_32(x); # else @@ -120,7 +120,7 @@ if(buffBigEndian) { memcpy(buf, &x, sizeof(UInt_t)); } #else -if(buffBigEndian) { +if (buffBigEndian) { memcpy(buf, &x, sizeof(UInt_t)); } else { # if defined(R__USEASMSWAP) @@ -142,7 +142,7 @@ if(buffBigEndian) { inline void tobuf(char *&buf, ULong_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP -if(buffBigEndian) { +if (buffBigEndian) { // To work around a stupid optimization bug in MSVC++ 6.0 const ULong_t *intermediary = &x; char *sw = (char *)intermediary; @@ -177,7 +177,7 @@ if(buffBigEndian) { } } #else -if(buffBigEndian) { +if (buffBigEndian) { if (sizeof(ULong_t) == 8) { memcpy(buf, &x, 8); } else { @@ -217,7 +217,7 @@ if(buffBigEndian) { inline void tobuf(char *&buf, Long_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP -if(buffBigEndian) { +if (buffBigEndian) { // To work around a stupid optimization bug in MSVC++ 6.0 const Long_t *intermediary = &x; char *sw = (char *)intermediary; @@ -266,7 +266,7 @@ if(buffBigEndian) { } } #else -if(buffBigEndian) { +if (buffBigEndian) { if (sizeof(Long_t) == 8) { memcpy(buf, &x, 8); } else { @@ -320,7 +320,7 @@ if(buffBigEndian) { inline void tobuf(char *&buf, ULong64_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP -if(buffBigEndian) { +if (buffBigEndian) { # if defined(R__USEASMSWAP) *((ULong64_t *)buf) = Rbswap_64(x); # else @@ -340,7 +340,7 @@ if(buffBigEndian) { memcpy(buf, &x, sizeof(ULong64_t)); } #else -if(buffBigEndian) { +if (buffBigEndian) { memcpy(buf, &x, sizeof(ULong64_t)); } else { # if defined(R__USEASMSWAP) @@ -366,7 +366,7 @@ if(buffBigEndian) { inline void tobuf(char *&buf, Float_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP -if(buffBigEndian) { +if (buffBigEndian) { # if defined(R__USEASMSWAP) union { volatile UInt_t i; @@ -389,7 +389,7 @@ if(buffBigEndian) { memcpy(buf, &x, sizeof(Float_t)); } #else -if(buffBigEndian) { +if (buffBigEndian) { memcpy(buf, &x, sizeof(Float_t)); } else { # if defined(R__USEASMSWAP) @@ -418,7 +418,7 @@ if(buffBigEndian) { inline void tobuf(char *&buf, Double_t x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP -if(buffBigEndian) { +if (buffBigEndian) { # if defined(R__USEASMSWAP) union { volatile ULong64_t l; @@ -445,7 +445,7 @@ if(buffBigEndian) { memcpy(buf, &x, sizeof(Double_t)); } #else -if(buffBigEndian) { +if (buffBigEndian) { memcpy(buf, &x, sizeof(Double_t)); } else { # if defined(R__USEASMSWAP) @@ -490,7 +490,7 @@ inline void frombuf(char *&buf, UChar_t *x) inline void frombuf(char *&buf, UShort_t *x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP -if(buffBigEndian) { +if (buffBigEndian) { # if defined(R__USEASMSWAP) *x = Rbswap_16(*((UShort_t *)buf)); # else @@ -502,7 +502,7 @@ if(buffBigEndian) { memcpy(x, buf, sizeof(UShort_t)); } #else -if(buffBigEndian) { +if (buffBigEndian) { memcpy(x, buf, sizeof(UShort_t)); } else { # if defined(R__USEASMSWAP) @@ -520,7 +520,7 @@ if(buffBigEndian) { inline void frombuf(char *&buf, UInt_t *x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP -if(buffBigEndian) { +if (buffBigEndian) { # if defined(R__USEASMSWAP) *x = Rbswap_32(*((UInt_t *)buf)); # else @@ -534,7 +534,7 @@ if(buffBigEndian) { memcpy(x, buf, sizeof(UInt_t)); } #else -if(buffBigEndian) { +if (buffBigEndian) { memcpy(x, buf, sizeof(UInt_t)); } else { # if defined(R__USEASMSWAP) @@ -554,7 +554,7 @@ if(buffBigEndian) { inline void frombuf(char *&buf, ULong_t *x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP -if(buffBigEndian) { +if (buffBigEndian) { char *sw = (char *)x; if (sizeof(ULong_t) == 8) { sw[0] = buf[7]; @@ -579,7 +579,7 @@ if(buffBigEndian) { } } #else -if(buffBigEndian) { +if (buffBigEndian) { if (sizeof(ULong_t) == 8) { memcpy(x, buf, 8); } else { @@ -610,7 +610,7 @@ if(buffBigEndian) { inline void frombuf(char *&buf, ULong64_t *x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP -if(buffBigEndian) { +if (buffBigEndian) { # if defined(R__USEASMSWAP) *x = Rbswap_64(*((ULong64_t *)buf)); # else @@ -628,7 +628,7 @@ if(buffBigEndian) { memcpy(x, buf, sizeof(ULong64_t)); } #else -if(buffBigEndian) { +if (buffBigEndian) { memcpy(x, buf, sizeof(ULong64_t)); } else { # if defined(R__USEASMSWAP) @@ -652,7 +652,7 @@ if(buffBigEndian) { inline void frombuf(char *&buf, Float_t *x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP -if(buffBigEndian) { +if (buffBigEndian) { # if defined(R__USEASMSWAP) // Use a union to allow strict-aliasing union { @@ -676,7 +676,7 @@ if(buffBigEndian) { memcpy(x, buf, sizeof(Float_t)); } #else -if(buffBigEndian) { +if (buffBigEndian) { memcpy(x, buf, sizeof(Float_t)); } else { # if defined(R__USEASMSWAP) @@ -705,7 +705,7 @@ if(buffBigEndian) { inline void frombuf(char *&buf, Double_t *x, Bool_t buffBigEndian = kTRUE) { #ifdef R__BYTESWAP -if(buffBigEndian) { +if (buffBigEndian) { # if defined(R__USEASMSWAP) // Use a union to allow strict-aliasing union { @@ -733,7 +733,7 @@ if(buffBigEndian) { memcpy(x, buf, sizeof(Double_t)); } #else -if(buffBigEndian) { +if (buffBigEndian) { memcpy(x, buf, sizeof(Double_t)); } else { # if defined(R__USEASMSWAP) diff --git a/io/sql/inc/TKeySQL.h b/io/sql/inc/TKeySQL.h index 179122931e8f8..22a7a0ad2f967 100644 --- a/io/sql/inc/TKeySQL.h +++ b/io/sql/inc/TKeySQL.h @@ -60,7 +60,7 @@ class TKeySQL : public TKey { virtual Int_t Read(TObject* obj); virtual TObject *ReadObj(); - virtual TObject *ReadObjWithBuffer(char *bufferRead); + virtual TObject *ReadObjWithBuffer(char *bufferRead, Bool_t def = kTRUE, Bool_t buffBigEndian = kTRUE); virtual void *ReadObjectAny(const TClass *expectedClass); virtual void ReadBuffer(char *&) {} diff --git a/io/sql/src/TKeySQL.cxx b/io/sql/src/TKeySQL.cxx index b3f36849a7c76..34439ed08e56d 100644 --- a/io/sql/src/TKeySQL.cxx +++ b/io/sql/src/TKeySQL.cxx @@ -232,7 +232,7 @@ TObject* TKeySQL::ReadObj() /// Read object derived from TObject class /// If it is not TObject or in case of error, return 0 -TObject* TKeySQL::ReadObjWithBuffer(char * /*bufferRead*/) +TObject* TKeySQL::ReadObjWithBuffer(char * /*bufferRead*/, Bool_t /*default*/, Bool_t /*whether buffer is big endian*/) { TObject* tobj = (TObject*) ReadKeyObject(0, TObject::Class()); diff --git a/io/xml/inc/TKeyXML.h b/io/xml/inc/TKeyXML.h index d249cfeaeaecd..b85609bb77c98 100644 --- a/io/xml/inc/TKeyXML.h +++ b/io/xml/inc/TKeyXML.h @@ -50,7 +50,7 @@ class TKeyXML : public TKey { virtual Int_t Read(TObject* tobj); virtual TObject *ReadObj(); - virtual TObject *ReadObjWithBuffer(char *bufferRead); + virtual TObject *ReadObjWithBuffer(char *bufferRead, Bool_t def = kTRUE, Bool_t buffBigEndian = kTRUE); virtual void *ReadObjectAny(const TClass *expectedClass); virtual void ReadBuffer(char *&) {} diff --git a/io/xml/src/TKeyXML.cxx b/io/xml/src/TKeyXML.cxx index 45957eb42a164..57fa236afcce4 100644 --- a/io/xml/src/TKeyXML.cxx +++ b/io/xml/src/TKeyXML.cxx @@ -280,7 +280,7 @@ TObject* TKeyXML::ReadObj() /// read object derived from TObject class, from key /// if it is not TObject or in case of error, return 0 -TObject* TKeyXML::ReadObjWithBuffer(char * /*bufferRead*/) +TObject* TKeyXML::ReadObjWithBuffer(char * /*bufferRead*/, Bool_t /*default*/, Bool_t /*whether buffer is big endian*/) { TObject* tobj = (TObject*) XmlReadAny(0, TObject::Class()); From dd6e8128f0625ef0bd27f9ffb7d925c5b9f54d11 Mon Sep 17 00:00:00 2001 From: zzxuanyuan Date: Sun, 22 May 2016 16:10:11 -0500 Subject: [PATCH 16/18] Add explanation of new arguments in constructors of TKey and TBuffer --- core/base/src/TBuffer.cxx | 11 +++++++++++ io/io/src/TKey.cxx | 24 ++++++++++++++++++++++++ 2 files changed, 35 insertions(+) diff --git a/core/base/src/TBuffer.cxx b/core/base/src/TBuffer.cxx index f29e2e0926916..863e1f9a70e80 100644 --- a/core/base/src/TBuffer.cxx +++ b/core/base/src/TBuffer.cxx @@ -35,6 +35,17 @@ static char *R__NoReAllocChar(char *, size_t, size_t) /// Create an I/O buffer object. Mode should be either TBuffer::kRead or /// TBuffer::kWrite. By default the I/O buffer has a size of /// TBuffer::kInitialSize (1024) bytes. +/// +/// \param[in] mode Read mode or write mode of this TBuffer +/// \param[in] def Determining whether this TKey is created with endianness defined by global gROOT or defined by buffBigEndian +/// \param[in] buffBigEndian Determining the endianness of this TKey's buffer only if def is kFALSE +/// +/// TBuffer might store StreamerInfo which is always stored as big endian on TFile. Therefore, we should get rid of the effect +/// of gROOT->IsBufBigEndian() and always define its buffer as big endian. For more explanation, take a look at the function: +/// +/// TKey::TKey(TDirectory* motherDir, const TKey &orig, UShort_t pidOffset, Bool_t def, Bool_t buffBigEndian); +/// +/// It provides details of why we need 'def' and 'buffBigEndian' and how to define them. TBuffer::TBuffer(EMode mode, Bool_t def, Bool_t buffBigEndian) { diff --git a/io/io/src/TKey.cxx b/io/io/src/TKey.cxx index f0bade8098b84..8a4e647a37fea 100644 --- a/io/io/src/TKey.cxx +++ b/io/io/src/TKey.cxx @@ -112,6 +112,30 @@ TKey::TKey(TDirectory* motherDir) : TNamed(), fDatime((UInt_t)0) //////////////////////////////////////////////////////////////////////////////// /// Copy a TKey from its original directory to the new 'motherDir' +/// +/// \param[in] motherDir Original directory +/// \param[in] orig Original TKey to be copied +/// \param[in] pidOffset The offset from original fPidOffset +/// \param[in] def Determining whether this TKey is created with endianness defined by global gROOT or defined by buffBigEndian +/// \param[in] buffBigEndian Determining the endianness of this TKey's buffer only if def is kFALSE +/// +/// Since there is an object of TBufferFile created within this TKey constructor, we need to parse 'def' and 'buffBigEndian' to it. +/// These two input arguments are designed to be compatible with TBufferFile constructor, so TKey's constructor functions do not include +/// these input arguments if there is no TBufferFile created. If def == 1, the endianness of TBufferFile will be defined as global +/// parameter gROOT->IsBufBigEndian(); if def == 0, the endianness of TBufferFile is defined by the next argument buffBigEndian. +/// If buffBigEndian = 1, the TBufferFile of this TKey is big endian; otherwise it is small endian. +/// The reason to add 'def' and 'buffBigEndian' is because we only change the endianness of data but never change the meta data. +/// For instance, StreamerInfo is considered as meta data and stored in a particular location in TFile. We always keep it as big endian. +/// We create it in the following way: +/// +/// TKey key(&list,"StreamerInfo",GetBestBuffer(), this, kFALSE, kTRUE); +/// +/// Similarly, when we want to read the object from TFile, we need to tell what endianness of the object to be read. For example, if we +/// want to read StreamerInfo from file, we have to tell read function it was stored as big endian: +/// +/// list = dynamic_cast(key->ReadObjWithBuffer(buffer,kFALSE,kTRUE)); +/// +/// If TKey is created for raw data, TKey and TBufferFile will be created as gROOT->IsBufBigEndian() defined. TKey::TKey(TDirectory* motherDir, const TKey &orig, UShort_t pidOffset, Bool_t def, Bool_t buffBigEndian) : TNamed(), fDatime((UInt_t)0) { From c02dd1bf210a489c890e13a288c8e58e1bdc9295 Mon Sep 17 00:00:00 2001 From: zzxuanyuan Date: Sun, 22 May 2016 16:14:03 -0500 Subject: [PATCH 17/18] Use kFALSE and kTRUE for Bool_t type instead of 0 and 1 --- io/io/src/TFile.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/io/io/src/TFile.cxx b/io/io/src/TFile.cxx index 3f942a3cdfa94..08fda17bcbbfa 100644 --- a/io/io/src/TFile.cxx +++ b/io/io/src/TFile.cxx @@ -1333,7 +1333,7 @@ TList *TFile::GetStreamerInfoList() return 0; } key->ReadKeyBuffer(buf); - list = dynamic_cast(key->ReadObjWithBuffer(buffer,0,1)); + list = dynamic_cast(key->ReadObjWithBuffer(buffer, kFALSE, kTRUE)); if (list) list->SetOwner(); delete [] buffer; delete key; @@ -3620,7 +3620,7 @@ void TFile::WriteStreamerInfo() //free previous StreamerInfo record if (fSeekInfo) MakeFree(fSeekInfo,fSeekInfo+fNbytesInfo-1); //Create new key - TKey key(&list,"StreamerInfo",GetBestBuffer(), this, 0, 1); + TKey key(&list,"StreamerInfo",GetBestBuffer(), this, kFALSE, kTRUE); fKeys->Remove(&key); fSeekInfo = key.GetSeekKey(); fNbytesInfo = key.GetNbytes(); From fa2f71f13d1ada66c202875aef821d561b28f660 Mon Sep 17 00:00:00 2001 From: zzxuanyuan Date: Sun, 22 May 2016 16:47:45 -0500 Subject: [PATCH 18/18] Add code explanation which determine if there is byte count in buffer --- io/io/src/TBufferFile.cxx | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/io/io/src/TBufferFile.cxx b/io/io/src/TBufferFile.cxx index 41c240246205f..b9dc2680c5ea8 100644 --- a/io/io/src/TBufferFile.cxx +++ b/io/io/src/TBufferFile.cxx @@ -3229,10 +3229,19 @@ Version_t TBufferFile::ReadVersion(UInt_t *startpos, UInt_t *bcnt, const TClass frombuf(this->fBufCur,&v.vers[0],0); } #endif - // no bytecount, backup and read version. - // read in next UShort_t and determine if it is zero or not. - // If it's not zero, it is 'highly possible' storing version - // and consequently the first four byte should be byte count. + // If IsBufBigEndian() indicates the buffer is big endian, we need to further verify if v.cnt contain byte count. + // If there is no bytecount, backup and read version, fBufCur will go back the fix size of sizeof(UInt_t) and start reading data. + // However, if the buffer is little endian, the next UShort_t should be read and verify if it is zero or not. If it's not zero, + // it is 'highly possible' storing version and consequently the first four byte should be byte count. + // For example, if there is no byte count and the first two bytes stores version and the next four bytes store fBufferSize like following: + // UShort_t + UInt_t ( Version_t + fBufferSize) + // But in TBufferFile.cxx, it takes a look at (v.cnt & kByteCountMask)(v.cnt is the first four bytes). If it is 0, + // ROOT determine there is no byte count. Otherwise, the next four bytes should be byte count. If TBufferFile is BigEndian: + // 00 02 00 00 7d 00 + // and in this example, version = 2 and fBufferSize = 32000. So v.cnt is 00 00 02 00. + // However, if we change TBufferFile to LittleEndian, the memory layout becomes: + // 02 00 00 7d 00 00 + // and in this case, v.cnt is 7d 00 00 02 and (v.cnt & kByteCountMask != 0) so ROOT thinks the next four bytes are byte count. UShort_t possibleVersion; if (IsBufBigEndian()) { if (!(v.cnt & kByteCountMask)) {