corrected compilation warnings
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 3 Oct 2007 09:07:08 +0000 (09:07 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 3 Oct 2007 09:07:08 +0000 (09:07 +0000)
20 files changed:
HLT/BASE/AliHLTComponent.cxx
HLT/BASE/AliHLTComponentHandler.cxx
HLT/BASE/AliHLTComponentHandler.h
HLT/BASE/AliHLTDataBuffer.cxx
HLT/BASE/AliHLTDataSink.cxx
HLT/BASE/AliHLTDataSource.cxx
HLT/BASE/AliHLTMemoryFile.cxx
HLT/BASE/AliHLTOfflineInterface.cxx
HLT/BASE/AliHLTProcessor.cxx
HLT/BASE/util/AliHLTAgentUtil.cxx
HLT/BASE/util/AliHLTDynamicAliLog.cxx
HLT/BASE/util/AliHLTLoaderPublisherComponent.cxx
HLT/BASE/util/AliHLTRootFileStreamerComponent.cxx
HLT/TPCLib/AliHLTTPCAgent.cxx
HLT/TPCLib/AliHLTTPCDigitReaderRaw.cxx
HLT/TPCLib/AliHLTTPCDigitReaderRaw.h
HLT/TPCLib/AliHLTTPCFileHandler.cxx
HLT/TPCLib/AliHLTTPCFitter.cxx
HLT/TPCLib/AliHLTTPCFitter.h
HLT/TPCLib/AliHLTTPCMemHandler.cxx

index 41217f9..b583744 100644 (file)
@@ -547,7 +547,7 @@ TObject* AliHLTComponent::CreateInputObject(int idx, int bForce)
   return pObj;
 }
 
-TObject* AliHLTComponent::GetInputObject(int idx, const char* classname, int bForce)
+TObject* AliHLTComponent::GetInputObject(int idx, const char* /*classname*/, int bForce)
 {
   // see header file for function documentation
   if (fpInputObjects==NULL) {
index 7849ee4..f95574a 100644 (file)
@@ -67,6 +67,7 @@ AliHLTComponentHandler::AliHLTComponentHandler()
 
 AliHLTComponentHandler::AliHLTComponentHandler(AliHLTComponentEnvironment* pEnv)
   :
+  AliHLTLogging(),
   fComponentList(),
   fScheduleList(),
   fLibraryList(),
@@ -88,25 +89,6 @@ AliHLTComponentHandler::AliHLTComponentHandler(AliHLTComponentEnvironment* pEnv)
   AddStandardComponents();
 }
 
-AliHLTComponentHandler::AliHLTComponentHandler(const AliHLTComponentHandler&)
-  :
-  fComponentList(),
-  fScheduleList(),
-  fLibraryList(),
-  fEnvironment(),
-  fStandardList()
-{
-  // see header file for class documentation
-  HLTFatal("copy constructor untested");
-}
-
-AliHLTComponentHandler& AliHLTComponentHandler::operator=(const AliHLTComponentHandler&)
-{ 
-  // see header file for class documentation
-  HLTFatal("assignment operator untested");
-  return *this;
-}
-
 AliHLTComponentHandler::~AliHLTComponentHandler()
 {
   // see header file for class documentation
index 3ee115d..d75a7e9 100644 (file)
@@ -41,10 +41,6 @@ class AliHLTComponentHandler : public AliHLTLogging {
   AliHLTComponentHandler();
   /** constructor */
   AliHLTComponentHandler(AliHLTComponentEnvironment* pEnv);
-  /** not a valid copy constructor, defined according to effective C++ style */
-  AliHLTComponentHandler(const AliHLTComponentHandler&);
-  /** not a valid assignment op, but defined according to effective C++ style */
-  AliHLTComponentHandler& operator=(const AliHLTComponentHandler&);
   /** destructor */
   virtual ~AliHLTComponentHandler();
 
@@ -189,6 +185,11 @@ class AliHLTComponentHandler : public AliHLTLogging {
  protected:
 
  private:
+  /** copy constructor prohibited */
+  AliHLTComponentHandler(const AliHLTComponentHandler&);
+  /** assignment operator prohibited */
+  AliHLTComponentHandler& operator=(const AliHLTComponentHandler&);
+
   /**
    * Find a component.
    * @param componentID  ID of the component to find
index 16da7ce..67437a2 100644 (file)
@@ -196,7 +196,7 @@ int AliHLTDataBuffer::Subscribe(const AliHLTComponent* pConsumer, AliHLTComponen
            segment++;
          }
          // check whether there was enough space for the segments
-         if (i!=tgtList.size()) {
+         if (i!=(int)tgtList.size()) {
            HLTError("too little space in block descriptor array: required %d, available %d", tgtList.size(), iArraySize);
            iResult=-ENOSPC;
          } else {
index d412ff9..31fee56 100644 (file)
@@ -82,7 +82,7 @@ int AliHLTDataSink::DoProcessing( const AliHLTComponentEventData& evtData,
 }
 
 int AliHLTDataSink::DumpEvent( const AliHLTComponentEventData& evtData,
-                              const AliHLTComponentBlockData* blocks, 
+                              const AliHLTComponentBlockData* /*blocks*/, 
                               AliHLTComponentTriggerData& trigData )
 {
   // we just forward to the high level method, all other parameters already
@@ -90,7 +90,7 @@ int AliHLTDataSink::DumpEvent( const AliHLTComponentEventData& evtData,
   return DumpEvent(evtData, trigData);
 }
 
-int AliHLTDataSink::DumpEvent( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData)
+int AliHLTDataSink::DumpEvent( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
 {
   HLTFatal("no processing method implemented");
   return -ENOSYS;
index 2ede4cd..dff1d57 100644 (file)
@@ -74,17 +74,17 @@ int AliHLTDataSource::DoProcessing( const AliHLTComponentEventData& evtData,
 }
 
 int AliHLTDataSource::GetEvent( const AliHLTComponentEventData& evtData,
-                                  AliHLTComponentTriggerData& trigData,
-                                  AliHLTUInt8_t* outputPtr, 
-                                  AliHLTUInt32_t& size,
-                                  vector<AliHLTComponentBlockData>& outputBlocks )
+                               AliHLTComponentTriggerData& trigData,
+                               AliHLTUInt8_t* /*outputPtr*/, 
+                               AliHLTUInt32_t& /*size*/,
+                               vector<AliHLTComponentBlockData>& /*outputBlocks*/ )
 {
   // we just forward to the high level method, all other parameters already
   // have been stored internally
   return GetEvent(evtData, trigData);
 }
 
-int AliHLTDataSource::GetEvent( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData)
+int AliHLTDataSource::GetEvent( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
 {
   HLTFatal("no processing method implemented");
   return -ENOSYS;
index 9fd25ce..5c41882 100644 (file)
@@ -109,7 +109,7 @@ int AliHLTMemoryFile::Close(int bFlush)
   return -fErrno;
 }
 
-Int_t    AliHLTMemoryFile::SysOpen(const char *pathname, Int_t flags, UInt_t mode)
+Int_t    AliHLTMemoryFile::SysOpen(const char* /*pathname*/, Int_t /*flags*/, UInt_t /*mode*/)
 {
   // see header file for function documentation
   if (fpBuffer==NULL || fSize==0) return 1;
@@ -119,14 +119,14 @@ Int_t    AliHLTMemoryFile::SysOpen(const char *pathname, Int_t flags, UInt_t mod
   return -1;
 }
 
-Int_t    AliHLTMemoryFile::SysClose(Int_t fd)
+Int_t    AliHLTMemoryFile::SysClose(Int_t /*fd*/)
 {
   // see header file for function documentation
   //HLTDebug("closing file %p size %d", this, fSize);
   return 0;
 }
 
-Int_t    AliHLTMemoryFile::SysRead(Int_t fd, void *buf, Int_t len)
+Int_t    AliHLTMemoryFile::SysRead(Int_t /*fd*/, void *buf, Int_t len)
 {
   // see header file for function documentation
   if (buf==NULL) return 0;
@@ -140,7 +140,7 @@ Int_t    AliHLTMemoryFile::SysRead(Int_t fd, void *buf, Int_t len)
   return read;
 }
 
-Int_t    AliHLTMemoryFile::SysWrite(Int_t fd, const void *buf, Int_t len)
+Int_t    AliHLTMemoryFile::SysWrite(Int_t /*fd*/, const void *buf, Int_t len)
 {
   // see header file for function documentation
   if (buf==NULL) return 0;
@@ -156,7 +156,7 @@ Int_t    AliHLTMemoryFile::SysWrite(Int_t fd, const void *buf, Int_t len)
   return -1;
 }
 
-Long64_t AliHLTMemoryFile::SysSeek(Int_t fd, Long64_t offset, Int_t whence)
+Long64_t AliHLTMemoryFile::SysSeek(Int_t /*fd*/, Long64_t offset, Int_t whence)
 {
   // see header file for function documentation
   //HLTDebug("seek %d from %d", offset, whence);
@@ -186,14 +186,14 @@ Long64_t AliHLTMemoryFile::SysSeek(Int_t fd, Long64_t offset, Int_t whence)
   return position;
 }
 
-Int_t    AliHLTMemoryFile::SysStat(Int_t fd, Long_t *id, Long64_t *size, Long_t *flags, Long_t *modtime)
+Int_t    AliHLTMemoryFile::SysStat(Int_t /*fd*/, Long_t */*id*/, Long64_t *size, Long_t */*flags*/, Long_t */*modtime*/)
 {
   // see header file for function documentation
   if (size) *size=fSize;
   return 0;
 }
 
-Int_t    AliHLTMemoryFile::SysSync(Int_t fd)
+Int_t    AliHLTMemoryFile::SysSync(Int_t /*fd*/)
 {
   // see header file for function documentation
   return 0;
index 6f7632b..59058e5 100644 (file)
@@ -90,7 +90,7 @@ AliRawReader* AliHLTOfflineInterface::GetRawReader() const
   return fpRawReader!=NULL?fpRawReader:fgpRawReader;
 }
 
-int AliHLTOfflineInterface::SetESD(Int_t eventNo, AliESDEvent* pESD)
+int AliHLTOfflineInterface::SetESD(Int_t /*eventNo*/, AliESDEvent* pESD)
 {
   fpESD=pESD;
   return 0;
index 4fd1d94..0221f56 100644 (file)
@@ -76,18 +76,18 @@ int AliHLTProcessor::DoProcessing( const AliHLTComponentEventData& evtData, cons
 }
 
 int AliHLTProcessor::DoEvent( const AliHLTComponentEventData& evtData,
-              const AliHLTComponentBlockData* blocks, 
-              AliHLTComponentTriggerData& trigData,
-              AliHLTUInt8_t* outputPtr, 
-              AliHLTUInt32_t& size,
-              vector<AliHLTComponentBlockData>& outputBlocks )
+                             const AliHLTComponentBlockData* /*blocks*/, 
+                             AliHLTComponentTriggerData& trigData,
+                             AliHLTUInt8_t* /*outputPtr*/, 
+                             AliHLTUInt32_t& /*size*/,
+                             vector<AliHLTComponentBlockData>& /*outputBlocks*/ )
 {
   // we just forward to the high level method, all other parameters already
   // have been stored internally
   return DoEvent(evtData, trigData);
 }
 
-int AliHLTProcessor::DoEvent( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData)
+int AliHLTProcessor::DoEvent( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
 {
   HLTFatal("no processing method implemented");
   return -ENOSYS;
index 3442bae..3b925ff 100644 (file)
@@ -46,7 +46,7 @@ AliHLTAgentUtil::~AliHLTAgentUtil()
 }
 
 int AliHLTAgentUtil::CreateConfigurations(AliHLTConfigurationHandler* handler,
-                                         AliRunLoader* runloader) const
+                                         AliRunLoader* /*runloader*/) const
 {
   // see header file for class documentation
   if (handler) {
@@ -54,7 +54,7 @@ int AliHLTAgentUtil::CreateConfigurations(AliHLTConfigurationHandler* handler,
   return 0;
 }
 
-const char* AliHLTAgentUtil::GetLocalRecConfigurations(AliRunLoader* runloader) const
+const char* AliHLTAgentUtil::GetLocalRecConfigurations(AliRunLoader* /*runloader*/) const
 {
   // see header file for class documentation
   return NULL;
index e7ba306..50e770c 100644 (file)
@@ -31,7 +31,7 @@
 /**
  * Notification callback for AliRoot logging methods
  */
-void LogNotification(AliLog::EType_t level, const char* message)
+void LogNotification(AliLog::EType_t /*level*/, const char* /*message*/)
 {
   // Notification callback for AliRoot logging methods
 
index f9d22cb..9b143b9 100644 (file)
@@ -210,8 +210,8 @@ int AliHLTLoaderPublisherComponent::DoDeinit()
   return iResult;
 }
 
-int AliHLTLoaderPublisherComponent::GetEvent(const AliHLTComponentEventData& evtData,
-                                                AliHLTComponentTriggerData& trigData)
+int AliHLTLoaderPublisherComponent::GetEvent(const AliHLTComponentEventData& /*evtData*/,
+                                            AliHLTComponentTriggerData& /*trigData*/)
 {
   // see header file for class documentation
   int iResult=0;
index de39881..09b1551 100644 (file)
@@ -130,7 +130,7 @@ int AliHLTRootFileStreamerComponent::DoInit( int argc, const char** argv )
   return iResult;
 }
 
-int AliHLTRootFileStreamerComponent::DoEvent( const AliHLTComponentEventData& evtData,
+int AliHLTRootFileStreamerComponent::DoEvent( const AliHLTComponentEventData& /*evtData*/,
                                            AliHLTComponentTriggerData& /*trigData*/ )
 {
   // see header file for class documentation
index 5d1abd5..4b1afe4 100644 (file)
@@ -46,7 +46,7 @@ AliHLTTPCAgent::~AliHLTTPCAgent()
 }
 
 int AliHLTTPCAgent::CreateConfigurations(AliHLTConfigurationHandler* handler,
-                                         AliRunLoader* runloader) const
+                                        AliRunLoader* /*runloader*/) const
 {
   // see header file for class documentation
   if (handler) {
@@ -94,7 +94,7 @@ int AliHLTTPCAgent::CreateConfigurations(AliHLTConfigurationHandler* handler,
   return 0;
 }
 
-const char* AliHLTTPCAgent::GetLocalRecConfigurations(AliRunLoader* runloader) const
+const char* AliHLTTPCAgent::GetLocalRecConfigurations(AliRunLoader* /*runloader*/) const
 {
   // see header file for class documentation
   return NULL;
index 5a755c0..1d89d0b 100644 (file)
@@ -50,11 +50,11 @@ AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw( unsigned formatVersion )
   fAltroBlock10BitWordCnt(0),
   fAltroBlock10BitFillWordCnt(0),
   fDataFormatVersion(formatVersion),
-  fVerify(false),
   fBunchPosition(0xFFFFU),
   fBunchTimebinStart(~0U),
   fBunchLength(0),
   fWordInBunch((unsigned)-1),
+  fVerify(false),
   
   fCurrentRow(0),
   fCurrentPad(0),
@@ -105,84 +105,6 @@ AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw( unsigned formatVersion )
       }
 }
 
-AliHLTTPCDigitReaderRaw::AliHLTTPCDigitReaderRaw(const AliHLTTPCDigitReaderRaw& src)
-  :
-  fBuffer(NULL),
-  fBufferSize(0),
-  fPatch(-1),
-  fSlice(-1),
-  fRow(-1),
-  fPad(-1),
-  fAltroBlockPositionBytes(0),
-  fAltroBlockLengthBytes(0),
-  fAltroBlockHWAddress(0),
-  fAltroBlock10BitWordCnt(0),
-  fAltroBlock10BitFillWordCnt(0),
-  fDataFormatVersion(src.fDataFormatVersion),
-  fVerify(false),
-  fBunchPosition(0xFFFFU),
-  fBunchTimebinStart(~0U),
-  fBunchLength(0),
-  fWordInBunch((unsigned)-1),
-  
-  fCurrentRow(0),
-  fCurrentPad(0),
-  fCurrentBin(-1),
-  fRowOffset(0),
-  fNRows(0),
-  fNMaxRows(0),
-  fNMaxPads(0),
-  fNTimeBins(0),
-  fData(NULL),
-  fMapErrThrown(0)
-{
-  // see header file for class documentation
-#ifndef HAVE_TPC_MAPPING
-  memset(fgMapping0, 0, fgkMapping0Size*fgkMappingDimension*sizeof(Int_t));
-  memset(fgMapping1, 0, fgkMapping1Size*fgkMappingDimension*sizeof(Int_t));
-  memset(fgMapping2, 0, fgkMapping2Size*fgkMappingDimension*sizeof(Int_t));
-  memset(fgMapping3, 0, fgkMapping3Size*fgkMappingDimension*sizeof(Int_t));
-  memset(fgMapping4, 0, fgkMapping4Size*fgkMappingDimension*sizeof(Int_t));
-  memset(fgMapping5, 0, fgkMapping5Size*fgkMappingDimension*sizeof(Int_t));
-#endif //#ifndef HAVE_TPC_MAPPING
-  HLTFatal("copy constructor not for use");
-}
-
-AliHLTTPCDigitReaderRaw& AliHLTTPCDigitReaderRaw::operator=(const AliHLTTPCDigitReaderRaw& src)
-{
-  // see header file for class documentation
-#ifndef HAVE_TPC_MAPPING
-  memset(fgMapping0, 0, fgkMapping0Size*fgkMappingDimension*sizeof(Int_t));
-  memset(fgMapping1, 0, fgkMapping1Size*fgkMappingDimension*sizeof(Int_t));
-  memset(fgMapping2, 0, fgkMapping2Size*fgkMappingDimension*sizeof(Int_t));
-  memset(fgMapping3, 0, fgkMapping3Size*fgkMappingDimension*sizeof(Int_t));
-  memset(fgMapping4, 0, fgkMapping4Size*fgkMappingDimension*sizeof(Int_t));
-  memset(fgMapping5, 0, fgkMapping5Size*fgkMappingDimension*sizeof(Int_t));
-#endif //#ifndef HAVE_TPC_MAPPING
-  fBuffer=NULL;
-  fBufferSize=0;
-  fPatch=-1;
-  fSlice=-1;
-  fRow=-1;
-  fPad=-1;
-  fDataFormatVersion=src.fDataFormatVersion;
-  fCurrentRow=0;
-  fCurrentPad=0;
-  fCurrentBin=-1;
-  fVerify=false;
-  
-  // For sorting
-  fNRows=0;
-  fRowOffset=0;
-  fNMaxRows=0;
-  fNMaxPads=0;
-  fNTimeBins=0;
-  fData=NULL;
-  fMapErrThrown=0;
-  HLTFatal("assignment operator not for use");
-  return (*this);
-}
-
 AliHLTTPCDigitReaderRaw::~AliHLTTPCDigitReaderRaw()
 {
   // see header file for class documentation
index 6dd5d4e..7f5b042 100644 (file)
@@ -66,10 +66,6 @@ public:
    *  - 5: As 1, but RCU trailer is 2 32 bit words.
    */
   AliHLTTPCDigitReaderRaw( unsigned formatVersion );
-  /** not a valid copy constructor, defined according to effective C++ style */
-  AliHLTTPCDigitReaderRaw(const AliHLTTPCDigitReaderRaw& src);
-  /** not a valid assignment op, but defined according to effective C++ style */
-  AliHLTTPCDigitReaderRaw& operator=(const AliHLTTPCDigitReaderRaw& src);
   /** destructor */
   virtual ~AliHLTTPCDigitReaderRaw();
     
@@ -250,6 +246,10 @@ protected:
   bool fVerify;                                                    // see above
 
 private:
+  /** copy constructor prohibited */
+  AliHLTTPCDigitReaderRaw(const AliHLTTPCDigitReaderRaw& src);
+  /** assignment operator prohibited */
+  AliHLTTPCDigitReaderRaw& operator=(const AliHLTTPCDigitReaderRaw& src);
   /** number of patches */ 
   static const Int_t fgkNofPatches=6;                              // see above
   /** dimension of each mapping array */ 
index 1bbd1c9..4a15589 100644 (file)
@@ -450,7 +450,7 @@ AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliDigits2Memory(UInt_t & nrow,Int
     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::AliDigits2Memory","ndigits")
       <<"No TPC digits (entries==0)!"<<ENDLOG;
     nrow = (UInt_t)(fRowMax-fRowMin+1);
-    Int_t size = nrow*sizeof(AliHLTTPCDigitRowData);
+    UInt_t size = nrow*sizeof(AliHLTTPCDigitRowData);
     if (tgtBuffer!=NULL && pTgtSize!=NULL && *pTgtSize>0) {
       if (size<=*pTgtSize) {
        data=reinterpret_cast<AliHLTTPCDigitRowData*>(tgtBuffer);
@@ -516,7 +516,7 @@ AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliDigits2Memory(UInt_t & nrow,Int
     nrows++;
   }
 
-  Int_t size = sizeof(AliHLTTPCDigitData)*ndigitcount
+  UInt_t size = sizeof(AliHLTTPCDigitData)*ndigitcount
     + nrows*sizeof(AliHLTTPCDigitRowData);
 
   LOG(AliHLTTPCLog::kDebug,"AliHLTTPCFileHandler::AliDigits2Memory","Digits")
index f1bc64d..955fe38 100644 (file)
@@ -57,23 +57,6 @@ AliHLTTPCFitter::AliHLTTPCFitter()
   memset(fNcl,0,36*6*sizeof(UInt_t));
 }
 
-AliHLTTPCFitter::AliHLTTPCFitter(const AliHLTTPCFitter& src)
-  :
-  fTrack(NULL),
-  fVertex(NULL),
-  fVertexConstraint(0)
-{
-  // dummy copy constructor according to eff C++
-  memset(fClusters,0,36*6*sizeof(AliHLTTPCSpacePointData*));
-  memset(fNcl,0,36*6*sizeof(UInt_t));
-}
-
-AliHLTTPCFitter& AliHLTTPCFitter::operator=(const AliHLTTPCFitter& src)
-{ 
-  // dummy assignment operator according to eff C++
-  return *this;
-}
-
 AliHLTTPCFitter::AliHLTTPCFitter(AliHLTTPCVertex *vertex,Bool_t vertexconstraint)
   :
   fTrack(NULL),
index 8ece9c8..79d90e1 100644 (file)
@@ -24,10 +24,6 @@ class AliHLTTPCFitter {
 
   public:
   AliHLTTPCFitter();
-  /** not a valid copy constructor, defined according to effective C++ style */
-  AliHLTTPCFitter(const AliHLTTPCFitter& src);
-  /** not a valid assignment op, but defined according to effective C++ style */
-  AliHLTTPCFitter& operator=(const AliHLTTPCFitter& src);
   AliHLTTPCFitter(AliHLTTPCVertex *vertex,Bool_t vertexconstraint=kTRUE);
   virtual ~AliHLTTPCFitter();
   
@@ -39,6 +35,11 @@ class AliHLTTPCFitter {
   void NoVertex() {fVertexConstraint=kFALSE;}
  
  private:
+  /** copy constructor prohibited */
+  AliHLTTPCFitter(const AliHLTTPCFitter& src);
+  /** assignment operator prohibited */
+  AliHLTTPCFitter& operator=(const AliHLTTPCFitter& src);
+
   AliHLTTPCTrack *fTrack; //!                    actual track
   AliHLTTPCVertex *fVertex; //!                  vertex info
   Bool_t fVertexConstraint; //               include vertex constraint
index 9f69b91..29b92f5 100644 (file)
@@ -523,7 +523,7 @@ Bool_t AliHLTTPCMemHandler::Binary2Memory(UInt_t & nrow,AliHLTTPCDigitRowData *d
   rewind(fInBinary);
   AliHLTTPCDigitRowData *rowPt = data;
   UInt_t rowcount = 0;
-  Int_t outsize =0;
+  UInt_t outsize =0;
   while(!feof(fInBinary)){
     Byte_t  *bytePt =(Byte_t *) rowPt;
 
@@ -537,7 +537,7 @@ Bool_t AliHLTTPCMemHandler::Binary2Memory(UInt_t & nrow,AliHLTTPCDigitRowData *d
     bytePt += sizeof(AliHLTTPCDigitRowData);
     outsize += sizeof(AliHLTTPCDigitRowData);
 
-    Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit;
+    UInt_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit;
 
     if (sz<outsize+size) {
       LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","Memory")