lenght => length 59/9659/1
Sylvestre Ledru [Mon, 12 Nov 2012 13:14:14 +0000 (14:14 +0100)]
Change-Id: I9c2e8c7495f5c4ba5c82d612cfc2a88445ed5a84

19 files changed:
scilab/modules/cacsd/demos/flat/fcts.sci
scilab/modules/cacsd/sci_gateway/fortran/sci_f_findbd.f
scilab/modules/cacsd/sci_gateway/fortran/sci_f_linmeq.f
scilab/modules/cacsd/sci_gateway/fortran/sci_f_sident.f
scilab/modules/cacsd/sci_gateway/fortran/sci_f_sorder.f
scilab/modules/core/src/c/stack3.c
scilab/modules/elementary_functions/includes/xerhlt.h
scilab/modules/output_stream/sci_gateway/c/sci_msprintf.c
scilab/modules/scicos/macros/scicos_scicos/do_compile_superblock42.sci
scilab/modules/scicos/macros/scicos_scicos/do_delete1.sci
scilab/modules/scicos/tests/unit_tests/PENDULUM_ANIM.sci
scilab/modules/scicos_blocks/macros/Misc/BPLATFORM.sci
scilab/modules/scicos_blocks/macros/Misc/PENDULUM_ANIM.sci
scilab/modules/spreadsheet/src/c/ripole/ole.c
scilab/modules/spreadsheet/src/c/ripole/olestream-unwrap.c
scilab/modules/statistics/macros/samplef.sci
scilab/modules/string/src/c/stripblanks.c
scilab/modules/xcos/demos/PENDULUM_ANIM.sci
scilab/modules/xcos/tests/unit_tests/PENDULUM_ANIM.sci

index a051423..b40908d 100644 (file)
@@ -9,7 +9,7 @@ function [xdot]=car(t,x)
 //
 //
 xdot=zeros(1,4) ;
-// car lenght for the control computation
+// car length for the control computation
 LCpct = bigL * 1.;
 // calcul de u1 et u2
 //
index f21a99f..c8ea9bf 100644 (file)
@@ -446,7 +446,7 @@ C
          IP =IP +1
       END IF 
 C
-C Determine the lenghts of working arrays.
+C Determine the lengths of working arrays.
 C The default value for LDWORK is computed using the formula
 C      LDWORK = MAX( minimum value needed, 2*CSIZE/3,
 C     $              CSIZE - ( M + L )*NSMP - 2*N*( N + M + L ) - L*M )
index 57126a9..4caba00 100644 (file)
@@ -339,7 +339,7 @@ C
          enddo
       endif
 C
-C Determine the lenghts of working arrays.
+C Determine the lengths of working arrays.
 C Use a larger value for NDWORK for enabling calls of block algorithms
 C in DGEES, and possibly in DGEHRD, DGEQRF, DGERQF, SB04PD.
 C
index 91a8a90..f2a0346 100644 (file)
@@ -374,7 +374,7 @@ C
          PRINTW =ITMP.EQ.1 
       END IF 
 C
-C Determine the lenghts of working arrays.
+C Determine the lengths of working arrays.
 C The value for LDWORK is the minimum value needed by IB01BD for each
 C method and algorithm implemented.  Using a larger value could
 C increase the efficiency.
index 66c3eab..dd5fecb 100644 (file)
@@ -428,9 +428,9 @@ C
          IP =IP +1
       END IF 
 C
-C Determine the lenghts of working arrays.
+C Determine the lengths of working arrays.
 C The quasi-optimal value for LDWORK (assumed block-size 64) is possibly
-C modified, so that the sum of the lenghts of DWORK and other needed
+C modified, so that the sum of the lengths of DWORK and other needed
 C arrays does not exceed the cache size. Specifically, the default value
 C for LDWORK is computed using the formulas
 C           nr = 2*( m + l )*s
index 92ac664..deb351f 100644 (file)
@@ -47,10 +47,10 @@ static int cx1 = 1;
  * read a matrix
  *------------------------------------------------------*/
 
-int C2F(readmat)(char *namex,int *m, int *n, double *scimat, unsigned long name_len)
+int C2F(readmat)(char *namex, int *m, int *n, double *scimat, unsigned long name_len)
 {
-  C2F(creadmat)(namex, m, n, scimat, name_len);
-  return 0;
+    C2F(creadmat)(namex, m, n, scimat, name_len);
+    return 0;
 }
 
 /*----------------------------------------------------------------
@@ -84,14 +84,24 @@ int C2F(creadmat)(char *namex, int *m, int *n, double *scimat, unsigned long nam
     /* read   : from scilab stack -> fortran variable */
     Fin = -1;
     C2F(stackg)(id);
-    if (Err > 0) return FALSE ;
-    if (Fin == 0) {
-               Scierror(4,_("Undefined variable %s.\n"),get_fname(namex,name_len));
-      return FALSE;
+    if (Err > 0)
+    {
+        return FALSE ;
+    }
+    if (Fin == 0)
+    {
+        Scierror(4, _("Undefined variable %s.\n"), get_fname(namex, name_len));
+        return FALSE;
+    }
+    if ( *Infstk(Fin ) == 2)
+    {
+        Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
     }
-    if ( *Infstk(Fin ) == 2)  Fin = *istk(iadr(*Lstk(Fin )) + 1 +1);
     /* get matrix data pointer */
-    if (! C2F(getrmat)("creadmat", &Fin, &Fin, m, n, &l, 8L))  return FALSE;
+    if (! C2F(getrmat)("creadmat", &Fin, &Fin, m, n, &l, 8L))
+    {
+        return FALSE;
+    }
 
     C2F(dmcopy)(stk(l ), m, scimat, m, m, n);
 
@@ -133,17 +143,27 @@ int C2F(creadcmat)(char *namex, int *m, int *n, double *scimat, unsigned long na
     /* read   : from scilab stack -> fortran variable */
     Fin = -1;
     C2F(stackg)(id);
-    if (Err > 0) return FALSE ;
-    if (Fin == 0) {
-      Scierror(4,_("Undefined variable %s.\n"),get_fname(namex,name_len));
-      return FALSE;
+    if (Err > 0)
+    {
+        return FALSE ;
+    }
+    if (Fin == 0)
+    {
+        Scierror(4, _("Undefined variable %s.\n"), get_fname(namex, name_len));
+        return FALSE;
+    }
+    if ( *Infstk(Fin ) == 2)
+    {
+        Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
     }
-    if ( *Infstk(Fin ) == 2)  Fin = *istk(iadr(*Lstk(Fin )) + 1 +1);
     /* get matrix data pointer */
-    if (! C2F(getcmat)("creadcmat", &Fin, &Fin, m, n, &l, 8L))         return FALSE;
+    if (! C2F(getcmat)("creadcmat", &Fin, &Fin, m, n, &l, 8L))
+    {
+        return FALSE;
+    }
     ix1 = *m * *n;
     C2F(dmcopy)(stk(l ), m, scimat, m, m, n);
-    C2F(dmcopy)(stk(l+ix1 ), m, scimat+ix1, m, m, n);
+    C2F(dmcopy)(stk(l + ix1 ), m, scimat + ix1, m, m, n);
 
     return TRUE;
 }
@@ -159,24 +179,30 @@ int C2F(creadcmat)(char *namex, int *m, int *n, double *scimat, unsigned long na
 
 int C2F(cwritemat)(char *namex, int *m, int *n,  double *mat, unsigned long name_len)
 {
-  int   ix1 = *m * *n;
-  int Rhs_k = Rhs , Top_k = Top ;
-  int l4, id[nsiz], lc, lr;
+    int   ix1 = *m * *n;
+    int Rhs_k = Rhs , Top_k = Top ;
+    int l4, id[nsiz], lc, lr;
 
-  C2F(str2name)(namex, id, name_len);
+    C2F(str2name)(namex, id, name_len);
 
-  Top = Top + Nbvars + 1;
-  if (! C2F(cremat)("cwritemat", &Top, &cx0, m, n, &lr, &lc, 9L)) return  FALSE;
-  C2F(dcopy)(&ix1, mat, &cx1, stk(lr ), &cx1);
-  Rhs = 0;
-  l4 = C2F(iop).lct[3];
-  C2F(iop).lct[3] = -1;
-  C2F(stackp)(id, &cx0);
-  C2F(iop).lct[3] = l4;
-  Top = Top_k;
-  Rhs = Rhs_k;
-  if (Err > 0)  return FALSE;
-  return TRUE;
+    Top = Top + Nbvars + 1;
+    if (! C2F(cremat)("cwritemat", &Top, &cx0, m, n, &lr, &lc, 9L))
+    {
+        return  FALSE;
+    }
+    C2F(dcopy)(&ix1, mat, &cx1, stk(lr ), &cx1);
+    Rhs = 0;
+    l4 = C2F(iop).lct[3];
+    C2F(iop).lct[3] = -1;
+    C2F(stackp)(id, &cx0);
+    C2F(iop).lct[3] = l4;
+    Top = Top_k;
+    Rhs = Rhs_k;
+    if (Err > 0)
+    {
+        return FALSE;
+    }
+    return TRUE;
 }
 
 
@@ -187,46 +213,55 @@ int C2F(cwritemat)(char *namex, int *m, int *n,  double *mat, unsigned long name
  * @param n: number of columns
  * @param mat: matrix entries stored columnwise in Scilab object for complex number
 */
-int C2F(cwritecmat)(char *namex,int *m, int*n,double *mat,unsigned long name_len)
-{
-       int   ix1 = *m * *n *2; /* real part + imaginary part */
-       int Rhs_k = Rhs , Top_k = Top ;
-       int l4, id[nsiz], lc, lr;
-       int IT=1; /* Type Complex */
-
-       C2F(str2name)(namex, id, name_len);
-
-       Top = Top + Nbvars + 1;
-       if (! C2F(cremat)("cwritecmat", &Top, &IT, m, n, &lr, &lc, 10L)) return  FALSE;
-       C2F(dcopy)(&ix1, mat, &cx1, stk(lr ), &cx1);
-       Rhs = 0;
-       l4 = C2F(iop).lct[3];
-       C2F(iop).lct[3] = -1;
-       C2F(stackp)(id, &cx0);
-       C2F(iop).lct[3] = l4;
-       Top = Top_k;
-       Rhs = Rhs_k;
-       if (Err > 0)  return FALSE;
-       return TRUE;
+int C2F(cwritecmat)(char *namex, int *m, int*n, double *mat, unsigned long name_len)
+{
+    int   ix1 = *m * *n * 2; /* real part + imaginary part */
+    int Rhs_k = Rhs , Top_k = Top ;
+    int l4, id[nsiz], lc, lr;
+    int IT = 1; /* Type Complex */
+
+    C2F(str2name)(namex, id, name_len);
+
+    Top = Top + Nbvars + 1;
+    if (! C2F(cremat)("cwritecmat", &Top, &IT, m, n, &lr, &lc, 10L))
+    {
+        return  FALSE;
+    }
+    C2F(dcopy)(&ix1, mat, &cx1, stk(lr ), &cx1);
+    Rhs = 0;
+    l4 = C2F(iop).lct[3];
+    C2F(iop).lct[3] = -1;
+    C2F(stackp)(id, &cx0);
+    C2F(iop).lct[3] = l4;
+    Top = Top_k;
+    Rhs = Rhs_k;
+    if (Err > 0)
+    {
+        return FALSE;
+    }
+    return TRUE;
 }
 /*--------------------------------------------------------------------------*/
- /* Put variable number into Scilab internal stack with name "namex" */
-int C2F(putvar)(int  *number,char *namex,  unsigned long name_len)
+/* Put variable number into Scilab internal stack with name "namex" */
+int C2F(putvar)(int  *number, char *namex,  unsigned long name_len)
 {
-  int Rhs_k = Rhs , Top_k = Top ;
-  int l4, id[nsiz],/* lc, lr,*/ cx0_2=1;
+    int Rhs_k = Rhs , Top_k = Top ;
+    int l4, id[nsiz],/* lc, lr,*/ cx0_2 = 1;
 
-  C2F(str2name)(namex, id, name_len);
-  Top = *number + Top -Rhs;
-  Rhs = 0;
-  l4 = C2F(iop).lct[3];
-  C2F(iop).lct[3] = -1;
-  C2F(stackp)(id, &cx0_2);
-  C2F(iop).lct[3] = l4;
-  Top = Top_k;
-  Rhs = Rhs_k;
-  if (Err > 0)  return FALSE;
-  return TRUE;
+    C2F(str2name)(namex, id, name_len);
+    Top = *number + Top - Rhs;
+    Rhs = 0;
+    l4 = C2F(iop).lct[3];
+    C2F(iop).lct[3] = -1;
+    C2F(stackp)(id, &cx0_2);
+    C2F(iop).lct[3] = l4;
+    Top = Top_k;
+    Rhs = Rhs_k;
+    if (Err > 0)
+    {
+        return FALSE;
+    }
+    return TRUE;
 }
 
 /*------------------------------------------------------
@@ -270,24 +305,31 @@ int C2F(creadchain)(char *namex,  int *itslen,  char *chai,  unsigned long name_
     C2F(str2name)(namex, id, name_len);
     Fin = -1;
     C2F(stackg)(id);
-    if (Err > 0) return FALSE ;
-    if (Fin == 0) {
-      Scierror(4,_("Undefined variable %s.\n"),get_fname(namex,name_len));
-      return FALSE ;
+    if (Err > 0)
+    {
+        return FALSE ;
     }
-    if (*Infstk(Fin ) == 2) {
-       Fin = *istk(iadr(*Lstk(Fin )) + 1 +1);
+    if (Fin == 0)
+    {
+        Scierror(4, _("Undefined variable %s.\n"), get_fname(namex, name_len));
+        return FALSE ;
     }
-    if (! C2F(getsmat)("creadchain", &Fin, &Fin, &m1, &n1, &cx1, &cx1, &lr1, &nlr1, 10L)) {
-       return FALSE;
+    if (*Infstk(Fin ) == 2)
+    {
+        Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
     }
-    if (m1 * n1 != 1) {
-      Scierror(999,_("%s: argument must be a string.\n"),"creadchain");
-      return FALSE ;
+    if (! C2F(getsmat)("creadchain", &Fin, &Fin, &m1, &n1, &cx1, &cx1, &lr1, &nlr1, 10L))
+    {
+        return FALSE;
+    }
+    if (m1 * n1 != 1)
+    {
+        Scierror(999, _("%s: argument must be a string.\n"), "creadchain");
+        return FALSE ;
     }
 
     ix1 = *itslen - 1;
-    *itslen = Min(ix1,nlr1);
+    *itslen = Min(ix1, nlr1);
     C2F(cvstr)(itslen, istk(lr1 ), chai, &cx1, chai_len);
     chai[*itslen] = '\0';
     return TRUE ;
@@ -326,30 +368,43 @@ int C2F(creadchains)(char *namex, int *ir, int *ic, int *itslen, char *chai, uns
     C2F(str2name)(namex, id, name_len);
     Fin = -1;
     C2F(stackg)(id);
-    if (Err > 0) return FALSE ;
+    if (Err > 0)
+    {
+        return FALSE ;
+    }
 
-    if (Fin == 0) {
-      Scierror(4,_("Undefined variable %s.\n"),get_fname(namex,name_len));
-      return FALSE ;
+    if (Fin == 0)
+    {
+        Scierror(4, _("Undefined variable %s.\n"), get_fname(namex, name_len));
+        return FALSE ;
     }
 
-    if (*Infstk(Fin ) == 2) {
-       Fin = *istk(iadr(*Lstk(Fin )) + 1 +1);
+    if (*Infstk(Fin ) == 2)
+    {
+        Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
     }
-    if (*ir == -1 && *ic == -1) {
-       if (! C2F(getsmat)("creadchain", &Fin, &Fin, ir, ic, &cx1, &cx1, &lr1, &nlr1, 10L))
-         return FALSE;
-       else
-         return TRUE ;
-    } else {
-       if (! C2F(getsmat)("creadchain", &Fin, &Fin, &m1, &n1, ir, ic, &lr1, &nlr1, 10L)) {
-         return FALSE;
-       }
+    if (*ir == -1 && *ic == -1)
+    {
+        if (! C2F(getsmat)("creadchain", &Fin, &Fin, ir, ic, &cx1, &cx1, &lr1, &nlr1, 10L))
+        {
+            return FALSE;
+        }
+        else
+        {
+            return TRUE ;
+        }
+    }
+    else
+    {
+        if (! C2F(getsmat)("creadchain", &Fin, &Fin, &m1, &n1, ir, ic, &lr1, &nlr1, 10L))
+        {
+            return FALSE;
+        }
     }
     ix1 = *itslen - 1;
-    *itslen = Min(ix1,nlr1);
+    *itslen = Min(ix1, nlr1);
     C2F(cvstr)(itslen, istk(lr1 ), chai, &cx1, chai_len);
-    chai[*itslen]='\0';
+    chai[*itslen] = '\0';
     return TRUE;
 }
 
@@ -371,8 +426,9 @@ int C2F(cwritechain)(char *namex, int *m, char *chai, unsigned long name_len, un
     Top_k = Top;
 
     Top = Top + Nbvars + 1;
-    if (! C2F(cresmat2)("cwritechain", &Top, m, &lr, 11L)) {
-       return FALSE;
+    if (! C2F(cresmat2)("cwritechain", &Top, m, &lr, 11L))
+    {
+        return FALSE;
     }
     C2F(cvstr)(m, istk(lr ), chai, &cx0, chai_len);
     Rhs_k = Rhs;
@@ -383,7 +439,10 @@ int C2F(cwritechain)(char *namex, int *m, char *chai, unsigned long name_len, un
     C2F(iop).lct[3] = l4;
     Top = Top_k ;
     Rhs = Rhs_k ;
-    if (Err > 0)  return FALSE;
+    if (Err > 0)
+    {
+        return FALSE;
+    }
     return TRUE ;
 }
 
@@ -393,8 +452,8 @@ int C2F(cwritechain)(char *namex, int *m, char *chai, unsigned long name_len, un
 
 int C2F(matptr)(char *namex, int *m, int *n, int *lp, unsigned long name_len)
 {
-  C2F(cmatptr)(namex, m, n, lp, name_len);
-  return 0;
+    C2F(cmatptr)(namex, m, n, lp, name_len);
+    return 0;
 }
 
 /*----------------------------------------------------------------
@@ -420,25 +479,28 @@ int C2F(matptr)(char *namex, int *m, int *n, int *lp, unsigned long name_len)
  *   see also  readmat.f, matz.f
  *----------------------------------------------------------------*/
 
-int C2F(cmatptr)(char *namex, int *m,int *n,int *lp, unsigned long name_len)
+int C2F(cmatptr)(char *namex, int *m, int *n, int *lp, unsigned long name_len)
 {
     int id[nsiz];
     C2F(str2name)(namex, id, name_len);
     /* get the position in fin */
     Fin = -1;
     C2F(stackg)(id);
-    if (Fin == 0) {
-      Scierror(4,_("Undefined variable %s.\n"),get_fname(namex,name_len));
-      *m = -1;
-      *n = -1;
-      return FALSE;
+    if (Fin == 0)
+    {
+        Scierror(4, _("Undefined variable %s.\n"), get_fname(namex, name_len));
+        *m = -1;
+        *n = -1;
+        return FALSE;
     }
     /* get data */
-    if (*Infstk(Fin ) == 2) {
-       Fin = *istk(iadr(*Lstk(Fin )) + 1 +1);
+    if (*Infstk(Fin ) == 2)
+    {
+        Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
     }
-    if (! C2F(getrmat)("creadmat", &Fin, &Fin, m, n, lp, 8L)) {
-       return FALSE;
+    if (! C2F(getrmat)("creadmat", &Fin, &Fin, m, n, lp, 8L))
+    {
+        return FALSE;
     }
     return TRUE ;
 }
@@ -479,18 +541,21 @@ int C2F(cmatcptr)(char *namex, int *m, int *n, int *lp, unsigned long name_len)
     /* get the position in fin */
     Fin = -1;
     C2F(stackg)(id);
-    if (Fin == 0) {
-      Scierror(4,_("Undefined variable %s.\n"),get_fname(namex,name_len));
-      *m = -1;
-      *n = -1;
-      return FALSE;
+    if (Fin == 0)
+    {
+        Scierror(4, _("Undefined variable %s.\n"), get_fname(namex, name_len));
+        *m = -1;
+        *n = -1;
+        return FALSE;
     }
     /* get data */
-    if (*Infstk(Fin ) == 2) {
-       Fin = *istk(iadr(*Lstk(Fin )) + 1 +1);
+    if (*Infstk(Fin ) == 2)
+    {
+        Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
     }
-    if (! C2F(getcmat)("creadmat", &Fin, &Fin, m, n, lp, 8L)) {
-       return FALSE;
+    if (! C2F(getcmat)("creadmat", &Fin, &Fin, m, n, lp, 8L))
+    {
+        return FALSE;
     }
     return TRUE ;
 }
@@ -518,25 +583,28 @@ int C2F(cmatcptr)(char *namex, int *m, int *n, int *lp, unsigned long name_len)
  *   see also  readmat.f, matz.f
  *----------------------------------------------------------------*/
 
-int C2F(cmatsptr)(char *namex, int *m, int *n,int *ix,int *j,int *lp,int *nlr, unsigned long name_len)
+int C2F(cmatsptr)(char *namex, int *m, int *n, int *ix, int *j, int *lp, int *nlr, unsigned long name_len)
 {
     int id[nsiz];
     C2F(str2name)(namex, id, name_len);
     /* get the position in fin */
     Fin = -1;
     C2F(stackg)(id);
-    if (Fin == 0) {
-      Scierror(4,_("Undefined variable %s.\n"),get_fname(namex,name_len));
-      *m = -1;
-      *n = -1;
-      return FALSE;
+    if (Fin == 0)
+    {
+        Scierror(4, _("Undefined variable %s.\n"), get_fname(namex, name_len));
+        *m = -1;
+        *n = -1;
+        return FALSE;
     }
     /* get data */
-    if (*Infstk(Fin ) == 2) {
-       Fin = *istk(iadr(*Lstk(Fin )) + 1 +1);
+    if (*Infstk(Fin ) == 2)
+    {
+        Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
     }
-    if (! C2F(getsmat)("creadmat", &Fin, &Fin, m, n, ix, j, lp, nlr, 8L)) {
-       return FALSE;
+    if (! C2F(getsmat)("creadmat", &Fin, &Fin, m, n, ix, j, lp, nlr, 8L))
+    {
+        return FALSE;
     }
     return TRUE ;
 }
@@ -549,27 +617,30 @@ int C2F(cmatsptr)(char *namex, int *m, int *n,int *ix,int *j,int *lp,int *nlr, u
 */
 void *Name2ptr(char *namex)
 {
-  int l1; int *loci;
-  int id[nsiz];
-  C2F(str2name)(namex, id, (unsigned long)strlen(namex));
-  /* get the position in fin */
-  Fin = -1;
-  C2F(stackg)(id);
-  if (Fin == 0) {
-    Scierror(4,_("Undefined variable %s.\n"),get_fname(namex,(long int)strlen(namex)));
-    return 0;
-  }
-  /* get data */
-  if (*Infstk(Fin ) == 2) {
-    Fin = *istk(iadr(*Lstk(Fin )) + 1 +1);
-  }
-  loci = (int *) stk(*Lstk(Fin));
-  if (loci[0] < 0)
+    int l1;
+    int *loci;
+    int id[nsiz];
+    C2F(str2name)(namex, id, (unsigned long)strlen(namex));
+    /* get the position in fin */
+    Fin = -1;
+    C2F(stackg)(id);
+    if (Fin == 0)
     {
-      l1 = loci[1];
-      loci = (int *) stk(l1);
+        Scierror(4, _("Undefined variable %s.\n"), get_fname(namex, (long int)strlen(namex)));
+        return 0;
     }
-  return loci;
+    /* get data */
+    if (*Infstk(Fin ) == 2)
+    {
+        Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
+    }
+    loci = (int *) stk(*Lstk(Fin));
+    if (loci[0] < 0)
+    {
+        l1 = loci[1];
+        loci = (int *) stk(l1);
+    }
+    return loci;
 }
 
 
@@ -586,17 +657,17 @@ void *Name2ptr(char *namex)
 */
 int Name2where(char *namex)
 {
-  int id[nsiz];
-  C2F(str2name)(namex, id, (unsigned long)strlen(namex));
-  /* get the position in fin */
-  Fin = -1;
-  C2F(stackg)(id);
-  if (Fin == 0)
-  {
-       Scierror(4,_("Undefined variable %s.\n"),get_fname(namex,(long int)strlen(namex)));
-    return 0;
-  }
-  return *Lstk(Fin);
+    int id[nsiz];
+    C2F(str2name)(namex, id, (unsigned long)strlen(namex));
+    /* get the position in fin */
+    Fin = -1;
+    C2F(stackg)(id);
+    if (Fin == 0)
+    {
+        Scierror(4, _("Undefined variable %s.\n"), get_fname(namex, (long int)strlen(namex)));
+        return 0;
+    }
+    return *Lstk(Fin);
 }
 
 /*----------------------------------------------------------------
@@ -608,25 +679,31 @@ int Name2where(char *namex)
  *----------------------------------------------------------------*/
 int C2F(str2name)(const char *namex, int *id, unsigned long name_len)
 {
-       int ix = 0;
+    int ix = 0;
     int i = 0;
-       char* temp = 0;
+    char* temp = 0;
 
     /* initialize id array */
-    for (i = 0; i < nsiz;i++) id[i] = 0;
+    for (i = 0; i < nsiz; i++)
+    {
+        id[i] = 0;
+    }
+
+    for (ix = 0; namex[ix] != ' ' && namex[ix] != '\0'; ix++)
+    {
+        ;
+    }
 
-       for (ix = 0; namex[ix] != ' ' && namex[ix] != '\0'; ix++);
-      
-       temp = (char*)MALLOC((ix + 1) * sizeof(char) );
+    temp = (char*)MALLOC((ix + 1) * sizeof(char) );
     if (temp)
     {
-           memcpy(temp, namex, ix);
-           temp[ix] = '\0';
+        memcpy(temp, namex, ix);
+        temp[ix] = '\0';
         /* cx0 = 0 convert name to ID */
-           C2F(cvname)(id, temp, &cx0, ix);
+        C2F(cvname)(id, temp, &cx0, ix);
         FREE(temp);
     }
-       return 0;
+    return 0;
 }
 /*----------------------------------------------------------------
  *     objptr returns the address of "name"
@@ -642,16 +719,18 @@ int C2F(objptr)(char *namex, int *lp, int *fin, unsigned long name_len)
     /*     ---- get the position in fin */
     Fin = -1;
     C2F(stackg)(id);
-    if (Fin == 0) {
-      C2F(putid)(&C2F(recu).ids[(C2F(recu).pt + 1) * nsiz - nsiz], id);
-      /*         we juste return false and lp is set to zero */
-      /*         call error(4) */
-      return FALSE;
+    if (Fin == 0)
+    {
+        C2F(putid)(&C2F(recu).ids[(C2F(recu).pt + 1) * nsiz - nsiz], id);
+        /*         we juste return false and lp is set to zero */
+        /*         call error(4) */
+        return FALSE;
     }
     *fin = Fin;
     *lp = *Lstk(Fin );
-    if (*Infstk(Fin ) == 2) {
-       *lp = *Lstk(*istk(iadr(*lp) + 1 +1) );
+    if (*Infstk(Fin ) == 2)
+    {
+        *lp = *Lstk(*istk(iadr(*lp) + 1 + 1) );
     }
     return  TRUE;
 }
@@ -660,77 +739,96 @@ int C2F(objptr)(char *namex, int *lp, int *fin, unsigned long name_len)
 /*--------------------------------------------------------------------------*/
 int C2F(creadbmat)(char *namex, int *m, int *n, int *scimat, unsigned long name_len)
 {
-       int l = 0;
-       int id[nsiz];
-       int c_x = 1;
-       int N = 0;
+    int l = 0;
+    int id[nsiz];
+    int c_x = 1;
+    int N = 0;
 
-       C2F(str2name)(namex, id, name_len);
-       /* read   : from scilab stack -> fortran variable */
-       Fin = -1;
-       C2F(stackg)(id);
-       if (Err > 0) return FALSE ;
-       if (Fin == 0) {
-               Scierror(4,_("Undefined variable %s.\n"),get_fname(namex,name_len));
-               return FALSE;
-       }
-       if ( *Infstk(Fin ) == 2)  Fin = *istk(iadr(*Lstk(Fin )) + 1 +1);
+    C2F(str2name)(namex, id, name_len);
+    /* read   : from scilab stack -> fortran variable */
+    Fin = -1;
+    C2F(stackg)(id);
+    if (Err > 0)
+    {
+        return FALSE ;
+    }
+    if (Fin == 0)
+    {
+        Scierror(4, _("Undefined variable %s.\n"), get_fname(namex, name_len));
+        return FALSE;
+    }
+    if ( *Infstk(Fin ) == 2)
+    {
+        Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
+    }
 
-       /* get matrix data pointer */
-       if (! C2F(getbmat)("creadbmat", &Fin, &Fin, m, n, &l , 9L))     return FALSE;
+    /* get matrix data pointer */
+    if (! C2F(getbmat)("creadbmat", &Fin, &Fin, m, n, &l , 9L))
+    {
+        return FALSE;
+    }
 
-       N = *n * *m;
-       C2F(icopy)(&N,istk(l),&c_x,scimat,&c_x);
+    N = *n * *m;
+    C2F(icopy)(&N, istk(l), &c_x, scimat, &c_x);
 
-       return TRUE;
+    return TRUE;
 }
 /*--------------------------------------------------------------------------*/
 int C2F(cwritebmat)(char *namex, int *m, int *n,  int *mat, unsigned long name_len)
 {
-       int   ix1 = *m * *n;
-       int Rhs_k = Rhs , Top_k = Top ;
-       int l4, id[nsiz], lr;
+    int   ix1 = *m * *n;
+    int Rhs_k = Rhs , Top_k = Top ;
+    int l4, id[nsiz], lr;
 
-       C2F(str2name)(namex, id, name_len);
-       Top = Top + Nbvars + 1;
-       if (! C2F(crebmat)("cwritebmat", &Top, m, n, &lr, 10L)) return  FALSE;
+    C2F(str2name)(namex, id, name_len);
+    Top = Top + Nbvars + 1;
+    if (! C2F(crebmat)("cwritebmat", &Top, m, n, &lr, 10L))
+    {
+        return  FALSE;
+    }
 
-       C2F(icopy)(&ix1, mat, &cx1, istk(lr ), &cx1);
-       Rhs = 0;
-       l4 = C2F(iop).lct[3];
-       C2F(iop).lct[3] = -1;
-       C2F(stackp)(id, &cx0);
-       C2F(iop).lct[3] = l4;
-       Top = Top_k;
-       Rhs = Rhs_k;
-       if (Err > 0)  return FALSE;
-       return TRUE;
+    C2F(icopy)(&ix1, mat, &cx1, istk(lr ), &cx1);
+    Rhs = 0;
+    l4 = C2F(iop).lct[3];
+    C2F(iop).lct[3] = -1;
+    C2F(stackp)(id, &cx0);
+    C2F(iop).lct[3] = l4;
+    Top = Top_k;
+    Rhs = Rhs_k;
+    if (Err > 0)
+    {
+        return FALSE;
+    }
+    return TRUE;
 
 }
 /*--------------------------------------------------------------------------*/
-int C2F(cmatbptr)(char *namex, int *m,int *n,int *lp, unsigned long name_len)
-{
-       int id[nsiz];
-       C2F(str2name)(namex, id, name_len);
-       /* get the position in fin */
-       Fin = -1;
-       C2F(stackg)(id);
-       if (Fin == 0)
-       {
-               Scierror(4,_("Undefined variable %s.\n"),get_fname(namex,name_len));
-               *m = -1;
-               *n = -1;
-               return FALSE;
-       }
-       /* get data */
-       if (*Infstk(Fin ) == 2)
-       {
-               Fin = *istk(iadr(*Lstk(Fin )) + 1 +1);
-       }
-
-       if (! C2F(getbmat)("creadbmat", &Fin, &Fin, m, n, lp , 9L))     return FALSE;
-
-       return TRUE ;
+int C2F(cmatbptr)(char *namex, int *m, int *n, int *lp, unsigned long name_len)
+{
+    int id[nsiz];
+    C2F(str2name)(namex, id, name_len);
+    /* get the position in fin */
+    Fin = -1;
+    C2F(stackg)(id);
+    if (Fin == 0)
+    {
+        Scierror(4, _("Undefined variable %s.\n"), get_fname(namex, name_len));
+        *m = -1;
+        *n = -1;
+        return FALSE;
+    }
+    /* get data */
+    if (*Infstk(Fin ) == 2)
+    {
+        Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
+    }
+
+    if (! C2F(getbmat)("creadbmat", &Fin, &Fin, m, n, lp , 9L))
+    {
+        return FALSE;
+    }
+
+    return TRUE ;
 }
 
 /*--------------------------------------------------------------------------*/
@@ -743,49 +841,61 @@ int C2F(cmatbptr)(char *namex, int *m,int *n,int *lp, unsigned long name_len)
 */
 int getlengthchain(char *namex)
 {
-       int m1, n1;
-       int id[nsiz];
-       int lr1;
-       int nlr1;
-       unsigned long name_len= (unsigned long)strlen(namex);
+    int m1, n1;
+    int id[nsiz];
+    int lr1;
+    int nlr1;
+    unsigned long name_len = (unsigned long)strlen(namex);
 
-       Err = 0;
-       C2F(str2name)(namex, id, name_len);
-       Fin = -1;
-       C2F(stackg)(id);
-       if (Err > 0)  return -1;
-       if (Fin == 0) return -1;
+    Err = 0;
+    C2F(str2name)(namex, id, name_len);
+    Fin = -1;
+    C2F(stackg)(id);
+    if (Err > 0)
+    {
+        return -1;
+    }
+    if (Fin == 0)
+    {
+        return -1;
+    }
 
 
-       if (*Infstk(Fin ) == 2)
-       {
-               Fin = *istk(iadr(*Lstk(Fin )) + 1 +1);
-       }
+    if (*Infstk(Fin ) == 2)
+    {
+        Fin = *istk(iadr(*Lstk(Fin )) + 1 + 1);
+    }
 
-       if (! C2F(getsmat)("getlengthchain", &Fin, &Fin, &m1, &n1, &cx1, &cx1, &lr1, &nlr1, 14L)) return -1;
+    if (! C2F(getsmat)("getlengthchain", &Fin, &Fin, &m1, &n1, &cx1, &cx1, &lr1, &nlr1, 14L))
+    {
+        return -1;
+    }
 
-       if (m1 * n1 != 1)  return -1;
-       return nlr1;
+    if (m1 * n1 != 1)
+    {
+        return -1;
+    }
+    return nlr1;
 }
 
 /*Compute sum of array's elements*/
 int iArraySum(int *_piArray, int _iStart, int _iEnd)
 {
-       /*Recursive function*/
-       /*
-       if(_iStart == _iEnd)
-               return _piArray[_iEnd];
-       return _piArray[_iEnd] + iArraySum(_piArray, _iStart, _iEnd-1);
-       */
-
-       /*Iterative function*/
-       int iIndex = 0;
-       int iVal = 0;
-       for(iIndex = _iStart >= 0 ? _iStart : 0; iIndex < _iEnd ; iIndex++)
-       {
-               iVal += _piArray[iIndex];
-       }
-       return iVal;
+    /*Recursive function*/
+    /*
+    if(_iStart == _iEnd)
+       return _piArray[_iEnd];
+    return _piArray[_iEnd] + iArraySum(_piArray, _iStart, _iEnd-1);
+    */
+
+    /*Iterative function*/
+    int iIndex = 0;
+    int iVal = 0;
+    for (iIndex = _iStart >= 0 ? _iStart : 0; iIndex < _iEnd ; iIndex++)
+    {
+        iVal += _piArray[iIndex];
+    }
+    return iVal;
 }
 
 /*--------------------------------------------------------------------------*/
@@ -794,21 +904,24 @@ int iArraySum(int *_piArray, int _iStart, int _iEnd)
 */
 int iIsComplex(int _iVar)
 {
-       /*Check if variable are by value or by reference*/
-       int it = 0;
-       int il = iadr(*Lstk(Top - Rhs + _iVar));
-       int iValType = *istk(il);
+    /*Check if variable are by value or by reference*/
+    int it = 0;
+    int il = iadr(*Lstk(Top - Rhs + _iVar));
+    int iValType = *istk(il);
 
-       if( iValType < 0)
-       {//by reference
-        il = iadr(*istk(il+1));
-       }
-       it = *istk(il + 3);
+    if ( iValType < 0)
+    {
+        //by reference
+        il = iadr(*istk(il + 1));
+    }
+    it = *istk(il + 3);
 
-       //if it > 1 the value is an interger so is not complex
-       if(it > 1)
-               it = 0;
-       return it;
+    //if it > 1 the value is an interger so is not complex
+    if (it > 1)
+    {
+        it = 0;
+    }
+    return it;
 }
 
 /*--------------------------------------------------------------------------*/
@@ -831,7 +944,7 @@ int iIsComplex(int _iVar)
 */
 void GetRhsPolyVar(int _iVarNum, int** _piVarName, int* _piRows, int* _piCols, int* _piPow, int* _piReal)
 {
-       GetRhsCPolyVar(_iVarNum, _piVarName, _piRows, _piCols, _piPow, _piReal, NULL);
+    GetRhsCPolyVar(_iVarNum, _piVarName, _piRows, _piCols, _piPow, _piReal, NULL);
 }
 
 /*--------------------------------------------------------------------------*/
@@ -844,19 +957,19 @@ void GetRhsPolyVar(int _iVarNum, int** _piVarName, int* _piRows, int* _piCols, i
 */
 void GetRhsCPolyVar(int _iVarNum, int** _piVarName, int* _piRows, int* _piCols, int* _piPow, int* _piReal, int *_piImg)
 {
-       int iAddrBase           = iadr(*Lstk(Top - Rhs + _iVarNum));
-       int iValType            = *istk(iAddrBase);
+    int iAddrBase              = iadr(*Lstk(Top - Rhs + _iVarNum));
+    int iValType               = *istk(iAddrBase);
 
-       if(iValType < 0)
-       {
-               iAddrBase               = iadr(*istk(iAddrBase + 1));
-       }
+    if (iValType < 0)
+    {
+        iAddrBase              = iadr(*istk(iAddrBase + 1));
+    }
 
-       iGetPolyFromAddress(iAddrBase, _piVarName, _piRows, _piCols, _piPow, _piReal, _piImg);
+    iGetPolyFromAddress(iAddrBase, _piVarName, _piRows, _piCols, _piPow, _piReal, _piImg);
 
-       C2F(intersci).ntypes[_iVarNum - 1] = '$' ;
-       C2F(intersci).iwhere[_iVarNum - 1] = *Lstk(_iVarNum);
-       C2F(intersci).lad[_iVarNum - 1] = *_piReal;
+    C2F(intersci).ntypes[_iVarNum - 1] = '$' ;
+    C2F(intersci).iwhere[_iVarNum - 1] = *Lstk(_iVarNum);
+    C2F(intersci).lad[_iVarNum - 1] = *_piReal;
 }
 
 /**********************************************************************
@@ -872,400 +985,435 @@ void GetRhsCPolyVar(int _iVarNum, int** _piVarName, int* _piRows, int* _piCols,
  **********************************************************************/
 void GetRhsSparseVar(int _iVarNum, int* _piRows, int* _piCols, int* _piTotalElem, int* _piElemByRow, int* _piColByRow, int* _piReal)
 {
-       GetRhsCSparseVar(_iVarNum, _piRows, _piCols, _piTotalElem, _piElemByRow, _piColByRow, _piReal, NULL);
+    GetRhsCSparseVar(_iVarNum, _piRows, _piCols, _piTotalElem, _piElemByRow, _piColByRow, _piReal, NULL);
 }
 
 void GetRhsCSparseVar(int _iVarNum, int* _piRows, int* _piCols, int* _piTotalElem, int* _piElemByRow, int* _piColByRow, int* _piReal, int* _piImg)
 {
-       int iAddrBase           = iadr(*Lstk(Top - Rhs + _iVarNum));
-       int iValType            = *istk(iAddrBase);
-       if(iValType < 0)
-       {
-               iAddrBase               = iadr(*istk(iAddrBase + 1));
-       }
+    int iAddrBase              = iadr(*Lstk(Top - Rhs + _iVarNum));
+    int iValType               = *istk(iAddrBase);
+    if (iValType < 0)
+    {
+        iAddrBase              = iadr(*istk(iAddrBase + 1));
+    }
 
-       iGetSparseFromAddress(iAddrBase, _piRows, _piCols, _piTotalElem, _piElemByRow, _piColByRow, _piReal, _piImg);
+    iGetSparseFromAddress(iAddrBase, _piRows, _piCols, _piTotalElem, _piElemByRow, _piColByRow, _piReal, _piImg);
 
-       C2F(intersci).ntypes[_iVarNum - 1] = '$' ;
-       C2F(intersci).iwhere[_iVarNum - 1] = *Lstk(_iVarNum);
-       C2F(intersci).lad[_iVarNum - 1] = *_piReal;
+    C2F(intersci).ntypes[_iVarNum - 1] = '$' ;
+    C2F(intersci).iwhere[_iVarNum - 1] = *Lstk(_iVarNum);
+    C2F(intersci).lad[_iVarNum - 1] = *_piReal;
 }
 
 void GetRhsBooleanSparseVar(int _iVarNum, int* _piRows, int* _piCols, int* _piTotalElem, int* _piElemByRow, int* _piColByRow)
 {
-       int iAddrBase           = iadr(*Lstk(Top - Rhs + _iVarNum));
-       int iValType            = *istk(iAddrBase);
+    int iAddrBase              = iadr(*Lstk(Top - Rhs + _iVarNum));
+    int iValType               = *istk(iAddrBase);
 
-       if(iValType < 0)
-       {
-               iAddrBase               = iadr(*istk(iAddrBase + 1));
-       }
+    if (iValType < 0)
+    {
+        iAddrBase              = iadr(*istk(iAddrBase + 1));
+    }
 
-       iGetBooleanSparseFromAddress(iAddrBase, _piRows, _piCols, _piTotalElem, _piElemByRow, _piColByRow);
-       C2F(intersci).ntypes[_iVarNum - 1] = '$' ;
-       C2F(intersci).iwhere[_iVarNum - 1] = *Lstk(_iVarNum);
+    iGetBooleanSparseFromAddress(iAddrBase, _piRows, _piCols, _piTotalElem, _piElemByRow, _piColByRow);
+    C2F(intersci).ntypes[_iVarNum - 1] = '$' ;
+    C2F(intersci).iwhere[_iVarNum - 1] = *Lstk(_iVarNum);
 }
 
 void CreatePolyVarFromPtr(int _iNewVal, int** _piVarName, int _iRows, int _iCols, int *_piPow, double* _pdblRealData)
 {
-       CreateCPolyVarFromPtr(_iNewVal, _piVarName, _iRows, _iCols, _piPow, _pdblRealData, NULL);
+    CreateCPolyVarFromPtr(_iNewVal, _piVarName, _iRows, _iCols, _piPow, _pdblRealData, NULL);
 }
 
 void CreateCPolyVarFromPtr(int _iNewVal, int** _piVarName, int _iRows, int _iCols, int *_piPow, double* _pdblRealData, double* _pdblImgData)
 {
-       int iIndex                      = 0;
-       int iAddrBase           = iadr(*Lstk(Top - Rhs + _iNewVal));
-       int iAddrPtr            = 0;
-       int iAddrData           = 0;
-
-       *istk(iAddrBase)        = sci_poly;
-       *istk(iAddrBase + 1)= _iRows;
-       *istk(iAddrBase + 2)= _iCols;
-       *istk(iAddrBase + 3)= 0; // Non complex values
-       memcpy(istk(iAddrBase + 4), *_piVarName, 4 * sizeof(int)); // name of variable ( scilab format )
-
-       iAddrPtr = iAddrBase + 8;
-       *istk(iAddrPtr) = 1;
-       iAddrPtr++;
-       for(iIndex = 0 ; iIndex < _iRows * _iCols ; iIndex++)
-       {
-               *istk(iAddrPtr + iIndex) = _piPow[iIndex] + *istk(iAddrPtr -1 + iIndex);
-       }
-       iAddrData = iAddrBase + (9 + _iRows * _iCols);
-
-
-       for(iIndex = 0 ; iIndex < iArraySum(_piPow, 0, _iRows * _iCols) ; iIndex++)
-       {
-               int iTemp = sadr(iAddrData) + iIndex;
-               *stk(iTemp) = _pdblRealData[iIndex];
-       }
-
-       if(_pdblImgData != NULL)
-       {
-               //iAddrData  += iArraySum(_piPow, 0, _iRows * _iCols) + 1;
-               *istk(iAddrBase + 3) = 1; // Use complex values
-               for(iIndex = 0 ; iIndex < iArraySum(_piPow, 0, _iRows * _iCols) ; iIndex++)
-               {
-                       int iTemp = sadr(iAddrData) + iArraySum(_piPow, 0, _iRows * _iCols) + iIndex;
-                       *stk(iTemp) = _pdblImgData[iIndex];
-               }
-       }
-
-       C2F(intersci).ntypes[Top - Rhs + _iNewVal - 1]  = '$';
-       C2F(intersci).iwhere[Top - Rhs + _iNewVal - 1]  = *Lstk(_iNewVal);
-       C2F(intersci).lad[Top - Rhs + _iNewVal - 1]             = sadr(iAddrData);
-
-       if(_pdblImgData == NULL)
-               *Lstk(Top - Rhs + _iNewVal + 1) = sadr(iAddrData) + iIndex;
-       else
-               *Lstk(Top - Rhs + _iNewVal + 1) = sadr(iAddrData) + iArraySum(_piPow, 0, _iRows * _iCols) + iIndex;
+    int iIndex                 = 0;
+    int iAddrBase              = iadr(*Lstk(Top - Rhs + _iNewVal));
+    int iAddrPtr               = 0;
+    int iAddrData              = 0;
+
+    *istk(iAddrBase)   = sci_poly;
+    *istk(iAddrBase + 1) = _iRows;
+    *istk(iAddrBase + 2) = _iCols;
+    *istk(iAddrBase + 3) = 0; // Non complex values
+    memcpy(istk(iAddrBase + 4), *_piVarName, 4 * sizeof(int)); // name of variable ( scilab format )
+
+    iAddrPtr = iAddrBase + 8;
+    *istk(iAddrPtr) = 1;
+    iAddrPtr++;
+    for (iIndex = 0 ; iIndex < _iRows * _iCols ; iIndex++)
+    {
+        *istk(iAddrPtr + iIndex) = _piPow[iIndex] + *istk(iAddrPtr - 1 + iIndex);
+    }
+    iAddrData = iAddrBase + (9 + _iRows * _iCols);
+
+
+    for (iIndex = 0 ; iIndex < iArraySum(_piPow, 0, _iRows * _iCols) ; iIndex++)
+    {
+        int iTemp = sadr(iAddrData) + iIndex;
+        *stk(iTemp) = _pdblRealData[iIndex];
+    }
+
+    if (_pdblImgData != NULL)
+    {
+        //iAddrData  += iArraySum(_piPow, 0, _iRows * _iCols) + 1;
+        *istk(iAddrBase + 3) = 1; // Use complex values
+        for (iIndex = 0 ; iIndex < iArraySum(_piPow, 0, _iRows * _iCols) ; iIndex++)
+        {
+            int iTemp = sadr(iAddrData) + iArraySum(_piPow, 0, _iRows * _iCols) + iIndex;
+            *stk(iTemp) = _pdblImgData[iIndex];
+        }
+    }
+
+    C2F(intersci).ntypes[Top - Rhs + _iNewVal - 1]     = '$';
+    C2F(intersci).iwhere[Top - Rhs + _iNewVal - 1]     = *Lstk(_iNewVal);
+    C2F(intersci).lad[Top - Rhs + _iNewVal - 1]                = sadr(iAddrData);
+
+    if (_pdblImgData == NULL)
+    {
+        *Lstk(Top - Rhs + _iNewVal + 1) = sadr(iAddrData) + iIndex;
+    }
+    else
+    {
+        *Lstk(Top - Rhs + _iNewVal + 1) = sadr(iAddrData) + iArraySum(_piPow, 0, _iRows * _iCols) + iIndex;
+    }
 }
 
 void GetRhsStringVar(int _iVarNum, int* _piRows, int* _piCols, int* _piLen, char* _pstData)
 {
-       int iAddrBase           = iadr(*Lstk(Top - Rhs + _iVarNum));
-       int iValType            = *istk(iAddrBase);
-       int iAddrData           = 0;
-       if(iValType < 0)
-       {
-               iAddrBase               = iadr(*istk(iAddrBase + 1));
-       }
+    int iAddrBase              = iadr(*Lstk(Top - Rhs + _iVarNum));
+    int iValType               = *istk(iAddrBase);
+    int iAddrData              = 0;
+    if (iValType < 0)
+    {
+        iAddrBase              = iadr(*istk(iAddrBase + 1));
+    }
 
-       iGetStringFromAddress(iAddrBase, _piRows, _piCols, _piLen, &iAddrData);
+    iGetStringFromAddress(iAddrBase, _piRows, _piCols, _piLen, &iAddrData);
 
-       if(iAddrData == 0)
-       {
-               return;
-       }
+    if (iAddrData == 0)
+    {
+        return;
+    }
+
+    if (_pstData == NULL)
+    {
+        return;
+    }
+    code2str(&_pstData, (int*) cstk(iAddrData), iArraySum(_piLen, 0, *_piRows * *_piCols));
 
-       if(_pstData == NULL)
-       {
-               return;
-       }
-       code2str(&_pstData, (int*) cstk(iAddrData), iArraySum(_piLen, 0, *_piRows * *_piCols));
-       
-       C2F(intersci).ntypes[_iVarNum - 1] = '$' ;
-       C2F(intersci).iwhere[_iVarNum - 1] = *Lstk(_iVarNum);
+    C2F(intersci).ntypes[_iVarNum - 1] = '$' ;
+    C2F(intersci).iwhere[_iVarNum - 1] = *Lstk(_iVarNum);
 }
 
 void CreateSparseVarFromPtr(int _iNewVal, int _iRows, int _iCols, int _iTotalElem, int* _piElemByRow, int* _piColByRow, double* _pdblRealData)
 {
-       CreateCSparseVarFromPtr(_iNewVal, _iRows, _iCols, _iTotalElem, _piElemByRow, _piColByRow, _pdblRealData, NULL);
+    CreateCSparseVarFromPtr(_iNewVal, _iRows, _iCols, _iTotalElem, _piElemByRow, _piColByRow, _pdblRealData, NULL);
 }
 
 void CreateCSparseVarFromPtr(int _iNewVal, int _iRows, int _iCols, int _iTotalElem, int* _piElemByRow, int* _piColByRow, double* _pdblRealData, double* _pdblImgData)
 {
-       int iIndex                      = 0;
-       int iAddrBase           = iadr(*Lstk(Top - Rhs + _iNewVal));
-       int iAddElemByRow       = 0;
-       int iAddrColByRow       = 0;
-       int iAddrRealData       = 0;
-       int iAddrImgData        = 0;
-
-       *istk(iAddrBase)        = sci_sparse;
-       *istk(iAddrBase + 1)= _iRows;
-       *istk(iAddrBase + 2)= _iCols;
-       *istk(iAddrBase + 3)= 0; // Non complex values
-       *istk(iAddrBase + 4)= _iTotalElem;
-
-       iAddElemByRow           = iAddrBase + 5;
-       iAddrColByRow           = iAddElemByRow + _iRows;
-       iAddrRealData           = iAddrColByRow + _iTotalElem;
-       iAddrImgData            = iAddrColByRow + 2 * _iTotalElem;
-
-       for(iIndex = 0 ; iIndex < _iRows ; iIndex++)
-               *istk(iAddElemByRow + iIndex) = _piElemByRow[iIndex];
-
-       for(iIndex = 0 ; iIndex < _iTotalElem ; iIndex++)
-       {
-               int iTemp               = 0;
-               *istk(iAddrColByRow + iIndex) = _piColByRow[iIndex];
-               iTemp                   = sadr(iAddrRealData) + iIndex;
-               *stk(iTemp)             = _pdblRealData[iIndex];
-       }
-
-       if(_pdblImgData != NULL)
-       {
-               *istk(iAddrBase + 3)= 1; // Use complex values
-               for(iIndex = 0 ; iIndex < _iTotalElem ; iIndex++)
-               {
-                       int iTemp               = 0;
-                       iTemp           = sadr(iAddrImgData) + iIndex;
-                       *stk(iTemp)     = _pdblImgData[iIndex];
-               }
-       }
-
-       C2F(intersci).ntypes[Top - Rhs + _iNewVal - 1]  = '$';
-       C2F(intersci).iwhere[Top - Rhs + _iNewVal - 1]  = *Lstk(_iNewVal);
-       C2F(intersci).lad[Top - Rhs + _iNewVal - 1]             = sadr(iAddrRealData);
-
-       if(_pdblImgData == NULL)
-               *Lstk(Top - Rhs + _iNewVal + 1) = sadr(iAddrRealData) + iIndex;
-       else
-               *Lstk(Top - Rhs + _iNewVal + 1) = sadr(iAddrRealData) + _iTotalElem + iIndex;
+    int iIndex                 = 0;
+    int iAddrBase              = iadr(*Lstk(Top - Rhs + _iNewVal));
+    int iAddElemByRow  = 0;
+    int iAddrColByRow  = 0;
+    int iAddrRealData  = 0;
+    int iAddrImgData   = 0;
+
+    *istk(iAddrBase)   = sci_sparse;
+    *istk(iAddrBase + 1) = _iRows;
+    *istk(iAddrBase + 2) = _iCols;
+    *istk(iAddrBase + 3) = 0; // Non complex values
+    *istk(iAddrBase + 4) = _iTotalElem;
+
+    iAddElemByRow              = iAddrBase + 5;
+    iAddrColByRow              = iAddElemByRow + _iRows;
+    iAddrRealData              = iAddrColByRow + _iTotalElem;
+    iAddrImgData               = iAddrColByRow + 2 * _iTotalElem;
+
+    for (iIndex = 0 ; iIndex < _iRows ; iIndex++)
+    {
+        *istk(iAddElemByRow + iIndex) = _piElemByRow[iIndex];
+    }
+
+    for (iIndex = 0 ; iIndex < _iTotalElem ; iIndex++)
+    {
+        int iTemp              = 0;
+        *istk(iAddrColByRow + iIndex) = _piColByRow[iIndex];
+        iTemp                  = sadr(iAddrRealData) + iIndex;
+        *stk(iTemp)            = _pdblRealData[iIndex];
+    }
+
+    if (_pdblImgData != NULL)
+    {
+        *istk(iAddrBase + 3) = 1; // Use complex values
+        for (iIndex = 0 ; iIndex < _iTotalElem ; iIndex++)
+        {
+            int iTemp          = 0;
+            iTemp              = sadr(iAddrImgData) + iIndex;
+            *stk(iTemp)        = _pdblImgData[iIndex];
+        }
+    }
+
+    C2F(intersci).ntypes[Top - Rhs + _iNewVal - 1]     = '$';
+    C2F(intersci).iwhere[Top - Rhs + _iNewVal - 1]     = *Lstk(_iNewVal);
+    C2F(intersci).lad[Top - Rhs + _iNewVal - 1]                = sadr(iAddrRealData);
+
+    if (_pdblImgData == NULL)
+    {
+        *Lstk(Top - Rhs + _iNewVal + 1) = sadr(iAddrRealData) + iIndex;
+    }
+    else
+    {
+        *Lstk(Top - Rhs + _iNewVal + 1) = sadr(iAddrRealData) + _iTotalElem + iIndex;
+    }
 
 
 }
 
 void CreateCBooleanSparseVarFromPtr(int _iNewVal, int _iRows, int _iCols, int _iTotalElem, int* _piElemByRow, int* _piColByRow)
 {
-       int iIndex                      = 0;
-       int iAddrBase           = iadr(*Lstk(Top - Rhs + _iNewVal));
-       int iAddElemByRow       = 0;
-       int iAddrColByRow       = 0;
-       int iAddrRealData       = 0;
+    int iIndex                 = 0;
+    int iAddrBase              = iadr(*Lstk(Top - Rhs + _iNewVal));
+    int iAddElemByRow  = 0;
+    int iAddrColByRow  = 0;
+    int iAddrRealData  = 0;
 
-       *istk(iAddrBase)        = sci_boolean_sparse;
-       *istk(iAddrBase + 1)= _iRows;
-       *istk(iAddrBase + 2)= _iCols;
-       *istk(iAddrBase + 3)= 0; // Non complex values
-       *istk(iAddrBase + 4)= _iTotalElem;
+    *istk(iAddrBase)   = sci_boolean_sparse;
+    *istk(iAddrBase + 1) = _iRows;
+    *istk(iAddrBase + 2) = _iCols;
+    *istk(iAddrBase + 3) = 0; // Non complex values
+    *istk(iAddrBase + 4) = _iTotalElem;
 
-       iAddElemByRow           = iAddrBase + 5;
-       iAddrColByRow           = iAddElemByRow + _iRows;
-       iAddrRealData           = iAddrColByRow + _iTotalElem;
+    iAddElemByRow              = iAddrBase + 5;
+    iAddrColByRow              = iAddElemByRow + _iRows;
+    iAddrRealData              = iAddrColByRow + _iTotalElem;
 
-       for(iIndex = 0 ; iIndex < _iRows ; iIndex++)
-               *istk(iAddElemByRow + iIndex) = _piElemByRow[iIndex];
+    for (iIndex = 0 ; iIndex < _iRows ; iIndex++)
+    {
+        *istk(iAddElemByRow + iIndex) = _piElemByRow[iIndex];
+    }
 
-       for(iIndex = 0 ; iIndex < _iTotalElem ; iIndex++)
-       {
-//             int iTemp               = 0;
-               *istk(iAddrColByRow + iIndex) = _piColByRow[iIndex];
-//             iTemp                   = sadr(iAddrRealData) + iIndex;
-//             *stk(iTemp)             = _piRealData[iIndex];
-       }
+    for (iIndex = 0 ; iIndex < _iTotalElem ; iIndex++)
+    {
+        //             int iTemp               = 0;
+        *istk(iAddrColByRow + iIndex) = _piColByRow[iIndex];
+        //             iTemp                   = sadr(iAddrRealData) + iIndex;
+        //             *stk(iTemp)             = _piRealData[iIndex];
+    }
 
-       C2F(intersci).ntypes[Top - Rhs + _iNewVal - 1]  = '$';
-       C2F(intersci).iwhere[Top - Rhs + _iNewVal - 1]  = *Lstk(_iNewVal);
-       C2F(intersci).lad[Top - Rhs + _iNewVal - 1]             = sadr(iAddrRealData);
+    C2F(intersci).ntypes[Top - Rhs + _iNewVal - 1]     = '$';
+    C2F(intersci).iwhere[Top - Rhs + _iNewVal - 1]     = *Lstk(_iNewVal);
+    C2F(intersci).lad[Top - Rhs + _iNewVal - 1]                = sadr(iAddrRealData);
 
-       *Lstk(Top - Rhs + _iNewVal + 1) = sadr(iAddrRealData) + iIndex;
+    *Lstk(Top - Rhs + _iNewVal + 1) = sadr(iAddrRealData) + iIndex;
 }
 
 int GetDimFromVar(int _iVarNum, int _iNum/*Oo*/, int* _piVal)
 {
-       int iType                               = GetType(_iVarNum);
-       int iRows                               = 0;
-       int iCols                               = 0;
-       int iRealData                   = 0;
-       double *pdblRealData    = NULL;
-       int *piRealData                 = NULL;
-
-       if(iType == sci_matrix)
-       {
-               if(iIsComplex(_iVarNum))
-               {
-                       SciError(89);
-                       return _iNum;
-               }
-               GetRhsVar(_iVarNum, MATRIX_OF_DOUBLE_DATATYPE, &iRows, &iCols, &iRealData);
-               pdblRealData = stk(iRealData);
-               *_piVal = (int)Max(pdblRealData[0], 0);
-       }
-       else if(iType == sci_ints)
-       {
-               int iComplex    = iIsComplex(_iVarNum);
-               int iYType              = 4;
-               int iXInc               = 1;
-               int iYInc               = 1;
-
-               GetRhsVar(_iVarNum, MATRIX_OF_INTEGER_DATATYPE, &iRows, &iCols, &iRealData);
-               if(iRows * iCols != 1)
-               {
-                       SciError(89);
-                       return _iNum;
-               }
-               iRows = 1;
-               piRealData = istk(iRealData);
-               C2F(tpconv)(&iComplex, &iYType, &iRows, piRealData, &iXInc, _piVal, &iYInc);
-               *_piVal = Max(*_piVal, 0);
-       }
-       else
-       {
-               SciError(89);
-               return _iNum;
-       }
-       return 0;
+    int iType                          = GetType(_iVarNum);
+    int iRows                          = 0;
+    int iCols                          = 0;
+    int iRealData                      = 0;
+    double *pdblRealData       = NULL;
+    int *piRealData                    = NULL;
+
+    if (iType == sci_matrix)
+    {
+        if (iIsComplex(_iVarNum))
+        {
+            SciError(89);
+            return _iNum;
+        }
+        GetRhsVar(_iVarNum, MATRIX_OF_DOUBLE_DATATYPE, &iRows, &iCols, &iRealData);
+        pdblRealData = stk(iRealData);
+        *_piVal = (int)Max(pdblRealData[0], 0);
+    }
+    else if (iType == sci_ints)
+    {
+        int iComplex   = iIsComplex(_iVarNum);
+        int iYType             = 4;
+        int iXInc              = 1;
+        int iYInc              = 1;
+
+        GetRhsVar(_iVarNum, MATRIX_OF_INTEGER_DATATYPE, &iRows, &iCols, &iRealData);
+        if (iRows * iCols != 1)
+        {
+            SciError(89);
+            return _iNum;
+        }
+        iRows = 1;
+        piRealData = istk(iRealData);
+        C2F(tpconv)(&iComplex, &iYType, &iRows, piRealData, &iXInc, _piVal, &iYInc);
+        *_piVal = Max(*_piVal, 0);
+    }
+    else
+    {
+        SciError(89);
+        return _iNum;
+    }
+    return 0;
 }
 
 void CreateBooleanVarFromPtr(int _iNewVal, int _iRows, int _iCols, int* _piBoolData)
 {
-       int iIndex                      = 0;
-       int iAddrBase           = iadr(*Lstk(Top - Rhs + _iNewVal));
-       int iAddrRealData       = 0;
+    int iIndex                 = 0;
+    int iAddrBase              = iadr(*Lstk(Top - Rhs + _iNewVal));
+    int iAddrRealData  = 0;
 
-       *istk(iAddrBase)        = sci_boolean;
-       *istk(iAddrBase + 1)= _iRows;
-       *istk(iAddrBase + 2)= _iCols;
-       iAddrRealData           = iAddrBase + 3;
+    *istk(iAddrBase)   = sci_boolean;
+    *istk(iAddrBase + 1) = _iRows;
+    *istk(iAddrBase + 2) = _iCols;
+    iAddrRealData              = iAddrBase + 3;
 
-       for(iIndex = 0 ; iIndex < _iRows*_iCols ; iIndex++)
-               *istk(iAddrRealData + iIndex) = _piBoolData[iIndex];
+    for (iIndex = 0 ; iIndex < _iRows * _iCols ; iIndex++)
+    {
+        *istk(iAddrRealData + iIndex) = _piBoolData[iIndex];
+    }
 
-       C2F(intersci).ntypes[Top - Rhs + _iNewVal - 1]  = '$';
-       C2F(intersci).iwhere[Top - Rhs + _iNewVal - 1]  = *Lstk(_iNewVal);
-       C2F(intersci).lad[Top - Rhs + _iNewVal - 1]             = sadr(iAddrRealData);
+    C2F(intersci).ntypes[Top - Rhs + _iNewVal - 1]     = '$';
+    C2F(intersci).iwhere[Top - Rhs + _iNewVal - 1]     = *Lstk(_iNewVal);
+    C2F(intersci).lad[Top - Rhs + _iNewVal - 1]                = sadr(iAddrRealData);
 }
 
 void CheckVarUsed(int _iVarNum)
 {
-       int iType = GetType(_iVarNum);
-       int iVar = Top - Rhs + _iVarNum;
-
-       int iAddress = iadr(*Lstk(iVar));
-       if (*istk(iAddress ) < 0)
-               iAddress = iadr(*istk(iAddress +1));
-
-
-       switch(iType)
-       {
-       case sci_matrix :
-               iAddress += 4;
-               break;
-       case sci_poly :
-               iAddress += 9 + (*istk(iAddress + 1) * *istk(iAddress + 2));
-               break;
-       case sci_boolean :
-               iAddress += 3;
-               break;
-       case sci_sparse :
-               iAddress += 5 + *istk(iAddress + 1) + *istk(iAddress + 4);
-               break;
-       case sci_ints :
-               iAddress += 4;
-               break;
-       case sci_strings :
-               iAddress += 4;
-       default:
-               break;
-       }
-//     C2F(intersci).iwhere[_iNewVal - 1]      = *Lstk(iNewPos);
-
-       C2F(intersci).ntypes[_iVarNum - 1] = '$' ;
-       C2F(intersci).iwhere[_iVarNum - 1] = *Lstk(iVar);
-       C2F(intersci).lad[_iVarNum - 1] = sadr(iAddress);
+    int iType = GetType(_iVarNum);
+    int iVar = Top - Rhs + _iVarNum;
+
+    int iAddress = iadr(*Lstk(iVar));
+    if (*istk(iAddress ) < 0)
+    {
+        iAddress = iadr(*istk(iAddress + 1));
+    }
+
+
+    switch (iType)
+    {
+        case sci_matrix :
+            iAddress += 4;
+            break;
+        case sci_poly :
+            iAddress += 9 + (*istk(iAddress + 1) * *istk(iAddress + 2));
+            break;
+        case sci_boolean :
+            iAddress += 3;
+            break;
+        case sci_sparse :
+            iAddress += 5 + *istk(iAddress + 1) + *istk(iAddress + 4);
+            break;
+        case sci_ints :
+            iAddress += 4;
+            break;
+        case sci_strings :
+            iAddress += 4;
+        default:
+            break;
+    }
+    // C2F(intersci).iwhere[_iNewVal - 1]      = *Lstk(iNewPos);
+
+    C2F(intersci).ntypes[_iVarNum - 1] = '$' ;
+    C2F(intersci).iwhere[_iVarNum - 1] = *Lstk(iVar);
+    C2F(intersci).lad[_iVarNum - 1] = sadr(iAddress);
 
 }
 
 void CheckAllVarUsed(int _iStart, int _iEnd)
 {
-       int iIndex = 0;
-       int iEnd = _iEnd;
-       int iStart = _iStart;
-       if(iEnd == -1)
-               iEnd = Rhs;
-       if(iStart == -1)
-               iStart = 1;
+    int iIndex = 0;
+    int iEnd = _iEnd;
+    int iStart = _iStart;
+    if (iEnd == -1)
+    {
+        iEnd = Rhs;
+    }
+    if (iStart == -1)
+    {
+        iStart = 1;
+    }
 
-       for(iIndex = iStart ; iIndex <= iEnd ; iIndex++)
-               CheckVarUsed(iIndex);
+    for (iIndex = iStart ; iIndex <= iEnd ; iIndex++)
+    {
+        CheckVarUsed(iIndex);
+    }
 }
 
 
 void GetVarDimension(int _iVarNum, int* _piRows, int* _piCols)
 {
-       int iVar = Top - Rhs + _iVarNum;
+    int iVar = Top - Rhs + _iVarNum;
 
-       int iAddress = iadr(*Lstk(iVar));
-       if (*istk(iAddress ) < 0)
-               iAddress = iadr(*istk(iAddress +1));
+    int iAddress = iadr(*Lstk(iVar));
+    if (*istk(iAddress ) < 0)
+    {
+        iAddress = iadr(*istk(iAddress + 1));
+    }
 
-       *_piRows = *istk(iAddress + 1);
-       *_piCols = *istk(iAddress + 2);
+    *_piRows = *istk(iAddress + 1);
+    *_piCols = *istk(iAddress + 2);
 }
 
 int iGetOrient(int _iVal)
 {
-       int iMode                       = 0;
-       int iRows                       = 0;
-       int iCols                       = 0;
-       int iRealData           = 0;
-       char **szRealData       = 0;
-
-       if(GetType(2) == sci_matrix)
-       {
-               GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &iRows, &iCols, &iRealData);
-               iMode = (int)stk(iRealData)[0];
-       }
-       else if(GetType(2) == sci_strings)
-       {
-               GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &iRows, &iCols, &szRealData);
-               iMode = (int)*szRealData[0];
-               freeArrayOfString(szRealData, iRows * iCols);
-       }
-       else
-       {
-               SciError(44);
-               return -2;
-       }
-
-       if(iRows != 1 || iCols != 1)
-       {
-               SciError(89);
-               return -2;
-       }
-
-       if(iMode == ROW_LETTER || iMode == BY_ROWS)
-               iMode = BY_ROWS;
-       else if(iMode == COL_LETTER || iMode == BY_COLS)
-               iMode = BY_COLS;
-       else if(iMode == STAR_LETTER || iMode == BY_ALL)
-               iMode = BY_ALL;
-       else if(iMode == MTLB_LETTER || iMode == BY_MTLB)
-       {//J'ai pas tout compris dans le fonctionnement pour MtLb
-               iMode = BY_ALL;
-               if(iRows > 1)
-                       iMode = BY_ROWS;
-               else if(iCols > 1)
-                       iMode = BY_COLS;
-       }
-       else
-       {
-               SciError(44);
-               return -2;
-       }
-       return iMode;
+    int iMode                  = 0;
+    int iRows                  = 0;
+    int iCols                  = 0;
+    int iRealData              = 0;
+    char **szRealData  = 0;
+
+    if (GetType(2) == sci_matrix)
+    {
+        GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &iRows, &iCols, &iRealData);
+        iMode = (int)stk(iRealData)[0];
+    }
+    else if (GetType(2) == sci_strings)
+    {
+        GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &iRows, &iCols, &szRealData);
+        iMode = (int) * szRealData[0];
+        freeArrayOfString(szRealData, iRows * iCols);
+    }
+    else
+    {
+        SciError(44);
+        return -2;
+    }
+
+    if (iRows != 1 || iCols != 1)
+    {
+        SciError(89);
+        return -2;
+    }
+
+    if (iMode == ROW_LETTER || iMode == BY_ROWS)
+    {
+        iMode = BY_ROWS;
+    }
+    else if (iMode == COL_LETTER || iMode == BY_COLS)
+    {
+        iMode = BY_COLS;
+    }
+    else if (iMode == STAR_LETTER || iMode == BY_ALL)
+    {
+        iMode = BY_ALL;
+    }
+    else if (iMode == MTLB_LETTER || iMode == BY_MTLB)
+    {
+        //J'ai pas tout compris dans le fonctionnement pour MtLb
+        iMode = BY_ALL;
+        if (iRows > 1)
+        {
+            iMode = BY_ROWS;
+        }
+        else if (iCols > 1)
+        {
+            iMode = BY_COLS;
+        }
+    }
+    else
+    {
+        SciError(44);
+        return -2;
+    }
+    return iMode;
 }
 
 /*
@@ -1286,42 +1434,46 @@ Note
 */
 int    _iAllocMatrixDoubleOrComplex(int _iPos, int _iComplex, int _iRows, int _iCols, double **_pdblRealData, double **_pdblImgData)
 {
-       int iNewPos                     = Top - Rhs + _iPos;
-       int iSize                       = _iRows * _iCols * (_iComplex + 1);
-       int iAddr                       = iadr(*Lstk(iNewPos));
-       int iAddrData           = iAddr + 4;
+    int iNewPos                        = Top - Rhs + _iPos;
+    int iSize                  = _iRows * _iCols * (_iComplex + 1);
+    int iAddr                  = iadr(*Lstk(iNewPos));
+    int iAddrData              = iAddr + 4;
 
-       Err                                     = sadr(iAddr + 4) - *Lstk(Bot);
+    Err                                        = sadr(iAddr + 4) - *Lstk(Bot);
 
-       if(Err > -iSize)
-               return 17;
+    if (Err > -iSize)
+    {
+        return 17;
+    }
 
-       iAllocComplexMatrixOfDoubleToAddress(istk(iAddr), _iComplex, _iRows, _iCols, _pdblRealData, _pdblImgData);
+    iAllocComplexMatrixOfDoubleToAddress(istk(iAddr), _iComplex, _iRows, _iCols, _pdblRealData, _pdblImgData);
 
-       intersci_.ntypes[_iPos - 1]     = '$';
-       intersci_.iwhere[_iPos - 1]     = *Lstk(iNewPos);
-       intersci_.lad[_iPos - 1]        = sadr(iAddrData);
+    intersci_.ntypes[_iPos - 1]        = '$';
+    intersci_.iwhere[_iPos - 1]        = *Lstk(iNewPos);
+    intersci_.lad[_iPos - 1]   = sadr(iAddrData);
 
-       *Lstk(iNewPos + 1) = sadr(iAddrData) + _iRows * _iCols * (_iComplex + 1);
-       return 0;
+    *Lstk(iNewPos + 1) = sadr(iAddrData) + _iRows * _iCols * (_iComplex + 1);
+    return 0;
 }
 
 /*for internal use, assign values in variable without, VarNum, just scilab address*/
 int    iAllocComplexMatrixOfDoubleToAddress(int* _piAddr, int _iComplex, int _iRows, int _iCols, double **_pdblRealData, double **_pdblImgData)
 {
-//     int iAddrData           = _iAddr + 4;
+    // int iAddrData           = _iAddr + 4;
 
-       _piAddr[0]                      = sci_matrix;
-       _piAddr[1]                      = Min(_iRows, _iRows * _iCols);
-       _piAddr[2]                      = Min(_iCols, _iRows * _iCols);
-       _piAddr[3]                      = _iComplex;
+    _piAddr[0]                 = sci_matrix;
+    _piAddr[1]                 = Min(_iRows, _iRows * _iCols);
+    _piAddr[2]                 = Min(_iCols, _iRows * _iCols);
+    _piAddr[3]                 = _iComplex;
 
 
-       *_pdblRealData          = (double*)(_piAddr + 4);
-       if(_iComplex != 0)
-               *_pdblImgData   = *_pdblRealData + _iRows * _iCols;
+    *_pdblRealData             = (double*)(_piAddr + 4);
+    if (_iComplex != 0)
+    {
+        *_pdblImgData  = *_pdblRealData + _iRows * _iCols;
+    }
 
-       return 0;
+    return 0;
 }
 
 /*
@@ -1335,10 +1487,12 @@ Arguments
 */
 int iAllocMatrixOfDouble(int _iPos, int _iRows, int _iCols, double **_pdblRealData)
 {
-       if(_iPos + 1 > Bot) 
-               return 10;//Too many names
+    if (_iPos + 1 > Bot)
+    {
+        return 10;    //Too many names
+    }
 
-       return _iAllocMatrixDoubleOrComplex(_iPos, 0, _iRows, _iCols, _pdblRealData, NULL);
+    return _iAllocMatrixDoubleOrComplex(_iPos, 0, _iRows, _iCols, _pdblRealData, NULL);
 }
 
 /*
@@ -1353,673 +1507,733 @@ Arguments
 */
 int    iAllocComplexMatrixOfDouble(int _iPos, int _iRows, int _iCols, double **_pdblRealData, double **_pdblImgData)
 {
-       return _iAllocMatrixDoubleOrComplex(_iPos, 1, _iRows,  _iCols, _pdblRealData, _pdblImgData);
+    return _iAllocMatrixDoubleOrComplex(_iPos, 1, _iRows,  _iCols, _pdblRealData, _pdblImgData);
 }
 
 /*Reserve space in stack for a matrix of polynom*/
 int iAllocMatrixOfPoly(int _iNewVal, int** _piVarName, int _iRows, int _iCols, int *_piPow, double** _pdblRealData)
 {
-       return iAllocComplexMatrixOfPoly(_iNewVal, 0, _piVarName, _iRows, _iCols, _piPow, _pdblRealData, NULL);
+    return iAllocComplexMatrixOfPoly(_iNewVal, 0, _piVarName, _iRows, _iCols, _piPow, _pdblRealData, NULL);
 }
 
 /*Reserve space in stack for a matrix of complex polynom*/
 int iAllocComplexMatrixOfPoly(int _iNewVal, int _iComplex, int** _piVarName, int _iRows, int _iCols, int *_piPow, double** _pdblRealData, double** _pdblImgData)
 {
-       int iNewPos                     = Top - Rhs + _iNewVal;
-       //int iNewPos                   = Top + _iNewVal;
-       int iAddrBase           = iadr(*Lstk(iNewPos));
-       int iAddrData           = 0;
+    int iNewPos                        = Top - Rhs + _iNewVal;
+    //int iNewPos                      = Top + _iNewVal;
+    int iAddrBase              = iadr(*Lstk(iNewPos));
+    int iAddrData              = 0;
 
-       iAllocComplexMatrixOfPolyToAddress(iAddrBase, _iComplex, _piVarName, _iRows, _iCols, _piPow, _pdblRealData, _pdblImgData);
-       iAddrData = iAddrBase + (9 + _iRows * _iCols);
+    iAllocComplexMatrixOfPolyToAddress(iAddrBase, _iComplex, _piVarName, _iRows, _iCols, _piPow, _pdblRealData, _pdblImgData);
+    iAddrData = iAddrBase + (9 + _iRows * _iCols);
 
-       C2F(intersci).ntypes[_iNewVal - 1]      = '$';
-       C2F(intersci).iwhere[_iNewVal - 1]      = *Lstk(iNewPos);
-       C2F(intersci).lad[_iNewVal - 1]         = sadr(iAddrData);
+    C2F(intersci).ntypes[_iNewVal - 1] = '$';
+    C2F(intersci).iwhere[_iNewVal - 1] = *Lstk(iNewPos);
+    C2F(intersci).lad[_iNewVal - 1]            = sadr(iAddrData);
 
-       *Lstk(iNewPos + 1) = sadr(iAddrData) + iArraySum(_piPow, 0, _iRows * _iCols) * (_iComplex + 1) * 2;
-       return 0;
+    *Lstk(iNewPos + 1) = sadr(iAddrData) + iArraySum(_piPow, 0, _iRows * _iCols) * (_iComplex + 1) * 2;
+    return 0;
 }
 
 
 /*for internal use, assign values in variable without, VarNum, just scilab address*/
 int iAllocComplexMatrixOfPolyToAddress(int _iAddr, int _iComplex, int** _piVarName, int _iRows, int _iCols, int *_piPow, double** _pdblRealData, double** _pdblImgData)
 {
-       int iAddrBase           = _iAddr;
-       int iAddrPtr            = 0;
-       int iAddrData           = 0;
-       int iIndex                      = 0;
+    int iAddrBase              = _iAddr;
+    int iAddrPtr               = 0;
+    int iAddrData              = 0;
+    int iIndex                 = 0;
 
-       *istk(iAddrBase)        = sci_poly;
-       *istk(iAddrBase + 1)= _iRows;
-       *istk(iAddrBase + 2)= _iCols;
-       *istk(iAddrBase + 3)= _iComplex;
-       memcpy(istk(iAddrBase + 4), *_piVarName, 4 * sizeof(int)); // name of variable ( scilab format )
+    *istk(iAddrBase)   = sci_poly;
+    *istk(iAddrBase + 1) = _iRows;
+    *istk(iAddrBase + 2) = _iCols;
+    *istk(iAddrBase + 3) = _iComplex;
+    memcpy(istk(iAddrBase + 4), *_piVarName, 4 * sizeof(int)); // name of variable ( scilab format )
 
-       iAddrPtr = iAddrBase + 8;
-       *istk(iAddrPtr) = 1;
-       iAddrPtr++;
+    iAddrPtr = iAddrBase + 8;
+    *istk(iAddrPtr) = 1;
+    iAddrPtr++;
 
-       for(iIndex = 0 ; iIndex < _iRows * _iCols ; iIndex++)
-       {
-               *istk(iAddrPtr + iIndex) = _piPow[iIndex] + *istk(iAddrPtr -1 + iIndex);
-       }
-       iAddrData = iAddrBase + (9 + _iRows * _iCols);
+    for (iIndex = 0 ; iIndex < _iRows * _iCols ; iIndex++)
+    {
+        *istk(iAddrPtr + iIndex) = _piPow[iIndex] + *istk(iAddrPtr - 1 + iIndex);
+    }
+    iAddrData = iAddrBase + (9 + _iRows * _iCols);
 
 
-       *_pdblRealData = stk(sadr(iAddrData));
-       if(_iComplex != 0)
-               *_pdblImgData = stk(sadr(iAddrData) + iArraySum(_piPow, 0, _iRows * _iCols));
+    *_pdblRealData = stk(sadr(iAddrData));
+    if (_iComplex != 0)
+    {
+        *_pdblImgData = stk(sadr(iAddrData) + iArraySum(_piPow, 0, _iRows * _iCols));
+    }
 
-       return 0;
+    return 0;
 }
 
 /*Reserve space in stack for a matrix of string*/
 int iAllocMatrixOfString(int _iNewVal, int _iRows, int _iCols, int *_piLen, char** _piStringData)
 {
-       int iNewPos                     = Top - Rhs + _iNewVal;
-       //int iNewPos                   = Top + _iNewVal;
-       int iAddrBase           = iadr(*Lstk(iNewPos));
-       int iAddrData           = 0;
+    int iNewPos                        = Top - Rhs + _iNewVal;
+    //int iNewPos                      = Top + _iNewVal;
+    int iAddrBase              = iadr(*Lstk(iNewPos));
+    int iAddrData              = 0;
 
-       iAllocMatrixOfStringToAddress(iAddrBase, _iRows, _iCols, _piLen, _piStringData);
-       iAddrData = iAddrBase + (5 + _iRows * _iCols);
+    iAllocMatrixOfStringToAddress(iAddrBase, _iRows, _iCols, _piLen, _piStringData);
+    iAddrData = iAddrBase + (5 + _iRows * _iCols);
 
-       *_piStringData = cstk(sadr(iAddrData));
+    *_piStringData = cstk(sadr(iAddrData));
 
-       C2F(intersci).ntypes[_iNewVal - 1]      = '$';
-       C2F(intersci).iwhere[_iNewVal - 1]      = *Lstk(iNewPos);
-       C2F(intersci).lad[_iNewVal - 1]         = sadr(iAddrData);
+    C2F(intersci).ntypes[_iNewVal - 1] = '$';
+    C2F(intersci).iwhere[_iNewVal - 1] = *Lstk(iNewPos);
+    C2F(intersci).lad[_iNewVal - 1]            = sadr(iAddrData);
 
-       *Lstk(iNewPos + 1) = sadr(iAddrData) + iArraySum(_piLen, 0, _iRows * _iCols);
-       return 0;
+    *Lstk(iNewPos + 1) = sadr(iAddrData) + iArraySum(_piLen, 0, _iRows * _iCols);
+    return 0;
 }
 
 int iAllocMatrixOfStringToAddress(int _iAddr, int _iRows, int _iCols, int *_piLen, char **_piStringData)
 {
-       int iAddrPtr    = 0;
-       int iIndex              = 0;
-       *istk(_iAddr)   = sci_strings;
-       *istk(_iAddr + 1)= _iRows;
-       *istk(_iAddr + 2)= _iCols;
-       *istk(_iAddr + 3)= 0; // Non complex values
-
-       iAddrPtr = _iAddr + 4;
-       *istk(iAddrPtr) = 1;
-       iAddrPtr++;
-       for(iIndex = 0 ; iIndex < _iRows * _iCols ; iIndex++)
-       {
-               *istk(iAddrPtr + iIndex) = _piLen[iIndex] + *istk(iAddrPtr -1 + iIndex);
-       }
-       return 0;
+    int iAddrPtr       = 0;
+    int iIndex         = 0;
+    *istk(_iAddr)      = sci_strings;
+    *istk(_iAddr + 1) = _iRows;
+    *istk(_iAddr + 2) = _iCols;
+    *istk(_iAddr + 3) = 0; // Non complex values
+
+    iAddrPtr = _iAddr + 4;
+    *istk(iAddrPtr) = 1;
+    iAddrPtr++;
+    for (iIndex = 0 ; iIndex < _iRows * _iCols ; iIndex++)
+    {
+        *istk(iAddrPtr + iIndex) = _piLen[iIndex] + *istk(iAddrPtr - 1 + iIndex);
+    }
+    return 0;
 }
 
 /*Reserve space in stack for a sparse matrix*/
 int iAllocSparseMatrix(int _iNewVal, int _iRows, int _iCols, int _iTotalElem, int** _piElemByRow, int** _piColByRow, double** _pdblRealData)
 {
-       return iAllocComplexSparseMatrix(_iNewVal, 0, _iRows, _iCols, _iTotalElem, _piElemByRow, _piColByRow, _pdblRealData, NULL);
+    return iAllocComplexSparseMatrix(_iNewVal, 0, _iRows, _iCols, _iTotalElem, _piElemByRow, _piColByRow, _pdblRealData, NULL);
 }
 
 /*Reserve space in stack for a complex sparse matrix*/
-int iAllocComplexSparseMatrix(int _iNewVal,int _iComplex, int _iRows, int _iCols, int _iTotalElem, int** _piElemByRow, int** _piColByRow, double** _pdblRealData, double** _pdblImgData)
+int iAllocComplexSparseMatrix(int _iNewVal, int _iComplex, int _iRows, int _iCols, int _iTotalElem, int** _piElemByRow, int** _piColByRow, double** _pdblRealData, double** _pdblImgData)
 {
-       int iNewPos                     = Top - Rhs + _iNewVal;
-       //int iNewPos                   = Top + _iNewVal;
-       int iAddrBase           = iadr(*Lstk(iNewPos));
-       int iAddElemByRow       = 0;
-       int iAddrColByRow       = 0;
-       int iAddrRealData       = 0;
-       int iAddrImgData        = 0;
+    int iNewPos                        = Top - Rhs + _iNewVal;
+    //int iNewPos                      = Top + _iNewVal;
+    int iAddrBase              = iadr(*Lstk(iNewPos));
+    int iAddElemByRow  = 0;
+    int iAddrColByRow  = 0;
+    int iAddrRealData  = 0;
+    int iAddrImgData   = 0;
 
-       *istk(iAddrBase)        = sci_sparse;
-       *istk(iAddrBase + 1)= _iRows;
-       *istk(iAddrBase + 2)= _iCols;
-       *istk(iAddrBase + 3)= _iComplex;
-       *istk(iAddrBase + 4)= _iTotalElem;
+    *istk(iAddrBase)   = sci_sparse;
+    *istk(iAddrBase + 1) = _iRows;
+    *istk(iAddrBase + 2) = _iCols;
+    *istk(iAddrBase + 3) = _iComplex;
+    *istk(iAddrBase + 4) = _iTotalElem;
 
-       iAddElemByRow           = iAddrBase + 5;
-       iAddrColByRow           = iAddElemByRow + _iRows;
-       iAddrRealData           = iAddrColByRow + _iTotalElem;
-       iAddrImgData            = iAddrColByRow + 2 * _iTotalElem;
+    iAddElemByRow              = iAddrBase + 5;
+    iAddrColByRow              = iAddElemByRow + _iRows;
+    iAddrRealData              = iAddrColByRow + _iTotalElem;
+    iAddrImgData               = iAddrColByRow + 2 * _iTotalElem;
 
 
-       *_piElemByRow = istk(iAddElemByRow);
-       *_piColByRow = istk(iAddrColByRow);
-       *_pdblRealData = stk(sadr(iAddrRealData));
+    *_piElemByRow = istk(iAddElemByRow);
+    *_piColByRow = istk(iAddrColByRow);
+    *_pdblRealData = stk(sadr(iAddrRealData));
 
-       if(_iComplex != 0)
-               *_pdblImgData = stk(sadr(iAddrImgData));
+    if (_iComplex != 0)
+    {
+        *_pdblImgData = stk(sadr(iAddrImgData));
+    }
 
-       C2F(intersci).ntypes[_iNewVal - 1]      = '$';
-       C2F(intersci).iwhere[_iNewVal - 1]      = *Lstk(iNewPos);
-       C2F(intersci).lad[_iNewVal - 1]         = sadr(iAddrRealData);
+    C2F(intersci).ntypes[_iNewVal - 1] = '$';
+    C2F(intersci).iwhere[_iNewVal - 1] = *Lstk(iNewPos);
+    C2F(intersci).lad[_iNewVal - 1]            = sadr(iAddrRealData);
 
-       if(_iComplex == 0)
-               *Lstk(iNewPos + 1) = sadr(iAddrRealData) + _iTotalElem;
-       else
-               *Lstk(iNewPos + 1) = sadr(iAddrRealData) + 2 * _iTotalElem;
+    if (_iComplex == 0)
+    {
+        *Lstk(iNewPos + 1) = sadr(iAddrRealData) + _iTotalElem;
+    }
+    else
+    {
+        *Lstk(iNewPos + 1) = sadr(iAddrRealData) + 2 * _iTotalElem;
+    }
 
-       return 0;
+    return 0;
 
 }
 
 /*Reserve space in stack for a matrix of boolean value*/
 int iAllocMatrixOfBoolean(int _iNewVal, int _iRows, int _iCols, int** _piBoolData)
 {
-       int iNewPos                     = Top - Rhs + _iNewVal;
-       //int iNewPos                   = Top + _iNewVal;
-       int iAddrBase           = iadr(*Lstk(iNewPos));
-       int iAddrRealData       = 0;
+    int iNewPos                        = Top - Rhs + _iNewVal;
+    //int iNewPos                      = Top + _iNewVal;
+    int iAddrBase              = iadr(*Lstk(iNewPos));
+    int iAddrRealData  = 0;
 
-       *istk(iAddrBase)        = sci_boolean;
-       *istk(iAddrBase + 1)= _iRows;
-       *istk(iAddrBase + 2)= _iCols;
-       iAddrRealData           = iAddrBase + 3;
+    *istk(iAddrBase)   = sci_boolean;
+    *istk(iAddrBase + 1) = _iRows;
+    *istk(iAddrBase + 2) = _iCols;
+    iAddrRealData              = iAddrBase + 3;
 
-       *_piBoolData = istk(iAddrRealData);
+    *_piBoolData = istk(iAddrRealData);
 
-       C2F(intersci).ntypes[_iNewVal - 1]      = '$';
-       C2F(intersci).iwhere[_iNewVal - 1]      = *Lstk(iNewPos);
-       C2F(intersci).lad[_iNewVal - 1]         = sadr(iAddrRealData);
+    C2F(intersci).ntypes[_iNewVal - 1] = '$';
+    C2F(intersci).iwhere[_iNewVal - 1] = *Lstk(iNewPos);
+    C2F(intersci).lad[_iNewVal - 1]            = sadr(iAddrRealData);
 
-       *Lstk(iNewPos + 1) = sadr(iAddrBase + _iRows * _iCols + 2);
-       return 0;
+    *Lstk(iNewPos + 1) = sadr(iAddrBase + _iRows * _iCols + 2);
+    return 0;
 }
 
 
 /*Reserve space in stack for a boolean sparse matrix*/
 int iAllocBooleanSparseMatrix(int _iNewVal, int _iRows, int _iCols, int _iTotalElem, int** _piElemByRow, int** _piColByRow)
 {
-       int iNewPos                     = Top - Rhs + _iNewVal;
-       //int iNewPos                   = Top + _iNewVal;
-       int iAddrBase           = iadr(*Lstk(iNewPos));
-       int iAddElemByRow       = 0;
-       int iAddrColByRow       = 0;
-       int iAddrRealData       = 0;
+    int iNewPos                        = Top - Rhs + _iNewVal;
+    //int iNewPos                      = Top + _iNewVal;
+    int iAddrBase              = iadr(*Lstk(iNewPos));
+    int iAddElemByRow  = 0;
+    int iAddrColByRow  = 0;
+    int iAddrRealData  = 0;
 
-       *istk(iAddrBase)        = sci_boolean_sparse;
-       *istk(iAddrBase + 1)= _iRows;
-       *istk(iAddrBase + 2)= _iCols;
-       *istk(iAddrBase + 3)= 0; // Non complex values
-       *istk(iAddrBase + 4)= _iTotalElem;
+    *istk(iAddrBase)   = sci_boolean_sparse;
+    *istk(iAddrBase + 1) = _iRows;
+    *istk(iAddrBase + 2) = _iCols;
+    *istk(iAddrBase + 3) = 0; // Non complex values
+    *istk(iAddrBase + 4) = _iTotalElem;
 
-       iAddElemByRow           = iAddrBase + 5;
-       iAddrColByRow           = iAddElemByRow + _iRows;
-       iAddrRealData           = iAddrColByRow + _iTotalElem;
+    iAddElemByRow              = iAddrBase + 5;
+    iAddrColByRow              = iAddElemByRow + _iRows;
+    iAddrRealData              = iAddrColByRow + _iTotalElem;
 
-       *_piElemByRow = istk(iAddElemByRow);
-       *_piColByRow = istk(iAddrColByRow);
+    *_piElemByRow = istk(iAddElemByRow);
+    *_piColByRow = istk(iAddrColByRow);
 
-       C2F(intersci).ntypes[_iNewVal - 1]      = '$';
-       C2F(intersci).iwhere[_iNewVal - 1]      = *Lstk(iNewPos);
-       C2F(intersci).lad[_iNewVal - 1]         = sadr(iAddrRealData);
+    C2F(intersci).ntypes[_iNewVal - 1] = '$';
+    C2F(intersci).iwhere[_iNewVal - 1] = *Lstk(iNewPos);
+    C2F(intersci).lad[_iNewVal - 1]            = sadr(iAddrRealData);
 
-       *Lstk(iNewPos + 1) = sadr(iAddrRealData);
-       return 0;
+    *Lstk(iNewPos + 1) = sadr(iAddrRealData);
+    return 0;
 }
 
 int iGetListItemType(int _iVar, int* _piParentList, int *_piItemNumber, int *_pElemType)
 {
-       int *piBase                     = NULL;
-       int *piOffset           = NULL;
-       int *piItem                     = NULL;
-       int iIndex                      = 0;
-
-       if(_piParentList == NULL)
-       {
-               int iAddrBase   =       iadr(*Lstk(Top - Rhs + _iVar));
-               int iValType    = *istk(iAddrBase);
-
-               if(iValType < 0)
-               {
-                       iAddrBase               =       iadr(*istk(iAddrBase + 1));
-               }
-
-               piBase                          = istk(iAddrBase);
-               piOffset                        = piBase + 2;
-       }
-       else
-       {
-               if(IsKindOfList(_piParentList))
-               {
-                       piBase                  = _piParentList;
-                       piOffset                = _piParentList + 2;
-               }
-               else
-               {
-                       return 0;
-               }
-       }
-
-       *_piItemNumber          = piBase[1];
-
-       if(_pElemType == NULL)
-               return 0;
-
-       //Warning : variable starts at a even ( pair ) address, so if the size is odd, we add 1 to have a even address.
-       piItem          = piOffset + (1 + *_piItemNumber + !(*_piItemNumber % 2));
-       for(iIndex = 0 ; iIndex < *_piItemNumber ; iIndex++)
-       {
-               _pElemType[iIndex] = piItem[(piOffset[iIndex] - 1) * 2]; //-/+ 1
-       }
-       return 0;
+    int *piBase                        = NULL;
+    int *piOffset              = NULL;
+    int *piItem                        = NULL;
+    int iIndex                 = 0;
+
+    if (_piParentList == NULL)
+    {
+        int iAddrBase  =       iadr(*Lstk(Top - Rhs + _iVar));
+        int iValType   = *istk(iAddrBase);
+
+        if (iValType < 0)
+        {
+            iAddrBase          =       iadr(*istk(iAddrBase + 1));
+        }
+
+        piBase                         = istk(iAddrBase);
+        piOffset                       = piBase + 2;
+    }
+    else
+    {
+        if (IsKindOfList(_piParentList))
+        {
+            piBase                     = _piParentList;
+            piOffset           = _piParentList + 2;
+        }
+        else
+        {
+            return 0;
+        }
+    }
+
+    *_piItemNumber             = piBase[1];
+
+    if (_pElemType == NULL)
+    {
+        return 0;
+    }
+
+    //Warning : variable starts at a even ( pair ) address, so if the size is odd, we add 1 to have a even address.
+    piItem             = piOffset + (1 + *_piItemNumber + !(*_piItemNumber % 2));
+    for (iIndex = 0 ; iIndex < *_piItemNumber ; iIndex++)
+    {
+        _pElemType[iIndex] = piItem[(piOffset[iIndex] - 1) * 2]; //-/+ 1
+    }
+    return 0;
 }
 
 int* iGetAddressFromItemPos(int *_piParent, int _iItemPos)
 {
-       int iItemCount          = _piParent[1];
-       int *piOffset           = _piParent + 2;
+    int iItemCount             = _piParent[1];
+    int *piOffset              = _piParent + 2;
 
-       int *piAddrItem         = NULL;
+    int *piAddrItem            = NULL;
 
-       if(_iItemPos > iItemCount)
-               return 0;
+    if (_iItemPos > iItemCount)
+    {
+        return 0;
+    }
 
-       piAddrItem                      = piOffset + iItemCount + 1 + !(iItemCount % 2);
-       //iAddrItem                     = iAddrOffset + iItemCount + 1 + !(iItemCount % 2);
-/*
-       for(iIndex = 0 ; iIndex < _iItemNumber ; iIndex++)
-               iAddrItem       += (*istk(iAddrOffset + _iItemNumber) - *istk(iAddrOffset + _iItemNumber - 1)) * 2;
-*/
-//     iAddrItem       += (piOffset[_iItemPos - 1] - 1) * (sizeof(double) / sizeof(int));
-       piAddrItem      += (piOffset[_iItemPos] - 1) * (sizeof(double) / sizeof(int));
+    piAddrItem                 = piOffset + iItemCount + 1 + !(iItemCount % 2);
+    //iAddrItem                        = iAddrOffset + iItemCount + 1 + !(iItemCount % 2);
+    /*
+       for(iIndex = 0 ; iIndex < _iItemNumber ; iIndex++)
+               iAddrItem       += (*istk(iAddrOffset + _iItemNumber) - *istk(iAddrOffset + _iItemNumber - 1)) * 2;
+    */
+    // iAddrItem       += (piOffset[_iItemPos - 1] - 1) * (sizeof(double) / sizeof(int));
+    piAddrItem += (piOffset[_iItemPos] - 1) * (sizeof(double) / sizeof(int));
 
-       return piAddrItem;
+    return piAddrItem;
 }
 
 int iGetAddressFromItemNumber(int _iVar, int _iItemNumber)
 {
-       int     iItemCount              = 0;
-       int iAddrBase           = iadr(*Lstk(Top - Rhs + _iVar));
-       int iAddrOffset         = iAddrBase + 2;
-       int iAddrItem           = 0;
-       int *piOffset           = istk(iAddrOffset);
+    int        iItemCount              = 0;
+    int iAddrBase              = iadr(*Lstk(Top - Rhs + _iVar));
+    int iAddrOffset            = iAddrBase + 2;
+    int iAddrItem              = 0;
+    int *piOffset              = istk(iAddrOffset);
 
-       iItemCount                      = *istk(iAddrBase + 1);
-       if(_iItemNumber > iItemCount)
-               return 0;
+    iItemCount                 = *istk(iAddrBase + 1);
+    if (_iItemNumber > iItemCount)
+    {
+        return 0;
+    }
 
-       iAddrItem                       = iAddrOffset + iItemCount + 1 + !(iItemCount % 2);
-/*
-       for(iIndex = 0 ; iIndex < _iItemNumber ; iIndex++)
-               iAddrItem       += (*istk(iAddrOffset + _iItemNumber) - *istk(iAddrOffset + _iItemNumber - 1)) * 2;
-*/
-       iAddrItem       += (piOffset[_iItemNumber - 1] - 1) * (sizeof(double) / sizeof(int));
+    iAddrItem                  = iAddrOffset + iItemCount + 1 + !(iItemCount % 2);
+    /*
+       for(iIndex = 0 ; iIndex < _iItemNumber ; iIndex++)
+               iAddrItem       += (*istk(iAddrOffset + _iItemNumber) - *istk(iAddrOffset + _iItemNumber - 1)) * 2;
+    */
+    iAddrItem  += (piOffset[_iItemNumber - 1] - 1) * (sizeof(double) / sizeof(int));
 
-       return iAddrItem;
+    return iAddrItem;
 }
 
 int* iGetListItemPointerFromItemNumber(int _iVar, int* _piParentList, int _iItemNumber)
 {
-       int *pItemAddr = _piParentList;
-       int iItemCount  = 0;
-       int *piOffset           = NULL;
-       int *piItem                     = NULL;
+    int *pItemAddr = _piParentList;
+    int iItemCount     = 0;
+    int *piOffset              = NULL;
+    int *piItem                        = NULL;
 
-       if(pItemAddr == NULL)
-       {//parent is the current list
-               int iAddrBase   =       iadr(*Lstk(Top - Rhs + _iVar));
-               int iValType    = *istk(iAddrBase);
+    if (pItemAddr == NULL)
+    {
+        //parent is the current list
+        int iAddrBase  =       iadr(*Lstk(Top - Rhs + _iVar));
+        int iValType   = *istk(iAddrBase);
 
-               if(iValType < 0)
-               {
-                       iAddrBase               =       iadr(*istk(iAddrBase + 1));
-               }
+        if (iValType < 0)
+        {
+            iAddrBase          =       iadr(*istk(iAddrBase + 1));
+        }
 
-               pItemAddr       = istk(iAddrBase);
-       }
+        pItemAddr      = istk(iAddrBase);
+    }
 
-       if(!IsKindOfList(pItemAddr))
-       {
-               return 0;
-       }
+    if (!IsKindOfList(pItemAddr))
+    {
+        return 0;
+    }
 
-       iItemCount      = pItemAddr[1];
-       piOffset                = pItemAddr + 2;
+    iItemCount = pItemAddr[1];
+    piOffset           = pItemAddr + 2;
 
-       if(_iItemNumber > iItemCount)
-               return 0;
+    if (_iItemNumber > iItemCount)
+    {
+        return 0;
+    }
 
-       piItem                  = piOffset + iItemCount + 1 + !(iItemCount % 2);
-/*
-       for(iIndex = 0 ; iIndex < _iItemNumber ; iIndex++)
-               iAddrItem       += (*istk(iAddrOffset + _iItemNumber) - *istk(iAddrOffset + _iItemNumber - 1)) * 2;
-*/
-       //_pElemType[iIndex] = piItem[(piOffset[iIndex] - 1) * 2]
-       //iAddrItem     += (piOffset[_iItemNumber - 1] - 1) * (sizeof(double) / sizeof(int));
-       piItem += (piOffset[_iItemNumber] - 1) * 2;
+    piItem                     = piOffset + iItemCount + 1 + !(iItemCount % 2);
+    /*
+       for(iIndex = 0 ; iIndex < _iItemNumber ; iIndex++)
+               iAddrItem       += (*istk(iAddrOffset + _iItemNumber) - *istk(iAddrOffset + _iItemNumber - 1)) * 2;
+    */
+    //_pElemType[iIndex] = piItem[(piOffset[iIndex] - 1) * 2]
+    //iAddrItem        += (piOffset[_iItemNumber - 1] - 1) * (sizeof(double) / sizeof(int));
+    piItem += (piOffset[_iItemNumber] - 1) * 2;
 
-       return piItem;
+    return piItem;
 }
 
 int iGetListItemDouble(int _iVar, int _iItemNumber, int *_piRows, int *_piCols, double **_pdblReal, double **_pdblImg)
 {
-       int iAddrItem           = 0;
-       int iReal                       = 0;
-       int iImg                        = 0;
+    int iAddrItem              = 0;
+    int iReal                  = 0;
+    int iImg                   = 0;
 
-       //iAddrItem is on the asked value
-       iAddrItem = iGetAddressFromItemNumber(_iVar, _iItemNumber);
-       if(iAddrItem != 0)
-               iGetDoubleFromAddress(iAddrItem, _piRows, _piCols, &iReal, &iImg);
+    //iAddrItem is on the asked value
+    iAddrItem = iGetAddressFromItemNumber(_iVar, _iItemNumber);
+    if (iAddrItem != 0)
+    {
+        iGetDoubleFromAddress(iAddrItem, _piRows, _piCols, &iReal, &iImg);
+    }
 
-       *_pdblReal              = stk(iReal);
-       if(_pdblImg != NULL && iImg != 0)
-               *_pdblImg       = stk(iImg);
-       return 0;
+    *_pdblReal         = stk(iReal);
+    if (_pdblImg != NULL && iImg != 0)
+    {
+        *_pdblImg      = stk(iImg);
+    }
+    return 0;
 }
 
 int iGetListItemPoly(int _iVar, int _iItemNumber, int **_piVarName, int *_piRows, int *_piCols, int *_piPow, double **_pdblReal, double **_pdblImg)
 {
-       int iReal               = 0;
-       int iImg                = 0;
-       int iAddrItem = iGetAddressFromItemNumber(_iVar, _iItemNumber);
+    int iReal          = 0;
+    int iImg           = 0;
+    int iAddrItem = iGetAddressFromItemNumber(_iVar, _iItemNumber);
 
-       if(iAddrItem != 0)
-               iGetPolyFromAddress(iAddrItem, _piVarName, _piRows, _piCols, _piPow, &iReal, &iImg);
+    if (iAddrItem != 0)
+    {
+        iGetPolyFromAddress(iAddrItem, _piVarName, _piRows, _piCols, _piPow, &iReal, &iImg);
+    }
 
-       if(iReal == 0)
-               return 0;
+    if (iReal == 0)
+    {
+        return 0;
+    }
 
-       *_pdblReal              = stk(iReal);
-       if(*_pdblImg != NULL && iImg != 0)
-               *_pdblImg       = stk(iImg);
-       return 0;
+    *_pdblReal         = stk(iReal);
+    if (*_pdblImg != NULL && iImg != 0)
+    {
+        *_pdblImg      = stk(iImg);
+    }
+    return 0;
 }
 
 int iGetListItemSparse(int _iVar, int _iItemNumber, int *_piRows, int *_piCols, int* _piTotalElem, int* _piElemByRow, double **_pdblReal, double **_pdblImg)
 {
-       return 0;
+    return 0;
 }
 
 int iGetListItemString(int _iVar, int _iItemNumber, int *_piRows, int *_piCols, int *_piLen, char* _pszData)
 {
-       int iAddrData   = 0;
-       int iAddrItem   = iGetAddressFromItemNumber(_iVar, _iItemNumber);
+    int iAddrData      = 0;
+    int iAddrItem      = iGetAddressFromItemNumber(_iVar, _iItemNumber);
 
-       iGetStringFromAddress(iAddrItem, _piRows, _piCols, _piLen, &iAddrData);
+    iGetStringFromAddress(iAddrItem, _piRows, _piCols, _piLen, &iAddrData);
 
-       if(iAddrData == 0 || _pszData == NULL)
-               return 0;
+    if (iAddrData == 0 || _pszData == NULL)
+    {
+        return 0;
+    }
 
-       code2str(&_pszData, (int*) cstk(iAddrData), iArraySum(_piLen, 0, *_piRows * *_piCols));
-       return 0;
+    code2str(&_pszData, (int*) cstk(iAddrData), iArraySum(_piLen, 0, *_piRows * *_piCols));
+    return 0;
 }
 
 //Get SubList reference
 int* iGetListItemList(int _iVar, int* _piParentList, int _iItemPos)
 {
-       int *piChild            = NULL;
+    int *piChild               = NULL;
 
 
-       if(_piParentList == NULL)
-       {//parent is the current list
-               int iAddrBase   =       iadr(*Lstk(Top - Rhs + _iVar));
-               int iValType    = *istk(iAddrBase);
+    if (_piParentList == NULL)
+    {
+        //parent is the current list
+        int iAddrBase  =       iadr(*Lstk(Top - Rhs + _iVar));
+        int iValType   = *istk(iAddrBase);
 
-               if(iValType < 0)
-               {
-                       iAddrBase               =       iadr(*istk(iAddrBase + 1));
-               }
+        if (iValType < 0)
+        {
+            iAddrBase          =       iadr(*istk(iAddrBase + 1));
+        }
 
-               _piParentList   = istk(iAddrBase);
-       }
+        _piParentList  = istk(iAddrBase);
+    }
 
-       if(!IsKindOfList(_piParentList))
-       {
-               return 0;
-       }
+    if (!IsKindOfList(_piParentList))
+    {
+        return 0;
+    }
 
-       if(_iItemPos == 0)
-       {
-               piChild = _piParentList;
-       }
-       else
-       {
-               piChild = iGetAddressFromItemPos(_piParentList, _iItemPos);
-       }
+    if (_iItemPos == 0)
+    {
+        piChild = _piParentList;
+    }
+    else
+    {
+        piChild = iGetAddressFromItemPos(_piParentList, _iItemPos);
+    }
 
-       if(!IsKindOfList(piChild))
-               return NULL;
-       return piChild;
+    if (!IsKindOfList(piChild))
+    {
+        return NULL;
+    }
+    return piChild;
 }
 
 //Get SubItem String
 int iGetListSubItemString(int _iVar, int* _piParentList, int _iItemNumber, int *_piRows, int *_piCols, int *_piLen, char* _pszData)
 {
-       int *piString = NULL;
-       int* piItemAdd = iGetListItemPointerFromItemNumber(_iVar, _piParentList, _iItemNumber);
+    int *piString = NULL;
+    int* piItemAdd = iGetListItemPointerFromItemNumber(_iVar, _piParentList, _iItemNumber);
 
-       if(piItemAdd == NULL)
-       {
-               return 1;
-       }
+    if (piItemAdd == NULL)
+    {
+        return 1;
+    }
 
-       iGetStringFromPointer(piItemAdd, _piRows, _piCols, _piLen, &piString);
+    iGetStringFromPointer(piItemAdd, _piRows, _piCols, _piLen, &piString);
 
-       if(_piLen == NULL || _pszData == NULL)
-       {
-               return 0;
-       }
+    if (_piLen == NULL || _pszData == NULL)
+    {
+        return 0;
+    }
 
-       code2str(&_pszData, piString, iArraySum(_piLen, 0, *_piRows * *_piCols));
-       {
-               return 0;
-       }
+    code2str(&_pszData, piString, iArraySum(_piLen, 0, *_piRows * *_piCols));
+    {
+        return 0;
+    }
 }
 
 
 //Internal fonctions to retrieve varaibles information from Address ( old "il" )
 int iGetDoubleFromAddress(int _iAddr, int *_piRows, int *_piCols, int *_piReal, int *_piImg)
 {
-       int iAddrOffset         = 0;
-       *_piRows                        = *istk(_iAddr + 1);
-       *_piCols                        = *istk(_iAddr + 2);
-       iAddrOffset                     = _iAddr + 4;//Stack header
+    int iAddrOffset            = 0;
+    *_piRows                   = *istk(_iAddr + 1);
+    *_piCols                   = *istk(_iAddr + 2);
+    iAddrOffset                        = _iAddr + 4;//Stack header
 
-       *_piReal        = sadr(iAddrOffset);
-       if(*istk(_iAddr + 3) == 1)//complex variable and allocated buffer
-               *_piImg         = sadr(iAddrOffset + *_piRows * *_piCols);
-       return 0;
+    *_piReal   = sadr(iAddrOffset);
+    if (*istk(_iAddr + 3) == 1) //complex variable and allocated buffer
+    {
+        *_piImg                = sadr(iAddrOffset + *_piRows * *_piCols);
+    }
+    return 0;
 }
 
 int iGetPolyFromAddress(int _iAddr, int** _piVarName, int* _piRows, int* _piCols, int* _piPow, int* _piReal, int *_piImg)
 {
-       int iIndex                      = 0;
-       int iAddrOffset         = 0;
-       *_piRows                        = *istk(_iAddr + 1);
-       *_piCols                        = *istk(_iAddr + 2);
-       *_piVarName                     = istk(_iAddr + 4);
-       iAddrOffset                     = _iAddr + 8; //4 Stack header + 4 variable name
+    int iIndex                 = 0;
+    int iAddrOffset            = 0;
+    *_piRows                   = *istk(_iAddr + 1);
+    *_piCols                   = *istk(_iAddr + 2);
+    *_piVarName                        = istk(_iAddr + 4);
+    iAddrOffset                        = _iAddr + 8; //4 Stack header + 4 variable name
 
 
-       if(_piPow == NULL)
-               return 0;
+    if (_piPow == NULL)
+    {
+        return 0;
+    }
 
-       /*Get all offest*/
-       for(iIndex = 0 ; iIndex < *_piRows * *_piCols; iIndex++)
-               _piPow[iIndex] = *istk(iAddrOffset + iIndex + 1) - *istk(iAddrOffset + iIndex );
+    /*Get all offest*/
+    for (iIndex = 0 ; iIndex < *_piRows * *_piCols; iIndex++)
+    {
+        _piPow[iIndex] = *istk(iAddrOffset + iIndex + 1) - *istk(iAddrOffset + iIndex );
+    }
 
-       *_piReal        = sadr(iAddrOffset + 1 + *_piRows * *_piCols);
-       if(_piImg != NULL && *istk(_iAddr + 3) == 1)//complex variable and allocated buffer
-               *_piImg         = sadr(iAddrOffset + 1 + *_piRows * *_piCols) + iArraySum(_piPow, 0, *_piRows * *_piCols);
-       return 0;
+    *_piReal   = sadr(iAddrOffset + 1 + *_piRows * *_piCols);
+    if (_piImg != NULL && *istk(_iAddr + 3) == 1) //complex variable and allocated buffer
+    {
+        *_piImg                = sadr(iAddrOffset + 1 + *_piRows * *_piCols) + iArraySum(_piPow, 0, *_piRows * *_piCols);
+    }
+    return 0;
 }
 
 int iGetSparseFromAddress(int _iAddr, int* _piRows, int* _piCols, int* _piTotalElem, int* _piElemByRow, int* _piColByRow, int* _piReal, int* _piImg)
 {
-       int iAddrColByRow       = 0;
-       int iAddElemByRow       = 0;
-       int iAddrRealData       = 0;
-       int iIndex                      = 0;
+    int iAddrColByRow  = 0;
+    int iAddElemByRow  = 0;
+    int iAddrRealData  = 0;
+    int iIndex                 = 0;
 
-       *_piRows                        = *istk(_iAddr + 1);
-       *_piCols                        = *istk(_iAddr + 2);
-       *_piTotalElem           = *istk(_iAddr + 4);
+    *_piRows                   = *istk(_iAddr + 1);
+    *_piCols                   = *istk(_iAddr + 2);
+    *_piTotalElem              = *istk(_iAddr + 4);
 
-       //if ptr are NULL, juste return the matrix size
-       if(_piElemByRow == NULL || _piColByRow == NULL)
-               return 0;
+    //if ptr are NULL, juste return the matrix size
+    if (_piElemByRow == NULL || _piColByRow == NULL)
+    {
+        return 0;
+    }
 
-       iAddElemByRow           = _iAddr + 5;
-       iAddrColByRow           = iAddElemByRow + *_piRows;
-       iAddrRealData           = iAddrColByRow + *_piTotalElem;
+    iAddElemByRow              = _iAddr + 5;
+    iAddrColByRow              = iAddElemByRow + *_piRows;
+    iAddrRealData              = iAddrColByRow + *_piTotalElem;
 
-       for(iIndex = 0 ; iIndex < *_piRows ; iIndex++)
-       {
-               _piElemByRow[iIndex] = *istk(iAddElemByRow + iIndex);
-       }
+    for (iIndex = 0 ; iIndex < *_piRows ; iIndex++)
+    {
+        _piElemByRow[iIndex] = *istk(iAddElemByRow + iIndex);
+    }
 
-       for(iIndex = 0 ; iIndex < *_piTotalElem ; iIndex++)
-       {
-               _piColByRow[iIndex] = *istk(iAddrColByRow + iIndex);
-       }
+    for (iIndex = 0 ; iIndex < *_piTotalElem ; iIndex++)
+    {
+        _piColByRow[iIndex] = *istk(iAddrColByRow + iIndex);
+    }
 
-       *_piReal = sadr(iAddrRealData);
-       if(_piImg != NULL && *istk(_iAddr + 3) == 1)
-               *_piImg  = sadr(iAddrRealData) + *_piTotalElem;
-       return 0;
+    *_piReal = sadr(iAddrRealData);
+    if (_piImg != NULL && *istk(_iAddr + 3) == 1)
+    {
+        *_piImg         = sadr(iAddrRealData) + *_piTotalElem;
+    }
+    return 0;
 }
 
 int iGetBooleanSparseFromAddress(int _iAddr, int* _piRows, int* _piCols, int* _piTotalElem, int* _piElemByRow, int* _piColByRow)
 {
-       int iAddrColByRow       = 0;
-       int iAddElemByRow       = 0;
-       int iIndex                      = 0;
-       *_piRows                        = *istk(_iAddr + 1);
-       *_piCols                        = *istk(_iAddr + 2);
-       *_piTotalElem           = *istk(_iAddr + 4);
+    int iAddrColByRow  = 0;
+    int iAddElemByRow  = 0;
+    int iIndex                 = 0;
+    *_piRows                   = *istk(_iAddr + 1);
+    *_piCols                   = *istk(_iAddr + 2);
+    *_piTotalElem              = *istk(_iAddr + 4);
 
-       //if ptr are NULL, juste return the matrix size
-       if(_piElemByRow == NULL || _piColByRow == NULL)
-               return 0;
+    //if ptr are NULL, juste return the matrix size
+    if (_piElemByRow == NULL || _piColByRow == NULL)
+    {
+        return 0;
+    }
 
-       iAddElemByRow           = _iAddr + 5;
-       iAddrColByRow           = iAddElemByRow + *_piRows;
+    iAddElemByRow              = _iAddr + 5;
+    iAddrColByRow              = iAddElemByRow + *_piRows;
 
-       for(iIndex = 0 ; iIndex < *_piRows ; iIndex++)
-               _piElemByRow[iIndex] = *istk(iAddElemByRow + iIndex);
+    for (iIndex = 0 ; iIndex < *_piRows ; iIndex++)
+    {
+        _piElemByRow[iIndex] = *istk(iAddElemByRow + iIndex);
+    }
 
-       for(iIndex = 0 ; iIndex < *_piTotalElem ; iIndex++)
-               _piColByRow[iIndex] = *istk(iAddrColByRow + iIndex);
-       return 0;
+    for (iIndex = 0 ; iIndex < *_piTotalElem ; iIndex++)
+    {
+        _piColByRow[iIndex] = *istk(iAddrColByRow + iIndex);
+    }
+    return 0;
 }
 
 int iGetBooleanFromAddress(int _iAddr, int *_piRows, int *_piCols, int* _piBool)
 {
-       return 0;
+    return 0;
 }
 
 int iGetStringFromAddress(int _iAddr, int *_piRows, int *_piCols, int *_piLen, int* _piString)
 {
-       int iAddrOffset         = 0;
-       int iAddrData           = 0;
-       int iIndex                      = 0;
+    int iAddrOffset            = 0;
+    int iAddrData              = 0;
+    int iIndex                 = 0;
 
-       *_piRows                        = *istk(_iAddr + 1);
-       *_piCols                        = *istk(_iAddr + 2);
+    *_piRows                   = *istk(_iAddr + 1);
+    *_piCols                   = *istk(_iAddr + 2);
 
 
-       if(_piLen == NULL)
-               return 0;
+    if (_piLen == NULL)
+    {
+        return 0;
+    }
 
-       iAddrOffset                     = _iAddr + 4;
-       /*Get all offest*/
-       for(iIndex = 0 ; iIndex < *_piRows * *_piCols; iIndex++)
-               _piLen[iIndex] = *istk(iAddrOffset + iIndex + 1) - *istk(iAddrOffset + iIndex );
+    iAddrOffset                        = _iAddr + 4;
+    /*Get all offest*/
+    for (iIndex = 0 ; iIndex < *_piRows * *_piCols; iIndex++)
+    {
+        _piLen[iIndex] = *istk(iAddrOffset + iIndex + 1) - *istk(iAddrOffset + iIndex );
+    }
 
-/*
-       iAddrData = iAddrBase + (5 + _iRows * _iCols);
+    /*
+       iAddrData = iAddrBase + (5 + _iRows * _iCols);
 
-       *_pszRealData = cstk(sadr(iAddrData));
-*/
-       iAddrData = _iAddr + (5 + *_piRows * *_piCols);
+       *_pszRealData = cstk(sadr(iAddrData));
+    */
+    iAddrData = _iAddr + (5 + *_piRows * *_piCols);
 
-       *_piString                      = cadr(iAddrData);
-       return 0;
+    *_piString                 = cadr(iAddrData);
+    return 0;
 }
 
 int iGetStringFromPointer(int* _piAddr, int *_piRows, int *_piCols, int *_piLen, int** _piString)
 {
-       int iIndex                      = 0;
-       int *piOffset           = NULL;
+    int iIndex                 = 0;
+    int *piOffset              = NULL;
 
-       *_piRows                                = _piAddr[1];
-       *_piCols                                = _piAddr[2];
+    *_piRows                           = _piAddr[1];
+    *_piCols                           = _piAddr[2];
 
 
-       if(_piLen == NULL)
-               return 0;
+    if (_piLen == NULL)
+    {
+        return 0;
+    }
 
-       piOffset                        = _piAddr + 4;
+    piOffset                   = _piAddr + 4;
 
-       /*Get all offest*/
-       for(iIndex = 0 ; iIndex < *_piRows * *_piCols; iIndex++)
-               _piLen[iIndex] = piOffset[iIndex + 1] - piOffset[iIndex];
+    /*Get all offest*/
+    for (iIndex = 0 ; iIndex < *_piRows * *_piCols; iIndex++)
+    {
+        _piLen[iIndex] = piOffset[iIndex + 1] - piOffset[iIndex];
+    }
 
-       *_piString                      = _piAddr + (5 + (*_piRows) * (*_piCols));
-       return 0;
+    *_piString                 = _piAddr + (5 + (*_piRows) * (*_piCols));
+    return 0;
 }
 
 void vGetPointerFromDoubleComplex(const doublecomplex *_poComplex, int _iSize, double *_pdblReal, double *_pdblImg)
 {
 
-       int iTwo        = 2;
-       int iOne        = 1;
-       double *pReal = (double*)&_poComplex[0].r;
-       double *pImg = (double*)&_poComplex[0].i;
-
-       if(_pdblReal != NULL && _pdblImg != NULL)
-       {
-               C2F(dcopy)(&_iSize, pReal, &iTwo, _pdblReal, &iOne);
-               C2F(dcopy)(&_iSize, pImg, &iTwo, _pdblImg, &iOne);
-       }
-       else if(_pdblReal != NULL && _pdblImg == NULL)
-       {
-               C2F(dcopy)(&_iSize, pReal, &iTwo, _pdblReal, &iOne);
-       }
-       else if(_pdblReal == NULL && _pdblImg != NULL)
-       {
-               C2F(dcopy)(&_iSize, pImg, &iTwo, _pdblImg, &iOne);
-       }
+    int iTwo   = 2;
+    int iOne   = 1;
+    double *pReal = (double*)&_poComplex[0].r;
+    double *pImg = (double*)&_poComplex[0].i;
+
+    if (_pdblReal != NULL && _pdblImg != NULL)
+    {
+        C2F(dcopy)(&_iSize, pReal, &iTwo, _pdblReal, &iOne);
+        C2F(dcopy)(&_iSize, pImg, &iTwo, _pdblImg, &iOne);
+    }
+    else if (_pdblReal != NULL && _pdblImg == NULL)
+    {
+        C2F(dcopy)(&_iSize, pReal, &iTwo, _pdblReal, &iOne);
+    }
+    else if (_pdblReal == NULL && _pdblImg != NULL)
+    {
+        C2F(dcopy)(&_iSize, pImg, &iTwo, _pdblImg, &iOne);
+    }
 }
 doublecomplex* oGetDoubleComplexFromPointer(double *_pdblReal, double *_pdblImg, int _iSize)
 {
-       doublecomplex *poComplex = (doublecomplex*)MALLOC(sizeof(doublecomplex) * _iSize);
-       int iTwo        = 2;
-       int iOne        = 1;
-       double *pReal = &poComplex[0].r;
-       double *pImg = &poComplex[0].i;
-
-       if(_pdblReal != NULL && _pdblImg != NULL)
-       {
-
-               C2F(dcopy)(&_iSize, _pdblReal, &iOne, pReal, &iTwo);
-               C2F(dcopy)(&_iSize, _pdblImg, &iOne, pImg, &iTwo);
-       }
-       else if(_pdblReal != NULL && _pdblImg == NULL)
-       {
-               double ZERO = 0.;
-               C2F(dcopy)(&_iSize, _pdblReal, &iOne, pReal, &iTwo);
-               C2F(dset)(&_iSize, &ZERO, pImg, &iTwo);
-       }
-       else if(_pdblReal == NULL && _pdblImg != NULL)
-       {
-               double ZERO = 0.;
-               C2F(dset)(&_iSize, &ZERO, pReal, &iTwo);
-               C2F(dcopy)(&_iSize, _pdblImg, &iOne, pImg, &iTwo);
-       }
-       else
-       {
-               FREE(poComplex);
-               return NULL;
-       }
-       return poComplex;
+    doublecomplex *poComplex = (doublecomplex*)MALLOC(sizeof(doublecomplex) * _iSize);
+    int iTwo   = 2;
+    int iOne   = 1;
+    double *pReal = &poComplex[0].r;
+    double *pImg = &poComplex[0].i;
+
+    if (_pdblReal != NULL && _pdblImg != NULL)
+    {
+
+        C2F(dcopy)(&_iSize, _pdblReal, &iOne, pReal, &iTwo);
+        C2F(dcopy)(&_iSize, _pdblImg, &iOne, pImg, &iTwo);
+    }
+    else if (_pdblReal != NULL && _pdblImg == NULL)
+    {
+        double ZERO = 0.;
+        C2F(dcopy)(&_iSize, _pdblReal, &iOne, pReal, &iTwo);
+        C2F(dset)(&_iSize, &ZERO, pImg, &iTwo);
+    }
+    else if (_pdblReal == NULL && _pdblImg != NULL)
+    {
+        double ZERO = 0.;
+        C2F(dset)(&_iSize, &ZERO, pReal, &iTwo);
+        C2F(dcopy)(&_iSize, _pdblImg, &iOne, pImg, &iTwo);
+    }
+    else
+    {
+        FREE(poComplex);
+        return NULL;
+    }
+    return poComplex;
 }
 void vFreeDoubleComplexFromPointer(doublecomplex *_poComplex)
 {
-       if(_poComplex != NULL)
-               FREE(_poComplex);
+    if (_poComplex != NULL)
+    {
+        FREE(_poComplex);
+    }
 }
 
 /*
@@ -2029,284 +2243,307 @@ To add data, call iListAllocxxxx
 */
 int* iAllocTList(int _iVar, int _iItemNumber)
 {
-       return iAllocListCommon(_iVar, _iItemNumber, sci_tlist);
+    return iAllocListCommon(_iVar, _iItemNumber, sci_tlist);
 }
 
 int* iAllocList(int _iVar, int _iItemNumber)
 {
-       return iAllocListCommon(_iVar, _iItemNumber, sci_list);
+    return iAllocListCommon(_iVar, _iItemNumber, sci_list);
 }
 
 int* iAllocMList(int _iVar, int _iItemNumber)
 {
-       return iAllocListCommon(_iVar, _iItemNumber, sci_mlist);
+    return iAllocListCommon(_iVar, _iItemNumber, sci_mlist);
 }
 
 int* iAllocHyperMatrix(int _iVar, int _iDims)
 {
-       return iAllocMList(_iVar, _iDims);
+    return iAllocMList(_iVar, _iDims);
 }
 
 int* iAllocListCommon(int _iVar, int _iItemNumber, int _iListType)
 {
-       int iAddrBase           = iadr(*Lstk(Top - Rhs + _iVar));
-       int *pRoot                      = NULL;
+    int iAddrBase              = iadr(*Lstk(Top - Rhs + _iVar));
+    int *pRoot                 = NULL;
 
-       pRoot = iListAllocListCommon(_iVar, istk(iAddrBase), 0 /*Main Root*/ , _iItemNumber, _iListType);
+    pRoot = iListAllocListCommon(_iVar, istk(iAddrBase), 0 /*Main Root*/ , _iItemNumber, _iListType);
 
 
-       if(_iItemNumber == 0)
-               *Lstk(Top - Rhs + _iVar + 1) = sadr(iAddrBase + _iItemNumber + 3);
+    if (_iItemNumber == 0)
+    {
+        *Lstk(Top - Rhs + _iVar + 1) = sadr(iAddrBase + _iItemNumber + 3);
+    }
 
-       C2F(intersci).ntypes[Top - Rhs + _iVar - 1]     = '$';
-       C2F(intersci).iwhere[Top - Rhs + _iVar - 1]     = *Lstk(_iVar);
-       // + 3 : 1 pour le type + 1 pour la taille + 1 pour le premier increment tjs a 1
-       C2F(intersci).lad[Top - Rhs + _iVar - 1]        = sadr(iAddrBase + _iItemNumber + 3);
+    C2F(intersci).ntypes[Top - Rhs + _iVar - 1]        = '$';
+    C2F(intersci).iwhere[Top - Rhs + _iVar - 1]        = *Lstk(_iVar);
+    // + 3 : 1 pour le type + 1 pour la taille + 1 pour le premier increment tjs a 1
+    C2F(intersci).lad[Top - Rhs + _iVar - 1]   = sadr(iAddrBase + _iItemNumber + 3);
 
-       return pRoot;
+    return pRoot;
 }
 
 int* iListAllocListCommon(int _iVar, int* _piParentList, int _iItemPos, int _iItemNumber, int _iListType)
 {
-       int iIndex                      = 0;
-       int *piChild            = NULL;
+    int iIndex                 = 0;
+    int *piChild               = NULL;
 
-       int *piItemPos          = 0;
-       if(_iItemPos == 0)
-       {
-               piChild = _piParentList;
-       }
-       else
-       {
-               piChild = iGetAddressFromItemPos(_piParentList, _iItemPos);
-       }
+    int *piItemPos             = 0;
+    if (_iItemPos == 0)
+    {
+        piChild = _piParentList;
+    }
+    else
+    {
+        piChild = iGetAddressFromItemPos(_piParentList, _iItemPos);
+    }
 
 
-       piChild[0]      = _iListType;
-       piChild[1]      = _iItemNumber;
-       piItemPos       = piChild + 2;
+    piChild[0] = _iListType;
+    piChild[1] = _iItemNumber;
+    piItemPos  = piChild + 2;
 
-       piItemPos[0]            = 1; //offset of the first variable
+    piItemPos[0]               = 1; //offset of the first variable
 
-       //Ensure that offset are null before add variable in the list
-       for(iIndex = 1 ; iIndex <= _iItemNumber ; iIndex++)
-               piItemPos[iIndex] = 0;
+    //Ensure that offset are null before add variable in the list
+    for (iIndex = 1 ; iIndex <= _iItemNumber ; iIndex++)
+    {
+        piItemPos[iIndex] = 0;
+    }
 
-       return piChild;
+    return piChild;
 }
 
 int* iListAllocList(int _iVar, int* _piParentList, int _iItemPos, int _iItemNumber)
 {
-       return iListAllocListCommon(_iVar, _piParentList, _iItemPos, _iItemNumber, sci_list);
+    return iListAllocListCommon(_iVar, _piParentList, _iItemPos, _iItemNumber, sci_list);
 }
 
 int* iListAllocTList(int _iVar, int* _piParentList, int _iItemPos, int _iItemNumber)
 {
-       return iListAllocListCommon(_iVar, _piParentList, _iItemPos, _iItemNumber, sci_tlist);
+    return iListAllocListCommon(_iVar, _piParentList, _iItemPos, _iItemNumber, sci_tlist);
 }
 
 int* iListAllocMList(int _iVar, int* _piParentList, int _iItemPos, int _iItemNumber)
 {
-       return iListAllocListCommon(_iVar, _piParentList, _iItemPos, _iItemNumber, sci_mlist);
+    return iListAllocListCommon(_iVar, _piParentList, _iItemPos, _iItemNumber, sci_mlist);
 }
 
 int* iListAllocHyperMatrix(int _iVar, int* _piParentList, int _iItemPos, int _iDims)
 {
-       return iListAllocMList(_iVar, _piParentList, _iItemPos, _iDims);
+    return iListAllocMList(_iVar, _piParentList, _iItemPos, _iDims);
 }
 
 int iListAllocMatrixOfDouble(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, double **_pdblRealData)
 {
-       return iListAllocComplexMatrixOfDouble(_iVar, _piParent, _iItemPos, 0, _iRows, _iCols, _pdblRealData, NULL);
+    return iListAllocComplexMatrixOfDouble(_iVar, _piParent, _iItemPos, 0, _iRows, _iCols, _pdblRealData, NULL);
 }
 
 int iListAllocComplexMatrixOfDouble(int _iVar, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, double **_pdblRealData, double **_pdblImgData)
 {
-       //int iAddrBase         = iadr(*Lstk(Top - Rhs + _iVar));
-       int iType                       = _piParent[0];
-       int iItemNumber         = _piParent[1];
-       int *piItemPos          = &_piParent[2];
-       int iIndex                      = 0;
-       int* piItemAddr         = NULL;
+    //int iAddrBase            = iadr(*Lstk(Top - Rhs + _iVar));
+    int iType                  = _piParent[0];
+    int iItemNumber            = _piParent[1];
+    int *piItemPos             = &_piParent[2];
+    int iIndex                 = 0;
+    int* piItemAddr            = NULL;
 
-       if(iType != sci_list && iType != sci_tlist && iType != sci_mlist)
-               return 1;
+    if (iType != sci_list && iType != sci_tlist && iType != sci_mlist)
+    {
+        return 1;
+    }
 
-       if(_iItemPos <= 0 || iItemNumber < _iItemPos)
-               return 2;
+    if (_iItemPos <= 0 || iItemNumber < _iItemPos)
+    {
+        return 2;
+    }
 
-       /*check if previous variables are already stored*/
-       for(iIndex = 0 ; iIndex < _iItemPos ; iIndex++)
-       {
-               if(piItemPos[iIndex] == 0)
-               {
-                       return 3;
-               }
-       }
+    /*check if previous variables are already stored*/
+    for (iIndex = 0 ; iIndex < _iItemPos ; iIndex++)
+    {
+        if (piItemPos[iIndex] == 0)
+        {
+            return 3;
+        }
+    }
 
-       /*complete Start address of the new variable*/
-       piItemAddr = iGetAddressFromItemPos(_piParent, _iItemPos);
-       iAllocComplexMatrixOfDoubleToAddress(piItemAddr, _iComplex, _iRows, _iCols, _pdblRealData, _pdblImgData);
+    /*complete Start address of the new variable*/
+    piItemAddr = iGetAddressFromItemPos(_piParent, _iItemPos);
+    iAllocComplexMatrixOfDoubleToAddress(piItemAddr, _iComplex, _iRows, _iCols, _pdblRealData, _pdblImgData);
 
-       //iAllocComplexMatrixOfDoubleToAddress(iStart, _iComplex, _iRows, _iCols, _pdblRealData, _pdblImgData);
+    //iAllocComplexMatrixOfDoubleToAddress(iStart, _iComplex, _iRows, _iCols, _pdblRealData, _pdblImgData);
 
-       piItemPos[_iItemPos] = piItemPos[_iItemPos - 1] + 2 + _iRows * _iCols * (_iComplex + 1);
+    piItemPos[_iItemPos] = piItemPos[_iItemPos - 1] + 2 + _iRows * _iCols * (_iComplex + 1);
 
-       if(_iItemPos == iItemNumber)
-       {
-               int* piEnd = (int*) (*_pdblRealData + _iRows * _iCols * (_iComplex + 1));
-               vCloseNode(_iVar, _piParent, _iItemPos, piEnd);
-       }
+    if (_iItemPos == iItemNumber)
+    {
+        int* piEnd = (int*) (*_pdblRealData + _iRows * _iCols * (_iComplex + 1));
+        vCloseNode(_iVar, _piParent, _iItemPos, piEnd);
+    }
 
-       return 0;
+    return 0;
 }
 
 void vCloseNode(int _iVar, int *_piCurrentNode, int _iItemPos, int *_piEnd)
 {
-       //Get Root address;
-       int *piRoot = istk(iadr(*Lstk(Top - Rhs + _iVar)));
-       int *piItemPos = &_piCurrentNode[2];
-       int iItemNumber         = _piCurrentNode[1];
-
-       //check if we are in bigger list.
-       if(piRoot == _piCurrentNode)
-       {//Main List, just close
-               //Close current list
-               int iScale = (int)(_piEnd - piRoot);
-               int iDoubleSclale = iScale / 2;
-               *Lstk(Top - Rhs + _iVar + 1) = *Lstk(Top - Rhs + _iVar) + iDoubleSclale;
-       }
-       else //Not the main list, try to go up
-       {
-               /* \o/ */
-               int iPos        = 0;
-               int *piParentParent = piGetParentNode(piRoot, _piCurrentNode, &iPos);
-               int *piOffset = &piParentParent[2];
-               int Ch1  = piItemPos[_iItemPos] + 1 + iItemNumber/2 + 1;
-               piOffset[iPos+1] = piOffset[iPos] - 1 + Ch1;
-               if(piRoot == piParentParent && ( iPos + 1) == iItemNumber)
-               {
-                       //Close Parent list
-                       int iScale = (int)(_piEnd - piRoot);
-                       int iDoubleSclale = iScale / 2;
-                       *Lstk(Top - Rhs + _iVar + 1) = *Lstk(Top - Rhs + _iVar) + iDoubleSclale;
-               }
-       }
+    //Get Root address;
+    int *piRoot = istk(iadr(*Lstk(Top - Rhs + _iVar)));
+    int *piItemPos = &_piCurrentNode[2];
+    int iItemNumber            = _piCurrentNode[1];
+
+    //check if we are in bigger list.
+    if (piRoot == _piCurrentNode)
+    {
+        //Main List, just close
+        //Close current list
+        int iScale = (int)(_piEnd - piRoot);
+        int iDoubleSclale = iScale / 2;
+        *Lstk(Top - Rhs + _iVar + 1) = *Lstk(Top - Rhs + _iVar) + iDoubleSclale;
+    }
+    else //Not the main list, try to go up
+    {
+        /* \o/ */
+        int iPos       = 0;
+        int *piParentParent = piGetParentNode(piRoot, _piCurrentNode, &iPos);
+        int *piOffset = &piParentParent[2];
+        int Ch1  = piItemPos[_iItemPos] + 1 + iItemNumber / 2 + 1;
+        piOffset[iPos + 1] = piOffset[iPos] - 1 + Ch1;
+        if (piRoot == piParentParent && ( iPos + 1) == iItemNumber)
+        {
+            //Close Parent list
+            int iScale = (int)(_piEnd - piRoot);
+            int iDoubleSclale = iScale / 2;
+            *Lstk(Top - Rhs + _iVar + 1) = *Lstk(Top - Rhs + _iVar) + iDoubleSclale;
+        }
+    }
 }
 
 int* piGetParentNode(int* _piStart, int* _piToFind, int *_piPos)
 {
-       if(IsKindOfList(_piStart))
-       {
-               int iItem       = _piStart[1];
-               int iIndex      = 0;
-               for(iIndex = 0 ; iIndex < iItem ; iIndex++)
-               {
-                       int *piChild = iGetAddressFromItemPos(_piStart, iIndex + 1);
-                       if(piChild == _piToFind)
-                       {
-                               *_piPos = iIndex;
-                               return _piStart;
-                       }
-                       else
-                       {
-                               int *piTemp = piGetParentNode(piChild, _piToFind, _piPos);
-                               if(piTemp != NULL)
-                               {
-                                       return piTemp;
-                               }
-                       }
-               }
-       }
-       return 0;
+    if (IsKindOfList(_piStart))
+    {
+        int iItem      = _piStart[1];
+        int iIndex     = 0;
+        for (iIndex = 0 ; iIndex < iItem ; iIndex++)
+        {
+            int *piChild = iGetAddressFromItemPos(_piStart, iIndex + 1);
+            if (piChild == _piToFind)
+            {
+                *_piPos        = iIndex;
+                return _piStart;
+            }
+            else
+            {
+                int *piTemp = piGetParentNode(piChild, _piToFind, _piPos);
+                if (piTemp != NULL)
+                {
+                    return piTemp;
+                }
+            }
+        }
+    }
+    return 0;
 }
 
 int IsKindOfList(int* _piNode)
 {
-       if(_piNode[0] == sci_list || _piNode[0] == sci_tlist || _piNode[0] == sci_mlist)
-               return 1;
-       else
-               return 0;
+    if (_piNode[0] == sci_list || _piNode[0] == sci_tlist || _piNode[0] == sci_mlist)
+    {
+        return 1;
+    }
+    else
+    {
+        return 0;
+    }
 }
 
 int iListAllocMatrixOfPoly(int _iVar, int* _piParent, int _iItemPos, int** _piVarName, int _iRows, int _iCols, int *_piPow, double** _pdblRealData)
 {
-       return iListAllocComplexMatrixOfPoly(_iVar, _piParent, _iItemPos, 0, _piVarName, _iRows, _iCols, _piPow, _pdblRealData, NULL);
+    return iListAllocComplexMatrixOfPoly(_iVar, _piParent, _iItemPos, 0, _piVarName, _iRows, _iCols, _piPow, _pdblRealData, NULL);
 }
 
 /*Reserve space in stack for a matrix of complex polynom*/
 int iListAllocComplexMatrixOfPoly(int _iVar, int* _piParent, int _iItemPos, int _iComplex, int** _piVarName, int _iRows, int _iCols, int *_piPow, double** _pdblRealData, double** _pdblImgData)
 {
-       int iAddrBase           = iadr(*Lstk(Top - Rhs + _iVar));
-       int iType                       = *istk(iAddrBase);
-       int iItemNumber         = *istk(iAddrBase + 1);
-       int *piItemPos          = istk(iAddrBase + 2); // size == iItemNumber
-       int iStart                      = 0;
-       int iIndex                      = 0;
+    int iAddrBase              = iadr(*Lstk(Top - Rhs + _iVar));
+    int iType                  = *istk(iAddrBase);
+    int iItemNumber            = *istk(iAddrBase + 1);
+    int *piItemPos             = istk(iAddrBase + 2); // size == iItemNumber
+    int iStart                 = 0;
+    int iIndex                 = 0;
 
-       if(iType != sci_list && iType != sci_tlist && iType != sci_mlist)
-               return 1;
+    if (iType != sci_list && iType != sci_tlist && iType != sci_mlist)
+    {
+        return 1;
+    }
 
-       if(_iItemPos <= 0 || iItemNumber < _iItemPos)
-               return 2;
+    if (_iItemPos <= 0 || iItemNumber < _iItemPos)
+    {
+        return 2;
+    }
 
-       /*check if previous variables are already stored*/
-       for(iIndex = 0 ; iIndex < _iItemPos ; iIndex++)
-       {
-               if(piItemPos[iIndex] == 0)
-               {
-                       return 3;
-               }
-       }
+    /*check if previous variables are already stored*/
+    for (iIndex = 0 ; iIndex < _iItemPos ; iIndex++)
+    {
+        if (piItemPos[iIndex] == 0)
+        {
+            return 3;
+        }
+    }
 
-       iStart = iGetAddressFromItemNumber(_iVar, _iItemPos);
-       iAllocComplexMatrixOfPolyToAddress(iStart, _iComplex, _piVarName, _iRows, _iCols, _piPow, _pdblRealData, _pdblImgData);
+    iStart = iGetAddressFromItemNumber(_iVar, _iItemPos);
+    iAllocComplexMatrixOfPolyToAddress(iStart, _iComplex, _piVarName, _iRows, _iCols, _piPow, _pdblRealData, _pdblImgData);
 
-       piItemPos[_iItemPos] = piItemPos[_iItemPos - 1] + ((9 + _iRows * _iCols) + !((_iRows * _iCols) % 2)) / 2 + iArraySum(_piPow, 0, _iRows * _iCols) * (_iComplex + 1);
-       if(_iItemPos == iItemNumber)
-       {
-               //*Lstk(Top - Rhs + _iVar + 1) = sadr(iAddrData) + iArraySum(_piPow, 0, _iRows * _iCols) * (_iComplex + 1) * 2;
-               int* piEnd = (int*) (*_pdblRealData + iArraySum(_piPow, 0, _iRows * _iCols) * (_iComplex + 1));
-               vCloseNode(_iVar, _piParent, _iItemPos, piEnd);
-       }
-       return 0;
+    piItemPos[_iItemPos] = piItemPos[_iItemPos - 1] + ((9 + _iRows * _iCols) + !((_iRows * _iCols) % 2)) / 2 + iArraySum(_piPow, 0, _iRows * _iCols) * (_iComplex + 1);
+    if (_iItemPos == iItemNumber)
+    {
+        //*Lstk(Top - Rhs + _iVar + 1) = sadr(iAddrData) + iArraySum(_piPow, 0, _iRows * _iCols) * (_iComplex + 1) * 2;
+        int* piEnd = (int*) (*_pdblRealData + iArraySum(_piPow, 0, _iRows * _iCols) * (_iComplex + 1));
+        vCloseNode(_iVar, _piParent, _iItemPos, piEnd);
+    }
+    return 0;
 }
 
 
 int iListAllocString(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int *_piLen, char** _pszData)
 {
-       int iAddrBase           = iadr(*Lstk(Top - Rhs + _iVar));
-       int iType                       = *istk(iAddrBase);
-       int iItemNumber         = *istk(iAddrBase + 1);
-       int *piItemPos          = istk(iAddrBase + 2); // size == iItemNumber
-       int iStart                      = 0;
-       int iIndex                      = 0;
-       int iAddrData           = 0;
+    int iAddrBase              = iadr(*Lstk(Top - Rhs + _iVar));
+    int iType                  = *istk(iAddrBase);
+    int iItemNumber            = *istk(iAddrBase + 1);
+    int *piItemPos             = istk(iAddrBase + 2); // size == iItemNumber
+    int iStart                 = 0;
+    int iIndex                 = 0;
+    int iAddrData              = 0;
 
-       if(iType != sci_list && iType != sci_tlist && iType != sci_mlist)
-               return 1;
+    if (iType != sci_list && iType != sci_tlist && iType != sci_mlist)
+    {
+        return 1;
+    }
 
-       if(_iItemPos <= 0 || iItemNumber < _iItemPos)
-               return 2;
+    if (_iItemPos <= 0 || iItemNumber < _iItemPos)
+    {
+        return 2;
+    }
 
-       /*check if previous variables are already stored*/
-       for(iIndex = 0 ; iIndex < _iItemPos ; iIndex++)
-       {
-               if(piItemPos[iIndex] == 0)
-               {
-                       return 3;
-               }
-       }
+    /*check if previous variables are already stored*/
+    for (iIndex = 0 ; iIndex < _iItemPos ; iIndex++)
+    {
+        if (piItemPos[iIndex] == 0)
+        {
+            return 3;
+        }
+    }
 
-       iStart = iGetAddressFromItemNumber(_iVar, _iItemPos);
-       iAllocMatrixOfStringToAddress(iStart, _iRows, _iCols, _piLen, _pszData);
+    iStart = iGetAddressFromItemNumber(_iVar, _iItemPos);
+    iAllocMatrixOfStringToAddress(iStart, _iRows, _iCols, _piLen, _pszData);
 
-       iAddrData = iAddrBase + (9 + _iRows * _iCols);
-       piItemPos[_iItemPos] = piItemPos[_iItemPos - 1] + ((9 + _iRows * _iCols) + !((_iRows * _iCols) % 2)) / 2 + iArraySum(_piLen, 0, _iRows * _iCols);
-       if(_iItemPos == iItemNumber)
-               *Lstk(Top - Rhs + _iVar + 1) = sadr(iAddrData) + iArraySum(_piLen, 0, _iRows * _iCols) * 2;
+    iAddrData = iAddrBase + (9 + _iRows * _iCols);
+    piItemPos[_iItemPos] = piItemPos[_iItemPos - 1] + ((9 + _iRows * _iCols) + !((_iRows * _iCols) % 2)) / 2 + iArraySum(_piLen, 0, _iRows * _iCols);
+    if (_iItemPos == iItemNumber)
+    {
+        *Lstk(Top - Rhs + _iVar + 1) = sadr(iAddrData) + iArraySum(_piLen, 0, _iRows * _iCols) * 2;
+    }
 
-       return 0;
+    return 0;
 }
 
 /*
@@ -2321,14 +2558,14 @@ Arguments
 */
 int GetRhsVarMatrixDouble(int number, int *_iRows, int *_iCols, double **_pdblRealData)
 {
-       unsigned long type_len;
-       int lr;
-       char typex;
-       type_len = 1L;
-       typex = MATRIX_OF_DOUBLE_DATATYPE[0];
-       C2F(getrhsvar)(&number, &typex, _iRows, _iCols, &lr, type_len);
-       *_pdblRealData = stk(lr);
-       return 0;
+    unsigned long type_len;
+    int lr;
+    char typex;
+    type_len = 1L;
+    typex = MATRIX_OF_DOUBLE_DATATYPE[0];
+    C2F(getrhsvar)(&number, &typex, _iRows, _iCols, &lr, type_len);
+    *_pdblRealData = stk(lr);
+    return 0;
 }
 /*
 GetRhsVarMatrixComplex --
@@ -2343,130 +2580,130 @@ Arguments
 */
 int GetRhsVarMatrixComplex(int number, int *_iRows, int *_iCols, double **_pdblRealData, double **_pdblImgData)
 {
-       unsigned long type_len;
-       int lr;
-       int lc;
-       char typex;
-       int it;
-       it = 1;
-       type_len = 1L;
-       typex = MATRIX_OF_DOUBLE_DATATYPE[0];
-       C2F(getrhscvar)(&number, &typex, &it, _iRows, _iCols, &lr, &lc, type_len);
-       *_pdblRealData = stk(lr);
-       *_pdblImgData = stk(lc);
-       return 0;
+    unsigned long type_len;
+    int lr;
+    int lc;
+    char typex;
+    int it;
+    it = 1;
+    type_len = 1L;
+    typex = MATRIX_OF_DOUBLE_DATATYPE[0];
+    C2F(getrhscvar)(&number, &typex, &it, _iRows, _iCols, &lr, &lc, type_len);
+    *_pdblRealData = stk(lr);
+    *_pdblImgData = stk(lc);
+    return 0;
 }
 
 int *GetLengthStringMatrixByName(char *name_, int *m, int *n)
 {
-       int *lenghtMatrix = NULL;
-       unsigned long name_len= (unsigned long)strlen(name_);
-       int x = 0;
-       int y = 0;
-       int mn = 0;
-       int lp = 0;
-       int j = 0;
-       
-       int iposx = 0, iposy = 0;
-       int lengthAtiposxiposy = 0;
-
-       if ( ! C2F(cmatsptr)  (name_, m,n, &iposx, &iposy, &lp, &lengthAtiposxiposy, name_len) )
-       {
-               *m = -1;
-               *n = -1;
-               return NULL;
-       }
-
-       mn = *m * *n;
-       lenghtMatrix = (int*)MALLOC(mn * sizeof(int));
-       if (!lenghtMatrix)
-       {
-               *m = -1;
-               *n = -1;
-               return NULL;
-       }
-
-       j = 0;
-       for (x = 1; x <= *m;x++)
-       {
-               for (y = 1; y <= *n;y++) 
-               {
-                       if ( !C2F(cmatsptr)  (name_, m,n, &x, &y, &lp, &lengthAtiposxiposy, name_len) )
-                       {
-                               FREE(lenghtMatrix);
-                               *m = -1;
-                               *n = -1;
-                               return NULL;
-                       }
-                       /* scilab string not finished by '\0' */
-                       /* we add to the length */
-                       lenghtMatrix[j] = lengthAtiposxiposy + 1;
-                       j++;
-               }
-       }
-       return lenghtMatrix;
+    int *lengthMatrix = NULL;
+    unsigned long name_len = (unsigned long)strlen(name_);
+    int x = 0;
+    int y = 0;
+    int mn = 0;
+    int lp = 0;
+    int j = 0;
+
+    int iposx = 0, iposy = 0;
+    int lengthAtiposxiposy = 0;
+
+    if ( ! C2F(cmatsptr)  (name_, m, n, &iposx, &iposy, &lp, &lengthAtiposxiposy, name_len) )
+    {
+        *m = -1;
+        *n = -1;
+        return NULL;
+    }
+
+    mn = *m * *n;
+    lengthMatrix = (int*)MALLOC(mn * sizeof(int));
+    if (!lengthMatrix)
+    {
+        *m = -1;
+        *n = -1;
+        return NULL;
+    }
+
+    j = 0;
+    for (x = 1; x <= *m; x++)
+    {
+        for (y = 1; y <= *n; y++)
+        {
+            if ( !C2F(cmatsptr)  (name_, m, n, &x, &y, &lp, &lengthAtiposxiposy, name_len) )
+            {
+                FREE(lengthMatrix);
+                *m = -1;
+                *n = -1;
+                return NULL;
+            }
+            /* scilab string not finished by '\0' */
+            /* we add to the length */
+            lengthMatrix[j] = lengthAtiposxiposy + 1;
+            j++;
+        }
+    }
+    return lengthMatrix;
 }
 
 /*Nouveau d├ębut, FAIRE DU TRI DANS TOUT CE MERDIER TONIO !!!!!!!*/
 
 int iGetDoubleFromPointer(int* _piAddr, int *_piRows, int *_piCols, double** _pdblReal)
 {
-       return 0;
+    return 0;
 }
 
 int iGetComplexDoubleFromPointer(int* _piAddr, int *_piRows, int *_piCols, double** _pdblReal, double** _pdblImg)
 {
-       return 0;
+    return 0;
 }
 
 int iGetPolyFromPointer(int* _piAddr, int** _piVarName, int* _piRows, int* _piCols, int* _piPow, double** _pdblReal)
 {
-       return 0;
+    return 0;
 }
 
 int iGetComplexPolyFromPointer(int* _piAddr, int** _piVarName, int* _piRows, int* _piCols, int* _piPow, double** _pdblReal, double** _pdblImg)
 {
-       return 0;
+    return 0;
 }
 
 int iGetBooleanFromPointer(int* _piAddr, int *_piRows, int *_piCols, int** _piBool)
 {
-       return 0;
+    return 0;
 }
 
 int iGetSparseFromPointer(int* _piAddr, int *_piRows, int *_piCols, int* _piTotalElem, int* _piElemByRow, double **_pdblReal)
 {
-       return 0;
+    return 0;
 }
 
 int iGetComplexSparseFromPointer(int* _piAddr, int *_piRows, int *_piCols, int* _piTotalElem, int* _piElemByRow, double **_pdblReal, double **_pdblImg)
 {
-       return 0;
+    return 0;
 }
 
 int iGetBooleanSparseFromPointer(int* _piAddr, int *_piRows, int *_piCols, int* _piTotalElem, int* _piElemByRow, int** _piBool)
 {
-       return 0;
+    return 0;
 }
 
 int iGetMatlabSparseFromPointer(int* _piAddr, int *_piRows, int *_piCols, int* _piTotalElem, int* _piElemByRow, double **_pdblReal)
 {
-       return 0;
+    return 0;
 }
 
 int iGetComplexMatlabSparseFromPointer(int* _piAddr, int *_piRows, int *_piCols, int* _piTotalElem, int* _piElemByRow, double **_pdblReal, double **_pdblImg)
 {
-       return 0;
+    return 0;
 }
 
 int iGetIntFromPointer(int* _piAddr, int *_piRows, int *_piCols, int *_piPrecision, int** _piInt)
 {
-       return 0;
+    return 0;
 }
 
 int iGetHandleFromPointer(int* _piAddr, int *_piRows, int *_piCols, int** _piHandle)
 {
-       return 0;
+    return 0;
 }
 
 
index 1c9fc03..7c7671f 100644 (file)
@@ -1,15 +1,15 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2007 - INRIA - Allan CORNET
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 #ifndef __XERHLT_H__
 #define __XERHLT_H__
 
@@ -18,8 +18,8 @@
 
 /**
 * do a long jump (slatec)
-* @param messg a message 
-* @param l lenght of messg
+* @param messg a message
+* @param l length of messg
 */
 ELEMENTARY_FUNCTIONS_IMPEXP void C2F(xerhlt) (char *messg, unsigned long l);
 
@@ -31,4 +31,4 @@ ELEMENTARY_FUNCTIONS_IMPEXP void C2F(xerhlt) (char *messg, unsigned long l);
 ELEMENTARY_FUNCTIONS_IMPEXP int setjmp_slatec_jmp_env(void);
 
 #endif /* __XERHLT_H__ */
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
index f74e97e..9bc5411 100644 (file)
@@ -32,7 +32,7 @@ int sci_msprintf(char *fname, unsigned long fname_len)
     char *ptrFormat = NULL;
     int K = 0;
     int i = 0;
-    int lenghtFormat = 0;
+    int lengthFormat = 0;
     int NumberPercent = 0;
     int NumberCols = 0;
     int nmax = 0;
@@ -49,7 +49,7 @@ int sci_msprintf(char *fname, unsigned long fname_len)
     int k = 0;
     int mOut = 0;
     int nOut = 0;
-    int lenghtSplitChar = (int)strlen(SPLIT_ON_CR_IN_FORMAT);
+    int lengthSplitChar = (int)strlen(SPLIT_ON_CR_IN_FORMAT);
 
     Nbvars = 0;
     CheckRhs(1, 1000);
@@ -131,13 +131,13 @@ int sci_msprintf(char *fname, unsigned long fname_len)
         }
     }
 
-    lenghtFormat = (int)strlen(ptrFormat);
-    for (i = 0; i < lenghtFormat; i++)
+    lengthFormat = (int)strlen(ptrFormat);
+    for (i = 0; i < lengthFormat; i++)
     {
         if (ptrFormat[i] == PERCENT_CHAR)
         {
             NumberPercent++;
-            if ( (i + 1 < lenghtFormat) && (ptrFormat[i + 1] == PERCENT_CHAR))
+            if ( (i + 1 < lengthFormat) && (ptrFormat[i + 1] == PERCENT_CHAR))
             {
                 NumberPercent--;
                 i++;
@@ -225,7 +225,7 @@ int sci_msprintf(char *fname, unsigned long fname_len)
         pStrTmp1 = pStrTmp;
         while (*pStrTmp != '\0')
         {
-            if (strncmp(pStrTmp, SPLIT_ON_CR_IN_FORMAT, lenghtSplitChar) == 0)
+            if (strncmp(pStrTmp, SPLIT_ON_CR_IN_FORMAT, lengthSplitChar) == 0)
             {
                 k = (int)(pStrTmp - pStrTmp1);
                 if (!cat_to_last)
@@ -292,7 +292,7 @@ int sci_msprintf(char *fname, unsigned long fname_len)
                     pOutputStrings[mOut - 1][k + ll] = EMPTY_CHAR;
                 }
                 k = 0;
-                pStrTmp += lenghtSplitChar;
+                pStrTmp += lengthSplitChar;
                 pStrTmp1 = pStrTmp;
                 cat_to_last = 0;
             }
@@ -379,11 +379,14 @@ int sci_msprintf(char *fname, unsigned long fname_len)
             }
         }
 
-        if (strncmp(pStrTmp - lenghtSplitChar, SPLIT_ON_CR_IN_FORMAT, lenghtSplitChar) != 0)
+        if (strncmp(pStrTmp - lengthSplitChar, SPLIT_ON_CR_IN_FORMAT, lengthSplitChar) != 0)
         {
             cat_to_last = 1;
         }
-        if (Rhs == 1) break;
+        if (Rhs == 1)
+        {
+            break;
+        }
 
     }
 
@@ -393,7 +396,10 @@ int sci_msprintf(char *fname, unsigned long fname_len)
         ptrFormat = NULL;
     }
 
-    if (rval == RET_BUG) return 0;
+    if (rval == RET_BUG)
+    {
+        return 0;
+    }
 
     /* Create a Scilab String */
     nOut = 1;
index fd17cab..edf514d 100644 (file)
@@ -1548,10 +1548,10 @@ function  [ok,XX,alreadyran,flgcdgen,szclkINTemp,freof] = do_compile_superblock4
   AfterCG_WinList = winsid();
 
   AfterCG_size = size(AfterCG_WinList); //** matrix
-  AfterCG_size = AfterCG_size(2) ; //** vector lenght
+  AfterCG_size = AfterCG_size(2) ; //** vector length
 
   BeforeCG_size = size(BeforeCG_WinList); //** matrix
-  BeforeCG_size = BeforeCG_size(2) ; //** vector lenght
+  BeforeCG_size = BeforeCG_size(2) ; //** vector length
 
   if (or(AfterCG_WinList<>BeforeCG_WinList)) & (AfterCG_size>BeforeCG_size) then
      //** means that a scope or other scicos object has created some
index bae4c5c..4dd8101 100644 (file)
@@ -49,7 +49,7 @@ function [scs_m,DEL,DELL]=do_delete1(scs_m,K,gr)
 //** 
 //**  where
 //**
-//**       o_size = size(gh_curwin.children.children); // o_size(1) => lenght  o_size(2) => 1
+//**       o_size = size(gh_curwin.children.children); // o_size(1) => length  o_size(2) => 1
 //**
 //**  the graphics "Compound" object are NOT deleted BUT set to "invisible" with the propriety
 //**
index 31fc37d..1454b42 100644 (file)
@@ -24,7 +24,7 @@ function [x,y,typ]=PENDULUM_ANIM(job,arg1,arg2)
       if ~ok then break,end
       mess=[]
       if plen<=0|csiz<=0 then
-        mess=[mess;'Pendulum lenght and cart size must be positive.';' ']
+        mess=[mess;'Pendulum length and cart size must be positive.';' ']
         ok=%f
       end
       if ymin>=ymax then
index 49bc3d7..e0e09e6 100644 (file)
@@ -43,7 +43,7 @@ function [x,y,typ]=BPLATFORM(job,arg1,arg2)
       if ~ok then break,end
       mess=[]
       if plen<=0|csiz<=0 then
-        mess=[mess;'Pendulum lenght and cart size must be positive.';' ']
+        mess=[mess;'Pendulum length and cart size must be positive.';' ']
         ok=%f
       end
       if ymin>=ymax then
index e36e618..81d4cd2 100644 (file)
@@ -44,7 +44,7 @@ function [x,y,typ]=PENDULUM_ANIM(job,arg1,arg2)
       if ~ok then break,end
       mess=[]
       if plen<=0|csiz<=0 then
-        mess=[mess;'Pendulum lenght and cart size must be positive.';' ']
+        mess=[mess;'Pendulum length and cart size must be positive.';' ']
         ok=%f
       end
       if ymin>=ymax then
index d6b0cac..b04d3a6 100644 (file)
@@ -54,7 +54,7 @@
 #define pps_propertystart(x)           ((x) +0x74)
 #define pps_sizeofproperty(x)          ((x) +0x78)
 
-/* Type lenghts*/
+/* Type lengths*/
 #define LEN_BYTE       1
 #define LEN_USHORT 2
 #define LEN_ULONG      4
@@ -241,7 +241,9 @@ int OLE_set_debug(struct OLE_object *ole, int level)
 {
     ole->debug = level;
     if (ole->debug > 0)
+    {
         LOGGER_log(_("%s:%d:OLE_set_debug: Debug level set to %d"), FL, ole->debug);
+    }
 
     return OLE_OK;
 }
@@ -456,7 +458,7 @@ int OLE_dbstosbs(char *raw_string, size_t byte_count, char *clean_string, int cl
 
     while ((raw_string < limit) && (byte_count > 0) && (byte_count--) && (clean_string_len--))
     {
-        int v = (char)*raw_string;
+        int v = (char) * raw_string;
 
         if (isprint(v))
         {
@@ -529,9 +531,13 @@ static int OLE_print_sector(struct OLE_object *ole, unsigned char *sector, unsig
             for (j = current_byte - 31; j <= current_byte; j++)
             {
                 if (isalnum(*(sector + j)))
+                {
                     printf("%c", *(sector + j));
+                }
                 else
+                {
                     printf(".");
+                }
             }
             printf("\n");
         }
@@ -560,9 +566,13 @@ int OLE_is_file_OLE(struct OLE_object *ole)
 {
 
     if (memcmp(OLE_id_v1, ole->header_block, sizeof(OLE_id_v1)) == 0)
+    {
         return 1;
+    }
     if (memcmp(OLE_id_v2, ole->header_block, sizeof(OLE_id_v2)) == 0)
+    {
         return 1;
+    }
 
     return 0;
 
@@ -624,10 +634,10 @@ int OLE_convert_header(struct OLE_object *ole)
     hb = ole->header_block;
 
     /** Note that the header_*(hb) calls are actually macros which are
-       ** defined in the ole.h file.  These macros basically take the
-       ** hb value and add the required offset, they don't affect the
-       ** value of hb (or they certainly SHOULD NOT! )
-       **/
+    ** defined in the ole.h file.  These macros basically take the
+    ** hb value and add the required offset, they don't affect the
+    ** value of hb (or they certainly SHOULD NOT! )
+    **/
 
     h->minor_version = get_2byte_value(header_minor_version(hb));
     h->dll_version = get_2byte_value(header_dll_version(hb));
@@ -647,9 +657,9 @@ int OLE_convert_header(struct OLE_object *ole)
     h->dif_sector_count = get_4byte_value(header_dif_sector_count(hb));
 
     /** Compute the maximum possible sector number by taking our OLE filesize
-       ** and dividing it by the size of our sector size.  While this isn't
-       ** absolutely accurate it is at least useful in providing us with an
-       ** upper-bound of what is an acceptable sector ID **/
+    ** and dividing it by the size of our sector size.  While this isn't
+    ** absolutely accurate it is at least useful in providing us with an
+    ** upper-bound of what is an acceptable sector ID **/
     ole->last_sector = (int)(ole->file_size >> h->sector_shift);
 
     /** Decode our first 109 sector-ID's into the master sector allocation table (MSAT/FAT) **/
@@ -657,7 +667,9 @@ int OLE_convert_header(struct OLE_object *ole)
     for (i = 0; i < h->fat_sector_count; i++)
     {
         if (i >= OLE_HEADER_FAT_SECTOR_COUNT_LIMIT)
+        {
             break;
+        }
         h->FAT[i] = get_4byte_value(fat_start + (LEN_ULONG * i));
     }
 
@@ -693,15 +705,25 @@ static int OLE_header_sanity_check(struct OLE_object *ole)
     max_sectors = (int)(ole->file_size / h->sector_size);
 
     if (h->sector_shift > 20)
+    {
         insanity++;
+    }
     if (h->mini_sector_shift > 10)
+    {
         insanity++;
+    }
     if ((int)h->fat_sector_count < 0)
+    {
         insanity++;
+    }
     if (h->fat_sector_count > (unsigned int)max_sectors)
+    {
         insanity++;
+    }
     if (h->directory_stream_start_sector > (unsigned int)max_sectors)
+    {
         insanity++;
+    }
 
     return insanity;
 }
@@ -750,7 +772,9 @@ int OLE_print_header(struct OLE_object *ole)
     for (i = 0; i < h->fat_sector_count; i++)
     {
         if (i >= OLE_HEADER_FAT_SECTOR_COUNT_LIMIT)
-            break;              /* We can't read beyond the 109th sector location */
+        {
+            break;    /* We can't read beyond the 109th sector location */
+        }
         printf("FAT[%d] = %d\n", i, h->FAT[i]);
     }
 
@@ -776,40 +800,40 @@ Changes:
 int OLE_convert_directory(struct OLE_object *ole, unsigned char *buf, struct OLE_directory_entry *dir)
 {
     /** Converts a  raw block of 128 bytes from the file to a
-       ** struct OLE_directory_entry data structure
-       **/
+    ** struct OLE_directory_entry data structure
+    **/
 
     /** Flush the element name **/
     memset(dir->element_name, '\0', OLE_DIRECTORY_ELEMENT_NAME_SIZE);
 
     /** The first 64 bytes of the structure are the element's name
-       ** in 16-bite UNICODE, meaning a maximum of 31 characters when
-       ** we account for the trailing zero byte
-       **/
+    ** in 16-bite UNICODE, meaning a maximum of 31 characters when
+    ** we account for the trailing zero byte
+    **/
 
     /** Copy the first 64 bytes of our *buf parameter into the element name **/
     memcpy(dir->element_name, buf, OLE_DIRECTORY_ELEMENT_NAME_SIZE);
 
     /** how many bytes of the above 64 bytes are used for the name (NOT CHARACTERS!), **
-       ** example, for a 8 character string with a trailing zero we use **
-       ** (8+1)*2 = 18 bytes
-       **/
+    ** example, for a 8 character string with a trailing zero we use **
+    ** (8+1)*2 = 18 bytes
+    **/
     dir->element_name_byte_count = get_2byte_value(buf + 0x40);
 
     /** Element type is of the following:
-       ** 0x00 - empty
-       ** 0x01 - user storage
-       ** 0x02 - user stream
-       ** 0x03 - lock bytes (we don't know what this is for)
-       ** 0x04 - property (again, we don't know)
-       ** 0x05 - root storage
-       **/
+    ** 0x00 - empty
+    ** 0x01 - user storage
+    ** 0x02 - user stream
+    ** 0x03 - lock bytes (we don't know what this is for)
+    ** 0x04 - property (again, we don't know)
+    ** 0x05 - root storage
+    **/
     dir->element_type = (char)get_1byte_value(buf + 0x42);
 
     /** Element colour for the red-black tree:
-       ** 0x00 - Red
-       ** 0x01 - Black
-       **/
+    ** 0x00 - Red
+    ** 0x01 - Black
+    **/
     dir->element_colour = (char)get_1byte_value(buf + 0x43);
 
     /** Directory ID (DID) of the left child, -1 if no sibling **/
@@ -819,8 +843,8 @@ int OLE_convert_directory(struct OLE_object *ole, unsigned char *buf, struct OLE
     dir->right_child = get_4byte_value(buf + 0x48);
 
     /** Directory ID (DID) of the root node entry of the RB tree of all
-       ** storage members (if this entry is a storage), else -1.
-       **/
+    ** storage members (if this entry is a storage), else -1.
+    **/
     dir->root = get_4byte_value(buf + 0x4c);
 
     memcpy(dir->class, buf + 0x50, 16);
@@ -924,11 +948,11 @@ int OLE_load_FAT(struct OLE_object *ole)
                 /*      pointer alive - so that we can facilitate debugging */
                 /*      otherwise the caller is always going to get a NULL pointer */
                 /*      and have no idea to what extent the data was read. */
-                 /**/
-                    /* This behavior may be changed later - but for now (beta development) */
-                    /*      it'll be okay to leave it here - just make sure we know to */
-                    /*      free the FAT block later. */
-                    return getblock_result;
+                /**/
+                /* This behavior may be changed later - but for now (beta development) */
+                /*      it'll be okay to leave it here - just make sure we know to */
+                /*      free the FAT block later. */
+                return getblock_result;
             }
 
             fat_position += ole->header.sector_size;
@@ -990,12 +1014,16 @@ int OLE_load_FAT(struct OLE_object *ole)
                 if (getblock_result != OLE_OK)
                 {
                     if (fat_block)
+                    {
                         FREE(fat_block);
+                    }
                     return getblock_result;
                 }
 
                 if (OLE_DPEDANTIC(ole->debug))
+                {
                     OLE_print_sector(ole, fat_block, ole->header.sector_size);
+                }
 
                 /* Now, traverse this block until we hit a < 0 */
                 /*      If we get what is a non-valid sector value */
@@ -1020,7 +1048,9 @@ int OLE_load_FAT(struct OLE_object *ole)
                                 LOGGER_log(_("%s:%d:OLE_load_FAT:ERROR: Not able to load block, import sector = 0x%x, fat position = 0x%x"), FL,
                                            import_sector, fat_position);
                                 if (fat_block)
+                                {
                                     FREE(fat_block);
+                                }
                                 return getblock_result;
                             }
 
@@ -1034,7 +1064,9 @@ int OLE_load_FAT(struct OLE_object *ole)
                                 DOLE LOGGER_log(_("%s:%d:OLE_load_FAT:ERROR: FAT memory boundary limit exceeded %p >= %p"), FL, fat_position,
                                                 ole->FAT_limit);
                                 if (fat_block)
+                                {
                                     FREE(fat_block);
+                                }
                                 return OLEER_MEMORY_OVERFLOW;
                             }
                             tick++;
@@ -1044,7 +1076,9 @@ int OLE_load_FAT(struct OLE_object *ole)
                         {
                             LOGGER_log(_("%s:%d:OLE_load_FAT:ERROR: FAT memory boundary limit exceeded %p >= %p"), FL, fat_position, ole->FAT_limit);
                             if (fat_block)
+                            {
                                 FREE(fat_block);
+                            }
                             return OLEER_MEMORY_OVERFLOW;
                         }
                     }
@@ -1058,23 +1092,27 @@ int OLE_load_FAT(struct OLE_object *ole)
                 while ((import_sector >= 0) && (DIF < fat_block_end));
 
                 /* Get the next sector of DIF/XBAT data ... */
-                 /**/
-                    /* If we still have more sectors full of extended FAT */
-                    /*      sectors that we have to read, then we neet to */
-                    /*      obtain the address of the next FAT-sector filled */
-                    /*      sector */
-                    if (i < ole->header.dif_sector_count - 1)
+                /**/
+                /* If we still have more sectors full of extended FAT */
+                /*      sectors that we have to read, then we neet to */
+                /*      obtain the address of the next FAT-sector filled */
+                /*      sector */
+                if (i < ole->header.dif_sector_count - 1)
                 {
                     current_sector = get_4byte_value(fat_block_end);
                     DOLE LOGGER_log("%s:%d:OLE_load_FAT:DEBUG: Next DIF/XBAT index sector located at 0x%x", FL, current_sector);
 
                     if ((int)current_sector < 0)
+                    {
                         break;
+                    }
                 }
             }                   /* For every DIF/XBAT sector we're supposed to read */
 
             if (fat_block)
+            {
                 FREE(fat_block);
+            }
         }                       /* If we have DIF/XBAT sectors to read into the FAT */
 
     }                           /* If we managed to allocate memory for our FAT table */
@@ -1109,7 +1147,9 @@ int OLE_follow_chain(struct OLE_object *ole, int FAT_sector_start)
     BTI_init(&n);
 
     if (FAT_sector_start < 0)
+    {
         return 0;
+    }
 
     DOLE LOGGER_log("%s:%d:OLE_follow_chain:DEBUG: Starting chain follow at sector %d", FL, FAT_sector_start);
 
@@ -1143,7 +1183,9 @@ int OLE_follow_chain(struct OLE_object *ole, int FAT_sector_start)
         /* 20040729-10H37 Added this to prevent endless loop which sometimes occurs at sector 0 */
 
         if (next_sector == current_sector)
+        {
             break;
+        }
 
         /*      fflush(stdout); */
         current_sector = next_sector;
@@ -1152,18 +1194,20 @@ int OLE_follow_chain(struct OLE_object *ole, int FAT_sector_start)
         /** Test to see if we should terminate this chain traversal **/
         switch (current_sector)
         {
-        case OLE_SECTORID_MSAT:
-        case OLE_SECTORID_SAT:
-        case OLE_SECTORID_ENDOFCHAIN:
-        case OLE_SECTORID_FREE:
-            break_out = 1;
-            break;
-        default:
-            break_out = 0;
+            case OLE_SECTORID_MSAT:
+            case OLE_SECTORID_SAT:
+            case OLE_SECTORID_ENDOFCHAIN:
+            case OLE_SECTORID_FREE:
+                break_out = 1;
+                break;
+            default:
+                break_out = 0;
         };
 
         if (current_sector < 0)
+        {
             break_out = 1;
+        }
 
     }
     while ((break_out == 0) && (current_sector < last_sector_of_file));
@@ -1199,7 +1243,9 @@ int OLE_follow_minichain(struct OLE_object *ole, int miniFAT_sector_start)
     DOLE LOGGER_log("%s:%d:OLE_follow_minichain:DEBUG: Starting at sector %d", FL, miniFAT_sector_start);
 
     if (miniFAT_sector_start < 0)
+    {
         return 0;
+    }
 
     do
     {
@@ -1224,7 +1270,9 @@ int OLE_follow_minichain(struct OLE_object *ole, int miniFAT_sector_start)
 
         /** 1. We cannot point to ourselves **/
         if (current_sector == next_sector)
+        {
             break;
+        }
 
         chain_length++;
         current_sector = next_sector;
@@ -1232,14 +1280,14 @@ int OLE_follow_minichain(struct OLE_object *ole, int miniFAT_sector_start)
         /** Test for non-positive type sector ID's **/
         switch (current_sector)
         {
-        case OLE_SECTORID_MSAT:
-        case OLE_SECTORID_SAT:
-        case OLE_SECTORID_ENDOFCHAIN:
-        case OLE_SECTORID_FREE:
-            break_out = 1;
-            break;
-        default:
-            break_out = 0;
+            case OLE_SECTORID_MSAT:
+            case OLE_SECTORID_SAT:
+            case OLE_SECTORID_ENDOFCHAIN:
+            case OLE_SECTORID_FREE:
+                break_out = 1;
+                break;
+            default:
+                break_out = 0;
         };
 
         DOLE LOGGER_log("%s:%d:OLE_follow_minichain:DEBUG: current sector = %d", FL, current_sector);
@@ -1285,7 +1333,9 @@ unsigned char *OLE_load_minichain(struct OLE_object *ole, int miniFAT_sector_sta
 
     /* Added this sanity checking 2003 Aug 28 */
     if (miniFAT_sector_start < 0)
+    {
         return NULL;
+    }
 
     chain_length = OLE_follow_minichain(ole, miniFAT_sector_start);
     DOLE LOGGER_log("%s:%d:OLE_load_minichain:DEBUG: Found %d mini-sectors to load (%d bytes)\n", FL, chain_length,
@@ -1294,7 +1344,9 @@ unsigned char *OLE_load_minichain(struct OLE_object *ole, int miniFAT_sector_sta
     /* 20040911-21H59 */
     /* If our chain is 0 length, then there's nothing to return */
     if (chain_length == 0)
+    {
         return NULL;
+    }
 
     bp = buffer = MALLOC(chain_length * ole->header.mini_sector_size * sizeof(unsigned char));
     if (buffer != NULL)
@@ -1313,14 +1365,14 @@ unsigned char *OLE_load_minichain(struct OLE_object *ole, int miniFAT_sector_sta
             /* NEXT LINES ADDED TO BE COHERENT WITH  OLE_follow_minichain ABOVE Serge Steer Scilab */
             switch (current_sector)
             {
-            case OLE_SECTORID_MSAT:
-            case OLE_SECTORID_SAT:
-            case OLE_SECTORID_ENDOFCHAIN:
-            case OLE_SECTORID_FREE:
-                break_out = 1;
-                break;
-            default:
-                break_out = 0;
+                case OLE_SECTORID_MSAT:
+                case OLE_SECTORID_SAT:
+                case OLE_SECTORID_ENDOFCHAIN:
+                case OLE_SECTORID_FREE:
+                    break_out = 1;
+                    break;
+                default:
+                    break_out = 0;
             };
             /* Test changed  Serge Steer Scilab */
             /* } while ((current_sector != OLE_SECTORID_ENDOFCHAIN)&&(current_sector >= 0)&&(current_sector <= ole->last_sector)); */
@@ -1368,7 +1420,9 @@ unsigned char *OLE_load_chain(struct OLE_object *ole, int FAT_sector_start)
     ole->last_chain_size = 0;
 
     if (FAT_sector_start < 0)
+    {
         return NULL;
+    }
 
     DOLE LOGGER_log("%s:%d:OLE_load_chain:DEBUG: Loading chain, starting at sector %d", FL, FAT_sector_start);
 
@@ -1477,7 +1531,9 @@ int OLE_open_file(struct OLE_object *ole, char *fullpath)
     DOLE LOGGER_log("%s:%d:OLE_open_file:DEBUG: File size of %s = %ld", FL, fullpath, st.st_size);
 
     if ((stat_result == 0) && (st.st_size < 512))
+    {
         return OLEER_NOT_OLE_FILE;
+    }
 
     ole->file_size = st.st_size;
 
@@ -1533,14 +1589,18 @@ int OLE_open_directory(struct OLE_object *ole, char *directory)
     /* If the function succeeds, the return value is nonzero.
      * If the function fails, the return value is zero. */
     if (result)
+    {
         result = 0;
+    }
 #endif
     if ((result != 0) && (errno != EEXIST))
     {
         LOGGER_log(_("%s:%d:OLE_open_directory:ERROR: %s"), FL, strerror(errno));
     }
     else
+    {
         result = OLE_OK;
+    }
 
     return result;
 }
@@ -1656,36 +1716,46 @@ int OLE_store_stream(struct OLE_object *ole, char *stream_name, char *directory,
 int OLE_decode_file_done(struct OLE_object *ole)
 {
     if (ole->f)
+    {
         fclose(ole->f);
-        /** Why weren't these active? (they were commented out ) **/
+    }
+    /** Why weren't these active? (they were commented out ) **/
     if (ole->FAT)
+    {
         FREE(ole->FAT);
+    }
     if (ole->miniFAT)
+    {
         FREE(ole->miniFAT);
+    }
     if (ole->ministream)
+    {
         FREE(ole->ministream);
+    }
     if (ole->properties)
+    {
         FREE(ole->properties);
+    }
 
     return 0;
 }
 
-    /*-----------------------------------------------------------------\
-       Function Name   : OLE_terminate_and_return
-       Returns Type    : int
-       ----Parameter List
-       1. struct OLE_object *ole,
-       2.  int result ,
-       ------------------
-       Exit Codes      :
-       Side Effects    :
-       --------------------------------------------------------------------
-       Comments:
+/*-----------------------------------------------------------------\
+Function Name  : OLE_terminate_and_return
+Returns Type   : int
+----Parameter List
+1. struct OLE_object *ole,
+2.  int result ,
+------------------
+Exit Codes     :
+Side Effects   :
+--------------------------------------------------------------------
+Comments:
 
-       --------------------------------------------------------------------
-       Changes:
+--------------------------------------------------------------------
+Changes:
 
-       \------------------------------------------------------------------*/
+\------------------------------------------------------------------*/
 int OLE_terminate_and_return(struct OLE_object *ole, int result)
 {
     OLE_decode_file_done(ole);
@@ -1696,43 +1766,52 @@ int OLE_terminate_and_return(struct OLE_object *ole, int result)
 int OLE_walk_tree(struct OLE_object *ole, char *fname, char *decode_path, int depth)
 {
 
-        /** Sanity check **/
+    /** Sanity check **/
 
     if (depth > 100)
+    {
         return 0;
+    }
     if (ole->total_file_count > 10000)
+    {
         return 0;
+    }
     if (element_type < 0)
+    {
         return 0;
+    }
 
     switch (element_type)
     {
 
-    case STGTY_ROOT:
-        /** ROOT DIRECTORY ENTRY **/
-        /** ROOT DIRECTORY ENTRY **/
-        /** ROOT DIRECTORY ENTRY **/
-        DOLE LOGGER_log("%s:%d:OLE_walk_tree:DEBUG: Loading ministream/SmallBlockArray", FL);
-        ole->ministream = OLE_load_chain(ole, adir->start_sector);
-        if (ole->ministream == NULL)
-            return OLEER_MINISTREAM_READ_FAIL;
-        DOLE LOGGER_log("%s:%d:OLE_decode_file:DEBUG: ministream done", FL);
+        case STGTY_ROOT:
+            /** ROOT DIRECTORY ENTRY **/
+            /** ROOT DIRECTORY ENTRY **/
+            /** ROOT DIRECTORY ENTRY **/
+            DOLE LOGGER_log("%s:%d:OLE_walk_tree:DEBUG: Loading ministream/SmallBlockArray", FL);
+            ole->ministream = OLE_load_chain(ole, adir->start_sector);
+            if (ole->ministream == NULL)
+            {
+                return OLEER_MINISTREAM_READ_FAIL;
+            }
+            DOLE LOGGER_log("%s:%d:OLE_decode_file:DEBUG: ministream done", FL);
     }
 
 }
 
-else
-if (adir->element_type == STGTY_STORAGE)
+else if (adir->element_type == STGTY_STORAGE)
 {
-        /** STORAGE ELEMENT **/
-        /** STORAGE ELEMENT **/
-        /** STORAGE ELEMENT **/
-DOLE LOGGER_log("%s:%d:OLE_decode_file:DEBUG: Item is directory, start child is at index %d\n", FL, i);
+    /** STORAGE ELEMENT **/
+    /** STORAGE ELEMENT **/
+    /** STORAGE ELEMENT **/
+    DOLE LOGGER_log("%s:%d:OLE_decode_file:DEBUG: Item is directory, start child is at index %d\n", FL, i);
 
-ole->ministream = OLE_load_chain(ole, adir->start_sector);
-if (ole->ministream == NULL)
-    return OLEER_MINISTREAM_READ_FAIL;
-DOLE LOGGER_log("%s:%d:OLE_decode_file:DEBUG: DIRECTORY ministream done", FL);
+    ole->ministream = OLE_load_chain(ole, adir->start_sector);
+    if (ole->ministream == NULL)
+    {
+        return OLEER_MINISTREAM_READ_FAIL;
+    }
+    DOLE LOGGER_log("%s:%d:OLE_decode_file:DEBUG: DIRECTORY ministream done", FL);
 
 }
 #endif
@@ -1761,9 +1840,9 @@ int OLE_decode_stream(struct OLE_object *ole, struct OLE_directory_entry *adir,
 
     if (adir->stream_size >= ole->header.mini_cutoff_size)
     {
-            /** Standard size sector stored stream **/
-            /** Standard size sector stored stream **/
-            /** Standard size sector stored stream **/
+        /** Standard size sector stored stream **/
+        /** Standard size sector stored stream **/
+        /** Standard size sector stored stream **/
         DOLE LOGGER_log("%s:%d:OLE_decode_stream:DEBUG:  Loading normal sized chain starting at sector %d", FL, adir->start_sector);
 
         stream_data = (char *)OLE_load_chain(ole, adir->start_sector);
@@ -1782,9 +1861,9 @@ int OLE_decode_stream(struct OLE_object *ole, struct OLE_directory_entry *adir,
     else
     {
 
-            /** Minichain/Minisector stored stream **/
-            /** Minichain/Minisector stored stream **/
-            /** Minichain/Minisector stored stream **/
+        /** Minichain/Minisector stored stream **/
+        /** Minichain/Minisector stored stream **/
+        /** Minichain/Minisector stored stream **/
         DOLE LOGGER_log("%s:%d:OLE_decode_stream:DEBUG: Minichain loader, starting at sector %d", FL, adir->start_sector);
 
         stream_data = (char *)OLE_load_minichain(ole, adir->start_sector);
@@ -1803,7 +1882,7 @@ int OLE_decode_stream(struct OLE_object *ole, struct OLE_directory_entry *adir,
 
     /* Added for Scilab */
     if ((stream_data != NULL) && (decode_result == OLEUW_STREAM_NOT_DECODED) &&
-        (ole->save_unknown_streams == 2) && ((strcmp(element_name, "Workbook") == 0) || (strcmp(element_name, "Book") == 0)))
+            (ole->save_unknown_streams == 2) && ((strcmp(element_name, "Workbook") == 0) || (strcmp(element_name, "Book") == 0)))
     {
         strcpy(element_name, "Workbook");
         OLE_store_stream(ole, element_name, decode_path, stream_data, adir->stream_size);
@@ -1827,27 +1906,29 @@ int OLE_decode_stream(struct OLE_object *ole, struct OLE_directory_entry *adir,
     /* Clean up an stream_data which we may have */
     /* read in from the chain-loader. */
     if (stream_data)
+    {
         FREE(stream_data);
+    }
 
     return result;
 }
 
-    /*-----------------------------------------------------------------\
-       Function Name   : OLE_decode_file
-       Returns Type    : int
-       ----Parameter List
-       1. char *fname,
-       2.  char *decode_path ,
-       ------------------
-       Exit Codes      :
-       Side Effects    :
-       --------------------------------------------------------------------
-       Comments:
+/*-----------------------------------------------------------------\
+Function Name  : OLE_decode_file
+Returns Type   : int
+----Parameter List
+1. char *fname,
+2.  char *decode_path ,
+------------------
+Exit Codes     :
+Side Effects   :
+--------------------------------------------------------------------
+Comments:
 
-       --------------------------------------------------------------------
-       Changes:
+--------------------------------------------------------------------
+Changes:
 
-       \------------------------------------------------------------------*/
+\------------------------------------------------------------------*/
 int OLE_decode_file(struct OLE_object *ole, char *fname, char *decode_path)
 {
     unsigned char *current_property, *property_limit;
@@ -1856,11 +1937,17 @@ int OLE_decode_file(struct OLE_object *ole, char *fname, char *decode_path)
 
     /* Reject any bad paramters. */
     if (ole == NULL)
+    {
         return OLEER_DECODE_NULL_OBJECT;
+    }
     if (fname == NULL)
+    {
         return OLEER_DECODE_NULL_FILENAME;
+    }
     if (decode_path == NULL)
+    {
         return OLEER_DECODE_NULL_PATH;
+    }
 
     /* We need to gain access to the OLE2 data file, without */
     /*      this pretty much everything is pointless. */
@@ -1868,7 +1955,9 @@ int OLE_decode_file(struct OLE_object *ole, char *fname, char *decode_path)
 
     result = OLE_open_file(ole, fname);
     if (result != 0)
+    {
         return result;
+    }
 
     /* Try create the output directory which we're using */
     /*      to write the decoded files out to. */
@@ -1876,7 +1965,9 @@ int OLE_decode_file(struct OLE_object *ole, char *fname, char *decode_path)
 
     result = OLE_open_directory(ole, decode_path);
     if (result != 0)
+    {
         return result;
+    }
 
     /* In order to successfully decode an OLE2 stream, we have to read */
     /*      and understand the first 512 bytes of the file, this is the */
@@ -1885,17 +1976,23 @@ int OLE_decode_file(struct OLE_object *ole, char *fname, char *decode_path)
 
     result = OLE_get_header(ole);
     if (result != 0)
+    {
         return result;
+    }
 
     DOLE LOGGER_log("%s:%d:OLE_decode_file:DEBUG: Converting main header", FL);
 
     result = OLE_convert_header(ole);
     if (result != 0)
+    {
         return result;
+    }
 
     result = OLE_header_sanity_check(ole);
     if (result > 0)
+    {
         return OLEER_INSANE_OLE_FILE;
+    }
 
     DOLE OLE_print_header(ole);
 
@@ -1903,7 +2000,9 @@ int OLE_decode_file(struct OLE_object *ole, char *fname, char *decode_path)
 
     result = OLE_load_FAT(ole);
     if (result != 0)
+    {
         return result;
+    }
 
     DOLE LOGGER_log("%s:%d:OLE_decode_file:DEBUG: Loading miniFAT chain", FL);
 
@@ -1915,7 +2014,9 @@ int OLE_decode_file(struct OLE_object *ole, char *fname, char *decode_path)
 
     ole->properties = OLE_load_chain(ole, ole->header.directory_stream_start_sector);
     if (ole->properties == NULL)
+    {
         return OLEER_PROPERTIES_READ_FAIL;
+    }
 
     i = 0;
     current_property = ole->properties;
@@ -1932,7 +2033,9 @@ int OLE_decode_file(struct OLE_object *ole, char *fname, char *decode_path)
 
         property_value = get_1byte_value(current_property);
         if (property_value < 1)
+        {
             break;
+        }
 
         DOLE LOGGER_log("%s:%d:OLE_decode_file:DEBUG:--------- DIRECTORY INDEX: %d", FL, i);
 
@@ -1946,7 +2049,9 @@ int OLE_decode_file(struct OLE_object *ole, char *fname, char *decode_path)
         }
 
         if (adir->element_colour > 1)
+        {
             break;
+        }
 
         if ((adir->element_type == STGTY_INVALID) || (adir->element_type > STGTY_ROOT))
         {
@@ -1957,9 +2062,9 @@ int OLE_decode_file(struct OLE_object *ole, char *fname, char *decode_path)
         }
         else if (adir->element_type == STGTY_ROOT)
         {
-                /** ROOT DIRECTORY ENTRY **/
-                /** ROOT DIRECTORY ENTRY **/
-                /** ROOT DIRECTORY ENTRY **/
+            /** ROOT DIRECTORY ENTRY **/
+            /** ROOT DIRECTORY ENTRY **/
+            /** ROOT DIRECTORY ENTRY **/
             DOLE LOGGER_log("%s:%d:OLE_decode_file:DEBUG: Loading ministream/SmallBlockArray", FL);
 
             ole->ministream = OLE_load_chain(ole, adir->start_sector);
@@ -1970,9 +2075,9 @@ int OLE_decode_file(struct OLE_object *ole, char *fname, char *decode_path)
         }
         else if (adir->element_type == STGTY_STORAGE)
         {
-                /** STORAGE ELEMENT **/
-                /** STORAGE ELEMENT **/
-                /** STORAGE ELEMENT **/
+            /** STORAGE ELEMENT **/
+            /** STORAGE ELEMENT **/
+            /** STORAGE ELEMENT **/
             DOLE LOGGER_log("%s:%d:OLE_decode_file:DEBUG: Item is directory, start child is at index %d\n", FL, i);
 
             ole->ministream = OLE_load_chain(ole, adir->start_sector);
@@ -1983,9 +2088,9 @@ int OLE_decode_file(struct OLE_object *ole, char *fname, char *decode_path)
         }
         else if (adir->element_type == STGTY_STREAM)
         {
-                /** STREAM ELEMENT **/
-                /** STREAM ELEMENT **/
-                /** STREAM ELEMENT **/
+            /** STREAM ELEMENT **/
+            /** STREAM ELEMENT **/
+            /** STREAM ELEMENT **/
             /* due to ole.c bugs we restrict here steams to decode to Workbooks (Excel) */
             char element_name[64];
 
@@ -2002,9 +2107,9 @@ int OLE_decode_file(struct OLE_object *ole, char *fname, char *decode_path)
         }
         else
         {
-                /** If the element isn't of the above types then it's possibly
-                               ** an empty element or just one used for the MSAT/SAT
-                               ** either way we just step over it and carry on **/
+            /** If the element isn't of the above types then it's possibly
+            ** an empty element or just one used for the MSAT/SAT
+            ** either way we just step over it and carry on **/
             DOLE LOGGER_log("%s:%d:OLE_decode_file:DEBUG: Element type %d does not need to be handled", FL, adir->element_type);
         }
 
index 2a307df..a34f3d7 100644 (file)
 #include "MALLOC.h"
 #include "charEncoding.h"
 #ifdef _MSC_VER
-       #include "strdup_windows.h"
+#include "strdup_windows.h"
 #endif
 
 
 #define DUW if (oleuw->debug)
 
-struct OLE10_header{
-       unsigned char data[6];
-       char *attach_name;
-       unsigned char data2[8];
-       char *fname_1;
-       char *fname_2;
-       size_t attach_size;
-       size_t attach_size_1;
-       size_t attach_start_offset;
+struct OLE10_header
+{
+    unsigned char data[6];
+    char *attach_name;
+    unsigned char data2[8];
+    char *fname_1;
+    char *fname_2;
+    size_t attach_size;
+    size_t attach_size_1;
+    size_t attach_start_offset;
 };
 
 
@@ -47,11 +48,11 @@ struct OLE10_header{
 \------------------------------------------------------------------*/
 int OLEUNWRAP_init( struct OLEUNWRAP_object *oleuw )
 {
-       oleuw->debug = 0;
-       oleuw->verbose = 0;
-       oleuw->filename_report_fn = NULL;
+    oleuw->debug = 0;
+    oleuw->verbose = 0;
+    oleuw->filename_report_fn = NULL;
 
-       return OLEUW_OK;
+    return OLEUW_OK;
 }
 
 /*-----------------------------------------------------------------\
@@ -72,8 +73,8 @@ int OLEUNWRAP_init( struct OLEUNWRAP_object *oleuw )
 \------------------------------------------------------------------*/
 int OLEUNWRAP_set_debug( struct OLEUNWRAP_object *oleuw, int level )
 {
-       oleuw->debug = level;
-       return OLEUW_OK;
+    oleuw->debug = level;
+    return OLEUW_OK;
 }
 
 /*-----------------------------------------------------------------\
@@ -94,8 +95,8 @@ int OLEUNWRAP_set_debug( struct OLEUNWRAP_object *oleuw, int level )
 \------------------------------------------------------------------*/
 int OLEUNWRAP_set_verbose( struct OLEUNWRAP_object *oleuw, int level )
 {
-       oleuw->verbose = level;
-       return OLEUW_OK;
+    oleuw->verbose = level;
+    return OLEUW_OK;
 }
 
 /*-----------------------------------------------------------------\
@@ -116,8 +117,8 @@ int OLEUNWRAP_set_verbose( struct OLEUNWRAP_object *oleuw, int level )
 \------------------------------------------------------------------*/
 int OLEUNWRAP_set_save_unknown_streams( struct OLEUNWRAP_object *oleuw, int level )
 {
-       oleuw->save_unknown_streams = level;
-       return OLEUW_OK;
+    oleuw->save_unknown_streams = level;
+    return OLEUW_OK;
 }
 
 
@@ -140,48 +141,53 @@ int OLEUNWRAP_set_save_unknown_streams( struct OLEUNWRAP_object *oleuw, int leve
 \------------------------------------------------------------------*/
 int OLEUNWRAP_save_stream( struct OLEUNWRAP_object *oleuw, char *fname, char *decode_path, char *stream, size_t bytes )
 {
-       char *full_name;
-       FILE *f;
-       int result = 0;
-
-       DUW LOGGER_log("%s:%d:OLEUNWRAP_save_stream:DEBUG: fname=%s, decodepath=%s, size=%ld"
-                       ,FL
-                       ,fname
-                       ,decode_path
-                       ,bytes
-                       );
-
-       full_name = PLD_dprintf("%s/%s", decode_path, fname );
-       if (full_name == NULL)
-       {
-               LOGGER_log(_("%s:%d:OLEUNWRAP_save_stream:ERROR: Unable to create filename string from '%s' and '%s'"),FL,fname,decode_path);
-               return -1;
-       }
-
-       wcfopen(f, full_name, "wb");
-       if (f != NULL)
-       {
-               size_t write_count;
-
-               write_count = fwrite( stream, 1, bytes, f );
-               if (write_count != bytes)
-               {
-                       LOGGER_log(_("%s:%d:OLEUNWRAP_save_stream:WARNING: Only wrote %d of %d bytes to file %s\n"),FL, write_count, bytes, full_name );
-               }
-
-               fclose(f);
-
-
-       } else {
-               LOGGER_log(_("%s:%d:OLEUNWRAP_save_stream:ERROR: Unable to open %s for writing (%s)\n"),FL,full_name, strerror(errno));
-               result = -1;
-       }
-
-       if (full_name) FREE(full_name);
-
-       DUW LOGGER_log("%s:%d:OLEUNWRAP_save_stream:DEBUG: Done saving '%s'",FL, fname);
-
-       return result;
+    char *full_name;
+    FILE *f;
+    int result = 0;
+
+    DUW LOGGER_log("%s:%d:OLEUNWRAP_save_stream:DEBUG: fname=%s, decodepath=%s, size=%ld"
+                   , FL
+                   , fname
+                   , decode_path
+                   , bytes
+                  );
+
+    full_name = PLD_dprintf("%s/%s", decode_path, fname );
+    if (full_name == NULL)
+    {
+        LOGGER_log(_("%s:%d:OLEUNWRAP_save_stream:ERROR: Unable to create filename string from '%s' and '%s'"), FL, fname, decode_path);
+        return -1;
+    }
+
+    wcfopen(f, full_name, "wb");
+    if (f != NULL)
+    {
+        size_t write_count;
+
+        write_count = fwrite( stream, 1, bytes, f );
+        if (write_count != bytes)
+        {
+            LOGGER_log(_("%s:%d:OLEUNWRAP_save_stream:WARNING: Only wrote %d of %d bytes to file %s\n"), FL, write_count, bytes, full_name );
+        }
+
+        fclose(f);
+
+
+    }
+    else
+    {
+        LOGGER_log(_("%s:%d:OLEUNWRAP_save_stream:ERROR: Unable to open %s for writing (%s)\n"), FL, full_name, strerror(errno));
+        result = -1;
+    }
+
+    if (full_name)
+    {
+        FREE(full_name);
+    }
+
+    DUW LOGGER_log("%s:%d:OLEUNWRAP_save_stream:DEBUG: Done saving '%s'", FL, fname);
+
+    return result;
 }
 
 /*-----------------------------------------------------------------\
@@ -201,13 +207,19 @@ int OLEUNWRAP_save_stream( struct OLEUNWRAP_object *oleuw, char *fname, char *de
 \------------------------------------------------------------------*/
 int OLEUNWRAP_sanitize_filename( char *fname )
 {
-               while (*fname)
-               {
-                       if( !isalnum((int)*fname) && (*fname != '.') ) *fname='_';
-                       if( (*fname < ' ')||(*fname > '~') ) *fname='_';
-                       fname++;
-               }
-               return 0;
+    while (*fname)
+    {
+        if ( !isalnum((int)*fname) && (*fname != '.') )
+        {
+            *fname = '_';
+        }
+        if ( (*fname < ' ') || (*fname > '~') )
+        {
+            *fname = '_';
+        }
+        fname++;
+    }
+    return 0;
 }
 
 /*-----------------------------------------------------------------\
@@ -227,84 +239,101 @@ int OLEUNWRAP_sanitize_filename( char *fname )
 \------------------------------------------------------------------*/
 int OLEUNWRAP_decode_attachment( struct OLEUNWRAP_object *oleuw, char *stream, size_t stream_size, char *decode_path )
 {
-       struct OLE10_header oh;
-       char *sp = stream;
-       char *data_start_point = stream;
-       int result = OLEUW_OK;
-
-       /* Get the data size*/
-       oh.attach_size_1 = (size_t)get_4byte_value( (unsigned char *) sp );
-       sp += 4;
-
-       DUW LOGGER_log("%s:%d:OLEUNWRAP_decode_attachment:DEBUG: attachsize = %d, stream length = %d\n", FL, oh.attach_size_1, stream_size );
-
-       oh.attach_start_offset = (stream_size -oh.attach_size_1);
-       data_start_point = stream +oh.attach_start_offset;
-
-       /*if (oh.attach_start_offset == 4)*/
-       if (oh.attach_start_offset < 4)
-       {
-         /* If we only had the stream byte-lenght in our header*/
-         /*            then we know we don't have a complex header.*/
-               oh.attach_name = PLD_dprintf("unknown-%ld",oh.attach_size_1);
-               oh.attach_size = oh.attach_size_1;
-       } else {
-
-               DUW LOGGER_log("%s:%d:OLEUNWRAP_decode_attachment:DEBUG: Decoding file information header",FL);
-               /* Unknown memory segment*/
-               memcpy( oh.data, sp, 2 );
-               sp += 2;
-
-               /* Full attachment string*/
-               oh.attach_name = strdup( sp );
-               sp = sp + strlen(oh.attach_name) +1;
-
-               /* Attachment full path*/
-               oh.fname_1 = strdup( sp );
-               sp += strlen(oh.fname_1) +1;
-
-               /* Unknown memory segment*/
-               memcpy( oh.data2, sp, 8 );
-               sp = sp +8;
-
-               /* Attachment full path*/
-               oh.fname_2 = strdup( sp );
-               sp += strlen(oh.fname_2) +1;
-
-               oh.attach_size = (size_t)get_4byte_value( (unsigned char*) sp );
-               sp += 4;
-
-               if (oh.attach_size > stream_size) oh.attach_size = stream_size;
-
-               data_start_point = sp;
-       }
-
-       DUW LOGGER_log(_("%s:%d:OLEUNWRAP_decode_attachment:DEBUG: Attachment %s:%s:%s size = %d\n"),FL, oh.attach_name, oh.fname_1, oh.fname_2, oh.attach_size );
-
-
-       /** 20050119:2053:PLD - Added to sanitize 8-bit filenames **/
-       /** Sanitize the output filename **/
-       OLEUNWRAP_sanitize_filename(oh.attach_name);
-       OLEUNWRAP_sanitize_filename(oh.fname_1);
-       OLEUNWRAP_sanitize_filename(oh.fname_2);
-
-       result = OLEUNWRAP_save_stream( oleuw, oh.attach_name, decode_path, data_start_point, oh.attach_size );
-       if (result == OLEUW_OK)
-       {
-               if (oleuw->debug > 0) LOGGER_log(_("%s:%d:OLEUNWRAP_decode_attachment:DEBUG: Calling reporter for the filename"),FL);
-               if ((oleuw->verbose > 0)&&(oleuw->filename_report_fn != NULL))
-               {
-                       oleuw->filename_report_fn(oh.attach_name);
-               }
-               /* Do call back to reporting function*/
-       }
-
-       /* Clean up our previously allocated data*/
-       if (oh.fname_1 != NULL) FREE(oh.fname_1);
-       if (oh.attach_name != NULL) FREE(oh.attach_name);
-       if (oh.fname_2 != NULL) FREE(oh.fname_2);
-
-       return OLEUW_OK;
+    struct OLE10_header oh;
+    char *sp = stream;
+    char *data_start_point = stream;
+    int result = OLEUW_OK;
+
+    /* Get the data size*/
+    oh.attach_size_1 = (size_t)get_4byte_value( (unsigned char *) sp );
+    sp += 4;
+
+    DUW LOGGER_log("%s:%d:OLEUNWRAP_decode_attachment:DEBUG: attachsize = %d, stream length = %d\n", FL, oh.attach_size_1, stream_size );
+
+    oh.attach_start_offset = (stream_size - oh.attach_size_1);
+    data_start_point = stream + oh.attach_start_offset;
+
+    /*if (oh.attach_start_offset == 4)*/
+    if (oh.attach_start_offset < 4)
+    {
+        /* If we only had the stream byte-length in our header*/
+        /*             then we know we don't have a complex header.*/
+        oh.attach_name = PLD_dprintf("unknown-%ld", oh.attach_size_1);
+        oh.attach_size = oh.attach_size_1;
+    }
+    else
+    {
+
+        DUW LOGGER_log("%s:%d:OLEUNWRAP_decode_attachment:DEBUG: Decoding file information header", FL);
+        /* Unknown memory segment*/
+        memcpy( oh.data, sp, 2 );
+        sp += 2;
+
+        /* Full attachment string*/
+        oh.attach_name = strdup( sp );
+        sp = sp + strlen(oh.attach_name) + 1;
+
+        /* Attachment full path*/
+        oh.fname_1 = strdup( sp );
+        sp += strlen(oh.fname_1) + 1;
+
+        /* Unknown memory segment*/
+        memcpy( oh.data2, sp, 8 );
+        sp = sp + 8;
+
+        /* Attachment full path*/
+        oh.fname_2 = strdup( sp );
+        sp += strlen(oh.fname_2) + 1;
+
+        oh.attach_size = (size_t)get_4byte_value( (unsigned char*) sp );
+        sp += 4;
+
+        if (oh.attach_size > stream_size)
+        {
+            oh.attach_size = stream_size;
+        }
+
+        data_start_point = sp;
+    }
+
+    DUW LOGGER_log(_("%s:%d:OLEUNWRAP_decode_attachment:DEBUG: Attachment %s:%s:%s size = %d\n"), FL, oh.attach_name, oh.fname_1, oh.fname_2, oh.attach_size );
+
+
+    /** 20050119:2053:PLD - Added to sanitize 8-bit filenames **/
+    /** Sanitize the output filename **/
+    OLEUNWRAP_sanitize_filename(oh.attach_name);
+    OLEUNWRAP_sanitize_filename(oh.fname_1);
+    OLEUNWRAP_sanitize_filename(oh.fname_2);
+
+    result = OLEUNWRAP_save_stream( oleuw, oh.attach_name, decode_path, data_start_point, oh.attach_size );
+    if (result == OLEUW_OK)
+    {
+        if (oleuw->debug > 0)
+        {
+            LOGGER_log(_("%s:%d:OLEUNWRAP_decode_attachment:DEBUG: Calling reporter for the filename"), FL);
+        }
+        if ((oleuw->verbose > 0) && (oleuw->filename_report_fn != NULL))
+        {
+            oleuw->filename_report_fn(oh.attach_name);
+        }
+        /* Do call back to reporting function*/
+    }
+
+    /* Clean up our previously allocated data*/
+    if (oh.fname_1 != NULL)
+    {
+        FREE(oh.fname_1);
+    }
+    if (oh.attach_name != NULL)
+    {
+        FREE(oh.attach_name);
+    }
+    if (oh.fname_2 != NULL)
+    {
+        FREE(oh.fname_2);
+    }
+
+    return OLEUW_OK;
 }
 
 /*-----------------------------------------------------------------\
@@ -325,18 +354,23 @@ int OLEUNWRAP_decode_attachment( struct OLEUNWRAP_object *oleuw, char *stream, s
 \------------------------------------------------------------------*/
 int OLEUNWRAP_decodestream( struct OLEUNWRAP_object *oleuw, char *element_string, char *stream, size_t stream_size, char *decode_path )
 {
-       int result = OLEUW_OK;
-
-       if (strstr(element_string, OLEUW_ELEMENT_10NATIVE_STRING) != NULL)
-       {
-               OLEUNWRAP_decode_attachment( oleuw, stream, stream_size, decode_path );
-
-       } else {
-               if (oleuw->debug) LOGGER_log(_("Unable to decode stream with element string '%s'\n"), element_string);
-               result = OLEUW_STREAM_NOT_DECODED;
-       }
-
-       return result;
+    int result = OLEUW_OK;
+
+    if (strstr(element_string, OLEUW_ELEMENT_10NATIVE_STRING) != NULL)
+    {
+        OLEUNWRAP_decode_attachment( oleuw, stream, stream_size, decode_path );
+
+    }
+    else
+    {
+        if (oleuw->debug)
+        {
+            LOGGER_log(_("Unable to decode stream with element string '%s'\n"), element_string);
+        }
+        result = OLEUW_STREAM_NOT_DECODED;
+    }
+
+    return result;
 }
 
 
@@ -359,8 +393,8 @@ int OLEUNWRAP_decodestream( struct OLEUNWRAP_object *oleuw, char *element_string
 int OLEUNWRAP_set_filename_report_fn( struct OLEUNWRAP_object *oleuw, int (*ptr_to_fn)(char *) )
 {
 
-       oleuw->filename_report_fn = ptr_to_fn;
+    oleuw->filename_report_fn = ptr_to_fn;
 
-       return 0;
+    return 0;
 }
 
index 9b989b6..e2d078a 100644 (file)
@@ -10,7 +10,7 @@
 
 function s=samplef(n,X,f,orient)
 // 
-//This function gives s, a  vector of lenght n.  It contains
+//This function gives s, a  vector of length n.  It contains
 //a  sample of  n  extractions, with  replacement, from  the
 //vector  (or  matrix)  X,  each element  counted  with  the
 //frequence given by the corresponding value in vector f.
@@ -19,14 +19,14 @@ function s=samplef(n,X,f,orient)
 //vector s whose values are a random sample of n values from
 //X,   each  value   with  a   probability  to   be  sampled
 //proportional  to the corresponding  value of  f, extracted
-//with replacement, from X.  f must have same lenght than X.
+//with replacement, from X.  f must have same length than X.
 //
 //s=samplef(n,X,f,'r')           (or,          equivalently,
 //s=samplef(n,X,f,1))    returns    a    matrix   of    type
 //size(X,'r')xn.  It contains a random sample of n rows from
 //X, each row with  a probability to be sampled proportional
 //to   the  corresponding   value  of   f,   extracted  with
-//replacement, from the  rows of X. The lenght  of f must be
+//replacement, from the  rows of X. The length  of f must be
 //equal to the number of rows of X.
 //
 //s=samplef(n,X,f,'c')           (or,          equivalently,
@@ -34,7 +34,7 @@ function s=samplef(n,X,f,orient)
 //nxsize(X,'c').  It  contains a random sample  of n columns
 //from  X, each  column  with a  probability  to be  sampled
 //proportional  to the corresponding  value of  f, extracted
-//with replacement, from the columns  of X.  The lenght of f
+//with replacement, from the columns  of X.  The length of f
 //must be equal to the number of columns of X.
 //
   [lhs,rhs]=argn(0)
index 46688c7..2eaa33d 100644 (file)
@@ -2,22 +2,22 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) INRIA - Allan CORNET , Cong WU
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
 
-/* desc : The algorithm of stripblanks                                    */                                    
+/* desc : The algorithm of stripblanks                                    */
 /*------------------------------------------------------------------------*/
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include "gw_string.h"
-#include "MALLOC.h" 
+#include "MALLOC.h"
 #include "stripblanks.h"
 #include "freeArrayOfString.h"
 /*------------------------------------------------------------------------*/
@@ -28,107 +28,124 @@ static char* substr(const char*str, unsigned start, unsigned end);
 /*------------------------------------------------------------------------*/
 static char* substr(const char*str, unsigned start, unsigned end)
 {
-       unsigned n = end - start;
-       char *stbuf = NULL;
-    stbuf = (char*)MALLOC(sizeof(char)*(n+1));
-       
-       if (stbuf)
-       {
-               if ( strcmp(str,"") != 0 )
-               {
-                       strncpy(stbuf, str + start, n);   /*Put a part of str into stbuf*/
-                       stbuf[n] = 0;
-               }
-               else strcpy(stbuf,"");
-       }
-       return stbuf;
+    unsigned n = end - start;
+    char *stbuf = NULL;
+    stbuf = (char*)MALLOC(sizeof(char) * (n + 1));
+
+    if (stbuf)
+    {
+        if ( strcmp(str, "") != 0 )
+        {
+            strncpy(stbuf, str + start, n);   /*Put a part of str into stbuf*/
+            stbuf[n] = 0;
+        }
+        else
+        {
+            strcpy(stbuf, "");
+        }
+    }
+    return stbuf;
 }
 /*------------------------------------------------------------------------*/
-void stripblanks(char **InputStrings,char **OutputStrings,int InputStringsDim,BOOL withTAB)
+void stripblanks(char **InputStrings, char **OutputStrings, int InputStringsDim, BOOL withTAB)
 {
     int x = 0;
-       char *replacedstr = NULL;
+    char *replacedstr = NULL;
+
+    for ( x = 0; x < InputStringsDim ; x++)   /*Search for all the matrix*/
+    {
+        int lengthInput_One = 0;
+        int lengthInput_Two = 0;
+        int i = 0;
+
+        /* search character ' ' or TAB from end of the string */
+        for ( i = (int)strlen(InputStrings[x]) - 1 ; i > 0 ; i--)
+        {
+            if (withTAB)
+            {
+                if ( (InputStrings[x][i] == (char)BLANK_CHARACTER) ||
+                        (InputStrings[x][i] == (char)TAB_CHARACTER) )
+                {
+                    continue;
+                }
+                else
+                {
+                    lengthInput_Two = i;
+                    break;
+                }
+            }
+            else
+            {
+                if (InputStrings[x][i] == (char)BLANK_CHARACTER)
+                {
+                    continue;
+                }
+                else
+                {
+                    lengthInput_Two = i;
+                    break;
+                }
+            }
+        }
+        /* search character ' ' or TAB from beginning of the string */
+        if (lengthInput_Two > 0)
+        {
+            for (i = 0; i < (int)strlen(InputStrings[x]); i++)
+            {
+                if (withTAB)
+                {
+                    if ( (InputStrings[x][i] == (char)BLANK_CHARACTER) ||
+                            (InputStrings[x][i] == (char)TAB_CHARACTER) )
+                    {
+                        continue;
+                    }
+                    else
+                    {
+                        lengthInput_One = i;
+                        break;
+                    }
+                }
+                else
+                {
+                    if (InputStrings[x][i] == (char)BLANK_CHARACTER)
+                    {
+                        continue;
+                    }
+                    else
+                    {
+                        lengthInput_One = i;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (lengthInput_One <= lengthInput_Two )
+        {
+            if ( (lengthInput_Two == 0)
+                    && ( (InputStrings[x][0] == (char)BLANK_CHARACTER )
+                         || (withTAB && (InputStrings[x][0] == (char)TAB_CHARACTER)) ) )
+            {
+                strcpy(OutputStrings[x], "\0");
+            }
+            else
+            {
+                /*Get the substring without tabs*/
+                replacedstr = substr(InputStrings[x], lengthInput_One, lengthInput_Two + 1 );
+                /*To add the substring into the output matrix*/
+                strcpy(OutputStrings[x], replacedstr);
+            }
 
-       for ( x = 0; x < InputStringsDim ; x++)   /*Search for all the matrix*/
-       {
-               int lenghtInput_One = 0;
-               int lenghtInput_Two = 0;
-               int i = 0;
-               
-               /* search character ' ' or TAB from end of the string */
-               for ( i = (int)strlen(InputStrings[x]) - 1 ; i > 0 ; i--)
-               {
-                       if (withTAB)
-                       {
-                               if ( (InputStrings[x][i] == (char)BLANK_CHARACTER) ||
-                                        (InputStrings[x][i] == (char)TAB_CHARACTER) )
-                                        continue;
-                               else
-                               {
-                                       lenghtInput_Two = i;
-                                       break;
-                               }
-                       }
-                       else
-                       {
-                               if (InputStrings[x][i] == (char)BLANK_CHARACTER)        continue;
-                               else
-                               {
-                                       lenghtInput_Two = i;
-                                       break;
-                               }
-                       }
-               }
-               /* search character ' ' or TAB from beginning of the string */
-               if (lenghtInput_Two > 0)
-               {
-                       for (i = 0;i<(int)strlen(InputStrings[x]); i++)
-                       {
-                               if (withTAB)
-                               {
-                                       if ( (InputStrings[x][i] == (char)BLANK_CHARACTER) ||
-                                               (InputStrings[x][i] == (char)TAB_CHARACTER) )
-                                               continue;
-                                       else
-                                       {
-                                               lenghtInput_One = i;
-                                               break;
-                                       }
-                               }
-                               else
-                               {
-                                       if (InputStrings[x][i] == (char)BLANK_CHARACTER)        continue;
-                                       else
-                                       {
-                                               lenghtInput_One = i;
-                                               break;
-                                       }
-                               }
-                       }
-               }
-               
-               if (lenghtInput_One <= lenghtInput_Two )
-               {
-                       if( (lenghtInput_Two == 0)
-                               && ( (InputStrings[x][0] == (char)BLANK_CHARACTER )
-                                       || (withTAB && (InputStrings[x][0] == (char)TAB_CHARACTER)) ) )
-                       {
-                               strcpy(OutputStrings[x],"\0");
-                       }
-                       else
-                       {
-                               /*Get the substring without tabs*/ 
-                               replacedstr=substr(InputStrings[x], lenghtInput_One, lenghtInput_Two+1 );
-                               /*To add the substring into the output matrix*/
-                               strcpy(OutputStrings[x],replacedstr);
-                       }
-                       
-                       if (replacedstr) {FREE(replacedstr);replacedstr = NULL;}
-               }
-               else
-               {
-                       strcpy(OutputStrings[x],InputStrings[x]);
-               }
-       }
+            if (replacedstr)
+            {
+                FREE(replacedstr);
+                replacedstr = NULL;
+            }
+        }
+        else
+        {
+            strcpy(OutputStrings[x], InputStrings[x]);
+        }
+    }
 }
 /*------------------------------------------------------------------------*/
index d9f894d..e95ba75 100644 (file)
@@ -24,7 +24,7 @@ function [x,y,typ]=PENDULUM_ANIM(job,arg1,arg2)
       if ~ok then break,end
       mess=[]
       if plen<=0|csiz<=0 then
-        mess=[mess;'Pendulum lenght and cart size must be positive.';' ']
+        mess=[mess;'Pendulum length and cart size must be positive.';' ']
         ok=%f
       end
       if ymin>=ymax then
index 133233c..ce50305 100644 (file)
@@ -24,7 +24,7 @@ function [x,y,typ]=PENDULUM_ANIM(job,arg1,arg2)
       if ~ok then break,end
       mess=[]
       if plen<=0|csiz<=0 then
-        mess=[mess;'Pendulum lenght and cart size must be positive.';' ']
+        mess=[mess;'Pendulum length and cart size must be positive.';' ']
         ok=%f
       end
       if ymin>=ymax then