Fixes for Coverity reports

diff --git a/STEER/AliCheb3D.cxx b/STEER/AliCheb3D.cxx
index 32afc138da874254dbda39a9327f5a29abff7076..be8981b914317efd8f3dd0a4cdb00ec664fe5c11 100644 (file)
--- a/STEER/AliCheb3D.cxx
+++ b/STEER/AliCheb3D.cxx
@@ -37,7 +37,11 @@ AliCheb3D::AliCheb3D() :
   fUsrFunName(""), 
   fUsrMacro(0) 
 {
-  for (int i=3;i--;) fBMin[i] = fBMax[i] = fBScale[i] = fBOffset[i] = 0;
+  for (int i=3;i--;) {
+    fBMin[i] = fBMax[i] = fBScale[i] = fBOffset[i] = 0;
+    fNPoints[i] = 0;
+    fGridOffs[i] = 0.;
+  }
 }
 
 //__________________________________________________________________________________________
@@ -59,6 +63,7 @@ AliCheb3D::AliCheb3D(const AliCheb3D& src) :
     fBScale[i]  = src.fBScale[i];
     fBOffset[i] = src.fBOffset[i];
     fNPoints[i] = src.fNPoints[i];
+    fGridOffs[i] = src.fGridOffs[i];
   }
   for (int i=0;i<fDimOut;i++) {
     AliCheb3DCalc* cbc = src.GetChebCalc(i);
@@ -78,7 +83,11 @@ AliCheb3D::AliCheb3D(const char* inpFile) :
   fUsrMacro(0)
 {
   // read coefs from text file
-  for (int i=3;i--;) fBMin[i] = fBMax[i] = fBScale[i] = fBOffset[i] = 0;
+  for (int i=3;i--;) {
+    fBMin[i] = fBMax[i] = fBScale[i] = fBOffset[i] = 0;
+    fNPoints[i] = 0;
+    fGridOffs[i] = 0.;
+  }
   LoadData(inpFile);
 }
 
@@ -94,7 +103,11 @@ AliCheb3D::AliCheb3D(FILE* stream) :
   fUsrMacro(0)
 {
   // read coefs from stream
-  for (int i=3;i--;) fBMin[i] = fBMax[i] = fBScale[i] = fBOffset[i] = 0;
+  for (int i=3;i--;) {
+    fBMin[i] = fBMax[i] = fBScale[i] = fBOffset[i] = 0;
+    fNPoints[i] = 0;
+    fGridOffs[i] = 0.;
+  }
   LoadData(stream);
 }
 
@@ -120,6 +133,11 @@ AliCheb3D::AliCheb3D(const char* funName, int DimOut, Float_t  *bmin,Float_t  *b
   // prec    : max allowed absolute difference between the user function and computed parameterization on the requested grid
   //
   if (DimOut<1) {Error("AliCheb3D","Requested output dimension is %d\nStop\n",fDimOut); exit(1);}
+  for (int i=3;i--;) {
+    fBMin[i] = fBMax[i] = fBScale[i] = fBOffset[i] = 0;
+    fNPoints[i] = 0;
+    fGridOffs[i] = 0.;
+  }
   SetDimOut(DimOut);
   PrepareBoundaries(bmin,bmax);
   DefineGrid(npoints);
@@ -150,6 +168,12 @@ AliCheb3D::AliCheb3D(void (*ptr)(float*,float*), int DimOut, Float_t  *bmin,Floa
   // prec    : max allowed absolute difference between the user function and computed parameterization on the requested grid
   //
   if (DimOut<1) {Error("AliCheb3D","Requested output dimension is %d\nStop\n",fDimOut); exit(1);}
+  if (DimOut<1) {Error("AliCheb3D","Requested output dimension is %d\nStop\n",fDimOut); exit(1);}
+  for (int i=3;i--;) {
+    fBMin[i] = fBMax[i] = fBScale[i] = fBOffset[i] = 0;
+    fNPoints[i] = 0;
+    fGridOffs[i] = 0.;
+  }
   SetDimOut(DimOut);
   PrepareBoundaries(bmin,bmax);
   DefineGrid(npoints);
@@ -182,6 +206,12 @@ AliCheb3D::AliCheb3D(void (*ptr)(float*,float*), int DimOut, Float_t  *bmin,Floa
   // prec    : max allowed absolute difference between the user function and computed parameterization on the requested grid
   //
   if (DimOut<1) {Error("AliCheb3D","Requested output dimension is %d\nStop\n",fDimOut); exit(1);}
+  if (DimOut<1) {Error("AliCheb3D","Requested output dimension is %d\nStop\n",fDimOut); exit(1);}
+  for (int i=3;i--;) {
+    fBMin[i] = fBMax[i] = fBScale[i] = fBOffset[i] = 0;
+    fNPoints[i] = 0;
+    fGridOffs[i] = 0.;
+  }
   SetDimOut(DimOut);
   PrepareBoundaries(bmin,bmax);
   SetUsrFunction(ptr);
@@ -217,6 +247,12 @@ AliCheb3D::AliCheb3D(void (*ptr)(float*,float*), int DimOut, Float_t  *bmin,Floa
   // prec    : max allowed absolute difference between the user function and computed parameterization on the requested grid
   //
   if (DimOut!=3) {Error("AliCheb3D","This constructor works only for 3D fits, %dD fit was requested\n",fDimOut); exit(1);}
+  if (DimOut<1) {Error("AliCheb3D","Requested output dimension is %d\nStop\n",fDimOut); exit(1);}
+  for (int i=3;i--;) {
+    fBMin[i] = fBMax[i] = fBScale[i] = fBOffset[i] = 0;
+    fNPoints[i] = 0;
+    fGridOffs[i] = 0.;
+  }
   SetDimOut(DimOut);
   PrepareBoundaries(bmin,bmax);
   SetUsrFunction(ptr);

diff --git a/STEER/AliMagWrapCheb.cxx b/STEER/AliMagWrapCheb.cxx
index d5eb83bb8a0c0f4bb63c2d13951422850f694883..9a668425a997f17da8525a6f0966243d698d60e6 100644 (file)
--- a/STEER/AliMagWrapCheb.cxx
+++ b/STEER/AliMagWrapCheb.cxx
@@ -532,8 +532,9 @@ Double_t AliMagWrapCheb::FieldCylSolBz(const Double_t *rphiz) const
   AliCheb3D* par = GetParamSol(id);
 #ifndef _BRING_TO_BOUNDARY_  
   return par->IsInside(rphiz) ? par->Eval(rphiz,2) : 0;
-#endif
+#else
   return par->Eval(rphiz,2);
+#endif
   //
 }
 

diff --git a/STEER/AliMillePede2.cxx b/STEER/AliMillePede2.cxx
index 7540eb4ae631001bde378e741931021301d8bb81..9f485ac868b58cf3dad87df1248e323bed9b2308 100644 (file)
--- a/STEER/AliMillePede2.cxx
+++ b/STEER/AliMillePede2.cxx
@@ -1004,6 +1004,10 @@ Int_t AliMillePede2::SolveGlobalMatEq()
   if (!res) {
     const char* faildump = "fgmr_failed.dat";
     int defout = dup(1);
+    if (defout<0) {
+      AliInfo("Failed on dup");
+      return gkFailed;
+    }
     int slvDump = open(faildump, O_RDWR|O_CREAT, 0666);
     dup2(slvDump,1);
     //

diff --git a/STEER/AliMultiplicity.cxx b/STEER/AliMultiplicity.cxx
index 542bb89c955e792f74cb1fab939b7eb68a783f30..97d1cdbb5bf3b52aa5e02ea9bc29bd990a0f0478 100644 (file)
--- a/STEER/AliMultiplicity.cxx
+++ b/STEER/AliMultiplicity.cxx
@@ -201,6 +201,13 @@ void AliMultiplicity::Duplicate(const AliMultiplicity& m){
     fLabelsL2 = new Int_t[fNtracks];
     if (m.fUsedClusT) fUsedClusT = new ULong64_t[fNtracks];
     else fUsedClusT = 0;
+    if(m.fTh)memcpy(fTh,m.fTh,fNtracks*sizeof(Double_t));
+    if(m.fPhi)memcpy(fPhi,m.fPhi,fNtracks*sizeof(Double_t));
+    if(m.fDeltTh)memcpy(fDeltTh,m.fDeltTh,fNtracks*sizeof(Double_t));
+    if(m.fDeltPhi)memcpy(fDeltPhi,m.fDeltPhi,fNtracks*sizeof(Double_t));
+    if(m.fLabels)memcpy(fLabels,m.fLabels,fNtracks*sizeof(Int_t));
+    if(m.fLabelsL2)memcpy(fLabelsL2,m.fLabelsL2,fNtracks*sizeof(Int_t));
+    if(fUsedClusT) memcpy(fUsedClusT,m.fUsedClusT,fNtracks*sizeof(ULong64_t));
   }
   else {
     fTh = 0;
@@ -217,23 +224,17 @@ void AliMultiplicity::Duplicate(const AliMultiplicity& m){
     fLabelssingle = new Int_t[fNsingle];
     if (m.fUsedClusS) fUsedClusS = new UInt_t[fNsingle];
     else fUsedClusS = 0;
+    if(m.fThsingle)memcpy(fThsingle,m.fThsingle,fNsingle*sizeof(Double_t));
+    if(m.fPhisingle)memcpy(fPhisingle,m.fPhisingle,fNsingle*sizeof(Double_t));
+    if(m.fLabelssingle)memcpy(fLabelssingle,m.fLabelssingle,fNsingle*sizeof(Int_t));
+    if(fUsedClusS) memcpy(fUsedClusS,m.fUsedClusS,fNsingle*sizeof(UInt_t));
   }
   else {
     fThsingle = 0;
     fPhisingle = 0;
     fLabelssingle = 0;
   }
-  if(m.fTh)memcpy(fTh,m.fTh,fNtracks*sizeof(Double_t));
-  if(m.fPhi)memcpy(fPhi,m.fPhi,fNtracks*sizeof(Double_t));
-  if(m.fDeltTh)memcpy(fDeltTh,m.fDeltTh,fNtracks*sizeof(Double_t));
-  if(m.fDeltPhi)memcpy(fDeltPhi,m.fDeltPhi,fNtracks*sizeof(Double_t));
-  if(m.fLabels)memcpy(fLabels,m.fLabels,fNtracks*sizeof(Int_t));
-  if(m.fLabelsL2)memcpy(fLabelsL2,m.fLabelsL2,fNtracks*sizeof(Int_t));
-  if(m.fThsingle)memcpy(fThsingle,m.fThsingle,fNsingle*sizeof(Double_t));
-  if(m.fPhisingle)memcpy(fPhisingle,m.fPhisingle,fNsingle*sizeof(Double_t));
-  if(m.fLabelssingle)memcpy(fLabelssingle,m.fLabelssingle,fNsingle*sizeof(Int_t));
-  if(fUsedClusS) memcpy(fUsedClusS,m.fUsedClusS,fNsingle*sizeof(UInt_t));
-  if(fUsedClusT) memcpy(fUsedClusT,m.fUsedClusT,fNtracks*sizeof(ULong64_t));
+
   fFiredChips[0] = m.fFiredChips[0];
   fFiredChips[1] = m.fFiredChips[1];
   for(Int_t ilayer = 0; ilayer < 6; ilayer++){

diff --git a/STEER/AliParamSolver.cxx b/STEER/AliParamSolver.cxx
index 5e5383815f1c1f1e1f478aaa55f66ae4ff57bd20..561a1b89e60b87cc4fd86147dcf59d9e17d35ff6 100644 (file)
--- a/STEER/AliParamSolver.cxx
+++ b/STEER/AliParamSolver.cxx
@@ -43,14 +43,14 @@ AliParamSolver& AliParamSolver::operator=(const AliParamSolver& src)
   if (src.fMatrix && (fNGlobal!=src.fNGlobal || fMaxPoints<src.fNPoints)) {
     fNGlobal   = src.fNGlobal;
     fMaxGlobal = src.fMaxGlobal;
-    if (fMatrix)   delete   fMatrix;
-    if (fSolGlo)   delete[] fSolGlo;
-    if (fSolLoc)   delete[] fSolLoc;
-    if (fRHSGlo)   delete[] fRHSGlo;
-    if (fRHSLoc)   delete[] fRHSLoc;
-    if (fMatGamma) delete[] fMatGamma;
-    if (fMatG)     delete[] fMatG;
-    if (fCovDGl)   delete[] fCovDGl;
+    if (fMatrix)   delete   fMatrix; fMatrix = 0;
+    if (fSolGlo)   delete[] fSolGlo; fSolGlo = 0;
+    if (fSolLoc)   delete[] fSolLoc; fSolLoc = 0;
+    if (fRHSGlo)   delete[] fRHSGlo; fRHSGlo = 0;
+    if (fRHSLoc)   delete[] fRHSLoc; fRHSLoc = 0;
+    if (fMatGamma) delete[] fMatGamma; fMatGamma = 0;
+    if (fMatG)     delete[] fMatG; fMatG = 0;
+    if (fCovDGl)   delete[] fCovDGl; fCovDGl = 0;
     Init(src.fMaxPoints);
   }
   if (src.fMatrix) {
@@ -306,14 +306,14 @@ void AliParamSolver::SetMaxGlobal(Int_t n)
   if (n>0 && n==fMaxGlobal) return;
   fMaxGlobal = n;
   fNGlobal = n;
-  if (fMatrix)   delete   fMatrix;
-  if (fSolGlo)   delete[] fSolGlo;
-  if (fSolLoc)   delete[] fSolLoc;
-  if (fRHSGlo)   delete[] fRHSGlo;
-  if (fRHSLoc)   delete[] fRHSLoc;
-  if (fMatGamma) delete[] fMatGamma;
-  if (fMatG)     delete[] fMatG;
-  if (fCovDGl)   delete[] fCovDGl;
+  if (fMatrix)   delete   fMatrix;   fMatrix = 0;
+  if (fSolGlo)   delete[] fSolGlo;   fSolGlo = 0;
+  if (fSolLoc)   delete[] fSolLoc;   fSolLoc = 0;
+  if (fRHSGlo)   delete[] fRHSGlo;   fRHSGlo = 0;
+  if (fRHSLoc)   delete[] fRHSLoc;   fRHSLoc = 0;
+  if (fMatGamma) delete[] fMatGamma; fMatGamma = 0;
+  if (fMatG)     delete[] fMatG;     fMatG = 0;
+  if (fCovDGl)   delete[] fCovDGl;   fCovDGl = 0;
   n = TMath::Max(16,fMaxPoints);
   Init(n);
   //

diff --git a/STEER/AliSymMatrix.cxx b/STEER/AliSymMatrix.cxx
index b5e69ed2f73678fb94331b2e5b8a91bf25d3a435..2c000cce0830047b6fdd7bd1f3244953ea231d37 100644 (file)
--- a/STEER/AliSymMatrix.cxx
+++ b/STEER/AliSymMatrix.cxx
@@ -108,12 +108,12 @@ AliSymMatrix&  AliSymMatrix::operator=(const AliSymMatrix& src)
       int nmainel = src.GetSizeBooked()*(src.GetSizeBooked()+1);
       memcpy(fElems,src.fElems,nmainel*sizeof(Double_t));
       if (src.GetSizeAdded()) { // transfer extra rows to main matrix
-       Double_t *pnt = fElems + nmainel*sizeof(Double_t);
+       Double_t *pnt = fElems + nmainel;//*sizeof(Double_t);
        int ncl = src.GetSizeBooked() + 1;
        for (int ir=0;ir<src.GetSizeAdded();ir++) {
          ncl += ir; 
          memcpy(pnt,src.fElemsAdd[ir],ncl*sizeof(Double_t));
-         pnt += ncl*sizeof(Double_t);
+         pnt += ncl;//*sizeof(Double_t);
        }
       }
       //
@@ -549,11 +549,11 @@ int AliSymMatrix::SolveSpmInv(double *vecB, Bool_t stabilize)
     }
   }
   //
-  for (Int_t i=0; i<nGlo; i++) for (Int_t j=0; j<nGlo; j++) {
-      double vl = TMath::Sqrt(colMax[i])*TMath::Sqrt(rowMax[j]); // Correct matrix V
-      if (i>=j) (*this)(i,j) *= vl;
-      else      (*fgBuffer)(j,i) *= vl;
-    }
+  if (stabilize) for (Int_t i=0; i<nGlo; i++) for (Int_t j=0; j<nGlo; j++) {
+       double vl = TMath::Sqrt(colMax[i])*TMath::Sqrt(rowMax[j]); // Correct matrix V
+       if (i>=j) (*this)(i,j) *= vl;
+       else      (*fgBuffer)(j,i) *= vl;
+      }
   //
   for (Int_t j=0; j<nGlo; j++) {
     rowMax[j] = 0.0;