Index: trunk/BNC/src/bncutils.cpp
===================================================================
--- trunk/BNC/src/bncutils.cpp	(revision 7526)
+++ trunk/BNC/src/bncutils.cpp	(revision 7527)
@@ -35,5 +35,5 @@
  * Created:    30-Aug-2006
  *
- * Changes:    
+ * Changes:
  *
  * -----------------------------------------------------------------------*/
@@ -145,5 +145,5 @@
   //   *secOfWeek -= 24*60*60;
 
-  // new version 
+  // new version
   if(mSecOfWeek < 4*60*60*1000 && glo_timeofday > 20*60*60)
     *secOfWeek += 24*60*60;
@@ -158,5 +158,5 @@
 }
 
-// 
+//
 ////////////////////////////////////////////////////////////////////////////
 void expandEnvVar(QString& str) {
@@ -188,10 +188,10 @@
 }
 
-// 
+//
 ////////////////////////////////////////////////////////////////////////////
 QDateTime dateAndTimeFromGPSweek(int GPSWeek, double GPSWeeks) {
 
   static const QDate zeroEpoch(1980, 1, 6);
- 
+
   QDate date(zeroEpoch);
   QTime time(0,0,0,0);
@@ -204,5 +204,5 @@
 }
 
-// 
+//
 ////////////////////////////////////////////////////////////////////////////
 void currentGPSWeeks(int& week, double& sec) {
@@ -216,5 +216,5 @@
     currDateTimeGPS = QDateTime::currentDateTime().toUTC();
     QDate hlp       = currDateTimeGPS.date();
-    currDateTimeGPS = currDateTimeGPS.addSecs(gnumleap(hlp.year(), 
+    currDateTimeGPS = currDateTimeGPS.addSecs(gnumleap(hlp.year(),
                                                      hlp.month(), hlp.day()));
   }
@@ -225,12 +225,12 @@
   week = int( (double(currDateGPS.toJulianDay()) - 2444244.5) / 7 );
 
-  sec = (currDateGPS.dayOfWeek() % 7) * 24.0 * 3600.0 + 
-        currTimeGPS.hour()                   * 3600.0 + 
-        currTimeGPS.minute()                 *   60.0 + 
+  sec = (currDateGPS.dayOfWeek() % 7) * 24.0 * 3600.0 +
+        currTimeGPS.hour()                   * 3600.0 +
+        currTimeGPS.minute()                 *   60.0 +
         currTimeGPS.second()                          +
         currTimeGPS.msec()                   / 1000.0;
 }
 
-// 
+//
 ////////////////////////////////////////////////////////////////////////////
 QDateTime currentDateAndTimeGPS() {
@@ -246,5 +246,5 @@
 }
 
-// 
+//
 ////////////////////////////////////////////////////////////////////////////
 QByteArray ggaString(const QByteArray& latitude,
@@ -268,7 +268,7 @@
   if (lat < 0.)  {lat=lat*(-1.); flagN="S";}
   QTime ttime(QDateTime::currentDateTime().toUTC().time());
-  int lat_deg = (int)lat;  
+  int lat_deg = (int)lat;
   double lat_min=(lat-lat_deg)*60.;
-  int lon_deg = (int)lon;  
+  int lon_deg = (int)lon;
   double lon_min=(lon-lon_deg)*60.;
   int hh = 0 , mm = 0;
@@ -287,6 +287,8 @@
   gga += QString("M,10.000,M,,");
   int xori;
+
   char XOR = 0;
-  char *Buff =gga.toAscii().data();
+  char Buff[gga.size()];
+  strncpy(Buff, gga.toAscii().data(), gga.size());
   int iLen = strlen(Buff);
   for (xori = 0; xori < iLen; xori++) {
@@ -298,5 +300,5 @@
 }
 
-// 
+//
 ////////////////////////////////////////////////////////////////////////////
 void RSW_to_XYZ(const ColumnVector& rr, const ColumnVector& vv,
@@ -337,5 +339,5 @@
   const double e2   = (t_CST::aell*t_CST::aell-bell*bell)/(t_CST::aell*t_CST::aell) ;
   const double e2c  = (t_CST::aell*t_CST::aell-bell*bell)/(bell*bell) ;
-  
+
   double nn, ss, zps, hOld, phiOld, theta, sin3, cos3;
 
@@ -347,5 +349,5 @@
 
   // Closed formula
-  Ell[0] = atan( (XYZ[2] + e2c * bell * sin3) / (ss - e2 * t_CST::aell * cos3) );  
+  Ell[0] = atan( (XYZ[2] + e2c * bell * sin3) / (ss - e2 * t_CST::aell * cos3) );
   Ell[1] = atan2(XYZ[1],XYZ[0]) ;
   nn = t_CST::aell/sqrt(1.0-e2*sin(Ell[0])*sin(Ell[0])) ;
@@ -429,14 +431,14 @@
 }
 
-// 
+//
 ////////////////////////////////////////////////////////////////////////////
 double Frac (double x) {
-  return x-floor(x); 
-}
-
-//
-////////////////////////////////////////////////////////////////////////////
-double Modulo (double x, double y) { 
-  return y*Frac(x/y); 
+  return x-floor(x);
+}
+
+//
+////////////////////////////////////////////////////////////////////////////
+double Modulo (double x, double y) {
+  return y*Frac(x/y);
 }
 
@@ -473,5 +475,5 @@
 
 
-// Jacobian XYZ --> NEU 
+// Jacobian XYZ --> NEU
 ////////////////////////////////////////////////////////////////////////////
 void jacobiXYZ_NEU(const double* Ell, Matrix& jacobi) {
@@ -487,11 +489,11 @@
   jacobi(1,2) = - sinPhi * sinLam;
   jacobi(1,3) =   cosPhi;
-                           
-  jacobi(2,1) = - sinLam;        
+
+  jacobi(2,1) = - sinLam;
   jacobi(2,2) =   cosLam;
-  jacobi(2,3) =   0.0;          
-                           
-  jacobi(3,1) = cosPhi * cosLam; 
-  jacobi(3,2) = cosPhi * sinLam; 
+  jacobi(2,3) =   0.0;
+
+  jacobi(3,1) = cosPhi * cosLam;
+  jacobi(3,2) = cosPhi * sinLam;
   jacobi(3,3) = sinPhi;
 }
@@ -524,9 +526,9 @@
   jacobi(3,2) = 0.0;
   jacobi(3,3) = sinPhi;
-} 
+}
 
 // Covariance Matrix in NEU
 ////////////////////////////////////////////////////////////////////////////
-void covariXYZ_NEU(const SymmetricMatrix& QQxyz, const double* Ell, 
+void covariXYZ_NEU(const SymmetricMatrix& QQxyz, const double* Ell,
                    SymmetricMatrix& Qneu) {
 
@@ -540,5 +542,5 @@
 // Covariance Matrix in XYZ
 ////////////////////////////////////////////////////////////////////////////
-void covariNEU_XYZ(const SymmetricMatrix& QQneu, const double* Ell, 
+void covariNEU_XYZ(const SymmetricMatrix& QQneu, const double* Ell,
                    SymmetricMatrix& Qxyz) {
 
@@ -558,5 +560,5 @@
   double* acc,            // aditional acceleration
   ColumnVector (*der)(double x, const ColumnVector& y, double* acc)
-                          // A pointer to a function that computes the 
+                          // A pointer to a function that computes the
                           // derivative of a function at a point (x,y)
                          ) {
@@ -568,8 +570,8 @@
 
   ColumnVector yf = yi + k1/6.0 + k2/3.0 + k3/3.0 + k4/6.0;
-  
+
   return yf;
 }
-// 
+//
 ////////////////////////////////////////////////////////////////////////////
 double djul(long jj, long mm, double tt) {
@@ -579,5 +581,5 @@
     jj = jj - 1;
     mm = mm + 12;
-  }  
+  }
   ii   = jj/100;
   kk   = 2 - ii + ii/4;
@@ -585,7 +587,7 @@
   djul = djul + floor( 30.6001*(mm + 1) ) + tt + kk;
   return djul;
-} 
-
-// 
+}
+
+//
 ////////////////////////////////////////////////////////////////////////////
 double gpjd(double second, int nweek) {
@@ -593,7 +595,7 @@
   deltat = nweek*7.0 + second/86400.0 ;
   return( 44244.0 + deltat) ;
-} 
-
-// 
+}
+
+//
 ////////////////////////////////////////////////////////////////////////////
 void jdgp(double tjul, double & second, long & nweek) {
@@ -604,5 +606,5 @@
 }
 
-// 
+//
 ////////////////////////////////////////////////////////////////////////////
 void jmt(double djul, long& jj, long& mm, double& dd) {
@@ -622,13 +624,13 @@
   jj  = ih1;
   if ( mm <= 2 ) jj = jj + 1;
-} 
-
-// 
-////////////////////////////////////////////////////////////////////////////
-void GPSweekFromDateAndTime(const QDateTime& dateTime, 
+}
+
+//
+////////////////////////////////////////////////////////////////////////////
+void GPSweekFromDateAndTime(const QDateTime& dateTime,
                             int& GPSWeek, double& GPSWeeks) {
 
   static const QDateTime zeroEpoch(QDate(1980, 1, 6),QTime(),Qt::UTC);
- 
+
   GPSWeek = zeroEpoch.daysTo(dateTime) / 7;
 
@@ -637,8 +639,8 @@
 
   GPSWeeks = (weekDay - 1) * 86400.0
-             - dateTime.time().msecsTo(QTime()) / 1e3; 
-}
-
-// 
+             - dateTime.time().msecsTo(QTime()) / 1e3;
+}
+
+//
 ////////////////////////////////////////////////////////////////////////////
 void GPSweekFromYMDhms(int year, int month, int day, int hour, int min,
@@ -650,8 +652,8 @@
   jdgp(mjd, GPSWeeks, GPSWeek_long);
   GPSWeek = GPSWeek_long;
-  GPSWeeks += hour * 3600.0 + min * 60.0 + sec;  
-}
-
-// 
+  GPSWeeks += hour * 3600.0 + min * 60.0 + sec;
+}
+
+//
 ////////////////////////////////////////////////////////////////////////////
 void mjdFromDateAndTime(const QDateTime& dateTime, int& mjd, double& dayfrac) {
@@ -663,9 +665,9 @@
   dayfrac = (dateTime.time().hour() +
              (dateTime.time().minute() +
-              (dateTime.time().second() + 
+              (dateTime.time().second() +
                dateTime.time().msec() / 1000.0) / 60.0) / 60.0) / 24.0;
 }
 
-// 
+//
 ////////////////////////////////////////////////////////////////////////////
 bool findInVector(const vector<QString>& vv, const QString& str) {
@@ -679,5 +681,5 @@
 }
 
-// 
+//
 ////////////////////////////////////////////////////////////////////////////
 int readInt(const QString& str, int pos, int len, int& value) {
@@ -687,5 +689,5 @@
 }
 
-// 
+//
 ////////////////////////////////////////////////////////////////////////////
 int readDbl(const QString& str, int pos, int len, double& value) {
@@ -703,6 +705,6 @@
 // Topocentrical Distance and Elevation
 ////////////////////////////////////////////////////////////////////////////
-void topos(double xRec, double yRec, double zRec, 
-           double xSat, double ySat, double zSat, 
+void topos(double xRec, double yRec, double zRec,
+           double xSat, double ySat, double zSat,
            double& rho, double& eleSat, double& azSat) {
 
@@ -712,5 +714,5 @@
   dx[2] = zSat-zRec;
 
-  rho =  sqrt( dx[0]*dx[0] + dx[1]*dx[1] + dx[2]*dx[2] ); 
+  rho =  sqrt( dx[0]*dx[0] + dx[1]*dx[1] + dx[2]*dx[2] );
 
   double xyzRec[3];
@@ -741,5 +743,5 @@
 }
 
-// 
+//
 ////////////////////////////////////////////////////////////////////////////
 QString fortranFormat(double value, int width, int prec) {
@@ -760,5 +762,5 @@
 //
 //////////////////////////////////////////////////////////////////////////////
-void kalman(const Matrix& AA, const ColumnVector& ll, const DiagonalMatrix& PP, 
+void kalman(const Matrix& AA, const ColumnVector& ll, const DiagonalMatrix& PP,
             SymmetricMatrix& QQ, ColumnVector& xx) {
 
@@ -777,15 +779,15 @@
   SRF.SubMatrix   (nObs+1, nObs+nPar, 1, nObs) = SA;
   SRF.SymSubMatrix(nObs+1, nObs+nPar)          = SS;
-  
+
   UpperTriangularMatrix UU;
   QRZ(SRF, UU);
-  
+
   SS = UU.SymSubMatrix(nObs+1, nObs+nPar);
   UpperTriangularMatrix SH_rt = UU.SymSubMatrix(1, nObs);
   Matrix YY  = UU.SubMatrix(1, nObs, nObs+1, nObs+nPar);
-  
+
   UpperTriangularMatrix SHi = SH_rt.i();
-  
-  Matrix KT  = SHi * YY; 
+
+  Matrix KT  = SHi * YY;
   SymmetricMatrix Hi; Hi << SHi * SHi.t();