Unformize the syntax to the same kind of declarations 81/8781/2
Sylvestre Ledru [Thu, 23 Aug 2012 09:04:55 +0000 (11:04 +0200)]
CreateVar(nbInputArgument(pvApiCtx) + 1, MATRIX_OF_INTEGER_DATATYPE, (un = 1, &un), (un = 1, &un), &ptrNCONT);
=>
un = 1;
CreateVar(nbInputArgument(pvApiCtx) + 1, MATRIX_OF_INTEGER_DATATYPE, &un, (un = 1, &un), &ptrNCONT);

This will facilitate the translation to api_scilab.

Change-Id: I0db32245dc1d370b4a8553ff30fffce1136f0225

22 files changed:
scilab/modules/cacsd/sci_gateway/c/sci_contr.c
scilab/modules/core/sci_gateway/c/sci_getscilabmode.c
scilab/modules/fileio/sci_gateway/c/sci_filesep.c
scilab/modules/fileio/sci_gateway/c/sci_getrelativefilename.c
scilab/modules/fileio/sci_gateway/c/sci_pathsep.c
scilab/modules/graphics/sci_gateway/c/sci_xgraduate.c
scilab/modules/history_manager/sci_gateway/c/sci_gethistoryfile.c
scilab/modules/interpolation/sci_gateway/c/sci_eval_cshep2d.c
scilab/modules/interpolation/sci_gateway/c/sci_linear_interpn.c
scilab/modules/jvm/sci_gateway/c/sci_system_setproperty.c
scilab/modules/localization/sci_gateway/c/sci_getlanguage.c
scilab/modules/scicos/sci_gateway/c/sci_curblockc.c
scilab/modules/scicos/sci_gateway/c/sci_getscicosvars.c
scilab/modules/scicos/sci_gateway/c/sci_phase_simulation.c
scilab/modules/special_functions/sci_gateway/c/sci_legendre.c
scilab/modules/tclsci/sci_gateway/c/sci_TCL_GetVersion.c
scilab/modules/umfpack/sci_gateway/c/sci_taucs_chsolve.c
scilab/modules/umfpack/sci_gateway/c/sci_umf_lusolve.c
scilab/modules/windows_tools/sci_gateway/c/sci_chartooem.c
scilab/modules/windows_tools/sci_gateway/c/sci_findfileassociation.c
scilab/modules/windows_tools/sci_gateway/c/sci_mcisendstring.c
scilab/modules/windows_tools/sci_gateway/c/sci_oemtochar.c

index 9416cd2..d5ea493 100644 (file)
@@ -1,12 +1,12 @@
 /*
 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-* Copyright (C) INRIA - 
+* Copyright (C) INRIA -
 * Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
-* 
+*
 * 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
 *
 */
@@ -64,84 +64,105 @@ int intab01od(char* fname)
 
     /*     [NCONT,U,KSTAIR,V,A,B]=ab01od(A,B,[TOL])   */
 
-    CheckRhs(2,3);  
-    CheckLhs(1,6);
+    CheckRhs(2, 3);
+    CheckLhs(1, 6);
 
-    if(iIsComplex(1) || GetType(1) != sci_matrix)
+    if (iIsComplex(1) || GetType(1) != sci_matrix)
     {
-        Scierror(999,_("%s: Wrong type for input argument #%d: A real matrix expected.\n"), fname, 1);
-        return 0; 
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), fname, 1);
+        return 0;
     }
 
-    if(iIsComplex(2) || GetType(2) != sci_matrix)
+    if (iIsComplex(2) || GetType(2) != sci_matrix)
     {
-        Scierror(999,_("%s: Wrong type for input argument #%d: A real matrix expected.\n"), fname, 2);
-        return 0; 
+        Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), fname, 2);
+        return 0;
     }
 
-    if(Rhs == 3)
+    if (Rhs == 3)
     {
-        if(iIsComplex(3) || GetType(3) != sci_matrix)
+        if (iIsComplex(3) || GetType(3) != sci_matrix)
         {
-            Scierror(999,_("%s: Wrong type for input argument #%d: A real scalar expected.\n"), fname, 3);
-            return 0; 
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real scalar expected.\n"), fname, 3);
+            return 0;
         }
     }
 
-    theTOL=(double) C2F(dlamch)("e",1L);
-    GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE,&mA,&nA,&ptrA);   
-    A=1;        /*     A */
-    N=mA;
-    theTOL=0.2*sqrt(2*theTOL)*N;
-    GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&mB,&nB,&ptrB);   
-    B=2;        /*     B */
-    M=nB;
+    theTOL = (double) C2F(dlamch)("e", 1L);
+    GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &mA, &nA, &ptrA);
+    A = 1;      /*     A */
+    N = mA;
+    theTOL = 0.2 * sqrt(2 * theTOL) * N;
+    GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &mB, &nB, &ptrB);
+    B = 2;      /*     B */
+    M = nB;
 
     if (nA != mB || mA != nA )
-    { 
-        Scierror(999,_("%s: Wrong values for input arguments #%d and #%d.\n"),fname, 1, 2);  return 0; 
+    {
+        Scierror(999, _("%s: Wrong values for input arguments #%d and #%d.\n"), fname, 1, 2);
+        return 0;
     }
-    if (Rhs == 3) {
+    if (Rhs == 3)
+    {
         /*    TOL is given:   ab01od(A,B,tol)   */
-        GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE,&mtol,&ntol,&ptrTOL);  
-        theTOL=*stk(ptrTOL);    /*     TOL */
-        if (theTOL>1.0||theTOL<0.0) {
-            Scierror(999,_("%s: Wrong value for input argument #%d: Must be in [%d %d].\n"), fname, 3, 0, 1);  return 0;
+        GetRhsVar(3, MATRIX_OF_DOUBLE_DATATYPE, &mtol, &ntol, &ptrTOL);
+        theTOL = *stk(ptrTOL);  /*     TOL */
+        if (theTOL > 1.0 || theTOL < 0.0)
+        {
+            Scierror(999, _("%s: Wrong value for input argument #%d: Must be in [%d %d].\n"), fname, 3, 0, 1);
+            return 0;
         }
     }
 
     /*     dimensions...    */
-    LDA=Max(1,N);  LDB=LDA;  LDU=LDA; LDV=Max(1,M);
-    LDWORK = Max(1, N*M + Max(N,M) + Max(N,3*M));
+    LDA = Max(1, N);
+    LDB = LDA;
+    LDU = LDA;
+    LDV = Max(1, M);
+    LDWORK = Max(1, N * M + Max(N, M) + Max(N, 3 * M));
 
     /*     other parameters of AB01OD   */
-    JOBU= "N"; if (Lhs >= 2)  JOBU="I";
-    JOBV= "N"; if (Lhs >= 4)  JOBV="I";
+    JOBU = "N";
+    if (Lhs >= 2)  JOBU = "I";
+    JOBV = "N";
+    if (Lhs >= 4)  JOBV = "I";
 
     /*     creating NCONT,U,KSTAIR,V,IWORK,DWORK   */
-    CreateVar(Rhs+1,MATRIX_OF_INTEGER_DATATYPE,(un=1,&un),(un=1,&un),&ptrNCONT);  NCONT=Rhs+1;
-    CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&N,&N,&ptrU);  U=Rhs+2;
-    CreateVar(Rhs+3,MATRIX_OF_INTEGER_DATATYPE,(un=1,&un),&N,&ptrKSTAIR);  KSTAIR=Rhs+3;
-    CreateVar(Rhs+4,MATRIX_OF_DOUBLE_DATATYPE,&M,&M,&ptrV);  V=Rhs+4;
-    CreateVar(Rhs+5,MATRIX_OF_INTEGER_DATATYPE,(un=1,&un),&M,&ptrIWORK);
-    CreateVar(Rhs+6,MATRIX_OF_DOUBLE_DATATYPE,(un=1,&un),&LDWORK,&ptrDWORK);
+    un = 1;
+    CreateVar(Rhs + 1, MATRIX_OF_INTEGER_DATATYPE, &un, &un, &ptrNCONT);
+    NCONT = Rhs + 1;
+    CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &N, &N, &ptrU);
+    U = Rhs + 2;
+    CreateVar(Rhs + 3, MATRIX_OF_INTEGER_DATATYPE, &un, &N, &ptrKSTAIR);
+    KSTAIR = Rhs + 3;
+    CreateVar(Rhs + 4, MATRIX_OF_DOUBLE_DATATYPE, &M, &M, &ptrV);
+    V = Rhs + 4;
+    CreateVar(Rhs + 5, MATRIX_OF_INTEGER_DATATYPE, &un, &M, &ptrIWORK);
+    CreateVar(Rhs + 6, MATRIX_OF_DOUBLE_DATATYPE, &un, &LDWORK, &ptrDWORK);
     C2F(ab01od)( "A", JOBU, JOBV, &N, &M, stk(ptrA), &LDA,
-        stk(ptrB), &LDB, stk(ptrU), &LDU, stk(ptrV), &LDV,
-        istk(ptrNCONT), &INDCON, istk(ptrKSTAIR), &theTOL,
-        istk(ptrIWORK), stk(ptrDWORK), &LDWORK, &INFO );
-    if (INFO != 0) {
+                 stk(ptrB), &LDB, stk(ptrU), &LDU, stk(ptrV), &LDV,
+                 istk(ptrNCONT), &INDCON, istk(ptrKSTAIR), &theTOL,
+                 istk(ptrIWORK), stk(ptrDWORK), &LDWORK, &INFO );
+    if (INFO != 0)
+    {
         C2F(errorinfo)("ab01od", &INFO, 6L);
         return 0;
     }
-    if (Lhs >= 3) {
+    if (Lhs >= 3)
+    {
         /*     resizing KSTAIR      */
-        CreateVar(Rhs+7,MATRIX_OF_INTEGER_DATATYPE,(un=1,&un),&INDCON,&ptrJUNK);
-        KSTAIR=Rhs+7;
-        C2F(icopy)(&INDCON,istk(ptrKSTAIR),(un=1,&un),istk(ptrJUNK),(one=1,&one)); }
+        CreateVar(Rhs + 7, MATRIX_OF_INTEGER_DATATYPE, &un, &INDCON, &ptrJUNK);
+        KSTAIR = Rhs + 7;
+        one = 1;
+        C2F(icopy)(&INDCON, istk(ptrKSTAIR), &un, istk(ptrJUNK), &one);
+    }
     /*     lhs variables: [NCONT,U,KSTAIR,V,A,B]=ab01od(A,B)   */
-    LhsVar(1)=NCONT; LhsVar(2)=U;
-    LhsVar(3)=KSTAIR; LhsVar(4)=V;
-    LhsVar(5)=A; LhsVar(6)=B;
+    LhsVar(1) = NCONT;
+    LhsVar(2) = U;
+    LhsVar(3) = KSTAIR;
+    LhsVar(4) = V;
+    LhsVar(5) = A;
+    LhsVar(6) = B;
     return 0;
 }
 /*--------------------------------------------------------------------------*/
index dfda30d..6fb4503 100644 (file)
@@ -1,11 +1,11 @@
 /*
  * 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
  *
  */
 #include "strdup_windows.h"
 #endif
 /*--------------------------------------------------------------------------*/
-int C2F(sci_getscilabmode)(char *fname,unsigned long fname_len)
+int C2F(sci_getscilabmode)(char *fname, unsigned long fname_len)
 {
-       int n1 = 0, m1 = 0;
-       char *output = NULL ;
+    int n1 = 0, m1 = 0;
+    char *output = NULL ;
 
-       Rhs=Max(Rhs,0);
-       CheckRhs(0,0) ;
-       CheckLhs(1,1) ;
+    Rhs = Max(Rhs, 0);
+    CheckRhs(0, 0) ;
+    CheckLhs(1, 1) ;
 
-       switch (getScilabMode())
-       {
-               case SCILAB_API: default :
-                       output = strdup("API");
-               break;
-               case SCILAB_STD:
-                       output = strdup("STD");
-               break;
-               case SCILAB_NW:
-                       output = strdup("NW");
-               break;
-               case SCILAB_NWNI:
-                       output = strdup("NWNI");
-               break;
-       }
+    switch (getScilabMode())
+    {
+        case SCILAB_API:
+        default :
+            output = strdup("API");
+            break;
+        case SCILAB_STD:
+            output = strdup("STD");
+            break;
+        case SCILAB_NW:
+            output = strdup("NW");
+            break;
+        case SCILAB_NWNI:
+            output = strdup("NWNI");
+            break;
+    }
 
-       n1=1;
-       CreateVarFromPtr(Rhs+1,STRING_DATATYPE,(m1=(int)strlen(output), &m1),&n1,&output);
-       if (output) {FREE(output);output=NULL;}
+    n1 = 1;
+    m1 = (int)strlen(output);
+    CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &m1, &n1, &output);
+    if (output)
+    {
+        FREE(output);
+        output = NULL;
+    }
 
-       LhsVar(1) = Rhs+1;
-       PutLhsVar();
-       return 0;
+    LhsVar(1) = Rhs + 1;
+    PutLhsVar();
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 71c5bd6..b6ef4b1 100644 (file)
@@ -2,11 +2,11 @@
  * 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
  *
  */
 #include "strdup_windows.h"
 #endif
 /*--------------------------------------------------------------------------*/
-int sci_filesep(char *fname,unsigned long fname_len)
+int sci_filesep(char *fname, unsigned long fname_len)
 {
-       static int n1,m1;
-       char *separator = NULL;
+    static int n1, m1;
+    char *separator = NULL;
 
-       CheckRhs(0,0);
-       CheckLhs(1,1);
+    CheckRhs(0, 0);
+    CheckLhs(1, 1);
 
-       separator = strdup(DIR_SEPARATOR);
+    separator = strdup(DIR_SEPARATOR);
 
-       n1 = 1;
-       CreateVarFromPtr(Rhs+1,STRING_DATATYPE,(m1=(int)strlen(separator), &m1),&n1,&separator);
-       LhsVar(1)=Rhs+1;
+    n1 = 1;
+    m1 = (int)strlen(separator);
+    CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &m1, &n1, &separator);
+    LhsVar(1) = Rhs + 1;
 
-    if (separator) {FREE(separator);separator=NULL;}
+    if (separator)
+    {
+        FREE(separator);
+        separator = NULL;
+    }
 
-       PutLhsVar();
+    PutLhsVar();
 
     return 0;
 }
index ae77d25..ed9ff47 100644 (file)
@@ -1,11 +1,11 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006 - INRIA - Pierre MARECHAL
- * 
+ *
  * 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
  *
  */
@@ -19,7 +19,7 @@
 #include "Scierror.h"
 #include "localization.h"
 #include "freeArrayOfString.h"
- /*--------------------------------------------------------------------------*/
+/*--------------------------------------------------------------------------*/
 /* ================================================================================== */
 // sci_getrelativefilename
 //
 /* ================================================================================== */
 int sci_getrelativefilename(char *fname, unsigned long l)
 {
-       static int n1 = 0,m1 = 0,n2 = 0,m2 = 0;
+    static int n1 = 0, m1 = 0, n2 = 0, m2 = 0;
+
+    CheckRhs(2, 2);
+    CheckLhs(1, 1);
+
+    if ( (GetType(1) == sci_strings) && (GetType(2) == sci_strings) )
+    {
+        char **param1 = NULL;
+        char **param2 = NULL;
+        char *result = (char*)MALLOC(PATH_MAX * sizeof(char));
+
+        GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &m1, &n1, &param1);
+
+        if ( (n1 * m1) != 1 )
+        {
+            freeArrayOfString(param1, m1 * n1);
+            Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
+            return 0;
+        }
+
+        GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &m2, &n2, &param2);
+        if ( (n2 * m2) != 1 )
+        {
+            freeArrayOfString(param1, m1 * n1);
+            freeArrayOfString(param2, m2 * n2);
+            Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
+            return 0;
+        }
+
+        // make sure the names are not too long
+
+        if ( strlen(param1[0]) > PATH_MAX )
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: Must be less than %d characters.\n"), fname, 1, PATH_MAX);
+        }
+
+        if ( strlen(param2[0]) > PATH_MAX )
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: Must be less than %d characters.\n"), fname, 2, PATH_MAX);
+        }
+
+        result = getrelativefilename(param1[0], param2[0]);
+        freeArrayOfString(param1, m1 * n1);
+        freeArrayOfString(param2, m2 * n2);
 
-       CheckRhs(2,2);
-       CheckLhs(1,1);
+        m1 = (int)strlen(result);
+        CreateVarFromPtr(Rhs + 3, STRING_DATATYPE, &m1, &n1, &result);
+        LhsVar(1) = Rhs + 3;
+        if (result)
+        {
+            FREE(result);
+            result = NULL;
+        }
+        PutLhsVar();
+    }
+    else
+    {
+        if (GetType(1) != sci_strings)
+        {
+            Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
+        }
+        else
+        {
+            Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
+        }
+    }
 
-       if ( (GetType(1) == sci_strings) && (GetType(2) == sci_strings) )
-       {
-               char **param1=NULL;
-               char **param2=NULL;
-               char *result=(char*)MALLOC(PATH_MAX*sizeof(char));
-               
-               GetRhsVar(1,MATRIX_OF_STRING_DATATYPE,&m1,&n1,&param1);
-               
-               if ( (n1*m1) != 1 )
-               {
-                       freeArrayOfString(param1,m1*n1);
-                       Scierror(999,_("%s: Wrong size for input argument #%d: A string expected.\n"),fname,1);
-                       return 0;
-               }
-               
-               GetRhsVar(2,MATRIX_OF_STRING_DATATYPE,&m2,&n2,&param2);
-               if ( (n2*m2) !=1 )
-               {
-                       freeArrayOfString(param1,m1*n1);
-                       freeArrayOfString(param2,m2*n2);
-                       Scierror(999,_("%s: Wrong size for input argument #%d: A string expected.\n"),fname,2);
-                       return 0;
-               }
-               
-               // make sure the names are not too long
-               
-               if( strlen(param1[0]) > PATH_MAX )
-               {
-                       Scierror(999,_("%s: Wrong size for input argument #%d: Must be less than %d characters.\n"),fname,1,PATH_MAX);
-               }
-               
-               if( strlen(param2[0]) > PATH_MAX )
-               {
-                       Scierror(999,_("%s: Wrong size for input argument #%d: Must be less than %d characters.\n"),fname,2,PATH_MAX);
-               }
-               
-               result = getrelativefilename(param1[0],param2[0]);
-               freeArrayOfString(param1,m1*n1);
-               freeArrayOfString(param2,m2*n2);
-               
-               CreateVarFromPtr(Rhs+3,STRING_DATATYPE,(m1=(int)strlen(result), &m1),&n1,&result);
-               LhsVar(1)=Rhs+3;
-               if (result) {FREE(result);result=NULL;}
-               PutLhsVar();
-       }
-       else
-       {
-               if(GetType(1) != sci_strings)
-               {
-                       Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"),fname,1);
-               }
-               else
-               {
-                       Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"),fname,2);
-               }
-       }
-       
-       return 0;
+    return 0;
 }
index c218845..9897869 100644 (file)
@@ -2,11 +2,11 @@
  * 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
  *
  */
 #include "MALLOC.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
-int sci_pathsep(char *fname,unsigned long fname_len)
+int sci_pathsep(char *fname, unsigned long fname_len)
 {
-       static int n1,m1;
-       char *separator=NULL;
+    static int n1, m1;
+    char *separator = NULL;
+
+    CheckRhs(0, 0);
+    CheckLhs(1, 1);
+
+    separator = (char*)MALLOC(sizeof(char) * (strlen(PATH_SEPARATOR) + 1));
+    if (separator) strcpy(separator, PATH_SEPARATOR);
 
-       CheckRhs(0,0);
-       CheckLhs(1,1);
+    n1 = 1;
+    m1 = (int)strlen(separator);
+    CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &m1, &n1, &separator);
+    LhsVar(1) = Rhs + 1;
 
-       separator=(char*)MALLOC(sizeof(char)*(strlen(PATH_SEPARATOR)+1));
-       if (separator) strcpy(separator,PATH_SEPARATOR);
-       
-       n1 = 1;
-       CreateVarFromPtr(Rhs+1,STRING_DATATYPE,(m1=(int)strlen(separator), &m1),&n1,&separator);
-       LhsVar(1)=Rhs+1;
-       
-       if (separator) {FREE(separator);separator=NULL;}
+    if (separator)
+    {
+        FREE(separator);
+        separator = NULL;
+    }
     PutLhsVar();
 
-       return 0;
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 5716d44..4f0be80 100644 (file)
@@ -2,11 +2,11 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006 - INRIA - Fabrice Leray
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
- * 
+ *
  * 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
  *
  */
 #include "Format.h"
 
 /*--------------------------------------------------------------------------*/
-int sci_xgraduate(char *fname,unsigned long fname_len)
+int sci_xgraduate(char *fname, unsigned long fname_len)
 {
-  double xa = 0., xi = 0.;
-  int m1 = 0,n1 = 0,l1 = 0,m2 = 0,n2 = 0,l2 = 0,i = 0;
-  int kMinr = 0,kMaxr = 0,ar = 0,lr = 0,np1 = 0,np2 = 0,un=1;
+    double xa = 0., xi = 0.;
+    int m1 = 0, n1 = 0, l1 = 0, m2 = 0, n2 = 0, l2 = 0, i = 0;
+    int kMinr = 0, kMaxr = 0, ar = 0, lr = 0, np1 = 0, np2 = 0, un = 1;
 
-  CheckRhs(2,2);
-  CheckLhs(2,7);
-  GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);  CheckScalar(1,m1,n1);
-  GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m2,&n2,&l2);  CheckScalar(2,m2,n2);
+    CheckRhs(2, 2);
+    CheckLhs(2, 7);
+    GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
+    CheckScalar(1, m1, n1);
+    GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
+    CheckScalar(2, m2, n2);
 
-  C2F(graduate)(stk(l1),stk(l2),&xi,&xa,&np1,&np2,&kMinr,&kMaxr,&ar);
+    C2F(graduate)(stk(l1), stk(l2), &xi, &xa, &np1, &np2, &kMinr, &kMaxr, &ar);
 
-  *stk(l1) = xi;
-  *stk(l2) = xa;
+    *stk(l1) = xi;
+    *stk(l2) = xa;
 
-  if (Lhs >= 3) { CreateVar(3,MATRIX_OF_DOUBLE_DATATYPE,&un,&un,&lr); *stk(lr ) = (double) np1;  }
-  if (Lhs >= 4) { CreateVar(4,MATRIX_OF_DOUBLE_DATATYPE,&un,&un,&lr); *stk(lr ) = (double) np2;  }
-  if (Lhs >= 5) { CreateVar(5,MATRIX_OF_DOUBLE_DATATYPE,&un,&un,&lr); *stk(lr ) = (double) kMinr;  }
-  if (Lhs >= 6) { CreateVar(6,MATRIX_OF_DOUBLE_DATATYPE,&un,&un,&lr); *stk(lr ) = (double) kMaxr;  }
-  if (Lhs >= 7) { CreateVar(7,MATRIX_OF_DOUBLE_DATATYPE,&un,&un,&lr); *stk(lr ) = (double) ar;  }
-  for (i= 1; i <= Lhs ; i++) { LhsVar(i) = i ; }
-       PutLhsVar();
-  return 0;
+    if (Lhs >= 3)
+    {
+        CreateVar(3, MATRIX_OF_DOUBLE_DATATYPE, &un, &un, &lr);
+        *stk(lr ) = (double) np1;
+    }
+    if (Lhs >= 4)
+    {
+        CreateVar(4, MATRIX_OF_DOUBLE_DATATYPE, &un, &un, &lr);
+        *stk(lr ) = (double) np2;
+    }
+    if (Lhs >= 5)
+    {
+        CreateVar(5, MATRIX_OF_DOUBLE_DATATYPE, &un, &un, &lr);
+        *stk(lr ) = (double) kMinr;
+    }
+    if (Lhs >= 6)
+    {
+        CreateVar(6, MATRIX_OF_DOUBLE_DATATYPE, &un, &un, &lr);
+        *stk(lr ) = (double) kMaxr;
+    }
+    if (Lhs >= 7)
+    {
+        CreateVar(7, MATRIX_OF_DOUBLE_DATATYPE, &un, &un, &lr);
+        *stk(lr ) = (double) ar;
+    }
+    for (i = 1; i <= Lhs ; i++)
+    {
+        LhsVar(i) = i;
+    }
+    PutLhsVar();
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 62b3ed0..31685e6 100644 (file)
 #include "Scierror.h"
 #include "localization.h"
 /*--------------------------------------------------------------------------*/
-int sci_gethistoryfile(char *fname,unsigned long fname_len)
+int sci_gethistoryfile(char *fname, unsigned long fname_len)
 {
-       char *filename = NULL;
-       int m1 = 0, n1 = 0;
+    char *filename = NULL;
+    int m1 = 0, n1 = 0;
 
-       CheckRhs(0,0) ;
-       CheckLhs(0,1) ;
+    CheckRhs(0, 0) ;
+    CheckLhs(0, 1) ;
 
-       filename = getFilenameScilabHistory();
+    filename = getFilenameScilabHistory();
 
-       if (filename)
-       {
-               n1=1;
-               CreateVarFromPtr(Rhs+ 1,STRING_DATATYPE,(m1=(int)strlen(filename), &m1),&n1,&filename);
-               if (filename) {FREE(filename);filename=NULL;}
-               LhsVar(1) = Rhs+1;
-               PutLhsVar();
-       }
-       else
-       {
-               Scierror(999,_("%s: An error occurred: %s\n"),fname,_("filename not defined."));
-       }
-       return 0;
+    if (filename)
+    {
+        n1 = 1;
+        m1 = (int)strlen(filename);
+        CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &m1, &n1, &filename);
+        if (filename)
+        {
+            FREE(filename);
+            filename = NULL;
+        }
+        LhsVar(1) = Rhs + 1;
+        PutLhsVar();
+    }
+    else
+    {
+        Scierror(999, _("%s: An error occurred: %s\n"), fname, _("filename not defined."));
+    }
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 1415837..e57f68f 100644 (file)
@@ -2,11 +2,11 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) Bruno Pincon
  * Copyright (C) DIGITEO - 2012 - 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
 */
 #include <string.h>
 #include "localization.h"
 /*--------------------------------------------------------------------------*/
 extern double C2F(cs2val)(double *px, double *py, int *n, double *x, double *y,
-    double *f, int *nr, int *lcell, int *lnext, double *xmin, double *ymin,
-    double *dx, double *dy, double *rmax, double *rw, double *a);
+                          double *f, int *nr, int *lcell, int *lnext, double *xmin, double *ymin,
+                          double *dx, double *dy, double *rmax, double *rw, double *a);
 extern int C2F(cs2grd) (double *px, double *py, int *n, double *x, double *y,
-    double *f, int *nr, int *lcell, int *lnext,  double *xmin, double *ymin,
-    double *dx, double *dy, double *rmax, double *rw, double *a,double *c,
-    double *cx, double *cy, int *ier);
+                        double *f, int *nr, int *lcell, int *lnext,  double *xmin, double *ymin,
+                        double *dx, double *dy, double *rmax, double *rw, double *a, double *c,
+                        double *cx, double *cy, int *ier);
 extern int C2F(cs2hes)  (double *px, double *py, int *n, double *x, double *y,
-    double *f, int *nr, int *lcell, int *lnext,  double *xmin, double *ymin,
-    double *dx, double *dy, double *rmax, double *rw, double *a, double *c,
-    double *cx, double *cy,  double *cxx, double *cxy, double *cyy, int *ier);
+                         double *f, int *nr, int *lcell, int *lnext,  double *xmin, double *ymin,
+                         double *dx, double *dy, double *rmax, double *rw, double *a, double *c,
+                         double *cx, double *cy,  double *cxx, double *cxy, double *cyy, int *ier);
 /*--------------------------------------------------------------------------*/
 int inteval_cshep2d(char *fname, unsigned long fname_len)
 {
@@ -57,7 +57,7 @@ int inteval_cshep2d(char *fname, unsigned long fname_len)
         SciErr sciErr;
         int *piAddressVar = NULL;
         sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddressVar);
-        if(sciErr.iErr)
+        if (sciErr.iErr)
         {
             printError(&sciErr, 0);
             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i);
@@ -73,13 +73,13 @@ int inteval_cshep2d(char *fname, unsigned long fname_len)
 
     if ( mx != my  ||  nx != ny )
     {
-        Scierror(999,_("%s: Wrong size for input arguments #%d and #%d: Same sizes expected.\n"),fname,1,2);
+        Scierror(999, _("%s: Wrong size for input arguments #%d and #%d: Same sizes expected.\n"), fname, 1, 2);
         return 0;
     }
 
-    GetRhsVar(3,TYPED_LIST_DATATYPE,&mt, &nt, &lt);
-    GetListRhsVar(3, 1,MATRIX_OF_STRING_DATATYPE, &m1,  &n1, &Str);    /* m1 = 1, n1 = 8 ? a verifier */
-    if ( strcmp(Str[0],"cshep2d") != 0)
+    GetRhsVar(3, TYPED_LIST_DATATYPE, &mt, &nt, &lt);
+    GetListRhsVar(3, 1, MATRIX_OF_STRING_DATATYPE, &m1,  &n1, &Str);   /* m1 = 1, n1 = 8 ? a verifier */
+    if ( strcmp(Str[0], "cshep2d") != 0)
     {
         /* Free Str */
         if (Str)
@@ -94,13 +94,13 @@ int inteval_cshep2d(char *fname, unsigned long fname_len)
             FREE(Str);
             Str = NULL;
         }
-        Scierror(999,_("%s: Wrong type for input argument #%d: %s tlist expected.\n"), fname,2,"cshep2d");
+        Scierror(999, _("%s: Wrong type for input argument #%d: %s tlist expected.\n"), fname, 2, "cshep2d");
         return 0;
     }
     /* Free Str */
     if (Str)
     {
-        int li=0;
+        int li = 0;
         while ( Str[li] != NULL)
         {
             FREE(Str[li]);
@@ -110,79 +110,90 @@ int inteval_cshep2d(char *fname, unsigned long fname_len)
         FREE(Str);
         Str = NULL;
     }
-    GetListRhsVar(3, 2,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2,  &lxyz);   /* m2 = n , n2 = 3  */
-    GetListRhsVar(3, 3,MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m3, &n3,  (int *)&Cell);  /* m3 = nr, n3 = nr */
-    GetListRhsVar(3, 4,MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m4, &n4,  (int *)&Next);  /* m4 = 1 , n4 = n  */
-    GetListRhsVar(3, 5,MATRIX_OF_DOUBLE_DATATYPE, &m5, &n5,  &lgrid);  /* m5 = 1 , n5 = 4  */
-    GetListRhsVar(3, 6,MATRIX_OF_DOUBLE_DATATYPE, &m6, &n6,  &lrmax);  /* m6 = 1 , n6 = 1  */
-    GetListRhsVar(3, 7,MATRIX_OF_DOUBLE_DATATYPE, &m7, &n7,  &lrw);    /* m7 = 1 , n7 = n  */
-    GetListRhsVar(3, 8,MATRIX_OF_DOUBLE_DATATYPE, &m8, &n8,  &la);     /* m8 = 9 , n8 = n  */
+    GetListRhsVar(3, 2, MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2,  &lxyz);  /* m2 = n , n2 = 3  */
+    GetListRhsVar(3, 3, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m3, &n3,  (int *)&Cell); /* m3 = nr, n3 = nr */
+    GetListRhsVar(3, 4, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m4, &n4,  (int *)&Next); /* m4 = 1 , n4 = n  */
+    GetListRhsVar(3, 5, MATRIX_OF_DOUBLE_DATATYPE, &m5, &n5,  &lgrid); /* m5 = 1 , n5 = 4  */
+    GetListRhsVar(3, 6, MATRIX_OF_DOUBLE_DATATYPE, &m6, &n6,  &lrmax); /* m6 = 1 , n6 = 1  */
+    GetListRhsVar(3, 7, MATRIX_OF_DOUBLE_DATATYPE, &m7, &n7,  &lrw);   /* m7 = 1 , n7 = n  */
+    GetListRhsVar(3, 8, MATRIX_OF_DOUBLE_DATATYPE, &m8, &n8,  &la);    /* m8 = 9 , n8 = n  */
 
-    cell = (int *)Cell.D; next = (int *)Next.D;
-    xp = stk(lx); yp = stk(ly); np = mx*nx;
-    n = m2; nr = m3;
-    xyz = stk(lxyz); grid = stk(lgrid);
+    cell = (int *)Cell.D;
+    next = (int *)Next.D;
+    xp = stk(lx);
+    yp = stk(ly);
+    np = mx * nx;
+    n = m2;
+    nr = m3;
+    xyz = stk(lxyz);
+    grid = stk(lgrid);
 
-    CreateVar(4,MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &lf); f = stk(lf);
+    CreateVar(4, MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &lf);
+    f = stk(lf);
     if ( Lhs > 1 )
     {
-        CreateVar(5,MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &ldfdx); dfdx = stk(ldfdx);
-        CreateVar(6,MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &ldfdy); dfdy = stk(ldfdy);
+        CreateVar(5, MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &ldfdx);
+        dfdx = stk(ldfdx);
+        CreateVar(6, MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &ldfdy);
+        dfdy = stk(ldfdy);
     }
     if ( Lhs > 3 )
     {
-        CreateVar(7,MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &ldffdxx); dffdxx = stk(ldffdxx);
-        CreateVar(8,MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &ldffdxy); dffdyy = stk(ldffdxy);
-        CreateVar(9,MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &ldffdyy); dffdxy = stk(ldffdyy);
+        CreateVar(7, MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &ldffdxx);
+        dffdxx = stk(ldffdxx);
+        CreateVar(8, MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &ldffdxy);
+        dffdyy = stk(ldffdxy);
+        CreateVar(9, MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &ldffdyy);
+        dffdxy = stk(ldffdyy);
     }
 
-    switch( Lhs )
+    switch ( Lhs )
     {
-    case ( 1 ) :
-        for ( i = 0 ; i < np ; i++ )
-            /*            DOUBLE PRECISION FUNCTION CS2VAL (PX,PY,N,X,Y,F,NR,
-            *                          LCELL,LNEXT,XMIN,YMIN,DX,DY,RMAX,RW,A)
-            */
-            f[i] = C2F(cs2val)(&xp[i], &yp[i], &n, xyz, &xyz[n], &xyz[2*n], &nr,
-            cell, next, grid, &grid[1], &grid[2], &grid[3],
-            stk(lrmax), stk(lrw), stk(la));
-        LhsVar(1) = 4;
-        break;
+        case ( 1 ) :
+            for ( i = 0 ; i < np ; i++ )
+                /*            DOUBLE PRECISION FUNCTION CS2VAL (PX,PY,N,X,Y,F,NR,
+                *                          LCELL,LNEXT,XMIN,YMIN,DX,DY,RMAX,RW,A)
+                */
+                f[i] = C2F(cs2val)(&xp[i], &yp[i], &n, xyz, &xyz[n], &xyz[2 * n], &nr,
+                                   cell, next, grid, &grid[1], &grid[2], &grid[3],
+                                   stk(lrmax), stk(lrw), stk(la));
+            LhsVar(1) = 4;
+            break;
 
-    case ( 2 ) :
-    case ( 3 ) :
-        for ( i = 0 ; i < np ; i++ )
-            /*      SUBROUTINE CS2GRD (PX,PY,N,X,Y,F,NR,LCELL,LNEXT,XMIN,
-            *.                   YMIN,DX,DY,RMAX,RW,A, C,CX,CY,IER)
-            */
-            C2F(cs2grd) (&xp[i], &yp[i], &n, xyz, &xyz[n], &xyz[2*n], &nr,
-            cell, next, grid, &grid[1], &grid[2], &grid[3],
-            stk(lrmax), stk(lrw), stk(la), &f[i], &dfdx[i], &dfdy[i], &ier);
-        LhsVar(1) = 4;
-        LhsVar(2) = 5;
-        LhsVar(3) = 6;
-        break;
+        case ( 2 ) :
+        case ( 3 ) :
+            for ( i = 0 ; i < np ; i++ )
+                /*      SUBROUTINE CS2GRD (PX,PY,N,X,Y,F,NR,LCELL,LNEXT,XMIN,
+                *.                   YMIN,DX,DY,RMAX,RW,A, C,CX,CY,IER)
+                */
+                C2F(cs2grd) (&xp[i], &yp[i], &n, xyz, &xyz[n], &xyz[2 * n], &nr,
+                             cell, next, grid, &grid[1], &grid[2], &grid[3],
+                             stk(lrmax), stk(lrw), stk(la), &f[i], &dfdx[i], &dfdy[i], &ier);
+            LhsVar(1) = 4;
+            LhsVar(2) = 5;
+            LhsVar(3) = 6;
+            break;
 
-    case ( 4 ) :
-    case ( 5 ) :
-    case ( 6 ) :
-        for ( i = 0 ; i < np ; i++ )
-        {
-            /*   SUBROUTINE CS2HES (PX,PY,N,X,Y,F,NR,LCELL,LNEXT,XMIN,
-            *.                     YMIN,DX,DY,RMAX,RW,A, C,CX,CY,CXX,CXY,CYY,IER)
-            */
-            C2F(cs2hes) (&xp[i], &yp[i], &n, xyz, &xyz[n], &xyz[2*n], &nr,
-                cell, next, grid, &grid[1], &grid[2], &grid[3],
-                stk(lrmax), stk(lrw), stk(la), &f[i], &dfdx[i], &dfdy[i],
-                &dffdxx[i], &dffdxy[i], &dffdyy[i], &ier);
-        }
-        LhsVar(1) = 4;
-        LhsVar(2) = 5;
-        LhsVar(3) = 6;
-        LhsVar(4) = 7;
-        LhsVar(5) = 8;
-        LhsVar(6) = 9;
-        break;
+        case ( 4 ) :
+        case ( 5 ) :
+        case ( 6 ) :
+            for ( i = 0 ; i < np ; i++ )
+            {
+                /*   SUBROUTINE CS2HES (PX,PY,N,X,Y,F,NR,LCELL,LNEXT,XMIN,
+                *.                     YMIN,DX,DY,RMAX,RW,A, C,CX,CY,CXX,CXY,CYY,IER)
+                */
+                C2F(cs2hes) (&xp[i], &yp[i], &n, xyz, &xyz[n], &xyz[2 * n], &nr,
+                             cell, next, grid, &grid[1], &grid[2], &grid[3],
+                             stk(lrmax), stk(lrw), stk(la), &f[i], &dfdx[i], &dfdy[i],
+                             &dffdxx[i], &dffdxy[i], &dffdyy[i], &ier);
+            }
+            LhsVar(1) = 4;
+            LhsVar(2) = 5;
+            LhsVar(3) = 6;
+            LhsVar(4) = 7;
+            LhsVar(5) = 8;
+            LhsVar(6) = 9;
+            break;
     }
     PutLhsVar();
     return 0;
index 96bd80c..358f6f0 100644 (file)
@@ -2,11 +2,11 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) Bruno Pincon
  * Copyright (C) DIGITEO - 2012 - 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
 */
 #include <string.h>
@@ -19,7 +19,8 @@
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
 #define NB_OUTMODE 6
-static TableType OutModeTable[NB_OUTMODE] = {
+static TableType OutModeTable[NB_OUTMODE] =
+{
     { "C0"        , C0         },
     { "by_zero"   , BY_ZERO    },
     { "natural"   , NATURAL    },
@@ -28,7 +29,7 @@ static TableType OutModeTable[NB_OUTMODE] = {
     { "linear"    , LINEAR     }
 };
 /*--------------------------------------------------------------------------*/
-int intlinear_interpn(char *fname,unsigned long fname_len)
+int intlinear_interpn(char *fname, unsigned long fname_len)
 {
     /*  interpolation lineaire n-dimensionnelle
     *
@@ -43,14 +44,14 @@ int intlinear_interpn(char *fname,unsigned long fname_len)
     n = (Rhs + 1) / 2 - 1;
     if ( n < 1 )
     {
-        Scierror(999,_("%s: Wrong number of input argument(s).\n"),fname);
+        Scierror(999, _("%s: Wrong number of input argument(s).\n"), fname);
         return 0;
     }
 
     /*  les points sur lesquels on evalue par interpolation */
     /*   l = I_UINT32; CreateVar(Rhs+1,MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &n, &one, &l); */
     /*   xp = (double **) istk(l); */
-    CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE, &n, &one, &l);  /* => lets store an array of pointers  */
+    CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &n, &one, &l); /* => lets store an array of pointers  */
     xp = (double **) stk(l);               /*   with size of 4 or 8 bytes */
 
     GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &mxp, &nxp, &lxp);
@@ -59,7 +60,7 @@ int intlinear_interpn(char *fname,unsigned long fname_len)
         SciErr sciErr;
         int *piAddressVar = NULL;
         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVar);
-        if(sciErr.iErr)
+        if (sciErr.iErr)
         {
             printError(&sciErr, 0);
             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
@@ -73,7 +74,7 @@ int intlinear_interpn(char *fname,unsigned long fname_len)
         }
     }
     xp[0] = stk(lxp);
-    np = mxp*nxp;
+    np = mxp * nxp;
     for (i = 2 ; i <= n ; i++ )
     {
         SciErr sciErr;
@@ -82,12 +83,12 @@ int intlinear_interpn(char *fname,unsigned long fname_len)
         GetRhsVar(i, MATRIX_OF_DOUBLE_DATATYPE, &mxpn, &nxpn, &lxpn);
         if ( mxp != mxpn || nxp != nxpn )
         {
-            Scierror(999,_("%s: Wrong size for input arguments #%d and #%d: Same sizes expected.\n"),fname,1,i);
+            Scierror(999, _("%s: Wrong size for input arguments #%d and #%d: Same sizes expected.\n"), fname, 1, i);
             return 0;
         }
 
         sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddressVar);
-        if(sciErr.iErr)
+        if (sciErr.iErr)
         {
             printError(&sciErr, 0);
             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i);
@@ -100,31 +101,32 @@ int intlinear_interpn(char *fname,unsigned long fname_len)
             return 0;
         }
 
-        xp[i-1] = stk(lxpn);
+        xp[i - 1] = stk(lxpn);
     }
 
     /* coordonnées de la grille */
-    l = I_INT32; CreateVar(Rhs+2,MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &n, &one, &l);
+    l = I_INT32;
+    CreateVar(Rhs + 2, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &n, &one, &l);
     dim = istk(l);
     /*   l = I_UINT32; CreateVar(Rhs+3,MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &n, &one, &l); */
     /*   x = (double **) istk(l); */
-    CreateVar(Rhs+3,MATRIX_OF_DOUBLE_DATATYPE, &n, &one, &l);  /* => lets store an array of pointers  */
+    CreateVar(Rhs + 3, MATRIX_OF_DOUBLE_DATATYPE, &n, &one, &l); /* => lets store an array of pointers  */
     x = (double **) stk(l);               /*    with size(void *) = 4 or 8 bytes */
 
     for ( i = 1 ; i <= n ; i++ )
     {
-        GetRhsVar(n+i,MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &lx);
-        if ( (mx != 1 && nx != 1) && mx*nx < 2)
+        GetRhsVar(n + i, MATRIX_OF_DOUBLE_DATATYPE, &mx, &nx, &lx);
+        if ( (mx != 1 && nx != 1) && mx * nx < 2)
         {
-            Scierror(999,_("%s: Wrong size for input argument #%d.\n"),fname,n+i);
+            Scierror(999, _("%s: Wrong size for input argument #%d.\n"), fname, n + i);
             return 0;
         }
-        x[i-1] = stk(lx);
-        dim[i-1] = mx*nx;
+        x[i - 1] = stk(lx);
+        dim[i - 1] = mx * nx;
         /* verify strict increasing order  */
-        if ( !good_order(x[i-1], mx*nx) )
+        if ( !good_order(x[i - 1], mx * nx) )
         {
-            Scierror(999,_("%s: Grid abscissae of dim %d not in strict increasing order.\n"), fname, n+i);
+            Scierror(999, _("%s: Grid abscissae of dim %d not in strict increasing order.\n"), fname, n + i);
             return 0;
         }
     }
@@ -132,60 +134,68 @@ int intlinear_interpn(char *fname,unsigned long fname_len)
     /* les valeurs de la grille */
     if ( n >= 3 )
     {
-        GetRhsRealHMat(2*n+1,&U);
+        GetRhsRealHMat(2 * n + 1, &U);
         if ( U.dimsize != n )
         {
-            Scierror(999,_("%s: %s must be a real %d-dim hypermatrix.\n"), fname, "U", n);
+            Scierror(999, _("%s: %s must be a real %d-dim hypermatrix.\n"), fname, "U", n);
             return 0;
         }
         for ( i = 0 ; i < n ; i++ )
             if ( U.dims[i] != dim[i] )
             {
-                Scierror(999,_("%s: Size incompatibility between grid points and grid values in dimension %d.\n"), fname, i+1);
+                Scierror(999, _("%s: Size incompatibility between grid points and grid values in dimension %d.\n"), fname, i + 1);
                 return 0;
             }
-            val = U.R;
+        val = U.R;
     }
     else  /* n = 1 or 2 */
     {
-        GetRhsVar(2*n+1,MATRIX_OF_DOUBLE_DATATYPE, &my, &ny, &ly);
+        GetRhsVar(2 * n + 1, MATRIX_OF_DOUBLE_DATATYPE, &my, &ny, &ly);
         if ( n == 1  &&  my*ny != dim[0] )
         {
-            Scierror(999,_("%s: Size incompatibility between grid points and values in dimension %d.\n"), fname,1);
+            Scierror(999, _("%s: Size incompatibility between grid points and values in dimension %d.\n"), fname, 1);
             return 0;
         }
         if ( n == 2  &&  (my != dim[0]  || ny != dim[1]) )
         {
-            Scierror(999,_("%s: Size incompatibility between grid points and values in dimension %d or %d.\n"), fname,1,2);
+            Scierror(999, _("%s: Size incompatibility between grid points and values in dimension %d or %d.\n"), fname, 1, 2);
             return 0;
         }
         val = stk(ly);
     }
 
     /* get the outmode */
-    if ( Rhs == 2*n + 2 )
+    if ( Rhs == 2 * n + 2 )
     {
         GetRhsScalarString(Rhs, &ns, &str_outmode);
         outmode =  get_type(OutModeTable, NB_OUTMODE, str_outmode, ns);
         if ( outmode == UNDEFINED || outmode == LINEAR )
         {
-            Scierror(999,_("%s: Wrong values for input argument #%d: Unsupported '%s' type.\n"),fname,2*n + 2,"outmode");
+            Scierror(999, _("%s: Wrong values for input argument #%d: Unsupported '%s' type.\n"), fname, 2 * n + 2, "outmode");
             return 0;
         };
     }
     else
         outmode = C0;
 
-    CreateVar(Rhs+4,MATRIX_OF_DOUBLE_DATATYPE, &n, &one, &l); u = stk(l);
-    m = 1; for ( i = 1 ; i <= n ; i++) m = 2*m;
-    CreateVar(Rhs+5,MATRIX_OF_DOUBLE_DATATYPE, &m, &one, &l); v = stk(l);
-    l = 4; CreateVar(Rhs+6,MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m, &one, &l); ad = istk(l);
-    l = 4; CreateVar(Rhs+7,MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &n, &one, &l); k = istk(l);
-    CreateVar(Rhs+8,MATRIX_OF_DOUBLE_DATATYPE, &mxp, &nxp, &l); yp = stk(l);
+    CreateVar(Rhs + 4, MATRIX_OF_DOUBLE_DATATYPE, &n, &one, &l);
+    u = stk(l);
+    m = 1;
+    for ( i = 1 ; i <= n ; i++) m = 2 * m;
+    CreateVar(Rhs + 5, MATRIX_OF_DOUBLE_DATATYPE, &m, &one, &l);
+    v = stk(l);
+    l = 4;
+    CreateVar(Rhs + 6, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m, &one, &l);
+    ad = istk(l);
+    l = 4;
+    CreateVar(Rhs + 7, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &n, &one, &l);
+    k = istk(l);
+    CreateVar(Rhs + 8, MATRIX_OF_DOUBLE_DATATYPE, &mxp, &nxp, &l);
+    yp = stk(l);
 
     nlinear_interp(x, val, dim, n, xp, yp, np, outmode, u, v, ad, k);
 
-    LhsVar(1) = Rhs+8;
+    LhsVar(1) = Rhs + 8;
     PutLhsVar();
     /* correction Warning Allan CORNET */
     /* warning C4715: 'intlinear_interpn' : not all control paths return a value */
index 4fbe77e..2ab069d 100644 (file)
@@ -1,11 +1,11 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 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
  *
  */
 #include "Scierror.h"
 #include "localization.h"
 /*--------------------------------------------------------------------------*/
-int sci_system_setproperty(char *fname,unsigned long fname_len)
+int sci_system_setproperty(char *fname, unsigned long fname_len)
 {
-       Rhs = Max(Rhs,0);
-       CheckRhs(2,2);
-       CheckLhs(1,1);
+    Rhs = Max(Rhs, 0);
+    CheckRhs(2, 2);
+    CheckLhs(1, 1);
 
-       if ( (GetType(1) == sci_strings) && (GetType(2) == sci_strings) )
-       {
-               static int m1,n1=0,l1=0;
-               static int m2,n2=0,l2=0;
-               char *propertyName = NULL;
-               char *propertyValue = NULL;
-               char *previousValue = NULL;
+    if ( (GetType(1) == sci_strings) && (GetType(2) == sci_strings) )
+    {
+        static int m1, n1 = 0, l1 = 0;
+        static int m2, n2 = 0, l2 = 0;
+        char *propertyName = NULL;
+        char *propertyValue = NULL;
+        char *previousValue = NULL;
 
-               GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
-               propertyName = cstk(l1);
+        GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
+        propertyName = cstk(l1);
 
-               GetRhsVar(2,STRING_DATATYPE,&m2,&n2,&l2);
-               propertyValue = cstk(l2);
+        GetRhsVar(2, STRING_DATATYPE, &m2, &n2, &l2);
+        propertyValue = cstk(l2);
 
-               previousValue = system_setproperty(propertyName,propertyValue);
+        previousValue = system_setproperty(propertyName, propertyValue);
 
-               if (previousValue)
-               {
-                       n1=1;
-                       CreateVarFromPtr(Rhs+1,STRING_DATATYPE,(m1=(int)strlen(propertyValue), &m1),&n1,&previousValue);
-               }
-               else
-               {
-                       n1 = 0;
-                       m1 = 0;
-                       l1 = 0;
-                       CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,&n1,&m1,&l1);
-               }
-               LhsVar(1)=Rhs+1;
-               if (previousValue) {FREE(previousValue); previousValue = NULL;}
+        if (previousValue)
+        {
+            n1 = 1;
+            m1 = (int)strlen(propertyValue);
+            CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &m1, &n1, &previousValue);
+        }
+        else
+        {
+            n1 = 0;
+            m1 = 0;
+            l1 = 0;
+            CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &n1, &m1, &l1);
+        }
+        LhsVar(1) = Rhs + 1;
+        if (previousValue)
+        {
+            FREE(previousValue);
+            previousValue = NULL;
+        }
         PutLhsVar();
-       }
-       else
-       {
-               Scierror(999,_("%s: Wrong type for input argument #%d or #%d: String expected.\n"),fname, 1, 2);
-       }
-       return 0;
+    }
+    else
+    {
+        Scierror(999, _("%s: Wrong type for input argument #%d or #%d: String expected.\n"), fname, 1, 2);
+    }
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 84c65a5..c997853 100644 (file)
@@ -1,11 +1,11 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA - Sylvestre LEDRU
- * 
+ *
  * 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
  *
  */
 #include "MALLOC.h"
 #include "stack-c.h"
 /*--------------------------------------------------------------------------*/
-int sci_getlanguage(char *fname,unsigned long fname_len)
+int sci_getlanguage(char *fname, unsigned long fname_len)
 {
-       static int n1,m1;
-       char *Output=NULL;
+    static int n1, m1;
+    char *Output = NULL;
 
-       CheckRhs(0,0);
-       CheckLhs(0,1);
+    CheckRhs(0, 0);
+    CheckLhs(0, 1);
 
-       Output=getlanguage();
+    Output = getlanguage();
 
-       n1=1;
-       CreateVarFromPtr( Rhs+1,STRING_DATATYPE,(m1=(int)strlen(Output), &m1),&n1,&Output);
-       LhsVar(1) = Rhs+1;
-       PutLhsVar();
+    n1 = 1;
+    m1 = (int)strlen(Output);
+    CreateVarFromPtr( Rhs + 1, STRING_DATATYPE, &m1, &n1, &Output);
+    LhsVar(1) = Rhs + 1;
+    PutLhsVar();
 
-       return 0;
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 27078c1..1b5064a 100644 (file)
 * 12/02/07 : update lhs to double output
 *
 */
-int sci_curblockc(char *fname,unsigned long fname_len)
+int sci_curblockc(char *fname, unsigned long fname_len)
 {
-       /***********************
-       * variables declaration
-       ***********************/
+    /***********************
+    * variables declaration
+    ***********************/
 
-       extern CURBLK_struct C2F(curblk);
+    extern CURBLK_struct C2F(curblk);
 
-       /* address of the data of the output parameter */
-       int l1 = 0;
-       /* local counter variable */
-       int j = 0, k = 0;
-       /* definition of min/max output argument */
-       static int minlhs = 1, maxlhs = 1;
+    /* address of the data of the output parameter */
+    int l1 = 0;
+    /* local counter variable */
+    int j = 1, k = 1;
+    /* definition of min/max output argument */
+    static int minlhs = 1, maxlhs = 1;
 
-       /**************************
-       * Check number of  outputs
-       **************************/
-       CheckLhs(minlhs, maxlhs);
+    /**************************
+    * Check number of  outputs
+    **************************/
+    CheckLhs(minlhs, maxlhs);
 
-       /************************
-       * Create double variable
-       ************************/
-       /* Create int32 variable at the top addr. of the stack */
-       CreateVar(1,MATRIX_OF_DOUBLE_DATATYPE,(j = 1,&j),(k = 1,&k),&l1);
+    /************************
+    * Create double variable
+    ************************/
+    /* Create int32 variable at the top addr. of the stack */
+    CreateVar(1, MATRIX_OF_DOUBLE_DATATYPE, &j, &k, &l1);
 
-       /* Store value of C2F(curblk).kfun at the l1 address in istk */
-       *stk(l1) = (double)C2F(curblk).kfun;
+    /* Store value of C2F(curblk).kfun at the l1 address in istk */
+    *stk(l1) = (double)C2F(curblk).kfun;
 
-       /* return the value stored at Top address to lhs variable */
-       LhsVar(1) = 1;
-       PutLhsVar();
+    /* return the value stored at Top address to lhs variable */
+    LhsVar(1) = 1;
+    PutLhsVar();
 
-       /* return 0 as default value */
-       return 0;
+    /* return 0 as default value */
+    return 0;
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
index d9c36b3..a828b18 100644 (file)
@@ -33,8 +33,8 @@
 #include "copyvarfromlistentry.h"
 #include "MALLOC.h"
 /*--------------------------------------------------------------------------*/
-extern void str2sci(char** x,int n,int m); /* core/src/c/str2sci.h */
-extern int C2F(mktlist)(); 
+extern void str2sci(char** x, int n, int m); /* core/src/c/str2sci.h */
+extern int C2F(mktlist)();
 /*--------------------------------------------------------------------------*/
 /* intgetscicosvarsc getscicosvars interface routine
 * retrieve some information during simulation.
@@ -74,464 +74,469 @@ extern int C2F(mktlist)();
 * 09/02/07, Alan : Update with oz/opar and restore il_sim_save only for opar
 *
 */
-int sci_getscicosvars(char *fname,unsigned long fname_len)
+int sci_getscicosvars(char *fname, unsigned long fname_len)
 {
-       /************************************
-       * variables and constants d?inition
-       ************************************/
-       /* auxilary variables for dimension and address */
-       int m1 = 0, n1 = 0;     /* dimension of input character string               */
-       int *il_str = NULL;   /* address of the description of the input parameter */
-       int *l_str = NULL;    /* address of the data of the input parameter        */
-       int l_tmp = 0;     /* temp variables to store address                   */
-       int *il_tmp = NULL;
-
-       /* definition of min/max input/output argument */
-       static int minrhs = 0, maxrhs = 1;
-
-       /* auxilary variables */
-       int nv = 0, mv = 0;                /* length of data                                      */
-       void *ptr = 0;                /* ptr for data comming from import structure          */
-       int *ptr_int = NULL;             /* ptr to store ptr on int                         */
-       double *ptr_dd = NULL;           /* ptr to store ptr on double                          */
-       scicos_block *ptr_scsblk = NULL; /* ptr to store ptr of scicos_block structure          */
-       outtb_el *ptr_elem = NULL;       /* ptr to store ptr of outtb_el structure              */
-       int nblk = 0, ng = 0;              /* to store number of blocks and number of zero cross. */
-       int *xptr = NULL, *zcptr = NULL;        /* to store xptr and zcptr of scicos_blocks            */
-       double *x = NULL,*xd = NULL,*g = NULL;         /* ptr for x, xd and g for scicos_blocks               */
-       int *funtyp = NULL;              /* ptr for funtyp */
-
-       int ierr = 0;       /* error flag                                */
-       int errc = 0;       /* error flag for ceateblklst                */
-       int ptr_pos = 0;    /* to store position in scilab string object */
-       int Topsave = 0;    /* to save the Top position                  */
-
-       int sz_str = 0;     /* local variabe to store size of string */
-       int i = 0,j = 0,k = 0;      /* local counter variable                */
-
-       /* number of entries -please update me-                        */
-       static int nentries = 69;
-       /* define accepted entries of getscicosvars -please update me- */
-       static char *entry[] = 
-          {"x"       , "nx"       , "xptr"   , "zcptr"      , "z"        ,
-               "nz"      , "zptr"     , "noz"    , "oz"         , "ozsz"     ,
-               "oztyp"   , "ozptr"    , "rpar"   , "rpptr"      , "ipar"     ,
-               "ipptr"   , "opar"     , "oparsz" , "opartyp"    , "opptr"    ,
-               "outtb"   , "inpptr"   , "outptr" , "inplnk"     , "outlnk"   ,
-               "subs"    , "tevts"    , "evtspt" , "pointi"     , "iord"     ,
-               "oord"    , "zord"     , "funtyp" , "ztyp"       , "cord"     ,
-               "ordclk"  , "clkptr"   , "ordptr" , "critev"     , "mod"      ,
-               "nmod"    , "iz"       , "nblk"   , "izptr"      , "outtbptr" ,
-               "outtbsz" , "outtbtyp" , "nlnk"   , "nsubs"      , "nevts"    ,
-               "niord"   , "noord"    , "nzord"  , "funptr"     , "ncord"    ,
-               "nordptr" , "iwa"      , "blocks" , "ng"         , "g"        ,
-               "t0"      , "tf"       , "Atol"   , "rtol"       , "ttol"     ,
-               "deltat"  , "hmax"     , "nelem"  , "outtb_elem"};
-
-       char **dyn_char = NULL; /* for allocation of first entry in tlist */
-
-       /****************************************
-       * Check number of inputs and outputs Rhs
-       ****************************************/
-       CheckRhs(minrhs, maxrhs);
-
-       /* Display usage of getscicosvars function if Rhs==0 */
-       if (Rhs == 0)
-       {
-               sciprint(_("\ngetscicosvars : utility function to retrieve\n"));
-               sciprint(_("                scicos arrays during simulation.\n\n"));
-               sciprint(_("Usage : [myvar]=getscicosvars([\"str1\";\"str2\";...]);\n\n"));
-               sciprint(_("- myvar : an int32 or double matrix or a Tlist.\n"));
-               sciprint(_("- [\"str1\";\"str2\",...] is a string matrix\n"));
-               sciprint(_("  that must be informed with the following values :\n"));
-
-               /* display allowed entries */
-               i = 0;
-               for (j = 0; j<nentries; j++)
-               {
-                       if (j == nentries-1) sciprint("\"%s\" ",entry[j]);
-                       else sciprint("\"%s\", ",entry[j]);
-                       i++;
-                       if (i==6) 
-                       {
-                               sciprint("\n");
-                               i=0;
-                       }
-               }
-               sciprint("\n");
-               return 0;
-       }
-
-       /*******************
-       * Check str (rhs 1)
-       *******************/
-       il_str = (int *) GetData(1); /* get ptr of int header of rsh 1 */
-       if(il_str[0] != sci_strings) /* Check if input argument is a character string matrix */
-       {
-               Scierror(55, _("%s : First argument must be a string.\n"),fname);
-               C2F(iop).err = 1;
-               return 0;
-       }
-
-       /*retrieve dimension of input string matrix*/
-       m1 = il_str[1]; /* number of row    */
-       n1 = il_str[2]; /* number of column */
-
-       /*Create header of Tlist*/
-       if ((dyn_char=MALLOC((1+m1*n1)*sizeof(char *)))==NULL)
-       {
-               Scierror(999, _("%s : No more memory.\n"),fname);
-               return 0;
-       }
-
-       /* Type of list is scicosvar */
-       if ((dyn_char[0]=MALLOC((strlen("scicosvar")+1)*sizeof(char)))==NULL)
-       {
-               FREE(dyn_char);
-               Scierror(999, _("%s : No more memory.\n"),fname);
-               return 0;
-       }
-       else strcpy(dyn_char[0],"scicosvar");
-
-       /*Check string matrix  */
-       for (j=0;j<m1*n1;j++)
-       {
-               sz_str = il_str[5+j]-il_str[4+j]; /* store the length of str */
-               /*get current position in the istk*/
-               if (j==0)
-                       ptr_pos=5+m1*n1; 
-               else
-                       ptr_pos += il_str[5+j-1]-il_str[4+j-1];
-               l_str = &il_str[ptr_pos]; /* get ptr of rsh 1 */
-               /* codetoascii convertion */
-               C2F(cha1).buf[0]=' ';
-               C2F(cvstr)(&sz_str,&l_str[0],&C2F(cha1).buf[0],(i=1,&i),sz_str);
-               C2F(cha1).buf[sz_str]='\0';
-               /* search if string is in accordance with entry*/
-               ierr=TRUE;
-               for (i=0;i<nentries;i++)
-               {
-                       if (strcmp(C2F(cha1).buf,entry[i]) == 0) 
-                       {
-                               /* Store string in header of Tlist */
-                               if ((dyn_char[j+1]=MALLOC(sizeof(char)*strlen(entry[i])+1))==NULL)
-                               {
-                                       FREE(dyn_char);
-                                       Scierror(999, _("%s : No more memory.\n"),fname);
-                                       return 0;
-                               }
-                               else strcpy(dyn_char[j+1],entry[i]);
-
-                               ierr=FALSE;
-                               break;
-                       }
-               }
-               /* if failed then display an error message and exit*/
-               if (ierr==TRUE)
-               {
-                       FREE(dyn_char);
-                       Scierror(999, _("%s : Undefined field in string matrix position : %d.\n"),fname,j+1);
-                       return 0;
-               }
-       }
-
-       /* store dyn_char on stack*/
-       if (n1*m1>1) str2sci(dyn_char,1,n1*m1+1);
-
-       /* return asked array */
-       for (j=0;j<m1*n1;j++)
-       {
-               sz_str = il_str[5+j]-il_str[4+j]; /* store the length of str */
-               /*get current position in the istk of the string*/
-               if (j==0)
-                       ptr_pos=5+m1*n1; 
-               else
-                       ptr_pos += il_str[5+j-1]-il_str[4+j-1];
-               l_str = &il_str[ptr_pos]; /* get ptr of rsh 1 */
-               /* codetoascii convertion */
-               C2F(cha1).buf[0]=' ';
-               C2F(cvstr)(&sz_str,&l_str[0],&C2F(cha1).buf[0],(i=1,&i),sz_str);
-               C2F(cha1).buf[sz_str]='\0';
-
-               /*****************************************************************
-               * entries that can be retrieve by il_state_save global variable
-               *****************************************************************/
-               if (strcmp(C2F(cha1).buf,"x") == 0)           /* retrieve continuous state */
-                       ierr=CopyVarFromlistentry(j+2,get_il_state(),2);
-               else if (strcmp(C2F(cha1).buf,"z") == 0)      /* retrieve discrete state */
-                       ierr=CopyVarFromlistentry(j+2,get_il_state(),3);
-               else if (strcmp(C2F(cha1).buf,"oz") == 0)     /* retrieve object discrete state */
-                       ierr=CopyVarFromlistentry(j+2,get_il_state(),4);
-               else if (strcmp(C2F(cha1).buf,"outtb") == 0)  /* retrieve outtb */
-                       ierr=CopyVarFromlistentry(j+2,get_il_state(),9);
-               else if (strcmp(C2F(cha1).buf,"tevts") == 0)  /* retrieve tevts */
-                       ierr=CopyVarFromlistentry(j+2,get_il_state(),6);
-
-               /***************************************************************
-               * entries that can be retrieve by il_sim_save global variable
-               ***************************************************************/
-               if (strcmp(C2F(cha1).buf,"opar") == 0)           /* retrieve object parameters */
-                       ierr=CopyVarFromlistentry(j+2,get_il_sim(),15);
-
-               /*************************************************
-               * int variables coming from import structure
-               *************************************************/
-               else if ((strcmp(C2F(cha1).buf,"mod") == 0)      || /* retrieve mode */
-                       (strcmp(C2F(cha1).buf,"nmod") == 0)     || /* retrieve nmode */
-                       (strcmp(C2F(cha1).buf,"iz") == 0)       || /* label int code of blocks */
-                       (strcmp(C2F(cha1).buf,"nblk") == 0)     || /* number of block */
-                       (strcmp(C2F(cha1).buf,"izptr") == 0)    || /* label int code of blocks ptr*/
-                       (strcmp(C2F(cha1).buf,"outtbptr") == 0) || /* outtb ptr */
-                       (strcmp(C2F(cha1).buf,"outtbsz") == 0)  || /* outtb size */
-                       (strcmp(C2F(cha1).buf,"outtbtyp") == 0) || /* outtb type */
-                       (strcmp(C2F(cha1).buf,"nlnk") == 0)     || /* number of link */
-                       (strcmp(C2F(cha1).buf,"nsubs") == 0)    || /* length of nsubs */
-                       (strcmp(C2F(cha1).buf,"nevts") == 0)    || /* length of evtspt & tevts */
-                       (strcmp(C2F(cha1).buf,"niord") == 0)    || /* length of iord */
-                       (strcmp(C2F(cha1).buf,"noord") == 0)    || /* length of oord */
-                       (strcmp(C2F(cha1).buf,"nzord") == 0)    || /* length of zord */
-                       (strcmp(C2F(cha1).buf,"funptr") == 0)   || /* retrieve function ptr */
-                       (strcmp(C2F(cha1).buf,"ncord") == 0)    || /* retrieve ncord */
-                       (strcmp(C2F(cha1).buf,"nordptr") == 0)  || /* retrieve nordptr */
-                       (strcmp(C2F(cha1).buf,"iwa") == 0)      || /* retrieve iwa */
-                       (strcmp(C2F(cha1).buf,"ng") == 0)       || /* retrieve ng */
-                       (strcmp(C2F(cha1).buf,"nx") == 0)       || /* retrieve nx */
-                       (strcmp(C2F(cha1).buf,"nz") == 0)       || /* retrieve nz */
-                       (strcmp(C2F(cha1).buf,"noz") == 0)      || /* retrieve noz */
-                       (strcmp(C2F(cha1).buf,"ozptr") == 0)    || /* retrieve ozptr */
-                       (strcmp(C2F(cha1).buf,"ozsz") == 0)     || /* retrieve ozsz */
-                       (strcmp(C2F(cha1).buf,"oztyp") == 0)    || /* retrieve oztyp */
-                       (strcmp(C2F(cha1).buf,"nelem") == 0)    || /* retrieve nelem */
-                       (strcmp(C2F(cha1).buf,"xptr") == 0)     || /* retrieve xptr */
-                       (strcmp(C2F(cha1).buf,"zcptr") == 0)    || /* retrieve zcptr */
-                       (strcmp(C2F(cha1).buf,"zptr") == 0)     || /* retrieve zptr */
-                       (strcmp(C2F(cha1).buf,"rpptr") == 0)    || /* retrieve rpptr */
-                       (strcmp(C2F(cha1).buf,"ipar") == 0)     || /* retrieve ipar */
-                       (strcmp(C2F(cha1).buf,"ipptr") == 0)    || /* retrieve ipptr */
-                       (strcmp(C2F(cha1).buf,"opptr") == 0)    || /* retrieve opptr */
-                       (strcmp(C2F(cha1).buf,"oparsz") == 0)   || /* retrieve oparsz */
-                       (strcmp(C2F(cha1).buf,"opartyp") == 0)  || /* retrieve opartyp */
-                       (strcmp(C2F(cha1).buf,"inpptr") == 0)   || /* retrieve inpptr */
-                       (strcmp(C2F(cha1).buf,"outptr") == 0)   || /* retrieve outptr */
-                       (strcmp(C2F(cha1).buf,"inplnk") == 0)   || /* retrieve inplnk */
-                       (strcmp(C2F(cha1).buf,"outlnk") == 0)   || /* retrieve outlnk */
-                       (strcmp(C2F(cha1).buf,"subs") == 0)     || /* retrieve subs */
-                       (strcmp(C2F(cha1).buf,"iord") == 0)     || /* retrieve iord */
-                       (strcmp(C2F(cha1).buf,"oord") == 0)     || /* retrieve iord */
-                       (strcmp(C2F(cha1).buf,"zord") == 0)     || /* retrieve iord */
-                       (strcmp(C2F(cha1).buf,"funtyp") == 0)   || /* retrieve funtyp */
-                       (strcmp(C2F(cha1).buf,"ztyp") == 0)     || /* retrieve ztyp */
-                       (strcmp(C2F(cha1).buf,"cord") == 0)     || /* retrieve cord */
-                       (strcmp(C2F(cha1).buf,"ordclk") == 0)   || /* retrieve ordclk */
-                       (strcmp(C2F(cha1).buf,"clkcpr") == 0)   || /* retrieve clkcpr */
-                       (strcmp(C2F(cha1).buf,"ordptr") == 0)   || /* retrieve ordptr */
-                       (strcmp(C2F(cha1).buf,"critev") == 0)   || /* retrieve critev */
-                       /* state */
-                       (strcmp(C2F(cha1).buf,"evtspt") == 0)   || /* retrieve evtspt */
-                       (strcmp(C2F(cha1).buf,"pointi") == 0)      /* retrieve nelem */
-                       )
-               {
-                       /* retrieve dims and prt of asked array with getscicosvarsfromimport */
-                       ierr = getscicosvarsfromimport(C2F(cha1).buf,&ptr,&nv,&mv);
-
-                       /* check ierr flag */
-                       if (ierr==TRUE)
-                       {
-                               l_tmp = I_INT32; /* define type of int */
-                               CreateVar(j+2,MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE,&nv,&mv,&l_tmp); /* Create int32 variable at the top+j+1 pos in the stack */
-                               il_tmp = (int *) istk(l_tmp);      /* Store value of address of istk(l_tmp) in il_tmp */
-                               ptr_int = (int *) ptr;             /* cast void* ptr to int* ptr */
-                               for (i=0;i<nv*mv;i++) il_tmp[i] = ptr_int[i]; /* copy returned array in istk */
-                       }
-               }
-
-               /*************************************************
-               * double variables coming from import structure
-               *************************************************/
-               else if ((strcmp(C2F(cha1).buf,"rpar") == 0)   || /* retrieve rpar      */
-                       (strcmp(C2F(cha1).buf,"g") == 0)      || /* retrieve g      */
-                       (strcmp(C2F(cha1).buf,"t0") == 0)     || /* retrieve t0     */
-                       (strcmp(C2F(cha1).buf,"tf") == 0)     || /* retrieve tf     */
-                       (strcmp(C2F(cha1).buf,"Atol") == 0)   || /* retrieve Atol   */
-                       (strcmp(C2F(cha1).buf,"rtol") == 0)   || /* retrieve rtol   */
-                       (strcmp(C2F(cha1).buf,"ttol") == 0)   || /* retrieve ttol   */
-                       (strcmp(C2F(cha1).buf,"deltat") == 0) || /* retrieve deltat */
-                       (strcmp(C2F(cha1).buf,"hmax") == 0)      /* retrieve hmax   */
-                       )
-               {
-                       /* retrieve dims and prt of asked array with getscicosvarsfromimport */
-                       ierr=getscicosvarsfromimport(C2F(cha1).buf,&ptr,&nv,&mv);
-
-                       /* check ierr flag */
-                       if (ierr==TRUE)
-                       {
-                               ptr_dd = (double *) ptr;
-                               CreateVar(j+2,MATRIX_OF_DOUBLE_DATATYPE,&nv,&mv,&l_tmp); /* Create double variable at the top+j+1 addr. of the stack */
-                               for (i=0;i<nv*mv;i++) *stk(l_tmp+i) = ptr_dd[i]; /* copy returned array in istk */
-                       }
-               }
-
-               /*************************************************
-               * scicos_block ptr coming from import structure
-               *************************************************/
-               else if ((strcmp(C2F(cha1).buf,"blocks") == 0)
-                       )
-               {
-                       /* retrieve scicos_block prt of asked array with getscicosvarsfromimport */
-                       ierr = getscicosvarsfromimport(C2F(cha1).buf,&ptr,&nv,&mv);
-
-                       /* check ierr flag */
-                       if (ierr==TRUE)
-                       {
-                               /* store ptr in ptrscs_blk */
-                               ptr_scsblk = (scicos_block *) ptr;
-
-                               /* retrieve nblk by import structure */
-                               strcpy(C2F(cha1).buf,"nblk");
-                               ierr = getscicosvarsfromimport(C2F(cha1).buf,&ptr,&nv,&mv);
-                               ptr_int = (int *) ptr; /* cast void* ptr to int* ptr */
-                               nblk = *ptr_int;
-
-                               /* retrieve ng by import structure */
-                               strcpy(C2F(cha1).buf,"ng");
-                               ierr = getscicosvarsfromimport(C2F(cha1).buf,&ptr,&nv,&mv);
-                               ptr_int = (int *) ptr; /* cast void* ptr to int* ptr */
-                               ng = *ptr_int;
-
-                               /*retrieve xptr by import structure*/
-                               strcpy(C2F(cha1).buf,"xptr");
-                               ierr = getscicosvarsfromimport(C2F(cha1).buf,&ptr,&nv,&mv);
-                               ptr_int = (int *) ptr;
-                               xptr = ptr_int;
-
-                               /*retrieve zcptr by import structure*/
-                               strcpy(C2F(cha1).buf,"zcptr");
-                               ierr = getscicosvarsfromimport(C2F(cha1).buf,&ptr,&nv,&mv);
-                               ptr_int = (int *) ptr;
-                               zcptr = ptr_int;
-
-                               /*retrieve x and xd by import structure*/
-                               strcpy(C2F(cha1).buf,"x");
-                               ierr = getscicosvarsfromimport(C2F(cha1).buf,&ptr,&nv,&mv);
-                               ptr_dd = (double *) ptr;
-                               x = ptr_dd;
-                               xd = &x[xptr[nblk]-1];
-
-                               /*retrieve g by import structure*/
-                               strcpy(C2F(cha1).buf,"g");
-                               ierr=getscicosvarsfromimport(C2F(cha1).buf,&ptr,&nv,&mv);
-                               ptr_dd = (double *) ptr;
-                               g = ptr_dd;
-
-                               /*retrieve funtyp by import structure*/
-                               strcpy(C2F(cha1).buf,"funtyp");
-                               ierr = getscicosvarsfromimport(C2F(cha1).buf,&ptr,&nv,&mv);
-                               funtyp = (int *) ptr;
-
-                               /* store blklst on stack */
-                               Topsave = Top;     /* save Top counter */
-                               Top = Top - Rhs + 1 + j; /* adjust Top counter */
-
-                               for (k=0;k<nblk;k++)
-                               {/* for each block, call createblklist */
-
-                                       /* set flag_imp <0 for createblklst */
-                                       i=-1;
-
-                                       /* the following test is done in order to know if block k
-                                       * have been already called with callf in scicos.c
-                                       */
-                                       if (ptr_scsblk[k].nx!=0)
-                                       {
-                                               if (ptr_scsblk[k].x!=&x[xptr[k]-1])
-                                               {
-                                                       /*fprintf(stderr,"k=%d,X,xd Non initialise",k);*/
-                                                       /* set flag_imp=k for createblklst <0 */
-                                                       i=k;
-                                               }
-                                       }
-                                       if (ptr_scsblk[k].ng!=0)
-                                       {
-                                               if ((ptr_scsblk[k].g!=&g[zcptr[k]-1]) && (ptr_scsblk[k].g!=&x[xptr[k]-1]))
-                                               {
-                                                       /*fprintf(stderr,"k=%d,g Non initialise",k);*/
-                                                       /* set flag_imp=k for createblklst <0 */
-                                                       i=k;
-                                               }
-                                       }
-                                       /* call createblklist */
-                                       ierr=createblklist(&ptr_scsblk[k], &errc,i,k+1);
-
-                                       /* if an error occurs in createblklist */
-                                       if (ierr==FALSE)
-                                       {
-                                               Top=Topsave;
-                                               break;
-                                       }
-                               }
-                               /* if success, create a list of Typed list scicos_block */
-                               if (ierr==TRUE)
-                               {
-                                       C2F(mklist)(&nblk);
-                                       Top=Topsave; /* adjust Top counter */
-                                       CreateVar(j+2,LIST_DATATYPE,&nblk,(i=1,&i),&l_tmp); /* this is done to inform common intersci */
-                               }
-
-                       }
-               }
-
-               /*******************************************
-               * outtb_elem coming from import structure
-               *******************************************/
-               else if ((strcmp(C2F(cha1).buf,"outtb_elem") == 0)) /* retrieve outtb_elem */
-               {
-                       /* retrieve dims and prt of asked array with getscicosvarsfromimport */
-                       ierr=getscicosvarsfromimport(C2F(cha1).buf,&ptr,&nv,&mv);
-
-                       /* check ierr flag */
-                       if (ierr==TRUE)
-                       {
-                               l_tmp = I_INT32; /* define type of int */
-                               CreateVar(j+2,MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE,&nv,&mv,&l_tmp); /* Create int32 variable at the top+j+1 addr. of the stack */
-                               il_tmp = (int *) istk(l_tmp);      /* Store value of address of istk(l_tmp) in il_tmp */
-                               ptr_elem = (outtb_el *) ptr;       /* cast void* ptr to int* ptr */
-                               for (i=0;i<nv;i++) /* copy returned array in istk */
-                               {
-                                       il_tmp[i] = ptr_elem[i].lnk + 1; /* +1 is for the connection with outtb list */
-                                       il_tmp[nv+i] = ptr_elem[i].pos + 1;
-                               }
-                       }
-               }
-
-               /* if return a FALSE value in
-               * error flag then display an error message.
-               */
-               if(ierr!=TRUE)
-               {
-                       Scierror(999, _("%s : Error.\n"),fname);
-                       FREE(dyn_char);
-                       return 0;
-               }
-       }
-       /**********************
-       * Create lsh argument
-       **********************/
-       /* create a tlist if number of string in rhs 1 is >1*/
-       if (j>1) 
-       {
-               Top=Top+j;
-               j++;
-               C2F(mktlist)(&j);
-               Top = Top-1;
-               CreateVar(2,TYPED_LIST_DATATYPE,&j,(i=1,&i),&l_tmp); /* this is done to inform common intersci */
-       }
-
-       /* put new variable in lsh argument */
-       LhsVar(1) = 2;
-       
-       /* end */
-       FREE(dyn_char);
+    /************************************
+    * variables and constants d?inition
+    ************************************/
+    /* auxilary variables for dimension and address */
+    int m1 = 0, n1 = 0;     /* dimension of input character string               */
+    int *il_str = NULL;   /* address of the description of the input parameter */
+    int *l_str = NULL;    /* address of the data of the input parameter        */
+    int l_tmp = 0;     /* temp variables to store address                   */
+    int *il_tmp = NULL;
+
+    /* definition of min/max input/output argument */
+    static int minrhs = 0, maxrhs = 1;
+
+    /* auxilary variables */
+    int nv = 0, mv = 0;                /* length of data                                      */
+    void *ptr = 0;                /* ptr for data comming from import structure          */
+    int *ptr_int = NULL;             /* ptr to store ptr on int                         */
+    double *ptr_dd = NULL;           /* ptr to store ptr on double                          */
+    scicos_block *ptr_scsblk = NULL; /* ptr to store ptr of scicos_block structure          */
+    outtb_el *ptr_elem = NULL;       /* ptr to store ptr of outtb_el structure              */
+    int nblk = 0, ng = 0;              /* to store number of blocks and number of zero cross. */
+    int *xptr = NULL, *zcptr = NULL;        /* to store xptr and zcptr of scicos_blocks            */
+    double *x = NULL, *xd = NULL, *g = NULL;       /* ptr for x, xd and g for scicos_blocks               */
+    int *funtyp = NULL;              /* ptr for funtyp */
+
+    int ierr = 0;       /* error flag                                */
+    int errc = 0;       /* error flag for ceateblklst                */
+    int ptr_pos = 0;    /* to store position in scilab string object */
+    int Topsave = 0;    /* to save the Top position                  */
+
+    int sz_str = 0;     /* local variabe to store size of string */
+    int i = 0, j = 0, k = 0;    /* local counter variable                */
+
+    /* number of entries -please update me-                        */
+    static int nentries = 69;
+    /* define accepted entries of getscicosvars -please update me- */
+    static char *entry[] =
+    {
+        "x"       , "nx"       , "xptr"   , "zcptr"      , "z"        ,
+        "nz"      , "zptr"     , "noz"    , "oz"         , "ozsz"     ,
+        "oztyp"   , "ozptr"    , "rpar"   , "rpptr"      , "ipar"     ,
+        "ipptr"   , "opar"     , "oparsz" , "opartyp"    , "opptr"    ,
+        "outtb"   , "inpptr"   , "outptr" , "inplnk"     , "outlnk"   ,
+        "subs"    , "tevts"    , "evtspt" , "pointi"     , "iord"     ,
+        "oord"    , "zord"     , "funtyp" , "ztyp"       , "cord"     ,
+        "ordclk"  , "clkptr"   , "ordptr" , "critev"     , "mod"      ,
+        "nmod"    , "iz"       , "nblk"   , "izptr"      , "outtbptr" ,
+        "outtbsz" , "outtbtyp" , "nlnk"   , "nsubs"      , "nevts"    ,
+        "niord"   , "noord"    , "nzord"  , "funptr"     , "ncord"    ,
+        "nordptr" , "iwa"      , "blocks" , "ng"         , "g"        ,
+        "t0"      , "tf"       , "Atol"   , "rtol"       , "ttol"     ,
+        "deltat"  , "hmax"     , "nelem"  , "outtb_elem"
+    };
+
+    char **dyn_char = NULL; /* for allocation of first entry in tlist */
+
+    /****************************************
+    * Check number of inputs and outputs Rhs
+    ****************************************/
+    CheckRhs(minrhs, maxrhs);
+
+    /* Display usage of getscicosvars function if Rhs==0 */
+    if (Rhs == 0)
+    {
+        sciprint(_("\ngetscicosvars : utility function to retrieve\n"));
+        sciprint(_("                scicos arrays during simulation.\n\n"));
+        sciprint(_("Usage : [myvar]=getscicosvars([\"str1\";\"str2\";...]);\n\n"));
+        sciprint(_("- myvar : an int32 or double matrix or a Tlist.\n"));
+        sciprint(_("- [\"str1\";\"str2\",...] is a string matrix\n"));
+        sciprint(_("  that must be informed with the following values :\n"));
+
+        /* display allowed entries */
+        i = 0;
+        for (j = 0; j < nentries; j++)
+        {
+            if (j == nentries - 1) sciprint("\"%s\" ", entry[j]);
+            else sciprint("\"%s\", ", entry[j]);
+            i++;
+            if (i == 6)
+            {
+                sciprint("\n");
+                i = 0;
+            }
+        }
+        sciprint("\n");
+        return 0;
+    }
+
+    /*******************
+    * Check str (rhs 1)
+    *******************/
+    il_str = (int *) GetData(1); /* get ptr of int header of rsh 1 */
+    if (il_str[0] != sci_strings) /* Check if input argument is a character string matrix */
+    {
+        Scierror(55, _("%s : First argument must be a string.\n"), fname);
+        C2F(iop).err = 1;
+        return 0;
+    }
+
+    /*retrieve dimension of input string matrix*/
+    m1 = il_str[1]; /* number of row    */
+    n1 = il_str[2]; /* number of column */
+
+    /*Create header of Tlist*/
+    if ((dyn_char = MALLOC((1 + m1 * n1) * sizeof(char *))) == NULL)
+    {
+        Scierror(999, _("%s : No more memory.\n"), fname);
+        return 0;
+    }
+
+    /* Type of list is scicosvar */
+    if ((dyn_char[0] = MALLOC((strlen("scicosvar") + 1) * sizeof(char))) == NULL)
+    {
+        FREE(dyn_char);
+        Scierror(999, _("%s : No more memory.\n"), fname);
+        return 0;
+    }
+    else strcpy(dyn_char[0], "scicosvar");
+
+    /*Check string matrix  */
+    for (j = 0; j < m1 * n1; j++)
+    {
+        sz_str = il_str[5 + j] - il_str[4 + j]; /* store the length of str */
+        /*get current position in the istk*/
+        if (j == 0)
+            ptr_pos = 5 + m1 * n1;
+        else
+            ptr_pos += il_str[5 + j - 1] - il_str[4 + j - 1];
+        l_str = &il_str[ptr_pos]; /* get ptr of rsh 1 */
+        /* codetoascii convertion */
+        C2F(cha1).buf[0] = ' ';
+        C2F(cvstr)(&sz_str, &l_str[0], &C2F(cha1).buf[0], (i = 1, &i), sz_str);
+        C2F(cha1).buf[sz_str] = '\0';
+        /* search if string is in accordance with entry*/
+        ierr = TRUE;
+        for (i = 0; i < nentries; i++)
+        {
+            if (strcmp(C2F(cha1).buf, entry[i]) == 0)
+            {
+                /* Store string in header of Tlist */
+                if ((dyn_char[j + 1] = MALLOC(sizeof(char) * strlen(entry[i]) + 1)) == NULL)
+                {
+                    FREE(dyn_char);
+                    Scierror(999, _("%s : No more memory.\n"), fname);
+                    return 0;
+                }
+                else strcpy(dyn_char[j + 1], entry[i]);
+
+                ierr = FALSE;
+                break;
+            }
+        }
+        /* if failed then display an error message and exit*/
+        if (ierr == TRUE)
+        {
+            FREE(dyn_char);
+            Scierror(999, _("%s : Undefined field in string matrix position : %d.\n"), fname, j + 1);
+            return 0;
+        }
+    }
+
+    /* store dyn_char on stack*/
+    if (n1 * m1 > 1) str2sci(dyn_char, 1, n1 * m1 + 1);
+
+    /* return asked array */
+    for (j = 0; j < m1 * n1; j++)
+    {
+        sz_str = il_str[5 + j] - il_str[4 + j]; /* store the length of str */
+        /*get current position in the istk of the string*/
+        if (j == 0)
+            ptr_pos = 5 + m1 * n1;
+        else
+            ptr_pos += il_str[5 + j - 1] - il_str[4 + j - 1];
+        l_str = &il_str[ptr_pos]; /* get ptr of rsh 1 */
+        /* codetoascii convertion */
+        C2F(cha1).buf[0] = ' ';
+        C2F(cvstr)(&sz_str, &l_str[0], &C2F(cha1).buf[0], (i = 1, &i), sz_str);
+        C2F(cha1).buf[sz_str] = '\0';
+
+        /*****************************************************************
+        * entries that can be retrieve by il_state_save global variable
+        *****************************************************************/
+        if (strcmp(C2F(cha1).buf, "x") == 0)          /* retrieve continuous state */
+            ierr = CopyVarFromlistentry(j + 2, get_il_state(), 2);
+        else if (strcmp(C2F(cha1).buf, "z") == 0)     /* retrieve discrete state */
+            ierr = CopyVarFromlistentry(j + 2, get_il_state(), 3);
+        else if (strcmp(C2F(cha1).buf, "oz") == 0)    /* retrieve object discrete state */
+            ierr = CopyVarFromlistentry(j + 2, get_il_state(), 4);
+        else if (strcmp(C2F(cha1).buf, "outtb") == 0) /* retrieve outtb */
+            ierr = CopyVarFromlistentry(j + 2, get_il_state(), 9);
+        else if (strcmp(C2F(cha1).buf, "tevts") == 0) /* retrieve tevts */
+            ierr = CopyVarFromlistentry(j + 2, get_il_state(), 6);
+
+        /***************************************************************
+        * entries that can be retrieve by il_sim_save global variable
+        ***************************************************************/
+        if (strcmp(C2F(cha1).buf, "opar") == 0)          /* retrieve object parameters */
+            ierr = CopyVarFromlistentry(j + 2, get_il_sim(), 15);
+
+        /*************************************************
+        * int variables coming from import structure
+        *************************************************/
+        else if ((strcmp(C2F(cha1).buf, "mod") == 0)      || /* retrieve mode */
+                 (strcmp(C2F(cha1).buf, "nmod") == 0)     || /* retrieve nmode */
+                 (strcmp(C2F(cha1).buf, "iz") == 0)       || /* label int code of blocks */
+                 (strcmp(C2F(cha1).buf, "nblk") == 0)     || /* number of block */
+                 (strcmp(C2F(cha1).buf, "izptr") == 0)    || /* label int code of blocks ptr*/
+                 (strcmp(C2F(cha1).buf, "outtbptr") == 0) || /* outtb ptr */
+                 (strcmp(C2F(cha1).buf, "outtbsz") == 0)  || /* outtb size */
+                 (strcmp(C2F(cha1).buf, "outtbtyp") == 0) || /* outtb type */
+                 (strcmp(C2F(cha1).buf, "nlnk") == 0)     || /* number of link */
+                 (strcmp(C2F(cha1).buf, "nsubs") == 0)    || /* length of nsubs */
+                 (strcmp(C2F(cha1).buf, "nevts") == 0)    || /* length of evtspt & tevts */
+                 (strcmp(C2F(cha1).buf, "niord") == 0)    || /* length of iord */
+                 (strcmp(C2F(cha1).buf, "noord") == 0)    || /* length of oord */
+                 (strcmp(C2F(cha1).buf, "nzord") == 0)    || /* length of zord */
+                 (strcmp(C2F(cha1).buf, "funptr") == 0)   || /* retrieve function ptr */
+                 (strcmp(C2F(cha1).buf, "ncord") == 0)    || /* retrieve ncord */
+                 (strcmp(C2F(cha1).buf, "nordptr") == 0)  || /* retrieve nordptr */
+                 (strcmp(C2F(cha1).buf, "iwa") == 0)      || /* retrieve iwa */
+                 (strcmp(C2F(cha1).buf, "ng") == 0)       || /* retrieve ng */
+                 (strcmp(C2F(cha1).buf, "nx") == 0)       || /* retrieve nx */
+                 (strcmp(C2F(cha1).buf, "nz") == 0)       || /* retrieve nz */
+                 (strcmp(C2F(cha1).buf, "noz") == 0)      || /* retrieve noz */
+                 (strcmp(C2F(cha1).buf, "ozptr") == 0)    || /* retrieve ozptr */
+                 (strcmp(C2F(cha1).buf, "ozsz") == 0)     || /* retrieve ozsz */
+                 (strcmp(C2F(cha1).buf, "oztyp") == 0)    || /* retrieve oztyp */
+                 (strcmp(C2F(cha1).buf, "nelem") == 0)    || /* retrieve nelem */
+                 (strcmp(C2F(cha1).buf, "xptr") == 0)     || /* retrieve xptr */
+                 (strcmp(C2F(cha1).buf, "zcptr") == 0)    || /* retrieve zcptr */
+                 (strcmp(C2F(cha1).buf, "zptr") == 0)     || /* retrieve zptr */
+                 (strcmp(C2F(cha1).buf, "rpptr") == 0)    || /* retrieve rpptr */
+                 (strcmp(C2F(cha1).buf, "ipar") == 0)     || /* retrieve ipar */
+                 (strcmp(C2F(cha1).buf, "ipptr") == 0)    || /* retrieve ipptr */
+                 (strcmp(C2F(cha1).buf, "opptr") == 0)    || /* retrieve opptr */
+                 (strcmp(C2F(cha1).buf, "oparsz") == 0)   || /* retrieve oparsz */
+                 (strcmp(C2F(cha1).buf, "opartyp") == 0)  || /* retrieve opartyp */
+                 (strcmp(C2F(cha1).buf, "inpptr") == 0)   || /* retrieve inpptr */
+                 (strcmp(C2F(cha1).buf, "outptr") == 0)   || /* retrieve outptr */
+                 (strcmp(C2F(cha1).buf, "inplnk") == 0)   || /* retrieve inplnk */
+                 (strcmp(C2F(cha1).buf, "outlnk") == 0)   || /* retrieve outlnk */
+                 (strcmp(C2F(cha1).buf, "subs") == 0)     || /* retrieve subs */
+                 (strcmp(C2F(cha1).buf, "iord") == 0)     || /* retrieve iord */
+                 (strcmp(C2F(cha1).buf, "oord") == 0)     || /* retrieve iord */
+                 (strcmp(C2F(cha1).buf, "zord") == 0)     || /* retrieve iord */
+                 (strcmp(C2F(cha1).buf, "funtyp") == 0)   || /* retrieve funtyp */
+                 (strcmp(C2F(cha1).buf, "ztyp") == 0)     || /* retrieve ztyp */
+                 (strcmp(C2F(cha1).buf, "cord") == 0)     || /* retrieve cord */
+                 (strcmp(C2F(cha1).buf, "ordclk") == 0)   || /* retrieve ordclk */
+                 (strcmp(C2F(cha1).buf, "clkcpr") == 0)   || /* retrieve clkcpr */
+                 (strcmp(C2F(cha1).buf, "ordptr") == 0)   || /* retrieve ordptr */
+                 (strcmp(C2F(cha1).buf, "critev") == 0)   || /* retrieve critev */
+                 /* state */
+                 (strcmp(C2F(cha1).buf, "evtspt") == 0)   || /* retrieve evtspt */
+                 (strcmp(C2F(cha1).buf, "pointi") == 0)     /* retrieve nelem */
+                )
+        {
+            /* retrieve dims and prt of asked array with getscicosvarsfromimport */
+            ierr = getscicosvarsfromimport(C2F(cha1).buf, &ptr, &nv, &mv);
+
+            /* check ierr flag */
+            if (ierr == TRUE)
+            {
+                l_tmp = I_INT32; /* define type of int */
+                CreateVar(j + 2, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &nv, &mv, &l_tmp); /* Create int32 variable at the top+j+1 pos in the stack */
+                il_tmp = (int *) istk(l_tmp);      /* Store value of address of istk(l_tmp) in il_tmp */
+                ptr_int = (int *) ptr;             /* cast void* ptr to int* ptr */
+                for (i = 0; i < nv * mv; i++) il_tmp[i] = ptr_int[i]; /* copy returned array in istk */
+            }
+        }
+
+        /*************************************************
+        * double variables coming from import structure
+        *************************************************/
+        else if ((strcmp(C2F(cha1).buf, "rpar") == 0)   || /* retrieve rpar      */
+                 (strcmp(C2F(cha1).buf, "g") == 0)      || /* retrieve g      */
+                 (strcmp(C2F(cha1).buf, "t0") == 0)     || /* retrieve t0     */
+                 (strcmp(C2F(cha1).buf, "tf") == 0)     || /* retrieve tf     */
+                 (strcmp(C2F(cha1).buf, "Atol") == 0)   || /* retrieve Atol   */
+                 (strcmp(C2F(cha1).buf, "rtol") == 0)   || /* retrieve rtol   */
+                 (strcmp(C2F(cha1).buf, "ttol") == 0)   || /* retrieve ttol   */
+                 (strcmp(C2F(cha1).buf, "deltat") == 0) || /* retrieve deltat */
+                 (strcmp(C2F(cha1).buf, "hmax") == 0)     /* retrieve hmax   */
+                )
+        {
+            /* retrieve dims and prt of asked array with getscicosvarsfromimport */
+            ierr = getscicosvarsfromimport(C2F(cha1).buf, &ptr, &nv, &mv);
+
+            /* check ierr flag */
+            if (ierr == TRUE)
+            {
+                ptr_dd = (double *) ptr;
+                CreateVar(j + 2, MATRIX_OF_DOUBLE_DATATYPE, &nv, &mv, &l_tmp); /* Create double variable at the top+j+1 addr. of the stack */
+                for (i = 0; i < nv * mv; i++) *stk(l_tmp + i) = ptr_dd[i]; /* copy returned array in istk */
+            }
+        }
+
+        /*************************************************
+        * scicos_block ptr coming from import structure
+        *************************************************/
+        else if ((strcmp(C2F(cha1).buf, "blocks") == 0)
+                )
+        {
+            /* retrieve scicos_block prt of asked array with getscicosvarsfromimport */
+            ierr = getscicosvarsfromimport(C2F(cha1).buf, &ptr, &nv, &mv);
+
+            /* check ierr flag */
+            if (ierr == TRUE)
+            {
+                /* store ptr in ptrscs_blk */
+                ptr_scsblk = (scicos_block *) ptr;
+
+                /* retrieve nblk by import structure */
+                strcpy(C2F(cha1).buf, "nblk");
+                ierr = getscicosvarsfromimport(C2F(cha1).buf, &ptr, &nv, &mv);
+                ptr_int = (int *) ptr; /* cast void* ptr to int* ptr */
+                nblk = *ptr_int;
+
+                /* retrieve ng by import structure */
+                strcpy(C2F(cha1).buf, "ng");
+                ierr = getscicosvarsfromimport(C2F(cha1).buf, &ptr, &nv, &mv);
+                ptr_int = (int *) ptr; /* cast void* ptr to int* ptr */
+                ng = *ptr_int;
+
+                /*retrieve xptr by import structure*/
+                strcpy(C2F(cha1).buf, "xptr");
+                ierr = getscicosvarsfromimport(C2F(cha1).buf, &ptr, &nv, &mv);
+                ptr_int = (int *) ptr;
+                xptr = ptr_int;
+
+                /*retrieve zcptr by import structure*/
+                strcpy(C2F(cha1).buf, "zcptr");
+                ierr = getscicosvarsfromimport(C2F(cha1).buf, &ptr, &nv, &mv);
+                ptr_int = (int *) ptr;
+                zcptr = ptr_int;
+
+                /*retrieve x and xd by import structure*/
+                strcpy(C2F(cha1).buf, "x");
+                ierr = getscicosvarsfromimport(C2F(cha1).buf, &ptr, &nv, &mv);
+                ptr_dd = (double *) ptr;
+                x = ptr_dd;
+                xd = &x[xptr[nblk] - 1];
+
+                /*retrieve g by import structure*/
+                strcpy(C2F(cha1).buf, "g");
+                ierr = getscicosvarsfromimport(C2F(cha1).buf, &ptr, &nv, &mv);
+                ptr_dd = (double *) ptr;
+                g = ptr_dd;
+
+                /*retrieve funtyp by import structure*/
+                strcpy(C2F(cha1).buf, "funtyp");
+                ierr = getscicosvarsfromimport(C2F(cha1).buf, &ptr, &nv, &mv);
+                funtyp = (int *) ptr;
+
+                /* store blklst on stack */
+                Topsave = Top;     /* save Top counter */
+                Top = Top - Rhs + 1 + j; /* adjust Top counter */
+
+                for (k = 0; k < nblk; k++)
+                {
+                    /* for each block, call createblklist */
+
+                    /* set flag_imp <0 for createblklst */
+                    i = -1;
+
+                    /* the following test is done in order to know if block k
+                    * have been already called with callf in scicos.c
+                    */
+                    if (ptr_scsblk[k].nx != 0)
+                    {
+                        if (ptr_scsblk[k].x != &x[xptr[k] - 1])
+                        {
+                            /*fprintf(stderr,"k=%d,X,xd Non initialise",k);*/
+                            /* set flag_imp=k for createblklst <0 */
+                            i = k;
+                        }
+                    }
+                    if (ptr_scsblk[k].ng != 0)
+                    {
+                        if ((ptr_scsblk[k].g != &g[zcptr[k] - 1]) && (ptr_scsblk[k].g != &x[xptr[k] - 1]))
+                        {
+                            /*fprintf(stderr,"k=%d,g Non initialise",k);*/
+                            /* set flag_imp=k for createblklst <0 */
+                            i = k;
+                        }
+                    }
+                    /* call createblklist */
+                    ierr = createblklist(&ptr_scsblk[k], &errc, i, k + 1);
+
+                    /* if an error occurs in createblklist */
+                    if (ierr == FALSE)
+                    {
+                        Top = Topsave;
+                        break;
+                    }
+                }
+                /* if success, create a list of Typed list scicos_block */
+                if (ierr == TRUE)
+                {
+                    C2F(mklist)(&nblk);
+                    Top = Topsave; /* adjust Top counter */
+                    i = 1;
+                    CreateVar(j + 2, LIST_DATATYPE, &nblk, &i, &l_tmp); /* this is done to inform common intersci */
+                }
+
+            }
+        }
+
+        /*******************************************
+        * outtb_elem coming from import structure
+        *******************************************/
+        else if ((strcmp(C2F(cha1).buf, "outtb_elem") == 0)) /* retrieve outtb_elem */
+        {
+            /* retrieve dims and prt of asked array with getscicosvarsfromimport */
+            ierr = getscicosvarsfromimport(C2F(cha1).buf, &ptr, &nv, &mv);
+
+            /* check ierr flag */
+            if (ierr == TRUE)
+            {
+                l_tmp = I_INT32; /* define type of int */
+                CreateVar(j + 2, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &nv, &mv, &l_tmp); /* Create int32 variable at the top+j+1 addr. of the stack */
+                il_tmp = (int *) istk(l_tmp);      /* Store value of address of istk(l_tmp) in il_tmp */
+                ptr_elem = (outtb_el *) ptr;       /* cast void* ptr to int* ptr */
+                for (i = 0; i < nv; i++) /* copy returned array in istk */
+                {
+                    il_tmp[i] = ptr_elem[i].lnk + 1; /* +1 is for the connection with outtb list */
+                    il_tmp[nv + i] = ptr_elem[i].pos + 1;
+                }
+            }
+        }
+
+        /* if return a FALSE value in
+        * error flag then display an error message.
+        */
+        if (ierr != TRUE)
+        {
+            Scierror(999, _("%s : Error.\n"), fname);
+            FREE(dyn_char);
+            return 0;
+        }
+    }
+    /**********************
+    * Create lsh argument
+    **********************/
+    /* create a tlist if number of string in rhs 1 is >1*/
+    if (j > 1)
+    {
+        Top = Top + j;
+        j++;
+        C2F(mktlist)(&j);
+        Top = Top - 1;
+        i = 1;
+        CreateVar(2, TYPED_LIST_DATATYPE, &j, &i, &l_tmp); /* this is done to inform common intersci */
+    }
+
+    /* put new variable in lsh argument */
+    LhsVar(1) = 2;
+
+    /* end */
+    FREE(dyn_char);
     PutLhsVar();
-       return 0;
+    return 0;
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
index cc01a92..c806b15 100644 (file)
 /*--------------------------------------------------------------------------*/
 extern COSIM_struct C2F(cosim);
 /*--------------------------------------------------------------------------*/
-int sci_phase_simulation(char *fname,unsigned long fname_len)
+int sci_phase_simulation(char *fname, unsigned long fname_len)
 {
-       int isrun = C2F(cosim).isrun;
+    int isrun = C2F(cosim).isrun;
 
-       if (!isrun) 
-       {
-               Scierror(999, _("%s: scicosim is not running.\n"),fname);
-       }
-       else 
-       {
-               int one = 1, l1 = 0;
+    if (!isrun)
+    {
+        Scierror(999, _("%s: scicosim is not running.\n"), fname);
+    }
+    else
+    {
+        int one = 1, l1 = 0;
 
-               CheckRhs(-1,0);
-               CheckLhs(1,1);
-               CreateVar(1, MATRIX_OF_INTEGER_DATATYPE,(one=1,&one),(one=1,&one),&l1);
-               *istk(l1) = get_phase_simulation();
-               LhsVar(1) = 1;
-               PutLhsVar();
-       }
+        CheckRhs(-1, 0);
+        CheckLhs(1, 1);
+        CreateVar(1, MATRIX_OF_INTEGER_DATATYPE, &one, &one, &l1);
+        *istk(l1) = get_phase_simulation();
+        LhsVar(1) = 1;
+        PutLhsVar();
+    }
 
-       return 0;
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 68e9a9b..7f3e215 100644 (file)
 #include "localization.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
-extern void C2F(dxlegf)(double *dnu1, int *nudiff, int *mu1, int *mu2, 
-                        double *x,int *id, double *pqa, int *ipqa, int *ierror);
+extern void C2F(dxlegf)(double *dnu1, int *nudiff, int *mu1, int *mu2,
+                        double *x, int *id, double *pqa, int *ipqa, int *ierror);
 /*--------------------------------------------------------------------------*/
 static double return_an_inf(void);
 static int verify_cstr(double x[], int nb_elt, int *xmin, int *xmax);
 /*--------------------------------------------------------------------------*/
-int sci_legendre(char *fname,unsigned long fname_len)
+int sci_legendre(char *fname, unsigned long fname_len)
 {
     /*
     *   Interface onto the (Slatec) dxleg.f code.
@@ -50,22 +50,22 @@ int sci_legendre(char *fname,unsigned long fname_len)
     double *x = NULL, xx = 0., dnu1 = 0., *pqa = NULL;
     int id = 0, ierror = 0, i = 0, j = 0, nudiff = 0;
 
-    CheckLhs(1, 1); 
+    CheckLhs(1, 1);
     CheckRhs(3, 4);
     GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &mN, &nN, &lN);
 
-    if ( ! verify_cstr(stk(lN), mN*nN, &n1, &n2) )
+    if ( ! verify_cstr(stk(lN), mN * nN, &n1, &n2) )
     {
-        Scierror(999,_("%s: Wrong type for first input argument.\n"), fname);
+        Scierror(999, _("%s: Wrong type for first input argument.\n"), fname);
         return 0;
     };
 
     if ( mN == 1 && nN == 1) N_is_scalar = 1;
 
-    GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE, &mM, &nM, &lM);
-    if ( ! verify_cstr(stk(lM), mM*nM, &m1, &m2) )
+    GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &mM, &nM, &lM);
+    if ( ! verify_cstr(stk(lM), mM * nM, &m1, &m2) )
     {
-        Scierror(999,_("%s: Wrong type for input argument #%d.\n"), fname,2);
+        Scierror(999, _("%s: Wrong type for input argument #%d.\n"), fname, 2);
         return 0;
     }
 
@@ -73,30 +73,30 @@ int sci_legendre(char *fname,unsigned long fname_len)
 
     if ( ! M_is_scalar  &&  ! N_is_scalar )
     {
-        Scierror(999,_("%s: Only one of arg1 and arg2 may be a vector.\n"), fname);
+        Scierror(999, _("%s: Only one of arg1 and arg2 may be a vector.\n"), fname);
         return 0;
     };
 
-    GetRhsCVar(3,MATRIX_OF_DOUBLE_DATATYPE, &it, &mx, &nx, &lx, &lc);
+    GetRhsCVar(3, MATRIX_OF_DOUBLE_DATATYPE, &it, &mx, &nx, &lx, &lc);
     if ( it != 0 )
     {
-        Scierror(999,_("%s: Wrong type for input argument #%d: Real matrix expected.\n"), fname, 3);
+        Scierror(999, _("%s: Wrong type for input argument #%d: Real matrix expected.\n"), fname, 3);
         return 0;
     };
 
-    mnx = mx*nx;
+    mnx = mx * nx;
     x = stk(lx);
     for ( i = 0 ; i < mnx ; i++ )
         if ( ! (fabs(x[i]) < 1.0) )
         {
-            Scierror(999,_("%s: Wrong value for input argument #%d: Matrix with elements in (%d,%d) expected.\n"), fname,3,-1,1);
+            Scierror(999, _("%s: Wrong value for input argument #%d: Matrix with elements in (%d,%d) expected.\n"), fname, 3, -1, 1);
             return 0;
         };
 
     if ( Rhs == 4 )
     {
-        GetRhsVar(4,STRING_DATATYPE, &ms, &ns, &ls);
-        if ( strcmp(cstk(ls),"norm") == 0)
+        GetRhsVar(4, STRING_DATATYPE, &ms, &ns, &ls);
+        if ( strcmp(cstk(ls), "norm") == 0)
         {
             normalised = 1;
         }
@@ -112,8 +112,10 @@ int sci_legendre(char *fname,unsigned long fname_len)
 
     MNp1 = Max (n2 - n1, m2 - m1) + 1;
 
-    CreateVar(Rhs+1, MATRIX_OF_DOUBLE_DATATYPE, &MNp1, &mnx, &lpqa); pqa = stk(lpqa);
-    CreateVar(Rhs+2, MATRIX_OF_INTEGER_DATATYPE, &MNp1, &mnx, &lipqa); ipqa = istk(lipqa);
+    CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &MNp1, &mnx, &lpqa);
+    pqa = stk(lpqa);
+    CreateVar(Rhs + 2, MATRIX_OF_INTEGER_DATATYPE, &MNp1, &mnx, &lipqa);
+    ipqa = istk(lipqa);
 
     if ( normalised )
     {
@@ -131,16 +133,16 @@ int sci_legendre(char *fname,unsigned long fname_len)
     {
         xx = fabs(x[i]); /* dxleg computes only for x in [0,1) */
         F2C(dxlegf) (&dnu1, &nudiff, &m1, &m2, &xx, &id,
-            stk(lpqa+i*MNp1), istk(lipqa+i*MNp1), &ierror);
+                     stk(lpqa + i * MNp1), istk(lipqa + i * MNp1), &ierror);
         if ( ierror != 0 )
         {
             if ( ierror == 207 ) /* @TODO what is 207 ? */
             {
-                Scierror(999,_("%s: overflow or underflow of an extended range number\n"), fname);
+                Scierror(999, _("%s: overflow or underflow of an extended range number\n"), fname);
             }
             else
             {
-                Scierror(999,_("%s: error number %d\n"), fname, ierror);
+                Scierror(999, _("%s: error number %d\n"), fname, ierror);
             }
             return 0;
         };
@@ -151,7 +153,7 @@ int sci_legendre(char *fname,unsigned long fname_len)
     *  When the "exponent" part (ipqa) is 0 then the number is exactly
     *  given by pqa else it leads to an overflow or an underflow.
     */
-    for ( i = 0 ; i < mnx*MNp1 ; i++ )
+    for ( i = 0 ; i < mnx * MNp1 ; i++ )
     {
         if ( ipqa[i] < 0 )
         {
@@ -164,22 +166,22 @@ int sci_legendre(char *fname,unsigned long fname_len)
     }
 
     /* complete the result by odd/even symmetry for negative x */
-    for ( i = 0 ; i < mnx ; i++ ) 
+    for ( i = 0 ; i < mnx ; i++ )
     {
-        if ( x[i] < 0.0 ) 
+        if ( x[i] < 0.0 )
         {
-            if ( (n1+m1) % 2 == 1 ) 
+            if ( (n1 + m1) % 2 == 1 )
             {
-                for ( j = 0 ; j < MNp1 ; j+=2 )
+                for ( j = 0 ; j < MNp1 ; j += 2 )
                 {
-                    pqa[i*MNp1 + j] = -pqa[i*MNp1 + j];
+                    pqa[i * MNp1 + j] = -pqa[i * MNp1 + j];
                 }
             }
-            else 
+            else
             {
-                for ( j = 1 ; j < MNp1 ; j+=2 )
+                for ( j = 1 ; j < MNp1 ; j += 2 )
                 {
-                    pqa[i*MNp1 + j] = -pqa[i*MNp1 + j];
+                    pqa[i * MNp1 + j] = -pqa[i * MNp1 + j];
                 }
             }
         }
@@ -199,7 +201,7 @@ static double return_an_inf()
 
     if ( first )
     {
-        inf = inf/(inf - (double) first);
+        inf = inf / (inf - (double) first);
         first = 0;
     }
     return (inf);
@@ -222,14 +224,14 @@ static int verify_cstr(double x[], int nb_elt, int *xmin, int *xmax)
     }
     for ( i = 1 ; i < nb_elt ; i++ )
     {
-        if ( x[i] != x[i-1]+1.0 )
+        if ( x[i] != x[i - 1] + 1.0 )
         {
             return 0;
         }
     }
 
     *xmin = (int) x[0];
-    *xmax = (int) x[nb_elt-1];
+    *xmax = (int) x[nb_elt - 1];
     return 1;
 }
 /*--------------------------------------------------------------------------*/
index 8c3d097..e794d0c 100644 (file)
@@ -1,11 +1,11 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2005 - 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
  *
  */
 #include "Scierror.h"
 #include "localization.h"
 #if _MSC_VER
-  #include "strdup_windows.h"
+#include "strdup_windows.h"
 #endif
 /*--------------------------------------------------------------------------*/
-int sci_TCL_GetVersion(char *fname,unsigned long l)
+int sci_TCL_GetVersion(char *fname, unsigned long l)
 {
-       static int l1,n1,m1;
-       int major=0;
-       int minor=0;
-       int patchLevel=0;
-       int type=0;
-       char *output=NULL ;
-       char VersionString[256];
-       char ReleaseType[256];
+    static int l1, n1, m1;
+    int major = 0;
+    int minor = 0;
+    int patchLevel = 0;
+    int type = 0;
+    char *output = NULL ;
+    char VersionString[256];
+    char ReleaseType[256];
+
+    CheckRhs(0, 1);
+    CheckLhs(1, 1);
 
-       CheckRhs(0,1);
-       CheckLhs(1,1);
+    Tcl_GetVersion(&major, &minor, &patchLevel, &type);
 
-       Tcl_GetVersion(&major, &minor, &patchLevel, &type);
+    if (Rhs == 0)
+    {
+        switch (type)
+        {
+            case TCL_ALPHA_RELEASE:
+                strcpy(ReleaseType, _("Alpha Release"));
+                break;
+            case TCL_BETA_RELEASE:
+                strcpy(ReleaseType, _("Beta Release"));
+                break;
+            case TCL_FINAL_RELEASE:
+                strcpy(ReleaseType, _("Final Release"));
+                break;
+            default:
+                strcpy(ReleaseType, _("Unknown Release"));
+                break;
+        }
 
-       if (Rhs == 0)
-       {
-               switch (type)
-               {
-                       case TCL_ALPHA_RELEASE:
-                               strcpy(ReleaseType,_("Alpha Release"));
-                               break;
-                       case TCL_BETA_RELEASE:
-                               strcpy(ReleaseType,_("Beta Release"));
-                               break;
-                       case TCL_FINAL_RELEASE:
-                               strcpy(ReleaseType,_("Final Release"));
-                               break;
-                       default:
-                               strcpy(ReleaseType,_("Unknown Release"));
-                               break;
-               }
+        sprintf(VersionString, "TCL/TK %d.%d.%d %s", major, minor, patchLevel, ReleaseType);
+        output = strdup(VersionString);
+        n1 = 1;
+        m1 = (int)strlen(output);
+        CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &m1, &n1, &output);
+        if (output)
+        {
+            FREE(output);
+            output = NULL;
+        }
 
-               sprintf(VersionString,"TCL/TK %d.%d.%d %s",major,minor,patchLevel,ReleaseType);
-               output=strdup(VersionString);
-               n1=1;
-               CreateVarFromPtr(Rhs+ 1,STRING_DATATYPE,(m1=(int)strlen(output), &m1),&n1,&output);
-               if (output) {FREE(output);output=NULL;}
+        LhsVar(1) = Rhs + 1;
+        PutLhsVar();
+    }
+    else
+    {
+        if (GetType(1) == sci_strings)
+        {
+            char *Param = NULL;
 
-               LhsVar(1) = Rhs+1;
-               PutLhsVar();
-       }
-       else
-       {
-               if (GetType(1) == sci_strings)
-               {
-                       char *Param=NULL;
+            GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
+            Param = cstk(l1);
 
-                       GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
-                       Param=cstk(l1);
+            if (strcmp(Param, "numbers") == 0)
+            {
+                int *VERSIONMATRIX = NULL;
+                VERSIONMATRIX = (int *)MALLOC( (4) * sizeof(int) );
 
-                       if (strcmp(Param,"numbers") == 0)
-                       {
-                               int *VERSIONMATRIX=NULL;
-                               VERSIONMATRIX=(int *)MALLOC( (4)*sizeof(int) );
+                VERSIONMATRIX[0] = (int)major;
+                VERSIONMATRIX[1] = (int)minor;
+                VERSIONMATRIX[2] = (int)patchLevel;
+                VERSIONMATRIX[3] = (int)type;
 
-                               VERSIONMATRIX[0]=(int)major;
-                               VERSIONMATRIX[1]=(int)minor;
-                               VERSIONMATRIX[2]=(int)patchLevel;
-                               VERSIONMATRIX[3]=(int)type;
+                m1 = 1;
+                n1 = 4;
+                CreateVarFromPtr(Rhs + 1, MATRIX_OF_INTEGER_DATATYPE, &m1, &n1 , &VERSIONMATRIX);
+                if (VERSIONMATRIX)
+                {
+                    FREE(VERSIONMATRIX);
+                    VERSIONMATRIX = NULL;
+                }
+                LhsVar(1) = Rhs + 1;
+                PutLhsVar();
 
-                               m1=1;
-                               n1=4;
-                               CreateVarFromPtr(Rhs+1,MATRIX_OF_INTEGER_DATATYPE, &m1, &n1 ,&VERSIONMATRIX);
-                if (VERSIONMATRIX){    FREE(VERSIONMATRIX); VERSIONMATRIX=NULL;}
-                               LhsVar(1)=Rhs+1;
-                               PutLhsVar();
-                               
-                       }
-                       else
-                       {
-                               Scierror(999,_("%s: Wrong value for input argument #%d: '%s' expected.\n"),fname, 1, "numbers");
-                       }
-               }
-               else
-               {
-                       Scierror(999,_("%s: Wrong type for input argument #%d: String expected.\n"),fname, 1);
-               }
+            }
+            else
+            {
+                Scierror(999, _("%s: Wrong value for input argument #%d: '%s' expected.\n"), fname, 1, "numbers");
+            }
+        }
+        else
+        {
+            Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
+        }
 
-       }
-       return 0;
+    }
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index b891c7e..66168ff 100644 (file)
@@ -1,7 +1,7 @@
 /*
- *   Copyright Bruno Pinçon, ESIAL-IECN, Inria CORIDA project 
+ *   Copyright Bruno Pinçon, ESIAL-IECN, Inria CORIDA project
  *   <bruno.pincon@iecn.u-nancy.fr>
- *   contributor:  Antonio Manoel Ferreria Frasson, Universidade Federal do 
+ *   contributor:  Antonio Manoel Ferreria Frasson, Universidade Federal do
  *                 Espírito Santo, Brazil. <frasson@ele.ufes.br>.
  *
  * PURPOSE: Scilab interfaces routines onto the UMFPACK sparse solver
@@ -65,105 +65,108 @@ extern CellAdr *ListCholFactors;
 
 int sci_taucs_chsolve(char* fname, unsigned long l)
 {
-       int mb = 0, nb = 0, lb = 0, lx = 0, one=1, lv = 0, lres = 0;
-       int mC_ptr = 0, nC_ptr = 0, lC_ptr = 0;
-       int mA = 0, nA = 0, i = 0, j = 0, n = 0, it_flag = 0, Refinement = 0;
-       double *b = NULL, *x = NULL, *v = NULL, *res = NULL, norm_res = 0., norm_res_bis = 0.;
-       long double *wk = NULL;
-       int A_is_upper_triangular = 0;
-       taucs_handle_factors * pC = NULL;
-       SciSparse A;
-
-       /* Check numbers of input/output arguments */
-       CheckRhs(2,3); CheckLhs(1,1);
-
-       /* First get arg #1 : the pointer to the Cholesky factors */
-       GetRhsVar(1,SCILAB_POINTER_DATATYPE, &mC_ptr, &nC_ptr, &lC_ptr);
-       pC = (taucs_handle_factors *) ((unsigned long int) *stk(lC_ptr));
-
-       /* Check if this pointer is a valid ref to a Cholesky factor object */
-       if ( ! IsAdrInList( (Adr)pC, ListCholFactors, &it_flag) )
-       {
-               Scierror(999,_("%s: Wrong value for input argument #%d: not a valid reference to Cholesky factors"),fname,1);
-               return 0;
-       };
-
-       /*  the number of rows/lines of the matrix  */
-       n = pC->n;
-       /* Get now arg #2 : the vector b */
-       GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE ,&mb,&nb,&lb);
-
-       /* test if the right hand side is compatible */
-       if (mb != n || nb < 1)  
-       {
-               Scierror(999,_("%s: Wrong size for input argument #%d.\n"),fname,2);
-               return 0;
-       };
-
-       /* get the pointer for b */
-       b = stk(lb);
-
-       if ( Rhs == 3 )
-       {
-               GetRhsVar(3,  SPARSE_MATRIX_DATATYPE, &mA, &nA, &A);
-               if ( mA != nA  ||  mA != n  ||  A.it == 1 )
-               {
-                       Scierror(999,_("%s: Wrong size for input argument #%d: not compatible with the Choleski factorisation.\n"),fname,3);
-                       return 0;
-               };
-               Refinement = 1;
-               A_is_upper_triangular = is_sparse_upper_triangular(&A);
-       }
-       else
-       {
-               Refinement = 0;
-       }
-       
-       /* allocate memory for the solution x */
-       CreateVar(Rhs+1, MATRIX_OF_DOUBLE_DATATYPE, &mb, &nb, &lx);
-       x = stk(lx);
-
-       /* allocate memory for a temporary vector v */
-       CreateVar(Rhs+2, MATRIX_OF_DOUBLE_DATATYPE, &mb, &one, &lv); v = stk(lv);
-
-       if ( Refinement )
-       {
-               CreateVar(Rhs+3, MATRIX_OF_DOUBLE_DATATYPE, &mb, &one, &lres); res = stk(lres);
-               if ( A_is_upper_triangular )
-                       if ( (wk = MALLOC( n * sizeof(long double))) == NULL )
-                       {
-                               Scierror(999,_("%s: not enough memory.\n"),fname);
-                               return 0;
-                       };
-       }
-
-       for ( j = 0; j < nb ; j++ )
-               {
-                       taucs_vec_permute(n, &b[j*mb], &x[j*mb], pC->p);
-                       taucs_supernodal_solve_llt(pC->C, v, &x[j*mb]);  /* FIXME : add a test here */
-                       taucs_vec_ipermute(n, v, &x[j*mb], pC->p);
-                       if ( Refinement )
-                               {
-                                       /* do one iterative refinement */
-                                       residu_with_prec_for_chol(&A, &x[j*mb], &b[j*mb], res, &norm_res, A_is_upper_triangular, wk);
-                                       /*  FIXME: do a test if the norm_res has an anormal value and send a warning
-                                        *         (the user has certainly not give the good matrix A 
-                                        */
-                                       taucs_vec_permute(n, res, v, pC->p);
-                                       taucs_supernodal_solve_llt(pC->C, res, v);  /* FIXME : add a test here */
-                                       taucs_vec_ipermute(n, res, v, pC->p);
-                                       for ( i = 0 ; i < n ; i++ )
-                                               v[i] = x[j*mb+i] - v[i];    /* v is the refined solution */
-                                       residu_with_prec_for_chol(&A, v, &b[j*mb], res, &norm_res_bis, A_is_upper_triangular, wk);
-                                       /* accept it if the 2 norm of the residual is improved */
-                                       if ( norm_res_bis < norm_res )
-                                               for ( i = 0 ; i < n ; i++ )
-                                                       x[j*mb+i] = v[i];
-                               }
-               }
-  
-       FREE(wk);
-       LhsVar(1) = Rhs+1;
-       PutLhsVar();
-       return 0;
+    int mb = 0, nb = 0, lb = 0, lx = 0, one = 1, lv = 0, lres = 0;
+    int mC_ptr = 0, nC_ptr = 0, lC_ptr = 0;
+    int mA = 0, nA = 0, i = 0, j = 0, n = 0, it_flag = 0, Refinement = 0;
+    double *b = NULL, *x = NULL, *v = NULL, *res = NULL, norm_res = 0., norm_res_bis = 0.;
+    long double *wk = NULL;
+    int A_is_upper_triangular = 0;
+    taucs_handle_factors * pC = NULL;
+    SciSparse A;
+
+    /* Check numbers of input/output arguments */
+    CheckRhs(2, 3);
+    CheckLhs(1, 1);
+
+    /* First get arg #1 : the pointer to the Cholesky factors */
+    GetRhsVar(1, SCILAB_POINTER_DATATYPE, &mC_ptr, &nC_ptr, &lC_ptr);
+    pC = (taucs_handle_factors *) ((unsigned long int) * stk(lC_ptr));
+
+    /* Check if this pointer is a valid ref to a Cholesky factor object */
+    if ( ! IsAdrInList( (Adr)pC, ListCholFactors, &it_flag) )
+    {
+        Scierror(999, _("%s: Wrong value for input argument #%d: not a valid reference to Cholesky factors"), fname, 1);
+        return 0;
+    };
+
+    /*  the number of rows/lines of the matrix  */
+    n = pC->n;
+    /* Get now arg #2 : the vector b */
+    GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE , &mb, &nb, &lb);
+
+    /* test if the right hand side is compatible */
+    if (mb != n || nb < 1)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d.\n"), fname, 2);
+        return 0;
+    };
+
+    /* get the pointer for b */
+    b = stk(lb);
+
+    if ( Rhs == 3 )
+    {
+        GetRhsVar(3,  SPARSE_MATRIX_DATATYPE, &mA, &nA, &A);
+        if ( mA != nA  ||  mA != n  ||  A.it == 1 )
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: not compatible with the Choleski factorisation.\n"), fname, 3);
+            return 0;
+        };
+        Refinement = 1;
+        A_is_upper_triangular = is_sparse_upper_triangular(&A);
+    }
+    else
+    {
+        Refinement = 0;
+    }
+
+    /* allocate memory for the solution x */
+    CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &mb, &nb, &lx);
+    x = stk(lx);
+
+    /* allocate memory for a temporary vector v */
+    CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &mb, &one, &lv);
+    v = stk(lv);
+
+    if ( Refinement )
+    {
+        CreateVar(Rhs + 3, MATRIX_OF_DOUBLE_DATATYPE, &mb, &one, &lres);
+        res = stk(lres);
+        if ( A_is_upper_triangular )
+            if ( (wk = MALLOC( n * sizeof(long double))) == NULL )
+            {
+                Scierror(999, _("%s: not enough memory.\n"), fname);
+                return 0;
+            };
+    }
+
+    for ( j = 0; j < nb ; j++ )
+    {
+        taucs_vec_permute(n, &b[j * mb], &x[j * mb], pC->p);
+        taucs_supernodal_solve_llt(pC->C, v, &x[j * mb]); /* FIXME : add a test here */
+        taucs_vec_ipermute(n, v, &x[j * mb], pC->p);
+        if ( Refinement )
+        {
+            /* do one iterative refinement */
+            residu_with_prec_for_chol(&A, &x[j * mb], &b[j * mb], res, &norm_res, A_is_upper_triangular, wk);
+            /*  FIXME: do a test if the norm_res has an anormal value and send a warning
+             *         (the user has certainly not give the good matrix A
+             */
+            taucs_vec_permute(n, res, v, pC->p);
+            taucs_supernodal_solve_llt(pC->C, res, v);  /* FIXME : add a test here */
+            taucs_vec_ipermute(n, res, v, pC->p);
+            for ( i = 0 ; i < n ; i++ )
+                v[i] = x[j * mb + i] - v[i]; /* v is the refined solution */
+            residu_with_prec_for_chol(&A, v, &b[j * mb], res, &norm_res_bis, A_is_upper_triangular, wk);
+            /* accept it if the 2 norm of the residual is improved */
+            if ( norm_res_bis < norm_res )
+                for ( i = 0 ; i < n ; i++ )
+                    x[j * mb + i] = v[i];
+        }
+    }
+
+    FREE(wk);
+    LhsVar(1) = Rhs + 1;
+    PutLhsVar();
+    return 0;
 }
index b7aec34..0b7c23c 100644 (file)
@@ -1,7 +1,7 @@
 /*
- *   Copyright Bruno Pinçon, ESIAL-IECN, Inria CORIDA project 
+ *   Copyright Bruno Pinçon, ESIAL-IECN, Inria CORIDA project
  *   <bruno.pincon@iecn.u-nancy.fr>
- *   contributor:  Antonio Manoel Ferreria Frasson, Universidade Federal do 
+ *   contributor:  Antonio Manoel Ferreria Frasson, Universidade Federal do
  *                 Espírito Santo, Brazil. <frasson@ele.ufes.br>.
  *
  * PURPOSE: Scilab interfaces routines onto the UMFPACK sparse solver
 
 extern CellAdr *ListNumeric;
 
-int sci_umf_lusolve(char* fname,unsigned long l)
+int sci_umf_lusolve(char* fname, unsigned long l)
 {
-       int mb, nb, lrb, lib, itb, mflag, nflag, lflag, lrx, lix, itx;
-       int mLU_ptr, nLU_ptr, lLU_ptr, it_flag, i;
-       int mA, nA, j, one=1, LastNum;
-       SciSparse AA;
-       CcsSparse A;
-       int NoTranspose, NoRaffinement;
-       double *br, *bi, *xr, *xi;
-
-       /* umfpack stuff */
-       double Info[UMFPACK_INFO]; // double *Info = (double *) NULL;
-       double Control[UMFPACK_CONTROL];
-       void * Numeric;
-       int lnz, unz, n, n_col, nz_udiag, umf_flag;
-       int *Wi, lWi, lW, mW;
-       double *W;
-  
-       /* Check numbers of input/output arguments */
-       CheckRhs(2,4); CheckLhs(1,1);
-
-       /* First get arg #1 : the pointer to the LU factors */
-       GetRhsVar(1,SCILAB_POINTER_DATATYPE, &mLU_ptr, &nLU_ptr, &lLU_ptr);
-       Numeric = (void *) ((unsigned long int) *stk(lLU_ptr));
-
-       /* Check if this pointer is a valid ref to a umfpack LU numeric object */
-       if ( ! IsAdrInList(Numeric, ListNumeric, &it_flag) )
-       {
-               Scierror(999,_("%s: Wrong value for input argument #%d: Must be a valid reference to (umf) LU factors.\n"),fname,1);
-               return 0;
-       };
-
-       /*  get some parameters of the factorisation (for some checking) */
-       if ( it_flag == 0 )
-               umfpack_di_get_lunz(&lnz, &unz, &n, &n_col, &nz_udiag, Numeric);
-       else
-               umfpack_zi_get_lunz(&lnz, &unz, &n, &n_col, &nz_udiag, Numeric);
-
-       if ( n != n_col ) 
-       {
-               Scierror(999,_("%s: An error occurred: %s.\n"),fname,_("This is not a factorisation of a square matrix"));
-               return 0;
-       };
-       if ( nz_udiag < n ) 
-       {
-               Scierror(999,_("%s: An error occurred: %s.\n"),fname,_("This is a factorisation of a singular matrix"));
-               return 0;
-       };
-
-       /* Get now arg #2 : the vector b */
-       GetRhsCVar(2,MATRIX_OF_DOUBLE_DATATYPE, &itb, &mb, &nb, &lrb, &lib);
-       if (mb != n || nb < 1)    /* test if the right hand side is compatible */
-       {
-               Scierror(999,_("%s: Wrong size for input argument #%d.\n"),fname,2);
-               return 0;
-       };
-
-       /* allocate memory for the solution x */
-       if ( it_flag == 1  ||  itb == 1 ) itx = 1; else itx = 0;     
-       CreateCVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE, &itx, &mb, &nb, &lrx, &lix);
-       xr = stk(lrx); xi = stk(lix);
-
-       /*  selection between the different options :
-        *   -- solving Ax=b or A'x=b (Note: we could add  A.'x=b)
-        *   -- with or without raffinement
-        */
-
-       if ( Rhs == 2 )
-       {
-               NoTranspose = 1;
-               NoRaffinement = 1;
-       }
-       else  /* 3 or 4 input arguments but the third must be a string */
-       {
-               GetRhsVar(3,STRING_DATATYPE,&mflag,&nflag,&lflag);
-               if ( strcmp(cstk(lflag),"Ax=b") == 0 )
-                       NoTranspose = 1;
-               else if ( strcmp(cstk(lflag),"A'x=b") == 0 )
-                       NoTranspose = 0;
-               else
-               {
-                       Scierror(999,_("%s: Wrong input argument #%d: '%s' or '%s' expected.\n"),fname,3,"Ax=b","A'x=b");
-                       return 0;
-               };
-               if ( Rhs == 4 ) 
-               {
-                       GetRhsVar(4, SPARSE_MATRIX_DATATYPE, &mA, &nA, &AA);
-                       /*  some check... but we can't be sure that the matrix corresponds to the LU factors */
-                       if ( mA != nA || mA != n || AA.it != it_flag )  
-                       {
-                               Scierror(999,_("%s: Wrong size for input argument #%d: %s.\n"),fname,4,_("Matrix is not compatible with the given LU factors"));
-                               return 0;
-                       };
-                       NoRaffinement = 0;
-               }
-               else NoRaffinement = 1;   /* only 3 input var => no raffinement */
-       }
-
-       /* allocate memory for umfpack_di_wsolve usage or umfpack_zi_wsolve usage*/
-       CreateVar(Rhs+2,  MATRIX_OF_INTEGER_DATATYPE, &n, &one, &lWi); Wi = istk(lWi);
-       if (it_flag == 1) 
-       {
-               if (NoRaffinement) mW = 4*n; 
-               else mW = 10*n;
-       }
-       else
-       {
-               if (NoRaffinement) mW = n; 
-               else mW = 5*n;
-       }
-       CreateVar(Rhs+3, MATRIX_OF_DOUBLE_DATATYPE, &mW, &one, &lW); W  = stk(lW);
-
-       if (! NoRaffinement)
-       {
-               SciSparseToCcsSparse(Rhs+4, &AA, &A);
-               LastNum = Rhs+4;
-       }
-       else
-       {
-               A.p = NULL; A.irow = NULL; A.R = NULL; A.I = NULL;
-               LastNum = Rhs+3;
-       }
-
-       /* get the pointer for b */
-       br = stk(lrb); bi = stk(lib);
-       if ( it_flag == 1  &&  itb == 0 )
-       {
-               CreateVar(LastNum+1,MATRIX_OF_DOUBLE_DATATYPE, &mb, &nb, &lib);
-               bi = stk(lib);
-               for ( i = 0 ; i < mb*nb ; i++ ) bi[i] = 0.0;
-       }
-
-       /* init Control */
-       if (it_flag == 0) 
-               umfpack_di_defaults(Control);
-       else
-               umfpack_zi_defaults(Control);
-       if (NoRaffinement)
-               Control[UMFPACK_IRSTEP] = 0;
-
-       if (NoTranspose) 
-               umf_flag = UMFPACK_A;
-       else
-               umf_flag = UMFPACK_At;
-
-       if (it_flag == 0)
-       {
-               for ( j = 0; j < nb ; j++ ) 
-               {
-                       umfpack_di_wsolve(umf_flag, A.p, A.irow, A.R, &xr[j*mb], &br[j*mb], Numeric, Control, Info, Wi, W);
-               }
-               if (itx == 1)
-               {
-                       for ( j = 0; j < nb ; j++ ) 
-                       {
-                               umfpack_di_wsolve(umf_flag, A.p, A.irow, A.R, &xi[j*mb], &bi[j*mb], Numeric, Control, Info, Wi, W);
-                       }
-               }
-       }
+    int mb, nb, lrb, lib, itb, mflag, nflag, lflag, lrx, lix, itx;
+    int mLU_ptr, nLU_ptr, lLU_ptr, it_flag, i;
+    int mA, nA, j, one = 1, LastNum;
+    SciSparse AA;
+    CcsSparse A;
+    int NoTranspose, NoRaffinement;
+    double *br, *bi, *xr, *xi;
+
+    /* umfpack stuff */
+    double Info[UMFPACK_INFO]; // double *Info = (double *) NULL;
+    double Control[UMFPACK_CONTROL];
+    void * Numeric;
+    int lnz, unz, n, n_col, nz_udiag, umf_flag;
+    int *Wi, lWi, lW, mW;
+    double *W;
+
+    /* Check numbers of input/output arguments */
+    CheckRhs(2, 4);
+    CheckLhs(1, 1);
+
+    /* First get arg #1 : the pointer to the LU factors */
+    GetRhsVar(1, SCILAB_POINTER_DATATYPE, &mLU_ptr, &nLU_ptr, &lLU_ptr);
+    Numeric = (void *) ((unsigned long int) * stk(lLU_ptr));
+
+    /* Check if this pointer is a valid ref to a umfpack LU numeric object */
+    if ( ! IsAdrInList(Numeric, ListNumeric, &it_flag) )
+    {
+        Scierror(999, _("%s: Wrong value for input argument #%d: Must be a valid reference to (umf) LU factors.\n"), fname, 1);
+        return 0;
+    };
+
+    /*  get some parameters of the factorisation (for some checking) */
+    if ( it_flag == 0 )
+        umfpack_di_get_lunz(&lnz, &unz, &n, &n_col, &nz_udiag, Numeric);
     else
-       {
-               for ( j = 0; j < nb ; j++ ) 
-               {
-                       umfpack_zi_wsolve(umf_flag, A.p, A.irow, A.R, A.I, &xr[j*mb], &xi[j*mb], &br[j*mb], &bi[j*mb], Numeric, Control, Info, Wi, W);
-               }
-       }
-
-       LhsVar(1) = Rhs+1;
-       PutLhsVar();
-       return 0;
+        umfpack_zi_get_lunz(&lnz, &unz, &n, &n_col, &nz_udiag, Numeric);
+
+    if ( n != n_col )
+    {
+        Scierror(999, _("%s: An error occurred: %s.\n"), fname, _("This is not a factorisation of a square matrix"));
+        return 0;
+    };
+    if ( nz_udiag < n )
+    {
+        Scierror(999, _("%s: An error occurred: %s.\n"), fname, _("This is a factorisation of a singular matrix"));
+        return 0;
+    };
+
+    /* Get now arg #2 : the vector b */
+    GetRhsCVar(2, MATRIX_OF_DOUBLE_DATATYPE, &itb, &mb, &nb, &lrb, &lib);
+    if (mb != n || nb < 1)    /* test if the right hand side is compatible */
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d.\n"), fname, 2);
+        return 0;
+    };
+
+    /* allocate memory for the solution x */
+    if ( it_flag == 1  ||  itb == 1 ) itx = 1;
+    else itx = 0;
+    CreateCVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &itx, &mb, &nb, &lrx, &lix);
+    xr = stk(lrx);
+    xi = stk(lix);
+
+    /*  selection between the different options :
+     *   -- solving Ax=b or A'x=b (Note: we could add  A.'x=b)
+     *   -- with or without raffinement
+     */
+
+    if ( Rhs == 2 )
+    {
+        NoTranspose = 1;
+        NoRaffinement = 1;
+    }
+    else  /* 3 or 4 input arguments but the third must be a string */
+    {
+        GetRhsVar(3, STRING_DATATYPE, &mflag, &nflag, &lflag);
+        if ( strcmp(cstk(lflag), "Ax=b") == 0 )
+            NoTranspose = 1;
+        else if ( strcmp(cstk(lflag), "A'x=b") == 0 )
+            NoTranspose = 0;
+        else
+        {
+            Scierror(999, _("%s: Wrong input argument #%d: '%s' or '%s' expected.\n"), fname, 3, "Ax=b", "A'x=b");
+            return 0;
+        };
+        if ( Rhs == 4 )
+        {
+            GetRhsVar(4, SPARSE_MATRIX_DATATYPE, &mA, &nA, &AA);
+            /*  some check... but we can't be sure that the matrix corresponds to the LU factors */
+            if ( mA != nA || mA != n || AA.it != it_flag )
+            {
+                Scierror(999, _("%s: Wrong size for input argument #%d: %s.\n"), fname, 4, _("Matrix is not compatible with the given LU factors"));
+                return 0;
+            };
+            NoRaffinement = 0;
+        }
+        else NoRaffinement = 1;   /* only 3 input var => no raffinement */
+    }
+
+    /* allocate memory for umfpack_di_wsolve usage or umfpack_zi_wsolve usage*/
+    CreateVar(Rhs + 2,  MATRIX_OF_INTEGER_DATATYPE, &n, &one, &lWi);
+    Wi = istk(lWi);
+    if (it_flag == 1)
+    {
+        if (NoRaffinement) mW = 4 * n;
+        else mW = 10 * n;
+    }
+    else
+    {
+        if (NoRaffinement) mW = n;
+        else mW = 5 * n;
+    }
+    CreateVar(Rhs + 3, MATRIX_OF_DOUBLE_DATATYPE, &mW, &one, &lW);
+    W  = stk(lW);
+
+    if (! NoRaffinement)
+    {
+        SciSparseToCcsSparse(Rhs + 4, &AA, &A);
+        LastNum = Rhs + 4;
+    }
+    else
+    {
+        A.p = NULL;
+        A.irow = NULL;
+        A.R = NULL;
+        A.I = NULL;
+        LastNum = Rhs + 3;
+    }
+
+    /* get the pointer for b */
+    br = stk(lrb);
+    bi = stk(lib);
+    if ( it_flag == 1  &&  itb == 0 )
+    {
+        CreateVar(LastNum + 1, MATRIX_OF_DOUBLE_DATATYPE, &mb, &nb, &lib);
+        bi = stk(lib);
+        for ( i = 0 ; i < mb * nb ; i++ ) bi[i] = 0.0;
+    }
+
+    /* init Control */
+    if (it_flag == 0)
+        umfpack_di_defaults(Control);
+    else
+        umfpack_zi_defaults(Control);
+    if (NoRaffinement)
+        Control[UMFPACK_IRSTEP] = 0;
+
+    if (NoTranspose)
+        umf_flag = UMFPACK_A;
+    else
+        umf_flag = UMFPACK_At;
+
+    if (it_flag == 0)
+    {
+        for ( j = 0; j < nb ; j++ )
+        {
+            umfpack_di_wsolve(umf_flag, A.p, A.irow, A.R, &xr[j * mb], &br[j * mb], Numeric, Control, Info, Wi, W);
+        }
+        if (itx == 1)
+        {
+            for ( j = 0; j < nb ; j++ )
+            {
+                umfpack_di_wsolve(umf_flag, A.p, A.irow, A.R, &xi[j * mb], &bi[j * mb], Numeric, Control, Info, Wi, W);
+            }
+        }
+    }
+    else
+    {
+        for ( j = 0; j < nb ; j++ )
+        {
+            umfpack_zi_wsolve(umf_flag, A.p, A.irow, A.R, A.I, &xr[j * mb], &xi[j * mb], &br[j * mb], &bi[j * mb], Numeric, Control, Info, Wi, W);
+        }
+    }
+
+    LhsVar(1) = Rhs + 1;
+    PutLhsVar();
+    return 0;
 }
index fa15ee3..bbda440 100644 (file)
@@ -1,11 +1,11 @@
 /*
 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 * Copyright (C) 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
 *
 */
 #include "warningmode.h"
 #include "sciprint.h"
 /*--------------------------------------------------------------------------*/
-int sci_chartooem(char *fname,unsigned long l)
+int sci_chartooem(char *fname, unsigned long l)
 {
-    static int l1,n1,m1;
-    char *Output=NULL;
+    static int l1, n1, m1;
+    char *Output = NULL;
 
     if (getWarningMode())
     {
@@ -32,37 +32,42 @@ int sci_chartooem(char *fname,unsigned long l)
         sciprint(_("%s: This feature will be permanently removed in Scilab %s\n\n"), _("Warning"), "5.4.1");
     }
 
-    CheckRhs(1,1);
-    CheckLhs(0,1);
+    CheckRhs(1, 1);
+    CheckLhs(0, 1);
 
-    if (GetType(1) == sci_strings)     
+    if (GetType(1) == sci_strings)
     {
-        char *Charstring=NULL;
+        char *Charstring = NULL;
 
-        GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
-        Charstring=cstk(l1);
+        GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
+        Charstring = cstk(l1);
 
-        Output=(char*)MALLOC((strlen(Charstring)+1)*sizeof(char));
+        Output = (char*)MALLOC((strlen(Charstring) + 1) * sizeof(char));
         if (getScilabMode() == SCILAB_STD)
         {
-            CharToOem(Charstring,Output);
+            CharToOem(Charstring, Output);
         }
         else
         {
-            wsprintf(Output,"%s",Charstring);
+            wsprintf(Output, "%s", Charstring);
         }
     }
     else
     {
-        Scierror(999,_("%s: Wrong type for input argument #%d: String expected.\n"),fname,1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
         return 0;
     }
 
-    n1=1;
-    CreateVarFromPtr( Rhs+1,STRING_DATATYPE,(m1=(int)strlen(Output), &m1),&n1,&Output);
-    if (Output) {FREE(Output);Output=NULL;}
-    LhsVar(1) = Rhs+1;
-    PutLhsVar();       
+    n1 = 1;
+    m1 = (int)strlen(Output);
+    CreateVarFromPtr( Rhs + 1, STRING_DATATYPE, &m1, &n1, &Output);
+    if (Output)
+    {
+        FREE(Output);
+        Output = NULL;
+    }
+    LhsVar(1) = Rhs + 1;
+    PutLhsVar();
     return 0;
 }
 /*--------------------------------------------------------------------------*/
index 57121e8..bd97250 100644 (file)
@@ -1,11 +1,11 @@
 /*
 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 * Copyright (C) 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
 *
 */
 #include <windows.h>
 #include <string.h>
 #include "gw_windows_tools.h"
-#include "MALLOC.h" 
+#include "MALLOC.h"
 #include "Scierror.h"
 #include "FindFileAssociation.h"
 #include "PATH_MAX.h"
 #include "stack-c.h"
 #include "localization.h"
 /*--------------------------------------------------------------------------*/
-int sci_findfileassociation(char *fname,unsigned long l)
-{      
-       static int l1,n1,m1;
-       char *Output=NULL;
-       char ExtraParam[PATH_MAX];
-       char AssocParam[PATH_MAX];
+int sci_findfileassociation(char *fname, unsigned long l)
+{
+    static int l1, n1, m1;
+    char *Output = NULL;
+    char ExtraParam[PATH_MAX];
+    char AssocParam[PATH_MAX];
+
+    Rhs = Max(Rhs, 0);
+    CheckRhs(1, 2);
+    CheckLhs(0, 1);
 
-       Rhs=Max(Rhs,0);
-       CheckRhs(1,2);
-       CheckLhs(0,1);
+    if (Rhs == 1)
+    {
+        if (GetType(1) != sci_strings)
+        {
+            Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n") , fname, 1);
+            return 0;
+        }
+        else
+        {
+            char *param = NULL;
 
-       if (Rhs == 1)
-       {
-               if (GetType(1) != sci_strings)
-               {
-                       Scierror(999,_("%s: Wrong type for input argument #%d: String expected.\n") ,fname,1);
-                       return 0;
-               }
-               else
-               {
-                       char *param=NULL;
+            GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
+            param = cstk(l1);
+            strcpy(AssocParam, param);
 
-                       GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
-                       param=cstk(l1);
-                       strcpy(AssocParam,param);
+            strcpy(ExtraParam, "open");
+        }
+    }
+    else
+    {
+        if ( (GetType(1) != sci_strings) && (GetType(2) != sci_strings) )
+        {
+            Scierror(999, _("%s: Wrong type for input arguments: Strings expected.\n"), fname);
+            return 0;
+        }
+        else
+        {
+            char *param = NULL;
 
-                       strcpy(ExtraParam,"open");
-               }
-       }
-       else
-       {
-               if ( (GetType(1) != sci_strings) && (GetType(2) != sci_strings) )
-               {
-                       Scierror(999,_("%s: Wrong type for input arguments: Strings expected.\n"),fname);
-                       return 0;
-               }
-               else
-               {
-                       char *param=NULL;
+            GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
+            param = cstk(l1);
 
-                       GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
-                       param=cstk(l1);
+            strcpy(AssocParam, param);
 
-                       strcpy(AssocParam,param);
+            GetRhsVar(2, STRING_DATATYPE, &m1, &n1, &l1);
+            param = cstk(l1);
 
-                       GetRhsVar(2,STRING_DATATYPE,&m1,&n1,&l1);
-                       param=cstk(l1);
+            strcpy(ExtraParam, param);
+        }
+    }
 
-                       strcpy(ExtraParam,param);
-               }
-       }
+    Output = FindFileAssociation(AssocParam, ExtraParam) ;
 
-       Output=FindFileAssociation(AssocParam,ExtraParam) ;
+    if (Output)
+    {
+        n1 = 1;
+        m1 = (int)strlen(Output);
+        CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &m1, &n1, &Output);
+    }
+    else
+    {
+        n1 = 0;
+        m1 = 0;
+        l1 = 0;
+        CreateVarFromPtr(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &n1, &m1, &l1);
+    }
 
-       if (Output)
-       {
-               n1=1;
-               CreateVarFromPtr(Rhs+ 1,STRING_DATATYPE,(m1=(int)strlen(Output), &m1),&n1,&Output);
-       }
-       else
-       {
-               n1=0;
-               m1=0;
-               l1=0;
-               CreateVarFromPtr(Rhs+ 1,MATRIX_OF_DOUBLE_DATATYPE,&n1,&m1,&l1);
-       }
-               
-       if (Output) {FREE(Output);Output=NULL;}
-    LhsVar(1) = Rhs+1;
-    PutLhsVar();       
+    if (Output)
+    {
+        FREE(Output);
+        Output = NULL;
+    }
+    LhsVar(1) = Rhs + 1;
+    PutLhsVar();
 
-       return 0;
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 9e8887c..f79c18b 100644 (file)
@@ -1,11 +1,11 @@
 /*
 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 * Copyright (C) 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
 *
 */
@@ -13,7 +13,7 @@
 /*--------------------------------------------------------------------------*/
 #include <windows.h>
 #include "gw_windows_tools.h"
-#include "MALLOC.h" 
+#include "MALLOC.h"
 #include "stack-c.h"
 #include "localization.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
 #pragma comment(lib, "winmm.lib")
 /*--------------------------------------------------------------------------*/
-int sci_mcisendstring(char *fname,unsigned long l)
+int sci_mcisendstring(char *fname, unsigned long l)
 {
-       int m1,n1,l1;
-
-       char *Output=NULL;
-       int *BoolOutput=NULL;
-       int *CodeOutput=NULL;
-
-       CheckRhs(1,1);
-    CheckLhs(1,3);
-
-       if (GetType(1) == sci_strings)  
-       {
-               MCIERROR Error;
-               char *MCICommand=NULL;
-               char ReturnString[2048];
-
-               GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
-               MCICommand=cstk(l1);
-
-               Error=mciSendString(MCICommand,(LPSTR)ReturnString,sizeof(ReturnString),NULL);
-
-               BoolOutput=(int*)MALLOC(sizeof(int));
-               CodeOutput=(int*)MALLOC(sizeof(int));
-
-               *BoolOutput=(int)0;
-               *CodeOutput=(int)Error;
-               if (Error)
-               {
-                       char ErrorText[128];
-                       *BoolOutput=(int)FALSE;
-                       
-                       if ( mciGetErrorString(Error,ErrorText,sizeof(ErrorText)) == FALSE )
-                       {
-                               wsprintf(ErrorText,"%s","Unknown MCI error");
-                       }
-
-                       Output = strdup(ErrorText);
-               }
-               else
-               {
-                       *BoolOutput=(int)TRUE;
-                       Output = strdup("OK");
-               }
-
-               n1=1;
-
-               if ( Lhs == 1 )
-               {
-                       CreateVarFromPtr(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &BoolOutput);
-                       LhsVar(1)=Rhs+1;
-               }
-               else
-               if ( Lhs == 2 )
-               {
-                       CreateVarFromPtr(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &BoolOutput);
-                       LhsVar(1)=Rhs+1;
-
-                       CreateVarFromPtr(Rhs+2,MATRIX_OF_INTEGER_DATATYPE, &n1, &n1, &CodeOutput);
-                       LhsVar(2)=Rhs+2;
-               }
-               else /* Lhs == 3 */
-               {
-                       CreateVarFromPtr(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &BoolOutput);
-                       LhsVar(1)=Rhs+1;
-
-                       CreateVarFromPtr(Rhs+2,MATRIX_OF_INTEGER_DATATYPE, &n1, &n1, &CodeOutput);
-                       LhsVar(2)=Rhs+2;
-
-                       CreateVarFromPtr(Rhs+ 3,STRING_DATATYPE,(m1=(int)strlen(Output), &m1),&n1,&Output);
-                       LhsVar(3)=Rhs+3;
-               }
-
-               if (Output) {FREE(Output);Output=NULL;}
-               if (BoolOutput) {FREE(BoolOutput);BoolOutput=NULL;}
-               if (CodeOutput) {FREE(CodeOutput);Output=NULL;}
+    int m1, n1, l1;
+
+    char *Output = NULL;
+    int *BoolOutput = NULL;
+    int *CodeOutput = NULL;
+
+    CheckRhs(1, 1);
+    CheckLhs(1, 3);
+
+    if (GetType(1) == sci_strings)
+    {
+        MCIERROR Error;
+        char *MCICommand = NULL;
+        char ReturnString[2048];
+
+        GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
+        MCICommand = cstk(l1);
+
+        Error = mciSendString(MCICommand, (LPSTR)ReturnString, sizeof(ReturnString), NULL);
+
+        BoolOutput = (int*)MALLOC(sizeof(int));
+        CodeOutput = (int*)MALLOC(sizeof(int));
+
+        *BoolOutput = (int)0;
+        *CodeOutput = (int)Error;
+        if (Error)
+        {
+            char ErrorText[128];
+            *BoolOutput = (int)FALSE;
+
+            if ( mciGetErrorString(Error, ErrorText, sizeof(ErrorText)) == FALSE )
+            {
+                wsprintf(ErrorText, "%s", "Unknown MCI error");
+            }
+
+            Output = strdup(ErrorText);
+        }
+        else
+        {
+            *BoolOutput = (int)TRUE;
+            Output = strdup("OK");
+        }
+
+        n1 = 1;
+
+        if ( Lhs == 1 )
+        {
+            CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &BoolOutput);
+            LhsVar(1) = Rhs + 1;
+        }
+        else if ( Lhs == 2 )
+        {
+            CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &BoolOutput);
+            LhsVar(1) = Rhs + 1;
+
+            CreateVarFromPtr(Rhs + 2, MATRIX_OF_INTEGER_DATATYPE, &n1, &n1, &CodeOutput);
+            LhsVar(2) = Rhs + 2;
+        }
+        else /* Lhs == 3 */
+        {
+            CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &BoolOutput);
+            LhsVar(1) = Rhs + 1;
+
+            CreateVarFromPtr(Rhs + 2, MATRIX_OF_INTEGER_DATATYPE, &n1, &n1, &CodeOutput);
+            LhsVar(2) = Rhs + 2;
+
+            m1 = (int)strlen(Output);
+            CreateVarFromPtr(Rhs + 3, STRING_DATATYPE, &m1, &n1, &Output);
+            LhsVar(3) = Rhs + 3;
+        }
+
+        if (Output)
+        {
+            FREE(Output);
+            Output = NULL;
+        }
+        if (BoolOutput)
+        {
+            FREE(BoolOutput);
+            BoolOutput = NULL;
+        }
+        if (CodeOutput)
+        {
+            FREE(CodeOutput);
+            Output = NULL;
+        }
 
         PutLhsVar();
 
-               return 0;
-       }
-       else
-       {
-               Scierror(999,_("%s: Wrong type for input argument #%d: String expected.\n"),fname,1);
-               return 0;
-       }
+        return 0;
+    }
+    else
+    {
+        Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
+        return 0;
+    }
 }
 /*--------------------------------------------------------------------------*/
index 54efbc8..9a0c7ca 100644 (file)
@@ -1,11 +1,11 @@
 /*
 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 * Copyright (C) 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
 *
 */
@@ -21,9 +21,9 @@
 #include "warningmode.h"
 #include "sciprint.h"
 /*--------------------------------------------------------------------------*/
-int sci_oemtochar(char *fname,unsigned long l)
+int sci_oemtochar(char *fname, unsigned long l)
 {
-    int l1 = 0,n1 = 0,m1 = 0;
+    int l1 = 0, n1 = 0, m1 = 0;
     char *Output = NULL;
 
     if (getWarningMode())
@@ -32,38 +32,43 @@ int sci_oemtochar(char *fname,unsigned long l)
         sciprint(_("%s: This feature will be permanently removed in Scilab %s\n\n"), _("Warning"), "5.4.1");
     }
 
-    CheckRhs(1,1);
-    CheckLhs(0,1);
+    CheckRhs(1, 1);
+    CheckLhs(0, 1);
 
-    if (GetType(1) == sci_strings)     
+    if (GetType(1) == sci_strings)
     {
         char *OEMstring = NULL;
 
-        GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
+        GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
         OEMstring = cstk(l1);
 
-        Output=(char*)MALLOC((strlen(OEMstring)+1)*sizeof(char));
+        Output = (char*)MALLOC((strlen(OEMstring) + 1) * sizeof(char));
         if (getScilabMode() == SCILAB_STD)
         {
-            OemToChar(OEMstring,Output);
+            OemToChar(OEMstring, Output);
         }
         else
         {
-            wsprintf(Output,"%s",OEMstring);
+            wsprintf(Output, "%s", OEMstring);
         }
     }
     else
     {
-        Scierror(999,_("%s: Wrong type for input argument #%d: String expected.\n"),fname,1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
         return 0;
     }
 
     n1 = 1;
-    CreateVarFromPtr(Rhs+ 1,STRING_DATATYPE,(m1=(int)strlen(Output), &m1),&n1,&Output);
-    if (Output) {FREE(Output);Output=NULL;}
+    m1 = (int)strlen(Output);
+    CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &m1, &n1, &Output);
+    if (Output)
+    {
+        FREE(Output);
+        Output = NULL;
+    }
 
-    LhsVar(1) = Rhs+1;
-    PutLhsVar();       
+    LhsVar(1) = Rhs + 1;
+    PutLhsVar();
     return 0;
 }
 /*--------------------------------------------------------------------------*/